What is the SupplyChain Object?

The SupplyChain Object is an IAB Tech Lab standard that provides transparency into the digital advertising supply chain. It acts as a digital record, listing all parties that handle an ad impression as it travels from the publisher to the advertiser, helping to expose fraud and inefficiency.

The Definition: Unpacking the SupplyChain Object

Programmatic advertising created a complex and often opaque system. Advertisers frequently had little insight into who was handling their bids or where their ads were truly being displayed. This lack of visibility created opportunities for ad fraud, domain spoofing, and hidden intermediary fees.

The IAB Tech Lab introduced several standards to bring clarity to the ecosystem. The first major step was `ads.txt`, or Authorized Digital Sellers. This simple text file allows publishers to publicly declare which companies are authorized to sell their ad inventory.

Next came `sellers.json`. This standard required ad exchanges and Supply-Side Platforms (SSPs) to publish a file listing the publisher accounts they work with. This allowed advertisers and Demand-Side Platforms (DSPs) to verify the identity of the sellers listed in a publisher’s `ads.txt` file.

The SupplyChain Object, often abbreviated as `schain`, is the final and most critical piece of this transparency framework. It connects all the dots in real time for each individual ad auction. While `ads.txt` and `sellers.json` validate the potential participants, `schain` confirms the specific path an ad impression actually took.

It functions as a chain of custody for the ad impression. Every entity that touches the bid request on its way to the advertiser must add a piece of information. This creates a full, auditable trail that reveals every intermediary involved in the transaction.

The Technical Mechanics of `schain`

At its core, the SupplyChain Object is a piece of structured data, specifically a JSON object. This object is embedded within the bid request that flows from the publisher’s website through the ad tech ecosystem to the advertiser’s DSP.

The process begins when an ad slot on a publisher’s website becomes available. The publisher’s ad server or header bidding wrapper sends an ad request to its primary SSP. This first SSP is responsible for creating the `schain` object and adding the very first ‘node’ to it.

If this SSP then passes the opportunity to another ad exchange or reseller, that second entity is required by the IAB standard to append its own node to the chain. This continues for every single hop the bid request makes.

By the time the bid request reaches the final buyer, the DSP, it contains a complete `schain` object. The DSP’s bidding algorithm can then parse this object to understand the full history of the ad impression it is about to bid on.

This allows the DSP to make a much more informed decision. It can see if the path from the publisher was direct and efficient or if it was long, convoluted, and passed through several unknown intermediaries.

This information is vital for Supply Path Optimization (SPO). Advertisers want the shortest, most direct path to the publisher. A shorter path means fewer intermediary fees are taken out, so more of the advertiser’s dollar goes to the publisher, which often results in better ad performance.

The DSP can also use the data within the `schain` to verify the identity of each participant. It cross-references the information in each node with the publicly available `sellers.json` files to confirm that every seller is legitimate.

The `schain` object itself has a few key properties. The most important ones include:

• `complete`: A value of 1 (true) or 0 (false) that indicates whether all nodes in the supply chain have been included. A value of 0 is a red flag for buyers.
• `ver`: The version of the specification being used, for example, ‘1.0’.
• `nodes`: This is an array that contains a list of objects, where each object represents a single entity in the supply chain.

Each object, or node, within the `nodes` array contains its own set of critical fields:

• `asi`: The Advertising System Identifier. This is the domain name of the ad system that added the node (e.g., ‘google.com’ or ‘rubiconproject.com’).
• `sid`: The Seller ID. This is the unique identifier for the publisher or seller within that advertising system. This ID should match an entry in the system’s `sellers.json` file.
• `hp`: The Hop type. A value of 1 indicates this entity has a direct, payment relationship with the publisher. A value of 0 indicates it is an intermediary.
• `rid`: The Request ID. A unique identifier for the transaction, used for logging and debugging.
• `name`: The name of the seller, which can be cross-referenced with the `sellers.json` file.
• `domain`: The domain of the seller, which helps verify the final publisher.

