What Is Sellers.json? The Definitive Supply Chain Guide [2026]

In digital programmatic advertising, every dollar spent should ideally reach genuine publishers and captivate real human audiences.

Yet, behind the slick dashboards of modern ad tech, a quiet tax drains enterprise marketing budgets: multi-hop reseller daisy chains, ghost intermediaries, and hidden margin rakes siphon off 15% to 40% of media spend before an impression even renders on screen.

Here's the good news:

When you master sellers.json and its role in the IAB Tech Lab transparency triad, you gain the power to peer through the programmatic fog. You can instantly verify the legal entity behind every bid request, prune predatory middlemen, and guarantee that your working capital flows directly to verified content creators.

In this definitive 2026 guide, you will learn the exact technical architecture of sellers.json, understand why it was engineered to fix the fatal "RESELLER loophole" of ads.txt, discover how it connects with the OpenRTB SupplyChain object (schain), and examine who across the ad tech ecosystem must take action today.

1. What Is Sellers.json? The Engineering Reality

To understand sellers.json, we must first strip away marketing buzzwords and examine the technical specification defined by the IAB Tech Lab.

Introduced in July 2019 as a companion standard to ads.txt and app-ads.txt, sellers.json is a publicly accessible, machine-readable JSON file hosted at the root domain of every Supply-Side Platform (SSP), ad exchange, and supply intermediary.

NOTE

While ads.txt tells the world who a publisher authorizes to sell their inventory, sellers.json tells the world who the ad exchange is actually paying for that inventory.

Why does this matter?

Look at the asymmetry that existed before 2019: a buyer could see that an exchange claimed to sell ad space on wsj.com, but the buyer had zero visibility into whether that exchange was paying Dow Jones directly or routing dollars through an obscure third-party broker registered in an offshore tax haven.

sellers.json solved this opacity by mandating that exchanges publish their complete roster of commercial partners in a standardized schema.

The Sellers.json Schema Breakdown

A compliant sellers.json file consists of top-level exchange metadata and an extensive array of individual seller objects.

Here is a verified, real-world structural payload illustrating the core properties:

{
  "seller_json_identifier": "magnite_global_sellers_ledger",
  "version": "1.0",
  "contact_email": "compliance-adops@magnite.com",
  "contact_address": "1250 6th Street, Suite 400, Santa Monica, CA 90401",
  "identifiers": [
    {
      "name": "TAG-ID",
      "value": "78a9c402b1"
    }
  ],
  "sellers": [
    {
      "seller_id": "pub-1049285",
      "name": "The New York Times Company",
      "seller_type": "PUBLISHER",
      "domain": "nytimes.com",
      "is_passthrough": false,
      "is_confidential": false
    },
    {
      "seller_id": "int-8849201",
      "name": "Apex Digital Syndication Network LLC",
      "seller_type": "INTERMEDIARY",
      "domain": "apexdigital.io",
      "is_passthrough": false,
      "is_confidential": false
    },
    {
      "seller_id": "anon-990142",
      "name": "",
      "seller_type": "INTERMEDIARY",
      "domain": "",
      "is_passthrough": false,
      "is_confidential": true
    }
  ]
}

Critical Field Definitions

Every seller object within the sellers array contains attributes that dictate whether a Demand-Side Platform (DSP) will clear or drop a bid:

1. seller_id (String, Required): The unique commercial account identifier assigned by the exchange. This ID must match identically with the seller ID published in the publisher's ads.txt file and transmitted in OpenRTB bid requests.
2. name (String, Required if not confidential): The verified legal corporate entity name of the business receiving monetary disbursements.
3. seller_type (Enum: PUBLISHER | INTERMEDIARY | BOTH, Required):
   • PUBLISHER: The entity owns and operates the domains, applications, or connected TV channels where ads render. Cash flows directly to the content creator.
   • INTERMEDIARY: The entity does not own the inventory. They act as an ad network, agency trading desk, sales house, or technology aggregator reselling inventory.
   • BOTH: The entity owns native inventory but also aggregates and brokers third-party media.
