What is Sellers.json?

Sellers.json is an IAB Tech Lab standard that increases transparency in the programmatic advertising supply chain by allowing buyers to identify all entities who are either direct sellers of or intermediaries in a digital advertising opportunity. It provides a public file that maps seller IDs to their legal business names and domains.

The Definition: Bringing Clarity to a Complex Supply Chain

Programmatic advertising was once a notoriously opaque market. Advertisers spent money with little certainty about where their dollars were truly going, and publishers often saw their inventory resold without their knowledge or consent. This lack of transparency created fertile ground for ad fraud and inefficiency.

To fix this, the IAB Technology Laboratory introduced a series of transparency standards. The first major step was `ads.txt`, which allows publishers to publicly declare which companies are authorized to sell their digital inventory. This was a significant improvement, but it only told one side of the story.

While `ads.txt` confirmed *who* could sell, it didn’t always clarify the identity of the final seller. An advertiser might see an authorized seller ID in a bid request, but they wouldn’t know the legal business entity tied to that account. Is it the publisher themselves or a third-party reseller?

Sellers.json was created to answer that question. It works as a companion to `ads.txt`. Ad exchanges and Supply-Side Platforms (SSPs) host a publicly accessible `sellers.json` file, creating a directory of all their sellers. This file gives buyers a way to look up a seller ID and discover the company’s legal name and whether they are the direct publisher or an intermediary.

Together, these standards create a verifiable chain of custody for ad inventory. Buyers can now cross-reference the information in a bid request with both the publisher’s `ads.txt` file and the exchange’s `sellers.json` file. This process verifies the entire supply path, from the advertiser’s bid to the publisher’s site.

Technical Mechanics: How Sellers.json Works Under the Hood

The core function of Sellers.json is to provide a lookup mechanism. It connects the abstract `seller_id` found in bid requests and `ads.txt` files to a concrete, real-world business entity. The process relies on a simple, publicly hosted file and coordination between publishers, SSPs, and Demand-Side Platforms (DSPs).

First, every SSP or ad exchange is required to host a `sellers.json` file at the root of their domain. For example, if an exchange operates on `example-ssp.com`, their file will be located at `https://example-ssp.com/sellers.json`. This predictable location allows any party, especially DSPs, to crawl and cache these files easily.

This file contains a single JSON object with a list of sellers. Each seller in that list is represented by their own JSON object containing several key fields. The most important of these are `seller_id`, `name`, `domain`, and `seller_type`. These fields provide the essential information a buyer needs to verify the seller’s identity.

The `seller_id` is the unique identifier for the account on the SSP’s platform. This is the same ID that a publisher would list in their `ads.txt` file. The `name` field contains the legal name of the business entity being paid for the inventory, while `domain` is their business domain.

Perhaps the most critical field for transparency is `seller_type`. This field can have one of three values: `PUBLISHER`, `INTERMEDIARY`, or `BOTH`. A `PUBLISHER` type indicates that the seller is the direct owner of the website and content, receiving direct payment for the inventory.

An `INTERMEDIARY` type means the seller is not the direct publisher. Instead, they are a reseller, an ad network, or another third party that does not have a direct contract with the website owner for ad payment. They are reselling inventory they have acquired from another source.

The `BOTH` value is used for entities that operate in both capacities. For example, a large media company might directly own and sell inventory for some properties (`PUBLISHER`) while also reselling inventory from smaller, affiliated blogs (`INTERMEDIARY`).

Now, let’s see how it all connects during an ad auction. An advertiser’s DSP receives a bid request for an ad impression. The DSP checks the publisher’s `ads.txt` file to confirm the exchange and `seller_id` are authorized. Then, the DSP looks up that exchange’s `sellers.json` file and finds the entry matching the `seller_id`.

By reading the `seller_type` and `name` from the `sellers.json` file, the DSP can make an informed decision. It can confirm it is buying from the actual publisher or a known, trusted intermediary. This simple lookup prevents fraudulent actors from misrepresenting low-quality inventory as premium publisher sites.

Key Fields in a Sellers.json File

Understanding the specific fields within the file is crucial for both buyers and sellers. While there are several fields, a few are central to the verification process.