Case Study A: The E-Commerce Brand and Brand Safety

An e-commerce company specializing in family-friendly apparel, let’s call them ‘BrandSafe Apparel’, noticed a problem. Their programmatic ad spend was increasing, but their brand safety scores were dropping, and customer complaints were rising about where their ads were appearing.

Upon investigation, they found their ads on websites with highly controversial and politically charged content. This directly contradicted their brand values. Their primary SSP was a well-known, trusted partner, so they were confused about how this was happening.

By analyzing the SupplyChain Object data in their DSP reports, they found the answer. While the first node in the chain was their trusted SSP, the bid requests were then being passed through a series of three additional, unknown resellers. These resellers were marked with `hp:0`, indicating they were intermediaries.

These intermediaries were buying the ad impressions and then reselling them on lower-quality, long-tail inventory that was not disclosed in the original bid request. BrandSafe Apparel was effectively paying a premium for inventory that was then arbitraged and placed on unsafe sites.

The Solution

The solution was swift and data-driven. The BrandSafe Apparel marketing team configured a new set of bidding rules within their DSP. They set a strict requirement that they would only bid on ad impressions where the SupplyChain had a maximum of two nodes.

Additionally, they required that the final seller ID (`sid`) in the chain must belong to a publisher on their pre-approved inclusion list. This immediately cut the fraudulent resellers out of their supply path. Their ads stopped appearing on inappropriate sites, and their wasted ad spend decreased by over 20% in the first month.

Case Study B: The B2B Company and Lead Quality

‘SaaSolutions Inc.’, a B2B software company, was running a programmatic display campaign to generate leads for its expensive enterprise product. The campaign was generating a high volume of form fills, but the sales team was complaining. The leads were extremely low-quality.

The submitted information came from students, competitors doing research, and sometimes completely fake profiles. The sales team was spending the majority of their time disqualifying leads instead of closing deals. The campaign’s cost-per-lead looked great on paper, but the cost-per-qualified-lead was astronomical.

The marketing team decided to audit their programmatic supply paths. They exported the SupplyChain data associated with every conversion. They found two alarming patterns in the data for the low-quality leads.

First, a large percentage of the converting impressions came from `schain` objects where the `complete` flag was set to `0`. This meant the full supply path was not being disclosed, which is a major red flag. Second, many of the seller IDs (`sid`) in the visible nodes did not correspond to any entry in the ad system’s public `sellers.json` file. They were bidding on misrepresented inventory.

The Solution

The fix involved implementing strict verification rules. Their DSP was configured to reject any bid request that did not have a complete SupplyChain Object (`schain.complete` must equal `1`). This alone filtered out a huge amount of suspicious traffic.

They also activated a feature to automatically verify every `sid` in the chain against its corresponding `sellers.json` file. Any bid request containing an unverified seller was immediately discarded. The total number of leads dropped, but lead quality increased by over 400%. The sales team was thrilled, and the campaign’s true ROI became clear.

Case Study C: The Publisher and Declining Revenue

‘GourmetFoodie.com’, a premium publisher with a large and loyal audience, noticed its programmatic CPMs had fallen by 30% over six months. Their direct-sold campaigns were performing well, but open auction revenue was in a freefall. Their ad ops team was under pressure to find the cause.

They spoke with some of their contacts at major advertiser brands. They were told that their ad inventory was frequently available for a much lower price through various other ad exchanges. This was confusing, as the publisher only worked with a small, select group of SSPs.

It turned out that unauthorized resellers were using domain spoofing techniques to misrepresent other, lower-quality inventory as being from GourmetFoodie.com. Because there was no SupplyChain Object in place, buyers’ DSPs had no way to distinguish the real inventory from the fake inventory. They were simply bidding on the cheaper, fraudulent supply.

The Solution

The publisher’s ad ops team took decisive action. First, they audited their `ads.txt` file, removing any partners who were not absolutely essential. This limited the number of authorized sellers. Second, and more importantly, they worked with their primary SSPs to ensure a proper SupplyChain Object was initiated for every single ad request originating from their site.

