# ads.txt Checker: Bulk ads.txt, app-ads.txt & sellers.json (`transparent_meteorite/ads-txt-checker`) Actor

Bulk ads.txt checker and app-ads.txt checker: fetch each domain's file, count DIRECT and RESELLER lines, flag invalid lines with line numbers and duplicates, and cross-check account IDs against exchange sellers.json. No login, no key.

- **URL**: https://apify.com/transparent_meteorite/ads-txt-checker.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** SEO tools, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.16 / 1,000 domain checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ads.txt Checker: Bulk ads.txt, app-ads.txt & sellers.json

Check ads.txt and app-ads.txt files for hundreds of domains in one run. Give it a list of publisher or app developer domains and get one row per file: whether it exists, how many DIRECT and RESELLER lines it has, every invalid line with its line number, duplicate lines, the top ad systems, and the account IDs that are not listed in the exchange's own sellers.json. No login, no API key, no proxy.

An ads.txt file (Authorized Digital Sellers) is a plain text file at `example.com/ads.txt` that lists who may sell a publisher's ad inventory. App publishers use `app-ads.txt` in the same format. A single typo, a missing account ID or an HTML error page served instead of the file can quietly cost a publisher demand, and a buyer or ad-ops team cannot check that by hand across a portfolio. This Actor does it in bulk and returns a table you can sort, filter and export.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled list checks 26 well-known publisher domains.
2. Click **Start**.
3. Open the **Checks** table in the Output tab, or export as JSON, CSV or Excel.
4. Replace the domains with your own portfolio and run again. Turn on **Check app-ads.txt** for app developers.

A default run of 26 domains with the sellers.json cross-check on finishes in well under a minute.

### What does this Actor do?

For each domain it downloads `/ads.txt` (and `/app-ads.txt` if you ask for it), following redirects safely, then parses it line by line against the IAB Tech Lab ads.txt specification.

| Group | Fields |
|---|---|
| Fetch | `domain`, `fileType`, `url`, `finalUrl`, `httpStatus`, `redirects`, `fetchStatus`, `hasAdsTxt`, `fileBytes` |
| Counts | `entries`, `directCount`, `resellerCount`, `uniqueAdSystems`, `topAdSystems`, `certIdCount` |
| Quality | `invalidLineCount`, `invalidLines` (line number, text, reason), `duplicateCount`, `duplicates` |
| Variables | `ownerDomain`, `managerDomain`, `contacts`, `subdomains` |
| sellers.json | `sellersChecked`, `missingSellers`, `sellersUnverifiable` |
| Run | `checkedAt` |

`hasAdsTxt` is true when a real file was found, for either file type; use `fileType` to tell ads.txt rows from app-ads.txt rows.

#### What counts as an invalid line

- Fewer than three or more than four comma-separated fields.
- An empty ad system domain or an ad system that is not a valid domain name.
- An empty account ID, or one that contains spaces.
- A relationship other than DIRECT or RESELLER.
- A certification authority ID that is malformed.
- A variable with no value, or an unknown variable name.

Each invalid line comes back as `{"line": 12, "text": "...", "error": "Relationship must be DIRECT or RESELLER, found \"SELLER\""}` so you can open the file and fix the exact line.

#### Fetch status values

`ok` (file found and parsed), `ok_truncated` (file larger than 5 MB, parsed up to the cap), `not_found` (404), `html_not_ads_txt` (the server returned a web page instead of a text file, the most common silent failure), `empty`, `http_403` and other HTTP codes, `dns_error`, `timeout`, `tls_error`, `connection_failed`, `blocked` and `too_many_redirects`. Rows for sites without a file are still returned, with the counts left empty (null), so your report shows which domains have a problem.

#### sellers.json cross-check