• `seller_id`: (String, Required) An opaque identifier for the seller account on the exchange’s system. This must match the ID listed in the publisher’s `ads.txt` file.
• `name`: (String, Required) The legal business name of the seller. This is the entity that gets paid.
• `domain`: (String, Required) The business domain of the seller. For example, `clickpatrol.com`.
• `seller_type`: (String, Required) Can be `PUBLISHER`, `INTERMEDIARY`, or `BOTH`. This clarifies the seller’s relationship to the ad inventory.
• `is_confidential`: (Integer, Optional) A value of `1` indicates the seller has chosen not to disclose their name and domain. Buyers typically treat confidential inventory with high suspicion and may choose not to bid on it.
• `comment`: (String, Optional) A human-readable string that can provide additional context about the seller.

Case Studies: Sellers.json in Action

Theoretical knowledge is useful, but real-world examples show the true impact of this standard. Let’s examine three distinct scenarios where Sellers.json played a key role in solving a problem.

Scenario A: The E-commerce Brand Losing Ad Spend

An online retailer specializing in high-end athletic wear was running a large programmatic display campaign. Their goal was to associate their brand with premium sports news and fitness websites. They provided their agency with a specific inclusion list of domains to target.

Despite this, their campaign performance was poor. Click-through rates were low, and conversions were almost non-existent. Worse, brand safety reports showed their ads appearing on low-quality, made-for-advertising (MFA) websites that were clearly not on their target list.

The investigation began by auditing the supply paths in their DSP reports. They discovered that while the domain in the bid request often matched their target list, the `seller_id` belonged to unknown entities. By cross-referencing these IDs with the exchanges’ `sellers.json` files, they found the problem.

A huge portion of their budget was flowing to sellers marked as `INTERMEDIARY`. These were ad arbitrage players who were buying cheap inventory on MFA sites and misrepresenting it as premium domains. The e-commerce brand was effectively buying fraudulent inventory.

The fix was immediate and decisive. The agency configured the DSP campaign settings to bid only on inventory where the `seller_type` in the corresponding `sellers.json` file was `PUBLISHER`. They also created a small, highly-vetted inclusion list of trusted intermediary partners.

The results were dramatic. Within a week, their ads were appearing on the correct, brand-safe websites. ROAS (Return on Ad Spend) for the campaign increased by over 150%, as the wasted spend on fraudulent inventory was eliminated. The brand was now paying for real access to their target audience.

Scenario B: The B2B Company Drowning in Bad Leads

A B2B software company targeting enterprise-level financial institutions was using display advertising for lead generation. They were targeting a specific set of financial news and analysis websites. While the campaign generated a high volume of form fills, the sales team was complaining.

The leads were consistently low quality. The contact information was often fake, and the companies listed were small businesses or from unrelated industries, not the enterprise finance firms they were targeting. The sales team’s productivity plummeted as they spent their days disqualifying junk leads.

Using a supply path optimization (SPO) tool, the marketing team analyzed their ad buys. They found that their DSP, in an attempt to achieve scale, was buying from dozens of different supply paths for the same publisher. Many of these paths led back to `INTERMEDIARY` sellers.

These resellers were not reaching the intended audience. Instead, they were using various methods to generate cheap clicks and form fills, which had no real purchase intent. The `sellers.json` data clearly showed that the company was paying obscure entities, not the premium financial publishers they intended.

The solution was to prune their supply chain. The team identified the `seller_id` for each of their target publishers directly from their `ads.txt` files. They then built a strict inclusion list in their DSP containing only these direct, `PUBLISHER`-type seller IDs.

As a result, the total volume of leads dropped by 70%. However, the quality of the remaining leads was exceptionally high. The cost-per-qualified-lead (CPQL) fell by 45%, and the sales team’s morale and efficiency improved as they began engaging with genuine prospects from their target market.

Scenario C: The Publisher with Plummeting Revenue

A well-respected digital magazine focused on technology trends noticed a concerning trend in their programmatic revenue reports. Their CPMs (cost per mille) were declining, and the fill rate from one of their main SSP partners had dropped significantly, despite stable website traffic.

The publisher’s ad operations team started digging. They suspected their inventory was being devalued somewhere in the supply chain. Using crawlers to check various exchanges, they found numerous unauthorized resellers listing their domain for sale.

These bad actors were essentially creating counterfeit versions of the publisher’s inventory. Buyers in the ecosystem saw the same inventory available from multiple sources, some legitimate and some not. This confusion led many DSPs to de-prioritize the publisher’s domain or bid much lower due to the perceived risk of fraud.