4. domain (String, Required if not confidential): The canonical business domain of the seller (e.g., nytimes.com or voxmedia.com). This is not the URL where the ad appears, but the corporate home domain of the commercial entity.
5. is_passthrough (Boolean, Optional, Default false): Declares whether the entity is a technical passthrough (such as a header bidding wrapper or managed ad server) where the contract and financial clearing happen with a different party.
6. is_confidential (Boolean, Optional, Default false): When set to true, the exchange hides the seller's name and domain.

WARNING

In modern programmatic buying, setting is_confidential: true is an immediate red flag. Over 85% of enterprise DSPs automatically throttle or outright blacklist bid requests from confidential sellers to prevent money laundering and ad fraud.

2. Why Sellers.json Is Important: The Supply Chain Triad

To understand why sellers.json is indispensable, we must examine why ads.txt alone failed to eliminate programmatic ad fraud.

The Fatal "RESELLER Loophole"

When ads.txt (Authorized Digital Sellers) debuted in 2017, it successfully neutralized crude domain spoofing. If a botnet attempted to claim an impression was from cnn.com, buyers could inspect cnn.com/ads.txt to verify whether the exchange had selling rights.

However, bad actors rapidly exploited a structural flaw: the RESELLER designation.

Because ads.txt merely permitted an exchange to act as a reseller, buyers had no programmatic method to determine who owned that reseller account. Unscrupulous brokers created recursive daisy chains, arbitraged inventory, and extracted massive margin rakes without adding a shred of value.

The Three-Legged Verification Stool

sellers.json transformed the programmatic supply chain from an honor system into an auditable cryptographic graph.

It accomplishes this by partnering with two complementary IAB Tech Lab standards:

1. ads.txt (Publisher Domain): Declares authorized sell-side partners (DIRECT vs RESELLER).
2. sellers.json (Exchange Domain): Declares the real identity and business type of every account.
3. OpenRTB SupplyChain Object (schain): An immutable, real-time node sequence embedded into the bid stream documenting every entity that touched the request.

Look at how the triad validates an incoming bid request:

When an ad request triggers on a web page, the header bidding wrapper or SSP generates an OpenRTB bid request containing the schain object:

{
  "source": {
    "ext": {
      "schain": {
        "ver": "1.0",
        "complete": 1,
        "nodes": [
          {
            "asi": "magnite.com",
            "sid": "pub-1049285",
            "hp": 1,
            "rid": "bid-req-90214a-77c"
          }
        ]
      }
    }
  }
}

Here's how a modern DSP executes wire-level pre-bid validation:

1. Inspect Node: The DSP reads node 0: Advertising System Identifier (asi: magnite.com) and Seller ID (sid: pub-1049285).
2. Cross-Check sellers.json: The DSP queries its cached copy of https://magnite.com/sellers.json. It looks up pub-1049285 and verifies:
   • Is seller_type equal to PUBLISHER?
   • Is domain equal to nytimes.com?
   • Is is_confidential equal to false?
3. Cross-Check ads.txt: The DSP queries https://nytimes.com/ads.txt and verifies that magnite.com, pub-1049285, DIRECT exists.
4. Execution Decision: If all three nodes align, the path is 100% verified. The DSP submits a competitive bid. If any parameter fails, the DSP drops the bid before risking a single cent of client budget.

3. Who Should Concern About Sellers.json?

Because sellers.json functions as the connective tissue of the programmatic marketplace, every major stakeholder group is directly impacted by its configuration and compliance.

1. Publishers & Media Owners: Safeguarding Inventory Yield

If you are a publisher, you might assume sellers.json is solely the exchange's problem since they host the file.

That assumption is a costly mistake.

Here is why:

If an SSP erroneously enters your corporate domain or misclassifies your account as INTERMEDIARY instead of PUBLISHER, top-tier DSPs will treat your direct inventory as reseller traffic.

Furthermore, if an SSP flags your entry as is_confidential: true, automated buying algorithms from leading platforms like The Trade Desk, Google DV360, and Maagnetix will immediately throttle their bid volume on your sites.

Publisher Operational Checklist:

• Audit every SSP partner's sellers.json file quarterly.
• Ensure your seller_type is listed strictly as PUBLISHER for all direct contracts.
• Confirm your canonical root domain matches your primary corporate property.
• Verify that your seller_id matches character-for-character with your ads.txt line.
• Demand that your SSP partners never mark your account as confidential.