For every DIRECT line the Actor looks up the account ID in the ad system's sellers.json (for example the file published by the exchange behind `pubmatic.com` or `openx.com`). Account IDs that the exchange does not list are returned in `missingSellers` with the line number. If an exchange does not publish a readable sellers.json, or blocks automated reads, its lines are reported in `sellersUnverifiable` with the reason, never as missing, so you do not get false alarms. Each exchange file is downloaded once per run and shared across all domains.

### Limits

- ads.txt is read from the domain you give. The Actor tries the bare domain, then the `www` host, then plain HTTP. Subdomain files that the IAB spec allows through the SUBDOMAIN variable are reported in `subdomains` but not followed.
- Files over 5 MB are cut at 5 MB. sellers.json files over 40 MB are skipped and reported as unverifiable.
- At most 60 different exchanges are looked up per run. Lines for further exchanges are listed as unverifiable.
- Some sites block automated requests. They show up with `http_403` or a timeout, not as a guess.
- Requests to private or internal addresses are blocked, only ports 80 and 443 are used, and no more than 5 redirects are followed.
- The Actor reads public files only. It does not judge whether a seller is legitimate, only whether the file is well-formed and whether the IDs exist in the exchange's list.

### Input

| Field | What it does |
|---|---|
| `domains` | Domains or URLs, one per line. Paths and `www` are ignored. Duplicates are removed. |
| `maxItems` | Maximum rows. A domain with both file types is two rows. Default 25. |
| `checkAdsTxt` | Fetch `/ads.txt`. On by default. |
| `checkAppAdsTxt` | Also fetch `/app-ads.txt`. Use the developer website domain listed in the app store. Off by default. |
| `crossCheckSellers` | Look up each DIRECT account ID in the exchange sellers.json. On by default. |

### Example input

```json
{
  "domains": ["nytimes.com", "forbes.com", "https://www.imdb.com/"],
  "maxItems": 25,
  "checkAdsTxt": true,
  "checkAppAdsTxt": false,
  "crossCheckSellers": true
}
```

### Output sample

```json
{
  "domain": "forbes.com",
  "fileType": "ads.txt",
  "finalUrl": "https://www.forbes.com/ads.txt",
  "httpStatus": 200,
  "fetchStatus": "ok",
  "hasAdsTxt": true,
  "entries": 88,
  "directCount": 58,
  "resellerCount": 30,
  "uniqueAdSystems": 24,
  "topAdSystems": [{"adSystem": "google.com", "count": 14}],
  "duplicateCount": 0,
  "invalidLineCount": 1,
  "invalidLines": [{"line": 41, "text": "...", "error": "Expected at least 3 comma-separated fields, found 2"}],
  "sellersChecked": 52,
  "missingSellers": [{"line": 17, "adSystem": "example-exchange.com", "accountId": "12345", "reason": "account ID not listed in the exchange sellers.json"}],
  "checkedAt": "2026-11-16T12:00:00.000Z"
}
```

Values change as the files change. A domain with no file returns `hasAdsTxt: false`, a `fetchStatus` and null counts.

### Use cases

- **Ad-ops audits.** Run your publisher portfolio weekly and send rows with `invalidLineCount > 0` or a non-empty `missingSellers` to the person who owns the site.
- **Buyers and agencies.** Before buying, check that the seller's ads.txt lists the reseller you are dealing with as DIRECT or RESELLER, and that the account ID exists at the exchange.
- **SSP and exchange onboarding.** Verify that a new publisher actually added your account line, and that it is not duplicated or malformed.
- **App publishers.** Check app-ads.txt on developer domains for a whole app catalogue, including `OWNERDOMAIN` and `MANAGERDOMAIN` values.
- **Migrations and redesigns.** Catch the case where a CMS or CDN change turns `/ads.txt` into an HTML page or a redirect loop.
- **Research.** Count the top ad systems across a list of publishers.

### Pricing

Pay per event, no subscription. Current prices:

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Actor Start | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| Domain checked | $0.0019 | $0.00177 | $0.0015 | $0.00116 | $0.00116 | $0.00116 |

