Best Tools to Check ads.txt Files

ads.txt stands for Authorized Digital Sellers. It is a plain-text file hosted at the root of your domain — `yourdomain.com/ads.txt` — that lists every ad exchange, network, and supply-side platform (SSP) authorised to sell advertising inventory on your website. The IAB Tech Lab introduced the standard in 2017 specifically to combat domain spoofing: a form of ad fraud where bad actors sell inventory claiming to be from a premium publisher domain they do not own.

When a demand-side platform (DSP) or advertiser places a programmatic bid, their system checks the publisher's ads.txt file before spending. If the selling entity listed in the bid request does not appear in the ads.txt file, the buyer either skips the bid entirely or applies a significant discount. A missing file, a misconfigured entry, or an outdated record translates directly to lower fill rates and reduced effective CPMs.

The ads.txt line format

Each line in a valid ads.txt file follows a precise four-field format. Understanding the structure is essential for spotting errors — most validation problems come from lines that deviate from this exact pattern.

# Format: domain, publisher-account-id, account-type, authority-id
# account-type must be DIRECT or RESELLER
# authority-id (TAG-ID) is optional but strongly recommended

google.com, pub-0000000000000000, DIRECT, f08c47fec0942fa0
appnexus.com, 1234, RESELLER, f5ab79cb980f11d1
openx.com, 540191398, RESELLER, 6a698e965929

# Lines starting with # are comments — ignored by parsers
# [email protected]
# SUBDOMAIN=sub.yourdomain.com

• domain: The root domain of the advertising system (e.g. `google.com`, not `ads.google.com`).
• publisher-account-id: Your account or publisher ID at that ad network.
• account-type: Either `DIRECT` (you have a direct contract) or `RESELLER` (sold via intermediary).
• authority-id: The optional but recommended TAG-ID or Seller Account ID from the Trustworthy Accountability Group. Omitting it reduces buyer confidence.

The enforcement of ads.txt by the programmatic ecosystem is not uniform — different DSPs handle invalid files differently, which makes the revenue impact hard to predict and easy to miss until CPMs drop noticeably. Understanding how buyers respond to errors explains why checking ads.txt regularly is worth the effort.

How DSPs respond to ads.txt issues

• Missing file (404): Most major DSPs treat a missing ads.txt as "unverified inventory." Some skip bidding entirely; others bid at a heavily discounted floor price.
• Invalid line format: Lines with wrong field counts or invalid account-type values are silently skipped — the entry is treated as if it does not exist.
• DIRECT vs RESELLER mismatch: If a network sells as DIRECT but your file lists them as RESELLER (or vice versa), buyers flag the discrepancy and reduce confidence in the inventory.
• Missing authority-id: The TAG Certified Channels programme requires authority-ids. Buyers enforcing TAG certification skip entries without them.
• Redirect to homepage: A 301 or 302 redirect from /ads.txt to the homepage is treated as a missing file by most crawlers.

Buyers of digital advertising can use ads.txt to determine if a digital media buying opportunity is authorized by the publisher and whether resellers are permitted to sell the publisher's inventory.

Google AdSense and ads.txt warnings

Google AdSense is particularly strict about ads.txt enforcement. If your AdSense publisher ID is not listed correctly in your ads.txt file, AdSense displays a warning in the dashboard and can reduce serving for your approved ads slots. The required AdSense entry follows this exact format: `google.com, pub-XXXXXXXXXXXXXXXXX, DIRECT, f08c47fec0942fa0`. The authority-id `f08c47fec0942fa0` is Google's fixed TAG-ID — it must appear exactly as written.

Checking ads.txt requires two separate verifications: accessibility (is the file reachable at the right URL?) and validity (is every line correctly formatted?). Both checks are quick and can be done in under two minutes with the right tools.

Most ads.txt problems fall into a small number of repeating patterns. Each one has a specific cause and a specific fix — once you know what to look for, they take minutes to resolve.

Wrong field count

The most common error is a line with the wrong number of comma-separated fields. Each line must have exactly three required fields (domain, account-id, account-type) and one optional field (authority-id). Two-field lines (just domain and account-id) and five-field lines (extra fields appended by copy-paste errors) both fail validation. Check every line that your validator flags — often the problem is a stray comma or a missing comma from manual editing.

Invalid account-type value

The account-type field accepts only two values: `DIRECT` and `RESELLER`. Case-insensitive parsers accept `direct` and `reseller`, but the IAB spec recommends uppercase. Any other value — `DIRECT/RESELLER`, `Partner`, `Network`, or a blank — fails validation and the line is skipped entirely by compliant parsers. Review each flagged line and correct the value to exactly `DIRECT` or `RESELLER` based on your contractual relationship with that network.

File served from wrong path or with wrong Content-Type