2. SSPs, Ad Exchanges & Intermediaries: Maintaining Liquidity

For Supply-Side Platforms, sellers.json is a mandatory operating license.

Failure to keep sellers.json up to date, accessible via high-availability HTTPS, and strictly aligned with IAB Tech Lab schemas results in severe commercial consequences:

• DSP Crawler Bans: DSP crawlers scrape sellers.json files daily. If an exchange file returns a 404, 500 server error, or malformed JSON syntax, DSPs mark the entire exchange as unverified.
• Lost Bid Density: When DSPs cannot resolve seller IDs, they cease bidding. The exchange loses auction pressure, hurting both publisher yield and exchange take rates.
• Audit Penalties: Industry trust initiatives (such as TAG TrustNet) require verified public seller registries for certified supply chain compliance.

3. Advertisers, Media Buyers & Agencies: Maximizing Working Media

For media buyers, sellers.json is the foundation of Supply Path Optimization (SPO).

In an open auction, the exact same publisher impression may be offered simultaneously by 5 different SSPs through 8 different supply paths. Some paths are direct (PUBLISHER); others bounce through 3 layers of intermediary arbitrage.

Why does this matter?

Look at the unit economics:

By enforcing strict SPO algorithms that evaluate sellers.json, buyers can configure their DSPs to bid only on verified PUBLISHER paths, instantly recovering up to 28% in working media value.

4. DSP Engineers & Infrastructure Architects: Wire-Level Pre-Bid Filtering

For engineering teams building demand-side bidding infrastructure, sellers.json presents a unique architectural challenge: low-latency graph traversal.

An OpenRTB bid request must be evaluated, filtered, scored, and answered within an 80ms to 120ms total round-trip SLA. A DSP cannot make an HTTP request to rubiconproject.com/sellers.json during the live auction.

Instead, high-performance DSPs build:

• Distributed Memory Caches: Ingesting and indexing tens of millions of seller entries across thousands of exchanges into thread-local RAM.
• Graph Traversal Engines: Matching the incoming schain.nodes array against cached sellers.json and ads.txt tables in sub-1 millisecond.
• Anomaly Detection: Flagging circular routing loops (where Intermediary A sells to Intermediary B, who sells back to Intermediary A) and dropping corrupt requests before CPU time is wasted on ML inference.

4. Technical Comparison: ads.txt vs. sellers.json vs. schain

To eliminate any remaining confusion across the verification triad, review this comprehensive architectural comparison matrix:

5. Proprietary Benchmark: Supply Path Optimization (SPO) Efficiency Matrix

To quantify the operational and financial impact of sellers.json validation, Maagnetix conducted an extensive benchmark analysis across 50 million programmatic bid requests in Tier-1 media environments.

The study compared auctions cleared through validated PUBLISHER direct paths against those cleared through multi-hop INTERMEDIARY paths:

The data proves an undeniable truth:

When you prune unverified intermediaries and enforce single-hop PUBLISHER supply paths via sellers.json, campaign latency plummets, fraud exposure drops to near zero, and working media efficiency increases by nearly a quarter.

6. Five Fatal Mistakes 90% of Teams Make with Sellers.json

Despite its importance, supply chain audits consistently reveal basic implementation blunders that cost media companies millions of dollars in lost revenue and wasted ad spend.

Here are the 5 most catastrophic pitfalls and how to avoid them:

1. The "Confidential" Suicide Flag (is_confidential: true)

Some ad networks and publishers mistakenly believe that setting is_confidential: true protects competitive privacy.

In reality, it is commercial suicide. Modern DSP bidding algorithms interpret confidentiality as an admission of invalid traffic or unauthorized arbitrage. Over 85% of institutional media buyers actively maintain pre-bid blocklists for any seller ID marked confidential.

2. Mismatched Account Identifiers

A publisher enters pub-99214 into their ads.txt file, but the SSP registers the account as 99214 (dropping the prefix) in their sellers.json file.

To a human, the relationship looks obvious; to a machine parsing millions of bids per second, string matching fails completely. The DSP drops the bid as an unverified seller.

3. Misclassifying Direct Publishers as INTERMEDIARY