Tier follows your Apify subscription plan.

Apify's free plan includes monthly platform credit that covers test runs.

Examples at the current price (one `domain-check` event per result; Free-plan tier):

| You pull | You pay |
|---|---|
| 100 results | $0.19 |
| 1,000 results | $1.90 |
| 10,000 results | $19.00 |

Scheduled runs stay cheap when each run only returns new records.

### Integrations and scheduling

Schedule it weekly and send the results to Google Sheets, Slack, email, Make, Zapier or n8n with the Apify integrations, or call it through the REST API and the Python and JavaScript clients. A simple alert: filter rows where `fetchStatus` is not `ok`, `invalidLineCount` is above 0 or `missingSellers` is not empty.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~ads-txt-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"domains":["nytimes.com","forbes.com"],"maxItems":25}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/ads-txt-checker").call(run_input={"domains": ["nytimes.com", "forbes.com"], "maxItems": 25})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["fetchStatus"], row["invalidLineCount"])
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/ads-txt-checker`, paste the input JSON, then map the dataset items to your sheet.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/ads-txt-checker` to Claude, Cursor or any MCP client, and your agent can run this Actor as a tool.

### Fair use and legal

The Actor reads only files that sites publish openly for ad buyers and exchanges (`ads.txt`, `app-ads.txt` and `sellers.json`). It does not log in or bypass any protection, and it sends a normal browser-style request. Use the results for your own audits and respect each site's terms. This is an independent tool, not affiliated with the IAB Tech Lab or any exchange.

### FAQ

**Does it work for app-ads.txt?** Yes. Turn on **Check app-ads.txt** and give the developer website domain from the app store listing.

**What is the difference between DIRECT and RESELLER?** DIRECT means the publisher has a direct account with the ad system. RESELLER means the ad system may resell the inventory through a partner. Both are counted separately.

**Why is a line reported as invalid when my ad server accepts it?** Some systems are lenient. The Actor follows the IAB specification, so a line with the wrong number of fields or an unknown relationship is flagged. Check the `error` text and decide.

**Why does a site show `html_not_ads_txt`?** The server answered with a web page (often a soft 404 or a login or bot page) instead of a text file. Ad systems cannot read that either, so it is worth fixing.

**Why are some account IDs "unverifiable" instead of missing?** Not every exchange publishes sellers.json, and some block automated reads. Those lines are separated so you only act on real mismatches.

**How many domains can I check per run?** Set **Max rows** as high as you need. The Actor checks six domains at a time and stops cleanly before the run time limit, listing unchecked domains in the `OUTPUT` record.

**Are failed checks charged?** A domain with no file is charged, because the answer "no ads.txt" is a result. Rows where the site could not be reached at all (DNS error, timeout, TLS error, blocked address) are returned for your report but not charged. Invalid domain names are skipped and not charged.

### Support

Found a domain that reads badly? Open an issue on the Issues tab with the run URL and the domain name.

### Related actors

More tools from the same publisher that fit this workflow:

