While programmatic advertising has become incredibly advantageous in the digital advertising world, it still faces its own set of obstacles that can get in the way of real-time bidding.
Arguably, the biggest obstacle standing in the way for both advertisers and publishers is ad fraud.
Ad fraud is becoming increasingly problematic for all parties involved in digital advertising. It generates tons of invalid traffic, which means advertisers are paying for false impressions. In turn, this deflates the value of ad inventory, which directly affects publishers as it significantly diminishes their profits.
This is precisely why the IAB Tech Lab has introduced Sellers.json and the OpenRTB Supply Chain Object.
When implemented correctly, Sellers.json and OpenRTB work together to enable buyers and sellers on real-time digital advertising platforms to identify any shady players, thus increasing trust among participating parties — and hopefully, increasing profits.
What Exactly is Sellers.json?
In technical terms, Sellers.json is a JSON file that gets hosted on the server-side platform’s (SSP) website. It typically provides a list of any and all authorized direct sellers or intermediaries bidding in real-time.
In more general terms, Sellers.json is a file designed to enable all parties involved in programmatic ad bidding to request and track the “entities” behind each opportunity. Essentially, this file maintains the mapping and relationship between all existing vendors and their identifiers within a given ad auction.
Ultimately, the goal is to give ad buyers and sellers more visibility into each step of the bidding event to create more transparency within the entire programmatic ecosystem. That includes steps like sending a bid response to serving an ad. This shows more transparency regarding where an advertiser’s money is going.
The premise is that by creating more transparency within the programmatic bidding ecosystem, the capacity to identify and prevent ad fraud, as well as unauthorized supply sources, will be greater.
How Does Sellers.json Work?
Sellers.json works by acting as an identification source (you can think of it as an ID card) for all ad tech players participating in the selling process of a live bidding auction.
With Sellers.json implemented, SSPs and exchanges have to provide a list of all their authorized resellers and publishers as well as their seller IDs and any other details regarding their partners. Each seller ID (denoted as seller_id) must map to an individual reseller or publisher, meaning that a single entity cannot have multiple seller IDs within a real-time advertising system.
When it comes to the tasks of the SSP, their responsibility is to store the following details:
- The name of the publisher
- The domain of the publisher
- The publisher’s account ID
- The type of relationship, i.e., sellers or resellers
For example, when a publisher wants to make their information transparent with the sellers.json file, here is what the advertiser will see:
“seller_Id”: “pub-1234789066554848”,
“seller_Type”: “PUBLISHER”,
“name”: “Publisher’s company name”,
“domain”: “example.com”
This information lets the advertiser know exactly who they’re working with, so they can track the publisher’s information back to the domain source to ensure that they aren’t a fake entity created to flood websites with invalid traffic.
Let’s pretend that a random user is visiting your website. As soon as this happens, a bid request gets sent to all the advertisers on the bidding platform to return their bids so that they can serve their ads.
Of course, the advertiser with the highest bid wins. However, the thing that helps these advertisers bid seamlessly and garner the safest and most direct path in their bid selling is the Sellers.json file.
The very presence of the Sellers.json file is what gives advertisers an idea of how many pathways they’re actually going through to purchase their ad inventory, which allows them to make smarter purchase decisions.
It also creates transparency, enabling the advertisers to see if any players on the platform are shady (such as the type that would diminish their credibility by producing invalid traffic).
So, if an advertiser bids on specific inventory for a dollar, having any shady players present would likely cause the bid to diminish to about 50 cents before it reaches the publisher.
How Does it Differ From Ads.txt and App-ads.txt Files?
You can think of Sellers.json as a step up from ads.txt and app-ads.txt, which are also both ad fraud prevention files.
JSON itself is not a txt file. A txt, or text file, contains a sequence of characters in a “human-readable” form that can be encoded into computer-readable formats. Additionally, txt files aren’t very flexible and tend to be more prone to error.
JSON stands for JavaScript Object Notation. It’s a data-interchange format that’s also human-readable. JSON is used to transmit data, specifically between web applications and servers, and are typically built into dictionaries in Python.
Another significant difference is that ads.txt and app-ads.txt were designed to crack down on two specific types of ad fraud: unauthorized reselling of inventory and domain spoofing, respectively. Essentially, the two file types enable buyers to get a peek at what kind of ad tech vendors that publishers have authorized to sell their inventory.
They fall short when you consider that ad tech vendors are buying and selling various impressions on open exchange platforms that include a multitude of intermediaries and resellers. This creates an intricate web of players that become involved in the sale of every single impression, which makes it nearly impossible to keep track of all the resellers and whether or not they’re authorized to sell by the specific vendor.
Now, with Sellers.json, the supply-side platform is able to publish a mapping list directly into its root domain. This is what enables that intricate web of players to become identifiable via mapping and tracking.
Why Sellers.json Is So Beneficial
The goal of Sellers.json is to provide the demand side and publishers within the digital advertising ecosystem with more transparency within the programmatic ad tech space.
Transparency in terms of preventing ad fraud has been one of the top concerns regarding programmatic advertising for quite a long time now, and the introduction of the Sellers.json file is seen as a very large step in the right direction to make programmatic advertising much more trustworthy and fair to all players involved.
Additionally, by combating ad fraud, brands can be more confident about the inventory they are buying, which means that Sellers.json also indirectly impacts brand safety. It also brings full transparency to the table to all of the intermediaries that participate in each bid sale request.
Sellers.json also allows for smaller payloads or bid request object sizes, as it provides a direct and transparent source of information as opposed to the traditional way — which involves supplying limited information as a condition with each bid request.
Knowing exactly who you’re engaging with when it comes to the sale of an impression not only helps prevent ad fraud, but also builds more trust among advertisers. It increases accountability by incentivizing sellers to conduct their bidding business openly and honestly, which in turn provides more value, generating more ad revenue.
By using Sellers.json, advertisers can help their ad partners reach their target audiences more efficiently since those partners have a better understanding of the supply path. This allows them to shift their focus to the paths that generate the most value per dollar spent.
In the end, everybody wins.
But What About the OpenRTB Supply Chain Object?
As mentioned much earlier, Sellers.json was designed to work directly with OpenRTB Supply Chain Object.
The Supply Chain Object enables buyers to view all the parties that are selling or reselling any given bid request. It’s the technical parameter that is sent into each ad call to indicate all the intermediaries involved in the transaction, leading directly back to the publisher.
The files themselves are made mostly of a set of nodes. Each node represents a specific participating entity in the selling of a bid request, and the entire chain of nodes from start to finish represents all the sellers who were paid for each individual bid request.
You can think of OpenRTB Supply Chain Object as the record of what happens to each impression. It allows the buyers to look at every party involved in the bid request, identifying the final vendor of the reselling chain.
Buyers can match each party to the seller ID given to publishers and decide whether or not they are trustworthy partners.
Who Benefits From Sellers.json?
Technically, everybody benefits from implementing Sellers.json. Sellers.json was designed to benefit both advertisers and publishers by increasing transparency and trust among ad partners.
The only people that won’t benefit are the shady players — the ones you don’t want on your bidding platform in the first place.
Unfortunately, thanks to ad fraud, over time a lot of trust has been lost among all the players within the digital advertising ecosystem. Both sides (DSPs and SSPs) have let go of vendors over the last year alone due to ad fraud and domain spoofing.
Additionally, while ads.txt has helped reduce the unauthorized reselling of inventory and domain spoofing, it has been proven easy to fool. Sellers.json cannot be manipulated once implemented.
Are There Any Disadvantages?
While Sellers.json is proven to be incredibly advantageous, there is one disadvantage to its implementation.
There’s an option within Sellers.json that allows a vendor to label their account confidential. This means they won’t have to disclose who they are, which basically defeats the whole purpose of using the file to create more transparency.
Vendors likely won’t choose to remain confidential. However, if more than a few choose to do so, this could create a transparency roadblock. Of course, there could be a legitimate reason for remaining confidential, such as having business contracts with a non-disclosure agreement (NDA) clause, but it’s still a potential and problematic flaw in the system.
Will Publishers Need to Implement Sellers.json Too?
It’s important to note that publishers are not required to have it implemented on their sites. Only the entities — such as the advertisers — who are selling their inventory are required to implement the Sellers.json file on their sites. However, publishers can still opt to keep their information confidential.
So, if you’re one of the players that’s selling or reselling a publisher’s inventory, you’ll be expected to add the Sellers.json file to your root domain as well as list all the individual publishers with whom you’re working.
Additionally, once the Sellers.json file is set up, you’ll need to upgrade your OpenRTB integrations to the 2.3 version (or later) in order to support the RTB Supply Chain Object. Otherwise, your Sellers.json file won’t be able to function correctly, as it depends on the OpenRTB Supply Chain Object for its technical mapping parameters.
Looking Towards a More Transparent Future
The Sellers.json tool was designed to provide advertisers with a more transparent environment that would allow them to purchase ad inventory without having to worry about ad fraud and domain spoofing, which negatively impacts the ad and revenue value.
As the ad tech industry matures, having Sellers.json on your side is like presenting a badge that denotes the quality of your ad inventory and domain. It’ll be something that all players look for when engaging in programmatic advertising, which will hopefully eliminate invalid traffic once and for all.
Want to learn more about tools like Sellers.json and how to keep your ad inventory safe from invalid traffic? Contact us today to find out how we make ad ops easier for publishers.
