Ads.txt Is Only One Third of the Check
If you've set up ads.txt, you've done the part of supply-chain transparency that lives on your own domain. But a buyer deciding whether to bid on your page doesn't stop there. Two other pieces sit alongside it: sellers.json, a file each ad system publishes about its own accounts, and the SupplyChain object (usually shortened to schain), a small block of data that travels inside every bid request. All three come from the IAB Tech Lab, and they're designed to be read together.
You don't write sellers.json or schain yourself. Your ad networks and exchanges do. That.s why problems in them often go unnoticed. This post explains what each piece says, how a buyer lines them up, what the relationship labels mean, and how to check that your own entries are right. If you need a refresher on the ads.txt file itself, start with our ads.txt guide; here we'll assume you know what a line in it looks like.
What Each File Answers
The easiest way to keep them straight is to think of each as answering one question, asked by a different party.
- ads.txt is you, the publisher, answering: "Which ad systems and account IDs may sell my inventory?" It lives at yourdomain.com/ads.txt.
- sellers.json is the ad system answering: "Who is behind each account ID on our platform, and are they the owner of the inventory or a middleman?" It lives at the root of the ad system's domain, for example adsystem.com/sellers.json.
- schain is the bid request answering: "Which accounts touched this particular impression on its way to you, in what order?" It isn't a file at all. It's a field in the OpenRTB request.
On its own, ads.txt can only tell a buyer that an account ID is authorized. It can't say whose account that is, or whether the request passed through three resellers before arriving. Sellers.json supplies the identity; schain supplies the path. Put together, a buyer can trace an impression from the exchange that's offering it back to the site that owns it.
Sellers.json, Field by Field
The IAB Tech Lab sellers.json specification keeps the format small. At the top there's a version (currently "1.0"), optional contact details, and a list called sellers. Each seller entry has these fields:
- seller_id (required): the account ID. The spec says it's the same ID that appears in ads.txt. For Google this is your pub- ID.
- seller_type (required): PUBLISHER, INTERMEDIARY or BOTH. More on these below.
- is_confidential (optional, defaults to 0): set to 1 when the seller's identity is hidden.
- name: the legal name of the entity that gets paid. Required unless the entry is confidential.
- domain: the business domain of that entity, as a root domain rather than a full URL. Required if the seller has a web presence and isn't confidential.
- is_passthrough, comment and ext: optional extras you'll rarely need to think about.
One rule matters more than the rest: the spec says all sellers must be listed, even confidential ones. A confidential seller still appears with its ID and type; only the name and domain are left out.
A transparent publisher entry in a network's file looks roughly like this (hypothetical values):
{"seller_id": "pub-1234567890123456", "seller_type": "PUBLISHER", "name": "Example Media LLC", "domain": "examplemedia.com"}
And a confidential one looks like this:
{"seller_id": "pub-1234567890123456", "is_confidential": 1, "seller_type": "PUBLISHER"}
The SupplyChain Object in a Bid Request
The SupplyChain object spec describes a short structure with three required parts: a version, a complete flag, and an ordered list of nodes. Each node represents one account that handled the request, and carries:
- asi: the domain of the ad system (for example google.com).
- sid: the seller's account ID in that system, which should match the ads.txt line and the seller_id in sellers.json.
- hp: whether that node is in the payment flow (in version 1.0 it's always 1).
- Optionally rid, name and domain. The spec says name and domain can be left out when sellers.json already provides them, which is the point: buyers can cache sellers.json instead of receiving identities in every request.
The first node should be the original seller of your inventory, and the last node is whoever sent the request to the buyer. When a reseller passes a request along, the spec says it copies the existing chain and appends its own node. If it can't, the chain is marked incomplete.
complete=1 means the chain runs all the way back to the owner of the site. complete=0 means at least one hop is missing, so the buyer can't see the full path. Where the object sits depends on the OpenRTB version: under source.ext.schain in OpenRTB 2.5 and directly as source.schain from 2.6 onward. You never edit it yourself.
How a buyer checks one impression
- Bid request arrivesSays site.domain is yoursite.com, with an schain attached
- Read the schain nodesEach node gives an ad system (asi) and account ID (sid)
- Look up yoursite.com/ads.txtIs the first seller's asi and sid listed, and as DIRECT or RESELLER?
- Look up each asi's sellers.jsonDoes each sid exist, and what type and name does it show?
- Check the chain is completecomplete=1 means it reaches the site owner
- Bid, bid lower or passEach buyer applies its own rules to gaps and mismatches
Buyers don't publish their exact rules, and they vary. Some may simply prefer fully verified paths when budgets are tight; others may decline to bid on paths they can't trace. The safe assumption is that every broken link in this chain makes your impression less attractive to at least some buyers.
DIRECT, RESELLER, PUBLISHER, INTERMEDIARY
These four labels are where most confusion starts, because two of them live in ads.txt and the other two (plus BOTH) live in sellers.json.
In ads.txt, the ads.txt 1.1 spec defines DIRECT as an account the publisher directly controls, which usually means a direct contract with that ad system. RESELLER means you've authorized another company to control that account and resell your space through it.
In sellers.json, PUBLISHER means the inventory sold through that account is on a site or app owned by the named entity, and the ad system pays them directly. INTERMEDIARY means the named entity doesn't own the inventory, or isn't paid directly. BOTH covers accounts that do some of each, which is common for media companies that sell their own sites and also represent others.
Which labels should line up
| Your setup | Your ads.txt says | Network's sellers.json shows |
|---|---|---|
| Your own AdSense account | google.com, your pub- ID, DIRECT | Your pub- ID as PUBLISHER |
| A managed network sells for you | Network's IDs, mostly RESELLER | Network's ID as INTERMEDIARY or BOTH |
| Network gave you your own account on its platform | That account ID, DIRECT | Your account, usually PUBLISHER |
| Media company selling its own and partner sites | Its IDs as DIRECT or RESELLER | BOTH |
A caveat on that table: neither spec contains a formal rule mapping DIRECT to PUBLISHER or RESELLER to INTERMEDIARY. The pairing follows from the definitions, and it's how the industry generally reads them, but your network may have a good reason for a particular setup. If something looks off, ask them before editing anything.
How Confidential or Mismatched Entries Cost Bids
Confidential entries
Google lets AdSense publishers choose whether their seller information is transparent or confidential. Its AdSense help page on sellers.json says that if your information isn't transparent, advertisers can't see your name, which might affect your revenue. Google doesn't put a number on that, and neither should anyone else without data.
There's an honest counterpoint. Google's own help for buyers says some publishers use personal accounts and may want confidentiality for privacy, and that it doesn't recommend making buying decisions based on confidentiality. So confidential isn't a red flag by itself. It does remove one piece of verification, and with many buyers in an auction, some will weigh that.
It's also very common. At the time of writing, a large majority of the publisher entries in Google's sellers.json are marked confidential, so you won't stand out by being one of them.
Mismatched or missing seller IDs
This is the more serious problem, because it breaks verification outright rather than just hiding a name. Typical causes:
- A typo in your ads.txt ID, so the line points at an account that doesn't exist or belongs to someone else.
- An old account: you closed one account and opened another, but ads.txt still lists the old ID.
- A network's ID that isn't in its own sellers.json, or appears there under a different type than your ads.txt line suggests.
- An incomplete chain, where a reseller in the path doesn't add its node, so the request arrives with complete=0.
You can fix the first two yourself. The last two belong to your network, but you're the one who notices lost revenue, so it's worth knowing what to ask. For broader context on what moves your earnings, see how to raise ad RPM.
Finding Your Own Entry
The spec asks ad systems to publish the file at the root of their domain. Google points to its file at realtimebidding.google.com/sellers.json, which redirects to a file on Google's cloud storage. Be warned: it's huge. When checked in November 2026 it was over 100 MB with hundreds of thousands of entries, so opening it in a browser tab may freeze. A more practical approach:
- Find your publisher ID. In AdSense it's under Account > Settings > Account information, and it looks like pub- followed by 16 digits.
- Download the file, then search it for your exact ID with a text editor that handles large files or a command-line search tool.
- Read the entry. Check the seller_type, whether is_confidential is set, and if it's transparent, whether the name and domain are what you'd expect.
For other networks, try theirdomain.com/sellers.json using the domain in the first field of their ads.txt lines. If you can't find a file, ask your account manager where it's published.
To switch an AdSense account from confidential to transparent, Google's help page gives the path: Account > Settings > Account information, then the "Seller information visibility" section, choose Transparent and optionally add a business domain. Google says the change appears in its sellers.json within 24 hours. Two details from that page are worth knowing before you click: the visibility setting is shared across AdSense, AdMob and Ad Manager, and switching back to confidential later doesn't erase what was visible while you were transparent. If you run the site under your own name, that's a privacy decision, not just a revenue one.
App-ads.txt in One Line
If you also publish apps, app-ads.txt is the same idea for apps: a file at the root of the developer website listed in your app store page, which buyers find through that listing rather than through a site domain.
A Practical Audit You Can Run This Afternoon
No special tools needed. Work through it in this order:
- List your active partners. Every network or exchange currently paying you. Anything not on this list shouldn't have DIRECT lines in your ads.txt.
- Check each DIRECT line against the partner's sellers.json. Search for the account ID. It should exist, and for your own accounts it should usually be PUBLISHER (or BOTH if you're a media company).
- Check your managed network's lines. If you work with a network like Mediavine or Raptive, each of their lines (mostly RESELLER) should point to an ID that actually exists in that ad system.s sellers.json, with a type that fits the label. You can't fix these, but you can report gaps to the network.
- Look at your own visibility setting. Decide whether transparent or confidential fits you, knowing what Google says about each.
- Remove dead lines. Old accounts and dropped networks don't help anyone and can confuse checks. Our guide to switching ad networks covers when to clean these up during a move.
- Ask your network about schain. You can't see bid requests, but you can ask whether they pass a complete SupplyChain object and whether every SSP in their stack is listed in their sellers.json.
If you're still at the stage of getting approved, these files matter less than the basics. Get your site in shape first with the AdSense approval guide, and run a free scan on AdGateScore to see how ready your site looks to each network.
What to Do Next
Open your ads.txt in one tab. Find your own publisher ID in the first network's sellers.json in another. If the ID matches, the type makes sense and the name is what you expect, you're done with that network; move to the next. If anything doesn't match, fix your own lines first, then send your network a short message naming the exact ID and what you found. Specific questions get answered faster than "is my sellers.json okay?"
We build AdGateScore, the ad network readiness scanner. Our articles draw on the requirements each network publishes and on what our scans find.