ads.txt is a plain-text file placed at the root of your domain that lists every advertising system authorized to sell your inventory, and Blogger supports it through a built-in setting on custom domains and through direct file hosting where your DNS allows. Each line declares one seller with four comma-separated values: the advertising system domain, your publisher account ID, a DIRECT or RESELLER relationship, and an optional certification authority ID. The file is read by buyers and crawlers from a single public location, so the same characters must match what your advertising partners publish. Because Blogger gives you only the file contents rather than a place to upload a final file, the practical workflow is to generate the text offline with a strict validator, then hand it to Blogger's built-in field under Settings. That separation between production of the file and publication of it is why the Ads Txt Generator fits naturally into a Blogger workflow: it produces the exact text in your browser, with no details sent anywhere, and exports it as a copyable block ready for the platform's setup screen.
Why Blogger sites need an ads.txt file
Buyers that resell your inventory from supply-side platforms use ads.txt to decide whether a seller is authorized to act on a publisher's behalf. The file lives at /ads.txt on the root of the domain that owns the inventory, and it must be served as plain text so crawlers and programmatic buyers can fetch it. For a Blogger blog, this is normally your custom domain — for example, example.com/ads.txt — since the underlying blogspot.com subdomain does not expose arbitrary root files in the same way.
If you monetize through Google AdSense, AdSense's crawler checks the file before deciding how to label your account in its supply path. A missing or malformed ads.txt can lower fill, because buyers may treat unverified inventory as unauthorized and step out of the auction entirely. The file is small in size but strict in format: the IAB Tech Lab spec defines four comma-separated fields per line, plus a strict whitespace and case policy, and any stray comma or extra space makes the line silently rejected by the buyer crawler.
Blogger's interface is straightforward on this point. There is no FTP-like upload box and no plugin directory; the platform accepts the file contents and serves the result at a predictable location on the custom domain. That is why the focus for most Blogger publishers is producing a clean file rather than figuring out where to host it.
What to gather before you generate ads.txt
You need at least one full record, copied verbatim from the advertising platform that asked you to authorize its sellers. Each record has three required fields and one optional one. Open the partner's account dashboard, the publisher setup email, or its help-center page, and copy the values exactly as they appear. Inventing an account ID, swapping the relationship flag, or substituting a similar domain typically produces a valid-looking file that no buyer will recognize.
| Field | Required? | Example (Google AdSense) | What to copy |
|---|---|---|---|
| Advertising system domain | Yes | google.com | The bare domain of the exchange; no https://, no path, no port |
| Publisher or seller account ID | Yes | pub-1234567890123456 | The exact ID issued by that platform, including any prefix it specifies |
| Relationship | Yes | DIRECT | DIRECT or RESELLER, written exactly as the platform documents |
| Certification authority ID | Optional | f08c47fec0942fa0 | Only if the platform documents an exact value for its seller record |
If you have more than one authorized seller, gather one full record per seller. AdSense often appears alongside other exchanges, header bidders, or programmatic partners, so list each one separately. Keep a backup copy of any existing ads.txt file before you change it; that backup lets you restore the previous declaration if a new partner record turns out to be incorrect.
| Aspect | DIRECT | RESELLER |
|---|---|---|
| Who controls the seller account | You do, directly | Another authorized entity controls it |
| Contract relationship | Direct contract with the advertising system | Indirect, through a partner that resells your inventory |
| When to pick it | The ID belongs to your own account on the platform | The ID belongs to the reseller's account on the platform |
Generate the ads.txt file with the Ads Txt Generator
With your records ready, the fastest path to a syntactically clean file is the Ads Txt Generator. The tool validates each line, prevents exact duplicate rows, lowercases domains, and outputs a copyable or downloadable file without sending account details anywhere. The entire flow runs in your browser.
- Open the generator and locate the single-row entry form.
- Type the bare advertising system domain — for example, google.com — with no scheme, path, port, or credentials. The tool lowercases this field and rejects inputs that don't fit a DNS-style host, so a pasted URL like https://google.com/ is not silently rewritten.
- Paste the publisher account ID exactly as the platform gave it. For Google AdSense, that is pub- followed by your account digits; other exchanges use different formats, so copy them from the partner's own instructions instead of inventing a prefix.
- Pick the relationship: DIRECT if you directly control the seller account, RESELLER if another authorized entity does. The generator accepts only these two values.
- Leave the certification authority ID blank unless the platform supplies an exact value. Google's published example is f08c47fec0942fa0; do not reuse that string for a different exchange.
- Add the row to the visible list and repeat for every authorized seller. The list supports up to 200 records and blocks exact duplicate rows so a copy-and-paste slip cannot silently double a seller.
- Read the generated output in full, then copy the text to your clipboard or download the file. The output is newline-terminated so it can be hosted as a plain-text resource.
Upload the ads.txt content to your Blogger blog
Blogger exposes a dedicated ads.txt field rather than a generic file upload, so the workflow on the platform is paste-into-settings rather than FTP. The route depends on whether you serve the blog from a blogspot.com subdomain or from a custom domain you own. Custom-domain setups are by far the most common path for monetization.
For a custom-domain blog, the supported steps are:
- Open the Blogger dashboard and pick the blog you monetize.
- Go to Settings and scroll to the Monetization section.
- Toggle on the ads.txt option and open the editor link.
- Paste the verified text from the generator into the editor.
- Save. Blogger publishes the saved text at https://your-domain.com/ads.txt on the custom domain and replaces any prior version.
If you still use a yourname.blogspot.com URL, the platform does not let you host an arbitrary /ads.txt on the blogspot.com hostname because that root is outside your control. Point a custom domain at the blog first, then use the steps above. Never publish under a subpath like /files/ads.txt, embed the file inside an HTML page, or place it behind login — buyers fetch exactly /ads.txt on the root, so anything else stays invisible to the crawler. For a deeper walk through this publishing step alongside the generator output, see how to create an ads.txt file and publish it.
Verify the live file at /ads.txt
Once Blogger saves the text, fetch the public URL in a browser and read the response as plain text. The line count should match the seller count in your generator output, every line should keep the four-field shape, and a trailing newline should be present. Open the URL from an incognito window — Blogger caches aggressively, so an old file can appear to still be live if you check from the same browser session.
Compare every line of the served file with the platform-supplied values you copied earlier. This is the moment to catch typos introduced during paste, swapped account IDs, or a transition between DIRECT and RESELLER that does not match your actual contract. For Google AdSense specifically, you can cross-check the seller you declared against how to authorize Google AdWords sellers in ads.txt; the published record must match what your AdSense account shows as a verified seller. If the public file diverges from your records, return to the generator, regenerate with the corrected values, and re-paste the full text into Blogger.
Mistakes that break ads.txt on Blogger
Most ads.txt problems on Blogger come from formatting rather than partner approval. The biggest sources of error show up repeatedly across published files:
- Capitalized or scheme-prefixed domain. Buyers expect a bare lowercase host; pasting https://Google.com may slip past your eyes and be ignored by the buyer.
- Wrong relationship flag. Marking a record RESELLER when you actually hold the seller account directly — or vice versa — makes the declaration inaccurate even when every other character is correct.
- Reused certification authority ID. The optional fourth field is exchange-specific. Copying Google's published example onto a non-Google record looks valid and protects nothing.
- Publishing at the wrong path. Buyers only fetch /ads.txt on the root domain; /p/ads.txt or /files/ads.txt is invisible to the crawler.
- Removing valid sellers when adding a new one. Each platform keeps its own seller record. Paste the rebuilt file in full rather than appending line-by-line.
- Skipping a backup. If a new entry breaks something, you need the prior version to roll back quickly.
Treat ads.txt as a living record rather than a one-time setup. Account changes, new partners, and switches between DIRECT and RESELLER at a demand source all require an update. For the underlying specification, the IAB Tech Lab ads.txt 1.1 reference defines the field order, case rules, and certification authority conventions used by every compliant exchange.