The ads.txt file must be accessible at exactly `yourdomain.com/ads.txt` — not `/ads.txt.php`, not `/ads-txt`, not a subdirectory path. The server should return a `200 OK` status with a `Content-Type` of `text/plain`. Some hosting platforms serve `.txt` files with `application/octet-stream`, which some crawlers reject. Use the Robots Validator alongside your ads.txt check — if robots.txt has similar accessibility problems, you likely have a server configuration issue affecting all `.txt` files at root.

Hidden characters and encoding problems

A particularly difficult ads.txt problem is lines that look correct visually but fail parsing because they contain hidden Unicode characters — non-breaking spaces, zero-width spaces, or smart quotes — introduced by copy-pasting from a PDF, a Word document, or a rich-text email. Most text editors do not show these characters. If a line fails validation with no obvious formatting error, retype it manually rather than copy-pasting. The Unicode and Encoding Repair Tool can strip invisible Unicode characters from pasted text before you put it in your ads.txt file.

ads.txt was designed for web publishers. The programmatic ad ecosystem extended the standard to two related specifications: app-ads.txt for mobile app inventory, and sellers.json for supply chain transparency. Understanding all three formats helps you build a complete authorisation picture.

app-ads.txt for mobile app publishers

Mobile app developers use app-ads.txt instead of ads.txt. The file format is identical — the same four-field line structure, the same DIRECT/RESELLER account types, the same authority-id field. The difference is discovery: for apps, ad platforms look up the developer's website URL from the App Store or Google Play listing and check for app-ads.txt at the root of that domain. You host app-ads.txt on your developer website, not in the app itself. Use the App-ads.txt Validator to check mobile app inventory authorisation using the same validation rules.

sellers.json — the supply chain complement

sellers.json is the complement to ads.txt from the other direction: ad networks and SSPs publish a sellers.json file at their own domain listing all publishers (sellers) they represent. A buyer can cross-reference your ads.txt RESELLER entry against the SSP's sellers.json to verify the supply chain is legitimate. While you do not create sellers.json as a publisher, understanding it explains why having correct authority-ids in your ads.txt matters — they are used to match your entries against sellers.json records.

A one-time ads.txt check is not enough — ad network entries change, new partners are onboarded, and file accessibility can break after server or CMS updates. Building a lightweight monitoring routine prevents silent revenue loss between manual audits.

Google AdSense dashboard warnings

The AdSense dashboard shows an ads.txt warning banner if your publisher ID is missing from your ads.txt file or if the file is not accessible. Check the AdSense dashboard after any server migration, CMS update, or `.htaccess` change — these are the three most common events that break ads.txt accessibility without the publisher noticing. The warning appears under the "Account" section in AdSense settings.

Programmatic partner notifications

Most major SSPs and ad networks send email notifications when their required ads.txt entries change. Subscribe to update notifications from each partner's publisher portal if available. When a partner updates their domain or authority-id, they typically give a 30–90 day migration window before old entries stop being honoured — but only publishers who are monitoring will catch the change in time.

Technical audit workflow

Include ads.txt validation in your quarterly technical SEO audit alongside robots.txt, sitemap validation, and canonical tag checks. Use the Robots.txt Rule Conflict Explainer to verify that no robots.txt rule accidentally blocks ad platform crawlers, and the Sitemap Validator to check sitemap health in the same session. These files live at the same server root level and are often affected by the same misconfiguration events.

Following these practices keeps your ads.txt file accurate, accessible, and effective — maximising bid eligibility while protecting your inventory from unauthorised resellers.

Keep the file lean and current

Remove entries for ad networks you no longer work with. An oversized ads.txt with dozens of inactive entries does not directly harm revenue, but it increases the surface area for errors and makes the file harder to audit. When you offboard from a network, remove their entries at the same time you remove their ad tags from your pages — treat both as part of the same offboarding process.

Always use authority-ids when available

The TAG authority-id (also called TAG-ID or Seller Account ID) is technically optional in the ads.txt spec, but major DSPs prefer entries that include it. It allows buyers to verify the full supply chain from publisher through to exchange using sellers.json cross-referencing. Every major ad network publishes their authority-id in their publisher documentation — include it in every entry where it is available.

• One entry per line: Never combine multiple networks on a single line — each authorised seller relationship gets its own line.
• Validate before every upload: Run the Ads.txt Validator on the file before uploading to catch errors you introduced during editing.
• Use UTF-8 encoding without BOM: Save the file as plain UTF-8. A BOM (Byte Order Mark) at the start of the file can break parsing in some ad platform crawlers.
• Do not use trailing whitespace: Many text editors add invisible trailing spaces. These can cause line-level parse failures in strict validators.
• Version control your ads.txt: Keep ads.txt in your site's version control repository. A git history lets you trace exactly when an entry was added or removed if revenue unexpectedly drops.