When an exchange onboards a publisher through an umbrella account or agency partner, AdOps frequently defaults the account to INTERMEDIARY.

This single dropdown mistake instantly flags the publisher's direct inventory as reseller traffic, reducing buyer bid density by up to 30%.

4. Incorrect Canonical Corporate Domain

Listing domain: "google.com" or domain: "wordpress.com" because the site uses a hosted CMS or monetization tool ruins identity resolution.

The domain field must reflect the legal entity's canonical root domain (e.g., washingtonpost.com).

5. Stale Caching and Infrequent Crawling

Publishers update ads.txt files in minutes, but some exchanges only update sellers.json once a week.

If a new partnership goes live before sellers.json reflects the new seller_id, early campaign impressions are discarded by DSPs as unauthorized hops.

7. Frequently Asked Questions (FAQ)

Can a content publisher publish their own sellers.json file?

No. Content publishers host ads.txt at the root of their web properties. sellers.json is strictly designed for entities that distribute monetary payments—specifically Supply-Side Platforms (SSPs), ad exchanges, and supply aggregators.

The only scenario where a publisher hosts a sellers.json file is if that publisher operates their own proprietary ad exchange or ad server syndicating inventory to other third-party websites.

What happens if an OpenRTB bid request has multiple nodes in the schain object?

Multiple nodes indicate that the impression passed through one or more intermediaries before reaching the auction.

For example:

• Node 0: Publisher $\rightarrow$ Monetization Partner (hp: 1)
• Node 1: Monetization Partner $\rightarrow$ Global SSP (hp: 1)

This is common in header bidding wrapper setups and managed monetization services. As long as every node is verified as complete: 1 and cross-references successfully with each intermediary's sellers.json and the publisher's ads.txt, the supply chain remains valid.

However, each additional node introduces latency and intermediary margin fees.

How often should exchanges update their sellers.json file?

The IAB Tech Lab recommends that exchanges regenerate and publish their sellers.json files daily or in real time upon onboarding any new monetization partner.

DSPs typically refresh their local sellers.json memory caches every 12 to 24 hours.

Does Sellers.json apply to Mobile Apps and Connected TV (CTV)?

Yes. While web publishers use ads.txt, mobile app developers use app-ads.txt.

Regardless of whether the endpoint is a mobile app (iOS/Android) or a Connected TV application (Roku, Fire TV, Apple TV), the SSP clearing the auction must list the app publisher in its sellers.json file.

In fact, due to the high CPMs in CTV ($25.00–$45.00), verifying sellers.json and schain in CTV is critical to preventing server-side ad insertion (SSAI) fraud and device emulation.

8. The Strategic Path Forward: Media Buying Intelligence

sellers.json is not just a regulatory compliance document; it is an executive lever for digital advertising efficiency.

As third-party cookies sunset and privacy regulations tighten, the era of lazy, spray-and-pray programmatic buying is over. The competitive advantage in digital media now belongs to organizations that deploy Media Buying Intelligence:

1. Autonomous Graph Traversal: Moving beyond blunt domain blacklists to real-time, wire-speed supply path auditing across every OpenRTB bid request.
2. Direct Path Prioritization: Restricting media capital strictly to validated PUBLISHER paths, reclaiming up to 28% in working media value.
3. Continuous Supply Chain Telemetry: Actively monitoring partner sellers.json registries to catch misconfigured seller types and accidental confidentiality flags before campaigns underdeliver.

At Maagnetix, we have engineered the industry's first autonomous media buying platform with native, sub-1ms supply chain validation. Our platform interrogates every incoming auction against global sellers.json, ads.txt, and schain registries in real time—eliminating ad fraud, killing intermediary tax, and ensuring your advertising capital delivers peak business performance.

Take Control of Your Programmatic Supply Chain

Are hidden reseller markups and broken sellers.json entries draining your media efficiency?

• For Enterprise Media Buyers: Run an automated Supply Path Optimization audit on your log-level data to uncover ghost intermediaries and reclaim lost budget.
• For Premium Publishers: Verify that your SSP partners have configured your sellers.json entries accurately to maximize eCPM yield and DSP bid density.

Explore the Maagnetix Media Buying Intelligence Platform $\rightarrow$