app-ads.txt vs ads.txt: the developer website, store listings and how verifiers find the file
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.

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:
- App developers “provide a website URL in their app’s store metadata and publish an app-ads.txt file on that website.”
- App stores publish app metadata in HTML
<meta>tags on each listing page. - 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:
- Extract the host name.
- Keep only the first (and, if present, second) name before the public suffix.
- Remove any
www.orm.prefix. - Append
/app-ads.txt. - 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.compages are checked againstexample.com/ads.txt. - Ads inside an app whose store listing says
https://example.comare checked againstexample.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:
- Publish app-ads.txt with the same entries on the new domain first.
- Update the developer website in every store that lists the app.
- Keep the file on the old domain for “an extended period (suggested 30 days, if possible)”.
- 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
- IAB Tech Lab Authorized Sellers for Apps (app-ads.txt) · IAB Tech Lab
- Ads.txt Version 1.1 · IAB Tech Lab
- Ensure your ads.txt files can be crawled · Google AdSense Help
- Provide your seller information with sellers.json · Google AdSense Help
Related guides
- ads.txt and subdomains: which file the crawler reads and when to use subdomain=
Which ads.txt file governs a subdomain, when you need subdomain= in the root file, and the configurations that silently make a subdomain Unauthorized in AdSense.
- ads.txt syntax for AdSense, line by line: pub ID, DIRECT, TAG ID, comments and variables
The AdSense ads.txt line field by field: google.com, your pub ID, DIRECT, f08c47fec0942fa0, plus comments, variables and the formatting errors that break parsing.
- Google's sellers.json for AdSense publishers: seller information visibility and what buyers see
What Google's sellers.json says about your AdSense account, how the Seller information visibility setting works, and how to find your own entry in the file.
- Where AdSense code cannot be placed: iframes, emails, software, apps, error pages and other off-limits screens
Where AdSense code is not allowed: iframes, emails, software and toolbars, unapproved app WebViews, pop-ups, private messaging, error and no-content pages.
- ads.txt "Not found" or "Unauthorized": a technical checklist for redirects, HTTPS, status codes and robots.txt
Diagnose ads.txt Not found and Unauthorized statuses: root vs www, HTTP vs HTTPS, redirect rules, 404 and soft 404, robots.txt, content type, with curl tests.