ads.txt & sellers.json

app-ads.txt vs ads.txt: the developer website, store listings and how verifiers find the file

Last updated Published By the editorial team6 min4 sources

Key takeaways

  • ads.txt authorizes sellers of website inventory and lives at the root of the site's domain; app-ads.txt authorizes sellers of app inventory and lives on the developer website listed in the app store.
  • Under the IAB Tech Lab app-ads.txt specification, publishing a developer website URL in the app store listing is required for an app's inventory to take part in the scheme.
  • Verifiers derive the app-ads.txt location from the developer URL: they keep the first subdomain before the registrable domain, drop www. or m., append /app-ads.txt and try HTTPS first.
  • The subdomain= directive used in ads.txt is unused in app-ads.txt and should be ignored; a subdomain's file is used if present, otherwise the parent domain's file.
  • The specification asks verifiers to crawl app store listings no more than weekly and suggests keeping an old app-ads.txt file online for about 30 days after changing the developer domain.
People using smartphones at a railway station
Image: Smartphone use at railway station,Rawpixel.com,CC0,via Wikimedia Commons.

ads.txt lists who may sell ads on a website and sits at the site’s root, for example example.com/ads.txt. app-ads.txt does the same for mobile and connected-TV apps, but verifiers find it through the app store: they read the developer website from the app’s store listing and fetch /app-ads.txt on that domain. The line format is the same; discovery and subdomain rules differ.

Side-by-side comparison

ads.txt app-ads.txt
Covers Web inventory (sites) App inventory (mobile, CTV, other store-distributed apps)
Specification IAB Tech Lab ads.txt 1.1 IAB Tech Lab app-ads.txt
File location Root of the site’s domain Root of the developer website from the store listing
How verifiers find it Domain of the page carrying the ad Store URL, then the appstore:developer_url meta tag, then the domain
subdomain= directive Supported, declared in the root file “Unused” and “should be ignored”
Subdomain handling Root domain first; subdomain file only if delegated First subdomain tried first, parent domain as fallback
Scheme Google crawls both HTTP and HTTPS HTTPS first, HTTP only “if SSL is unavailable”
Record format domain, account ID, DIRECT or RESELLER, optional cert ID Same as ads.txt

The app-ads.txt spec states that “the structure and content of the app-ads.txt file is the same as ads.txt for web files”, and that the different file name exists “so that app and web configurations are managed separately and do not create conflicts”. Everything in ads.txt syntax about fields, comments and variables applies to both.

How do verifiers find an app’s app-ads.txt?

The spec describes three participants:

  1. App developers “provide a website URL in their app’s store metadata and publish an app-ads.txt file on that website.”
  2. App stores publish app metadata in HTML <meta> tags on each listing page.
  3. Authorized seller verifiers crawl store listings for the developer URL, then crawl the developer website for the file.

The store-side tags defined by the spec:

<meta name="appstore:developer_url" content="https://www.path.to/page" />
<meta name="appstore:bundle_id" content="com.example.myapp" />
<meta name="appstore:store_id" content="SKU12345" />

You do not add these tags yourself; the store generates them from the developer website you enter in the store console. What you control is that field. The spec is explicit: “Publishing a website and providing its URL is required for the app’s ad inventory to participate in the authorized seller scheme.”

The bid request carries a storeurl, which lets the verifier go from an ad opportunity to the listing, from the listing to your domain, and from your domain to your list of authorized sellers.

How is the developer URL turned into a file path?

The spec’s “Translate developer URL to an app-ads.txt path” steps:

  1. Extract the host name.
  2. Keep only the first (and, if present, second) name before the public suffix.
  3. Remove any www. or m. prefix.
  4. Append /app-ads.txt.
  5. Try HTTPS first, falling back to HTTP “if SSL is unavailable.”

Examples from the spec’s Appendix A:

Developer URL in the store Domain used
https://www.example.com/test example.com
https://m.example.com/test example.com
https://subdomain.example.com/test subdomain.example.com
https://another.subdomain.example.com/test subdomain.example.com
https://subdomain.www.example.com/test example.com
https://www.example.co.uk/test example.co.uk

Then the fallback rule: verifiers “must use the app-ads.txt file found on the subdomain”, “only defaulting to the app-ads.txt file found on the subdomain’s parent if no file is found on that subdomain.”

This is the opposite direction from ads.txt. For websites, the root domain’s file governs subdomains unless it delegates them with subdomain=, as explained in ads.txt and subdomains. For apps, a file on the developer subdomain takes precedence automatically.

Why do publishers often need both files?

Many businesses have a website and apps. The two files serve different inventory and are checked by different processes:

  • Ads on example.com pages are checked against example.com/ads.txt.
  • Ads inside an app whose store listing says https://example.com are checked against example.com/app-ads.txt.

Both files can sit side by side at the same root. Each contains only the sellers for its own inventory. A seller that sells both your web and app inventory, such as Google, can appear in both files, with the account ID of the product that sells each type.