This `schain` would always have GourmetFoodie.com’s official seller ID as the first node in the chain, marked with `hp:1`. Legitimate buyers could now use this data to identify and prioritize the authentic supply path. They could filter out any bid requests claiming to be from the publisher but lacking the correct `schain` data.

Within two months, the fraudulent resellers were cut off from the demand. Buyers flocked back to the verified, authentic inventory, and the publisher’s CPMs not only recovered but surpassed their previous highs.

The Financial Impact of Implementation

Adopting the SupplyChain Object has a direct and measurable financial impact for both advertisers and publishers. It is not just a technical standard; it is a tool for financial efficiency and revenue protection.

For an advertiser, the ROI is calculated through waste reduction. Let’s consider a brand with a $1 million annual programmatic media budget. Industry reports consistently show that ad fraud, non-viewable impressions, and supply path inefficiencies can consume 15% to 25% of a budget.

By using `schain` data to bid only on verified, direct inventory, an advertiser can reclaim a large portion of that waste. A conservative 15% efficiency gain translates to $150,000 in savings. This money can be reinvested into working media, directly improving campaign performance and lowering the effective cost per acquisition (CPA).

For publishers, the financial impact comes from increased revenue. Transparency builds trust, and trust attracts higher bids. When buyers can verify the authenticity and directness of a publisher’s inventory, they are willing to pay a premium for it.

A publisher who correctly implements `schain` across their ad stack can expect to see their average CPMs in the open auction increase. A lift of 10% to 20% is a realistic outcome. For a site generating $1 million in programmatic revenue, that represents an additional $100,000 to $200,000 in high-margin income.

Furthermore, there is a significant financial risk in *not* adopting the standard. Many of the largest DSPs in the world now actively deprioritize or completely block bid requests that lack a valid and complete SupplyChain Object. Failing to implement it means becoming invisible to a growing portion of premium demand.

Strategic Nuance: Myths and Advanced Tactics

To fully benefit from the SupplyChain Object, it’s important to understand its strategic application and move beyond common misunderstandings.

Myths vs. Reality

Myth: SupplyChain Object is only for fighting ad fraud.
Reality: While fraud prevention is a primary benefit, its use in Supply Path Optimization (SPO) is equally important. By analyzing `schain` data, advertisers can find the most efficient, direct path to a publisher’s inventory. This reduces the number of intermediaries taking a cut, which means more of the ad spend reaches the publisher and the advertiser gets better value.

Myth: `ads.txt` is all you need for transparency.
Reality: `ads.txt` is a list of who is *authorized* to sell inventory. The SupplyChain Object is a record of who *actually handled* a specific ad impression. They are two sides of the same coin. `ads.txt` is the approved guest list for a party; `schain` is the video footage of who actually came through the door for a specific transaction.

Myth: It is too complex for my team to implement.
Reality: The most technically difficult part, which is creating and appending the nodes, is handled by SSPs and ad exchanges. For advertisers and publishers, the main task is to enable the feature and use the resulting data. Modern DSPs and publisher ad servers have made this a straightforward process of checking a box and interpreting reports.

Advanced Tips for a Competitive Edge

Analyze Chain Length: Do not just check for validity; analyze the length of the `nodes` array. A supply chain with more than three or four hops often indicates a high degree of arbitrage where value is being lost at each step. Set rules in your DSP to prioritize or bid exclusively on shorter chains.

Cross-Reference Seller IDs with Performance: Go beyond simple verification. Maintain an internal database that scores seller IDs (`sid`) based on your historical campaign performance. Prioritize bidding on `sid`s from trusted, high-performing publishers, creating your own private marketplace of quality.

Watch for Node Anomalies: A sophisticated red flag for fraud is an anomaly in the node structure. For example, if a node in the middle of the chain is marked as the final payment entity (`hp:1`), it is a clear sign of misrepresentation. The `hp:1` node should almost always be the first node in the chain. Configure alerts or filters to block any source that exhibits this behavior.

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)