To fix this, the publisher took control of their supply chain. First, they updated their `ads.txt` file to be extremely precise, removing any old or non-essential partners and ensuring every entry was marked `DIRECT`. Second, they worked with their authorized SSPs to verify their `sellers.json` entries were correct, with their legal name and a `seller_type` of `PUBLISHER`.

Finally, they proactively monitored the ecosystem for unauthorized sellers and sent formal requests to exchanges to remove them. By cleaning up their authorized paths and ensuring their `sellers.json` identity was clear, they presented a single, trustworthy source of inventory to buyers.

Within a few weeks, the publisher’s CPMs began to recover. Buyers, now able to confidently identify the legitimate supply path, consolidated their bids on the authorized SSPs. The publisher’s revenue not only returned to its previous levels but exceeded them, as trust in their inventory was restored across the programmatic market.

The Financial Impact of Transparency

The implementation of Sellers.json has a direct and measurable financial impact for both honest advertisers and publishers. It directly combats the hidden costs often referred to as the “ad tech tax”. This term describes the portion of an advertiser’s dollar that is siphoned off by various intermediaries before it ever reaches the publisher.

In a non-transparent supply chain, this tax can be substantial. An advertiser might bid $10.00 CPM for an impression. That bid could pass through multiple resellers, each taking a cut. By the time the payment reaches the publisher, they might only receive $4.00, with $6.00 (60%) consumed by the supply chain.

Sellers.json gives advertisers the data to fight this. By analyzing `seller_type` data, a buyer can choose to purchase inventory through the most direct path possible. Instead of buying from a long chain of intermediaries, they can buy from the SSP that has a direct contract with the publisher.

In this optimized scenario, the advertiser’s $10.00 bid might only have one stop: the publisher’s chosen SSP. The SSP takes its standard fee, perhaps 15-20%. The publisher now receives $8.00-$8.50. This is a massive improvement for both sides.

The advertiser benefits because more of their money is going toward purchasing high-quality media, which improves campaign performance and ROAS. The publisher benefits by capturing a much larger share of the advertiser’s budget, allowing them to invest more in creating quality content. It creates a healthier, more efficient, and more sustainable digital advertising ecosystem.

Strategic Nuance: Beyond the Basics

Simply knowing what Sellers.json is isn’t enough to gain a competitive advantage. True expertise lies in understanding its limitations and using it as part of a broader strategy. This involves debunking common myths and applying advanced tactics.

Myths vs. Reality

Myth: Sellers.json and `ads.txt` completely eliminate all ad fraud.
Reality: These standards are highly effective against specific types of fraud, namely domain spoofing and unauthorized reselling. However, they do not prevent other forms of invalid traffic, such as bots viewing ads on an otherwise legitimate publisher’s website. They are essential tools, but they must be paired with comprehensive ad fraud detection solutions.

Myth: Advertisers should always block any seller with the `INTERMEDIARY` type.
Reality: While it’s wise to be skeptical of unknown intermediaries, a blanket block is too simplistic. Some intermediaries provide real value. For instance, they might bundle inventory from niche blogs that are too small to have direct SSP relationships, or they might offer unique ad formats. The correct strategy is not to block all intermediaries, but to curate an inclusion list of vetted, trusted partners who demonstrably add value.

Advanced Tips for Advertisers

Go Beyond Verification with SPO: Use Sellers.json data as a primary input for Supply Path Optimization (SPO). Don’t just verify sellers; analyze the paths. You may find you can access the same publisher through five different SSPs. Analyze performance data to see which SSP provides the most efficient, direct, and highest-performing path to that inventory and consolidate your spend there.

Cross-Reference with the SupplyChain Object: For ultimate transparency, correlate Sellers.json data with the `schain` object passed in the bid request. While `sellers.json` gives you the identity of the final seller, the `schain` object provides a hop-by-hop record of every entity that touched the impression. Using them together gives you a complete, verifiable picture of the entire supply chain for every single bid.

Audit Your SSP Partners: Don’t just set and forget. Periodically crawl and analyze the `sellers.json` files of the SSPs you work with. Are they being updated regularly? Is there a sudden increase in sellers marked as `is_confidential`? A high percentage of opaque or new, unknown intermediaries can be a red flag about the quality of that SSP’s network.

Abisola

Meet Abisola! As the content manager at ClickPatrol, she’s the go-to expert on all things fake traffic. From bot clicks to ad fraud, Abisola knows how to spot, stop, and educate others about the sneaky tactics that inflate numbers but don’t bring real results.

View all posts by Abisola (Abisola)