Google’s sellers.json help page confirms the account split: a publisher can have AdSense, AdMob and Ad Manager accounts, the “seller_id is unique to each product”, and your transparency status and business domain are shared across all three. So the publisher ID in your app-ads.txt may differ from the one in your ads.txt. Copy each line from the account that monetizes that inventory. AdSense itself is built for web pages; in apps, AdSense ads are only allowed through approved web content viewing frames, as covered in where AdSense code cannot go.

What should you do when you change the developer website?

The spec asks verifiers to crawl each store listing “no more frequently than weekly”, so a change in the store console is not instant. Its advice when changing domains:

  1. Publish app-ads.txt with the same entries on the new domain first.
  2. Update the developer website in every store that lists the app.
  3. Keep the file on the old domain for “an extended period (suggested 30 days, if possible)”.
  4. Only then remove it.

Removing the old file too early risks “non-coverage”; removing entries from it risks “unavailable inventory”.

Can you split sellers between apps?

Not inside one file. The spec says developers “who want to partition the authorized sellers between individual apps must use separate developer domains/subdomains”, because a single app-ads.txt cannot say that a seller is authorized for only some apps. It adds: “We generally advise against attempting to exert fine-grained control using app-ads.txt.”

If you do need separation, use one subdomain per group of apps, for example games.example.com and tools.example.com, set the developer website of each app accordingly, and publish a file on each subdomain. The subdomain rule above means each file is used before the parent domain’s.

Does a developer with no ad sellers need a file?

Optionally. The spec points to the ads.txt guidance for “files without authorized advertising system records”. In ads.txt 1.1, the way to state that no seller is authorized is a single placeholder record:

placeholder.example.com, placeholder, DIRECT, placeholder

How do I test my app-ads.txt the way a verifier would?

First, copy the developer website exactly as it appears in each store listing, and apply the translation rules above to get the domain. Then fetch the file on HTTPS, which the spec says verifiers try first:

curl -sIL https://example.com/app-ads.txt
curl -sL https://example.com/app-ads.txt

The first command should end with status 200 and a plain-text content type; the second should print your seller lines, not HTML. If the developer URL uses a subdomain, test that subdomain first, then the parent domain, because that is the order the spec gives verifiers. Repeat for every store where the app is listed: if two stores list different developer websites, each domain needs a file.

Troubleshooting app-ads.txt

Problem Likely cause Fix
File at example.com/app-ads.txt, store says https://studio.example.com Verifier looks on studio.example.com first Put the file on the subdomain, or change the store URL
File named ads.txt only Wrong file name for apps Add app-ads.txt
Store listing has no developer website Spec requires it Add the URL in each store console
Changes not reflected Store listings crawled at most weekly Wait; keep old files during domain changes
subdomain= lines added Ignored in app-ads.txt Use per-subdomain files instead
HTML or 404 at /app-ads.txt Same delivery issues as ads.txt Apply the checks in ads.txt Not found or Unauthorized

Delivery requirements are shared with ads.txt: a plain-text file at the exact path, a 200 status, no HTML fallback, no bot challenge. The curl tests that work for /ads.txt work for /app-ads.txt by changing the path.

Frequently asked questions

Can I put my app sellers in ads.txt instead of app-ads.txt?

No. The IAB app-ads.txt specification uses a separate file name so that app and web configurations are managed separately and do not conflict. Verifiers checking app inventory look for /app-ads.txt on the developer domain from the store listing, not for /ads.txt. If the same domain hosts both a website and your developer page, publish both files side by side at the root.

Does app-ads.txt have to be on the same domain as my website?

Only if that domain is the developer website you entered in the app store listing. Verifiers read the developer URL from the store, canonicalize it and fetch /app-ads.txt there. If your store listing points to a different domain, for example a studio site, the file must be on that domain. Updating one without the other is a common reason for an app being reported as unauthorized.

Can I authorize a seller for only one of my apps?

Not within one file. The specification says there is no provision for authorizing a seller for only a subset of apps in a single app-ads.txt. Developers who want different seller lists per app must use separate developer domains or subdomains, each listed in the relevant store listings, and the specification generally advises against fine-grained control through app-ads.txt.

How long does a change take to be picked up?

The specification does not set a recrawl schedule for app-ads.txt files themselves, but it asks verifiers to crawl each app store listing no more than weekly. A change of developer URL in the store can therefore take time to be noticed. The specification suggests keeping the old file in place for an extended period, about 30 days if possible, after changing domains.

Sources

  1. IAB Tech Lab Authorized Sellers for Apps (app-ads.txt) · IAB Tech Lab
  2. Ads.txt Version 1.1 · IAB Tech Lab
  3. Ensure your ads.txt files can be crawled · Google AdSense Help
  4. Provide your seller information with sellers.json · Google AdSense Help