- [Competitor Ad Footprint by Domain](https://apify.com/transparent_meteorite/ad-footprint-by-domain): check a competitor domain for Google and Meta ads
- [Website Technology Versions & Confidence](https://apify.com/transparent_meteorite/website-tech-stack-detector): see which ad and analytics tech a site runs
- [Domain Intelligence Lookup](https://apify.com/transparent_meteorite/domain-intelligence-lookup): WHOIS, DNS, SPF, DMARC and SSL for the same domains
- [Technical SEO Audit](https://apify.com/transparent_meteorite/technical-seo-page-audit): crawl the site behind each domain
- [Sitemap Extractor](https://apify.com/transparent_meteorite/sitemap-link-inventory): list every URL from sitemap.xml

Use from AI agents: every actor here is callable through the Apify MCP server (mcp.apify.com).

### Changelog

- **0.1**: First private build. ads.txt and app-ads.txt parsing, line-level errors, duplicates, sellers.json cross-check.

# Actor input Schema

## `domains` (type: `array`):

Publisher or app developer domains, one per line: nytimes.com or https://www.example.com/. Paths and www are ignored.

## `maxItems` (type: `integer`):

Stops after this many rows (a domain checked for ads.txt and app-ads.txt is two rows).

## `checkAdsTxt` (type: `boolean`):

Fetch /ads.txt for each domain (websites).

## `checkAppAdsTxt` (type: `boolean`):

Also fetch /app-ads.txt for each domain (mobile and CTV apps; use the developer website domain).

## `crossCheckSellers` (type: `boolean`):

For every DIRECT line, look up the account ID in the ad system's sellers.json and list IDs that are not found in missingSellers. Exchanges without a readable sellers.json are listed in sellersUnverifiable, never as missing.

## Actor input object example

```json
{
  "domains": [
    "nytimes.com",
    "theguardian.com",
    "bbc.com",
    "forbes.com",
    "washingtonpost.com",
    "espn.com",
    "weather.com",
    "imdb.com",
    "nbcnews.com",
    "foxnews.com",
    "usatoday.com",
    "buzzfeed.com",
    "theverge.com",
    "wired.com",
    "engadget.com",
    "techcrunch.com",
    "mashable.com",
    "huffpost.com",
    "nypost.com",
    "latimes.com",
    "cnet.com",
    "zdnet.com",
    "pcmag.com",
    "variety.com",
    "billboard.com",
    "people.com"
  ],
  "maxItems": 26,
  "checkAdsTxt": true,
  "checkAppAdsTxt": false,
  "crossCheckSellers": true
}
```

# Actor output Schema

## `checks` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "nytimes.com",
        "theguardian.com",
        "bbc.com",
        "forbes.com",
        "washingtonpost.com",
        "espn.com",
        "weather.com",
        "imdb.com",
        "nbcnews.com",
        "foxnews.com",
        "usatoday.com",
        "buzzfeed.com",
        "theverge.com",
        "wired.com",
        "engadget.com",
        "techcrunch.com",
        "mashable.com",
        "huffpost.com",
        "nypost.com",
        "latimes.com",
        "cnet.com",
        "zdnet.com",
        "pcmag.com",
        "variety.com",
        "billboard.com",
        "people.com"
    ],
    "maxItems": 26
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/ads-txt-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "nytimes.com",
        "theguardian.com",
        "bbc.com",
        "forbes.com",
        "washingtonpost.com",
        "espn.com",
        "weather.com",
        "imdb.com",
        "nbcnews.com",
        "foxnews.com",
        "usatoday.com",
        "buzzfeed.com",
        "theverge.com",
        "wired.com",
        "engadget.com",
        "techcrunch.com",
        "mashable.com",
        "huffpost.com",
        "nypost.com",
        "latimes.com",
        "cnet.com",
        "zdnet.com",
        "pcmag.com",
        "variety.com",
        "billboard.com",
        "people.com",
    ],
    "maxItems": 26,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/ads-txt-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "nytimes.com",
    "theguardian.com",
    "bbc.com",
    "forbes.com",
    "washingtonpost.com",
    "espn.com",
    "weather.com",
    "imdb.com",
    "nbcnews.com",
    "foxnews.com",
    "usatoday.com",
    "buzzfeed.com",
    "theverge.com",
    "wired.com",
    "engadget.com",
    "techcrunch.com",
    "mashable.com",
    "huffpost.com",
    "nypost.com",
    "latimes.com",
    "cnet.com",
    "zdnet.com",
    "pcmag.com",
    "variety.com",
    "billboard.com",
    "people.com"
  ],
  "maxItems": 26
}' |
apify call transparent_meteorite/ads-txt-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/ads-txt-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oYWfXR1zTYqVyYcIz/builds/sMkcYPwMjyiDIc1cy/openapi.json
