Key Takeaways

• sellers.json is a publicly accessible file hosted by SSPs that declares the identity of every seller on their platform. It's the SSP's counterpart to the publisher's ads.txt file.
• The file includes three critical fields per seller: seller_id (the account number), seller_type (PUBLISHER, INTERMEDIARY, or BOTH), and domain (the seller's business domain).
• DSPs use sellers.json to verify the identity behind every ads.txt entry. When your ads.txt says SSP X account 12345 is authorized, the DSP checks SSP X's sellers.json to confirm account 12345 belongs to you.
• 24% of ads.txt entries fail sellers.json cross-verification. This means a quarter of the lines in publisher ads.txt files don't match what SSPs report, based on BeamFlow's analysis of 120K+ domains.
• Publishers can't control sellers.json directly. SSPs maintain their own files. But publishers need to monitor them because SSP changes to sellers.json directly affect whether your ads.txt entries verify successfully.

---

What Is sellers.json? (And Why It Matters)

ads.txt tells the world who is authorized to sell your inventory.

sellers.json tells the world who those sellers actually are.

The two files work as a pair. Your ads.txt declares: "Account 12345 on SSP X is authorized to sell my inventory as a DIRECT relationship." The SSP's sellers.json responds: "Account 12345 belongs to Publisher Inc., their domain is publisher.com, and they are a PUBLISHER type seller."

When a DSP receives a bid request, it checks both files. If your ads.txt authorizes the seller and the SSP's sellers.json confirms the seller's identity matches, verification passes. If either file contradicts the other, verification fails. The bid doesn't happen.

IAB Tech Lab released the sellers.json specification in July 2019 as a companion to the OpenRTB SupplyChain object. Together with ads.txt, these three standards form the foundation of supply chain transparency in programmatic advertising.

How sellers.json Works

Every SSP (sell-side platform) and ad exchange maintains a sellers.json file at a standard location on their domain:

text
https://ssp-domain.com/sellers.json

For example:

• https://google.com/sellers.json
• https://pubmatic.com/sellers.json
• https://rubiconproject.com/sellers.json

The file is a JSON document containing an array of seller objects. Each seller object represents one entity that uses the SSP to sell advertising inventory.

Here's what a simplified sellers.json entry looks like:

json
{
  "seller_id": "pub-1234567890123456",
  "name": "Example Publisher Inc.",
  "domain": "example-publisher.com",
  "seller_type": "PUBLISHER"
}

The Key Fields

seller_id (required): The unique identifier for this seller on the SSP's platform. This is the same ID that appears in the publisher's ads.txt file as the account ID field. The seller_id is the link between the two files.

name (required): The legal or business name of the seller entity. For PUBLISHER types, this should be the publisher's company name. For INTERMEDIARY types, this is the name of the ad network or reseller.

domain (required): The business domain of the seller. For publishers, this is the domain where their content is hosted (e.g., example-publisher.com). This field is critical for verification because DSPs compare it against the domain in the bid request.

seller_type (required): One of three values:

• PUBLISHER: The entity owns the inventory. The SSP pays them directly. This corresponds to DIRECT entries in ads.txt.
• INTERMEDIARY: The entity doesn't own the inventory. They're reselling inventory from other publishers through this SSP account. This corresponds to RESELLER entries in ads.txt.
• BOTH: The entity operates as both a publisher (with their own inventory) and an intermediary (reselling others' inventory) under the same account. Used when the same seller_id handles both types.

is_confidential (optional): A flag indicating whether the seller's identity is hidden. When set to true, the name, domain, and seller_type may be omitted. Confidential entries reduce verification capabilities and some DSPs penalize or skip confidential sellers.

The Verification Flow in Practice

Here's how sellers.json fits into the full verification process when a DSP evaluates a bid request:

Step 1: DSP receives a bid request from SSP X for inventory on publisher.com, with seller ID pub-12345.

Step 2: DSP checks publisher.com/ads.txt for a line matching SSP X and seller ID pub-12345. Finds: ssp-x.com, pub-12345, DIRECT, f08c47fec0942fa0. The publisher authorizes this sale as DIRECT.

Step 3: DSP checks ssp-x.com/sellers.json for seller ID pub-12345. Finds:

json
{
  "seller_id": "pub-12345",
  "name": "Publisher Corp",
  "domain": "publisher.com",
  "seller_type": "PUBLISHER"
}

Step 4: DSP verifies alignment:

• ads.txt says DIRECT. sellers.json says PUBLISHER. These match. Check.
• sellers.json domain is publisher.com. The bid request domain is publisher.com. These match. Check.
• Verification passes. DSP bids.

Now here's a failure scenario:

Step 1-2: Same as above. ads.txt says DIRECT for seller ID pub-12345.

Step 3: DSP checks sellers.json. Finds:

json
{
  "seller_id": "pub-12345",
  "name": "Ad Network LLC",
  "domain": "adnetwork.com",
  "seller_type": "INTERMEDIARY"
}

Step 4: DSP sees the mismatch:

• ads.txt says DIRECT. sellers.json says INTERMEDIARY. Conflict.
• sellers.json domain is adnetwork.com, not publisher.com. Conflict.
• Verification fails. DSP rejects the bid.

The publisher labeled the relationship as DIRECT in their ads.txt, but the SSP's sellers.json shows that account belongs to an intermediary, not the publisher. The DSP can't trust the authorization chain.

Why sellers.json Matters to Publishers

Publishers don't create or maintain sellers.json files. SSPs do. But sellers.json directly affects publishers in several ways:

Your ads.txt accuracy depends on sellers.json

You might write a perfect ads.txt file. Correct account IDs. Correct relationship types. But if the SSP's sellers.json tells a different story about your account, verification fails. And you may have no idea.

SSPs update sellers.json at their discretion. They can change your seller_type, update the domain field, or reclassify your account without telling you. When they do, your previously correct ads.txt entry becomes a verification mismatch.

24% of entries fail cross-verification

BeamFlow's analysis of 120K+ publisher domains found that 24% of ads.txt entries fail sellers.json cross-verification. That's a quarter of all entries where the publisher's claim doesn't match the SSP's record.

These failures come from:

• Account ID mismatches: The ID in ads.txt doesn't exist in the SSP's sellers.json
• Relationship type conflicts: ads.txt says DIRECT but sellers.json says INTERMEDIARY (or vice versa)
• Domain mismatches: sellers.json lists a different domain than the publisher's actual domain
• Missing entries: The seller_id doesn't appear in sellers.json at all

You can't control it, but you need to monitor it

Since SSPs maintain their sellers.json files, you can't fix mismatches on their end. But you can:

• Monitor your entries in each SSP's sellers.json for changes
• Contact SSPs when you discover a mismatch
• Update your ads.txt to align with what sellers.json actually shows
• Choose SSPs that maintain accurate, transparent sellers.json files

sellers.json and Supply Path Optimization

DSPs use sellers.json data as a key input for supply path optimization (SPO). The file tells buyers:

Who the real sellers are. By checking seller_type and domain, DSPs can distinguish between publishers selling their own inventory and intermediaries reselling others' inventory.

How many hops exist in the supply path. If a bid request passes through multiple intermediaries, each one should appear in the SupplyChain object and each should be verifiable through their respective sellers.json files.

Whether the supply chain is transparent. Confidential entries (is_confidential: true) hide seller identity. DSPs running strict SPO may deprioritize or skip paths that include confidential sellers.

The shorter and more transparent the path, the more a DSP will bid. A DIRECT path verified through sellers.json is the gold standard. A RESELLER path through multiple intermediaries with confidential sellers is the lowest tier.

The Confidential Seller Problem

The sellers.json spec lets SSPs mark sellers as confidential. When a seller is confidential, their name, domain, and seller_type can be hidden. The entry shows the seller_id and the confidential flag, but nothing else.

json
{
  "seller_id": "99999",
  "is_confidential": 1
}

Confidential entries exist for business reasons (SSPs protecting competitive relationships), but they create a verification gap. A DSP can't verify the identity of a confidential seller. This means:

• The bid request can't be fully verified
• SPO algorithms may deprioritize the path
• Some DSPs may refuse to bid on inventory from confidential sellers
• Trust in the supply chain is reduced

If your SSP has your account marked as confidential, ask them to make it non-confidential. The transparency benefits (higher verification scores, better SPO treatment, increased buyer confidence) outweigh any confidentiality benefits.

How Big Are These Files?

sellers.json files can be massive. Major SSPs have tens of thousands of sellers. Google's sellers.json has over 100,000 entries. These files are multiple megabytes in size.

DSPs don't fetch these files in real time during auctions. They cache the data and refresh periodically (usually daily). This means changes to sellers.json take 24-72 hours to propagate to DSP verification systems.

Frequently Asked Questions

Can I view an SSP's sellers.json?

Yes. sellers.json files are public by spec. Visit https://[ssp-domain]/sellers.json in your browser. For example, https://google.com/sellers.json shows Google's complete seller directory. The file is JSON, so it may be hard to read in raw form, but browser extensions or JSON formatters make it readable.

What if my SSP doesn't have a sellers.json file?

Some smaller SSPs haven't implemented sellers.json. Without it, DSPs can't verify your authorization chain through that SSP. This hurts your verification scores and may reduce demand from buyers that require full supply chain transparency.

How do I find my entry in an SSP's sellers.json?

Search the file for your seller_id (the account ID from your ads.txt entry). In a browser, use Ctrl+F/Cmd+F and search for your ID. Verify the name, domain, and seller_type match your expectations.

What should I do if sellers.json shows incorrect information for my account?

Contact the SSP's support or your account manager. Provide the correct information (your business name, domain, and relationship type). Request that they update your entry. Follow up until the change is confirmed. Then re-verify.

How often do SSPs update sellers.json?

It varies by SSP. Major SSPs update frequently (some daily). Smaller SSPs may update less often. There's no standardized update cadence. This is why monitoring is important. Changes can happen at any time, and you won't be notified.