The World's Largest Open-Source Database of app-ads.txt, ads.txt & sellers.json

🌟 What is AdsDB?

AdsDB is the most comprehensive, continuously updated, open-source repository of app-ads.txt, ads.txt, and sellers.json files ever assembled. We have scanned, crawled, and indexed the entire publicly accessible internet to build a single, unified database of every Authorized Digital Sellers file we can find — spanning over 50,000 domains, containing more than 49,000 app-ads.txt files and 1,400 sellers.json files, totaling over 3 GB of raw advertising supply chain data.

This is not a sample. This is not a demo. This is the real, complete, continuously-updated programmatic advertising supply chain of the internet — stored in a simple, navigable folder structure that anyone can clone, search, and analyze.

Whether you are a Demand-Side Platform (DSP) engineer validating bid requests, a Supply-Side Platform (SSP) compliance officer auditing your seller network, a data scientist researching the programmatic ecosystem, or a fraud analyst hunting for domain spoofing — AdsDB gives you the raw data you need without requiring you to build and maintain your own web crawler.

Keywords: Authorized Digital Sellers, app-ads.txt database, ads.txt database, sellers.json database, programmatic advertising data, ad fraud prevention dataset, IAB Tech Lab compliance, RTB supply chain, supply path optimization data, SSP sellers list, DSP bid validation, ad exchange transparency, mobile app advertising authorization, CTV ads.txt, OTT advertising supply chain, digital advertising fraud detection, domain spoofing prevention, ad inventory authorization, publisher ad monetization, advertising supply chain verification, OpenRTB supply chain object, schain validation, seller ID lookup, publisher ID database, ad network directory, global advertising ecosystem data.

🎯 Why AdsDB Exists — The Problem It Solves

The digital advertising industry moves $600+ billion per year globally. With that much money flowing through automated real-time bidding systems, fraud and opacity are massive problems.

The Scale of Ad Fraud

• $84 billion was lost to ad fraud globally in 2023 (Juniper Research)
• 1 in 5 programmatic ad impressions is estimated to be fraudulent
• Domain spoofing — where a bad actor pretends to be a premium publisher — accounts for billions in wasted ad spend annually
• Unauthorized reselling of ad inventory creates opaque supply chains where advertisers have no idea who they're actually buying from

The IAB's Solution: Transparency Files

The IAB Tech Lab created three interconnected specifications to combat this:

The problem? These files are scattered across hundreds of thousands of individual websites. To build a complete picture of the supply chain, you would need to:

1. Maintain a list of every publisher domain and app developer website on the internet
2. Continuously crawl each one to fetch their ads.txt / app-ads.txt files
3. Continuously crawl every SSP and ad exchange to fetch their sellers.json
4. Parse, normalize, and store all of this data
5. Keep it all up to date as publishers and exchanges modify their files daily

📊 Database Statistics at a Glance

These numbers grow daily as new publishers, app developers, SSPs, and ad exchanges are discovered and crawled.

📂 Repository Structure & How to Navigate

AdsDB organizes the entire internet's advertising authorization data into a simple, deterministic folder structure based on the first character of each domain name.

The Pattern

db/{first-character-of-domain}/{full-domain-name}/app-ads.txt
db/{first-character-of-domain}/{full-domain-name}/sellers.json

Folder Layout

db/
├── 0/                          # Domains starting with '0'
│   ├── 001.games/
│   │   └── app-ads.txt
│   └── ...
├── a/                          # Domains starting with 'a'
│   ├── adcolony.com/
│   │   └── sellers.json
│   ├── appnexus.com/
│   │   └── sellers.json
│   ├── applovin.com/
│   │   ├── app-ads.txt
│   │   └── sellers.json
│   └── ...
├── g/
│   ├── google.com/
│   │   └── sellers.json
│   └── ...
├── i/
│   ├── indexexchange.com/
│   │   └── sellers.json
│   ├── inmobi.com/
│   │   └── sellers.json
│   ├── ironsrc.com/
│   │   └── sellers.json
│   └── ...
├── o/
│   ├── openx.com/
│   │   └── sellers.json
│   └── ...
├── u/
│   ├── unity.com/
│   │   └── sellers.json
│   └── ...
├── v/
│   ├── vungle.com/
│   │   └── sellers.json
│   └── ...
└── z/

Quick Lookup Examples

Additional Index Files

📋 Complete Guide to app-ads.txt

What is app-ads.txt?

app-ads.txt (Authorized Digital Sellers for Applications) is a text file that mobile app developers and publishers host on their developer website to publicly declare which advertising systems, exchanges, and resellers are authorized to sell their in-app ad inventory.

It was introduced by the IAB Tech Lab in 2019 as an extension of the original ads.txt specification, adapted specifically for the mobile app and Connected TV (CTV) ecosystem.

Why Does app-ads.txt Exist?

In the mobile app world, ad inventory is sold through intermediaries — the app developer doesn't directly negotiate with every advertiser. Instead, they use monetization SDKs (like AdMob, AppLovin MAX, IronSource, Unity Ads) which connect to ad exchanges that run real-time auctions.

The problem: Without app-ads.txt, a bad actor could claim to be selling inventory for a popular app (say, a game with millions of downloads) without actually having any relationship with the app developer. Advertisers would bid on this fake inventory and waste their money on impressions that were never shown to real users inside the real app.

app-ads.txt solves this by creating a public, machine-readable declaration: "These are the ONLY companies authorized to sell my ad inventory."

Where is app-ads.txt Hosted?

Unlike ads.txt (which is hosted on the publisher's website), app-ads.txt is hosted on the developer website listed in the app store.

• On the Google Play Store, the developer website is listed in the app's store listing
• On the Apple App Store, the developer website is found in the app's metadata

For example, if an app developer's website is https://example-games.com, then their app-ads.txt file would be at https://example-games.com/app-ads.txt.

How DSPs and Ad Exchanges Use app-ads.txt

When a DSP receives a bid request for an in-app ad impression, the bid request contains the app bundle ID and the publisher domain. The DSP then:

1. Looks up the app in the app store to find the developer website
2. Fetches the app-ads.txt file from that website
3. Checks whether the exchange sending the bid request is listed as an authorized seller
4. If the exchange is NOT listed → the bid request is rejected as potentially fraudulent

app-ads.txt Adoption Statistics

• Over 80% of top-grossing mobile apps on Google Play have an app-ads.txt file
• Over 70% of top-grossing iOS apps have an app-ads.txt file
• Major DSPs like The Trade Desk, DV360 (Google), and MediaMath require valid app-ads.txt before bidding
• Ad networks like AdMob, AppLovin, Unity Ads, IronSource, and Vungle all participate in the app-ads.txt ecosystem

📋 Complete Guide to ads.txt

What is ads.txt?

ads.txt (Authorized Digital Sellers) is a simple text file that web publishers place at the root of their domain to publicly declare which companies are authorized to sell their digital advertising inventory. Originally proposed by the IAB Tech Lab in 2017, ads.txt was the first of the transparency files designed to combat ad fraud in the programmatic advertising supply chain.

How ads.txt Works

A publisher like example-news.com places a file at https://example-news.com/ads.txt. This file contains a list of entries, each representing an authorized seller with:

• The domain of the advertising system (SSP/exchange)
• The publisher's account ID within that system
• The relationship type (DIRECT or RESELLER)
• An optional certification authority ID (typically the TAG ID)

Example ads.txt Entry

google.com, pub-1234567890, DIRECT, f08c47fec0942fa0
indexexchange.com, 12345, RESELLER, 50b1c356f2c5c8fc
openx.com, 67890, RESELLER, a698e2ec2f3ecb1b

This tells the world: Google is authorized to directly sell this publisher's inventory, while Index Exchange and OpenX are authorized resellers.

ads.txt vs app-ads.txt

The Impact of ads.txt on the Industry

• Reduced domain spoofing by an estimated 10-15% industry-wide
• Become a requirement for major DSPs before they will bid on inventory
• Led to the creation of the entire IAB transparency stack (app-ads.txt, sellers.json, SupplyChain object)
• Empowered publishers to publicly control who profits from their content

📋 Complete Guide to sellers.json

What is sellers.json?

sellers.json is a JSON file hosted by advertising exchanges, Supply-Side Platforms (SSPs), and ad networks that lists all of the publishers, app developers, and intermediaries they are authorized to sell ad inventory on behalf of.

While ads.txt and app-ads.txt are the publisher's declaration ("these exchanges can sell my inventory"), sellers.json is the exchange's declaration ("these are the publishers and intermediaries whose inventory I sell").

Together, they form a two-way verification system — a publisher says "Exchange X can sell my ads," and Exchange X says "Publisher Y is in my network." If both match, the supply path is verified.

Where is sellers.json Hosted?

Every SSP and ad exchange that participates in OpenRTB is expected to host a sellers.json file at their domain root:

https://google.com/sellers.json
https://openx.com/sellers.json
https://indexexchange.com/sellers.json
https://pubmatic.com/sellers.json
https://rubiconproject.com/sellers.json

sellers.json File Size

sellers.json files can be massive. Major exchanges like Google, PubMatic, and Index Exchange have sellers.json files that are tens of megabytes to over 100 MB because they list hundreds of thousands of sellers. AdsDB stores all of these files, including the very large ones via Git LFS.

What's Inside a sellers.json File?

• Contact information for the exchange
• An array of sellers, each with: seller_id, seller_type (PUBLISHER, INTERMEDIARY, or BOTH), name, domain, is_confidential, and is_passthrough

Example sellers.json Structure

{
  "contact_email": "adops@example-exchange.com",
  "contact_address": "123 Ad Street, New York, NY",
  "version": "1.0",
  "identifiers": [
    { "name": "TAG-ID", "value": "abc123def456" }
  ],
  "sellers": [
    {
      "seller_id": "pub-1234567890",
      "seller_type": "PUBLISHER",
      "name": "Example News Corp",
      "domain": "example-news.com",
      "is_confidential": 0
    },
    {
      "seller_id": "reseller-9999",
      "seller_type": "INTERMEDIARY",
      "name": "Ad Reseller Inc",
      "domain": "adreseller.com",
      "is_confidential": 0
    }
  ]
}

🔗 How ads.txt, app-ads.txt, and sellers.json Work Together

The true power of the IAB transparency stack is realized when all three files are used together to verify the entire supply chain from publisher to advertiser.

The Complete Verification Flow

Cross-Referencing with AdsDB

With AdsDB, you can automate this entire verification flow:

1. Read the publisher's app-ads.txt from db/{letter}/{domain}/app-ads.txt
2. Extract all authorized exchanges and their account IDs
3. Read each exchange's sellers.json from db/{letter}/{exchange-domain}/sellers.json
4. Cross-reference the account IDs to verify the supply chain
5. Flag any mismatches — these are potential fraud indicators

⛓ Supply Chain Object (schain) Explained

What is the SupplyChain Object?

The SupplyChain object (commonly called schain) is an OpenRTB extension that allows each participant in the ad supply chain to add a "node" representing themselves, creating a complete, ordered list of every intermediary between the publisher and the DSP.

How schain Relates to ads.txt and sellers.json

• ads.txt / app-ads.txt tell you WHO is authorized
• sellers.json tells you WHO the exchange works with
• schain tells you the EXACT PATH a specific bid request traveled through

AdsDB provides the reference data needed to validate each node in an schain — look up the exchange's sellers.json to verify the asi and sid, then cross-reference with the publisher's app-ads.txt.

schain Validation Example

When a DSP receives an schain like:

{
  "schain": {
    "ver": "1.0",
    "complete": 1,
    "nodes": [
      { "asi": "exchange1.com", "sid": "pub-111", "hp": 1 },
      { "asi": "exchange2.com", "sid": "reseller-222", "hp": 1 }
    ]
  }
}

Using AdsDB, you can:

1. Open db/e/exchange1.com/sellers.json → verify pub-111 exists and is a PUBLISHER
2. Open db/e/exchange2.com/sellers.json → verify reseller-222 exists and is an INTERMEDIARY
3. Check the publisher's app-ads.txt → verify both exchanges are listed

🎯 Use Cases — Who Is This For?

🏢 Major Ad Networks & SSPs Indexed in AdsDB

AdsDB contains sellers.json files from all major advertising platforms, including but not limited to:

Global Tier-1 SSPs & Exchanges

Mobile & In-App Focused

RTB & Programmatic Specialists

And 1,400+ more exchanges, networks, and intermediaries from every region of the world.

🚀 How to Use This Data

Prerequisites

Because some sellers.json files exceed 100 MB, this repository uses Git LFS (Large File Storage). Make sure you have it installed.

Cloning the Repository

# Step 1: Install Git LFS (if not already installed)
git lfs install

# Step 2: Clone the full AdsDB repository
git clone https://github.com/KONTRUSTMEDIA/adsdb.git

# Step 3: Navigate into the database
cd adsdb/db/

Quick Search with Command-Line Tools

# Find all sellers.json files
find db/ -name "sellers.json" -type f

# Find all app-ads.txt files
find db/ -name "app-ads.txt" -type f

# Search for a specific ad network across all app-ads.txt files
grep -r "google.com" db/ --include="app-ads.txt" | head -20

# Search for a specific publisher in all sellers.json files
grep -r "example-publisher.com" db/ --include="sellers.json"

# Count how many publishers authorize Google AdMob
grep -rl "google.com" db/ --include="app-ads.txt" | wc -l

# Find all DIRECT relationships in a specific app-ads.txt
grep "DIRECT" db/a/applovin.com/app-ads.txt

Parsing sellers.json with jq

# List all seller IDs in Google's sellers.json
jq '.sellers[].seller_id' db/g/google.com/sellers.json

# Find a specific seller by domain
jq '.sellers[] | select(.domain == "example.com")' db/g/google.com/sellers.json

# Count total sellers in an exchange's sellers.json
jq '.sellers | length' db/o/openx.com/sellers.json

# List all PUBLISHER type sellers
jq '.sellers[] | select(.seller_type == "PUBLISHER")' db/i/indexexchange.com/sellers.json

# Find confidential sellers
jq '.sellers[] | select(.is_confidential == 1)' db/g/google.com/sellers.json

💻 Querying the Database with Code Examples

Python: Load and Analyze app-ads.txt

import os
from collections import Counter

def parse_app_ads_txt(filepath):
    """Parse an app-ads.txt file and return structured entries."""
    entries = []
    with open(filepath, 'r', errors='ignore') as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            parts = [p.strip() for p in line.split(',')]
            if len(parts) >= 3:
                entries.append({
                    'domain': parts[0].lower(),
                    'account_id': parts[1],
                    'relationship': parts[2].upper(),
                    'authority_id': parts[3] if len(parts) > 3 else None
                })
    return entries

# Find the most popular ad networks across all app-ads.txt files
network_counter = Counter()
db_path = 'db/'

for letter_dir in os.listdir(db_path):
    letter_path = os.path.join(db_path, letter_dir)
    if not os.path.isdir(letter_path):
        continue
    for domain_dir in os.listdir(letter_path):
        ads_file = os.path.join(letter_path, domain_dir, 'app-ads.txt')
        if os.path.exists(ads_file):
            for entry in parse_app_ads_txt(ads_file):
                network_counter[entry['domain']] += 1

for network, count in network_counter.most_common(20):
    print(f"{network}: {count} publishers")

Python: Cross-Reference app-ads.txt with sellers.json

import json, os

def load_sellers_json(filepath):
    """Load sellers.json and return a dict of seller_id -> seller_info."""
    with open(filepath, 'r', errors='ignore') as f:
        data = json.load(f)
    return {str(s.get('seller_id', '')): s for s in data.get('sellers', [])}

def verify_supply_chain(publisher_domain, exchange_domain, account_id):
    """Verify a supply chain entry is valid using AdsDB data."""
    first_char = publisher_domain[0].lower()
    ads_path = f'db/{first_char}/{publisher_domain}/app-ads.txt'

    if not os.path.exists(ads_path):
        return 'NO_ADS_TXT'

    entries = parse_app_ads_txt(ads_path)
    authorized = any(
        e['domain'] == exchange_domain and e['account_id'] == account_id
        for e in entries
    )
    if not authorized:
        return 'NOT_AUTHORIZED'

    ex_char = exchange_domain[0].lower()
    sellers_path = f'db/{ex_char}/{exchange_domain}/sellers.json'
    if not os.path.exists(sellers_path):
        return 'NO_SELLERS_JSON'

    sellers = load_sellers_json(sellers_path)
    return 'VERIFIED' if account_id in sellers else 'SELLER_NOT_FOUND'

# Example
result = verify_supply_chain('example-app.com', 'google.com', 'pub-1234567890')
print(f"Verification result: {result}")

Node.js: Stream-Parse Large sellers.json Files

const fs = require('fs');
const path = require('path');
const JSONStream = require('JSONStream');

function streamSellersJson(exchangeDomain) {
  const firstChar = exchangeDomain[0].toLowerCase();
  const filePath = path.join('db', firstChar, exchangeDomain, 'sellers.json');

  return new Promise((resolve, reject) => {
    const sellers = [];
    fs.createReadStream(filePath)
      .pipe(JSONStream.parse('sellers.*'))
      .on('data', (seller) => sellers.push(seller))
      .on('end', () => resolve(sellers))
      .on('error', reject);
  });
}

async function main() {
  const sellers = await streamSellersJson('openx.com');
  const publishers = sellers.filter(s => s.seller_type === 'PUBLISHER');
  console.log(`OpenX has ${publishers.length} direct publishers`);
  console.log(`OpenX has ${sellers.length} total sellers`);
}

main().catch(console.error);

Bash: Generate a Report for a Domain

#!/bin/bash
DOMAIN=$1
FIRST_CHAR=$(echo "$DOMAIN" | cut -c1 | tr '[:upper:]' '[:lower:]')
ADS_FILE="db/${FIRST_CHAR}/${DOMAIN}/app-ads.txt"

if [ ! -f "$ADS_FILE" ]; then
    echo "No app-ads.txt found for $DOMAIN"; exit 1
fi

echo "=== Authorized Sellers for $DOMAIN ==="
echo ""
echo "DIRECT relationships:"
grep -i "DIRECT" "$ADS_FILE" | grep -v "^#" | sort
echo ""
echo "RESELLER relationships:"
grep -i "RESELLER" "$ADS_FILE" | grep -v "^#" | sort
echo ""
echo "Total DIRECT: $(grep -ci 'DIRECT' "$ADS_FILE")"
echo "Total RESELLER: $(grep -ci 'RESELLER' "$ADS_FILE")"

📝 Understanding the app-ads.txt File Format In Depth

Line Format

<exchange_domain>, <seller_account_id>, <relationship_type>, [<authority_id>]

Relationship Types

• DIRECT — The publisher has a direct account with the advertising system. Most transparent and trusted.
• RESELLER — The publisher's inventory is sold through an intermediary. Adds complexity to the supply chain.

Special Directives

Common Pitfalls

1. Wrong domain format — Using www.google.com instead of google.com
2. Incorrect seller IDs — Typos in the account ID prevent verification
3. Missing entries — Not listing all exchanges means DSPs won't bid through those exchanges
4. Stale entries — Listing exchanges you no longer work with
5. Incorrect relationship type — Marking RESELLER as DIRECT or vice versa

📝 Understanding the sellers.json File Format In Depth

Top-Level Fields

Seller Object Fields

Seller Types Explained

• PUBLISHER — Directly owns ad inventory. This is the origin of the supply chain.
• INTERMEDIARY — Resells inventory from others. Adds a layer to the supply chain.
• BOTH — Acts as both publisher (for some inventory) and intermediary (for other inventory).

Confidential Sellers

Some sellers are marked as is_confidential: 1. The exchange has chosen not to publicly disclose their identity. While allowed by the spec, it reduces transparency and can be a red flag for fraud analysts.

🛡 Ad Fraud Prevention with AdsDB

Types of Ad Fraud That AdsDB Helps Detect

Building a Fraud Detection Pipeline

📈 Supply Path Optimization (SPO) with AdsDB

What is Supply Path Optimization?

Supply Path Optimization (SPO) is the practice of reducing the number of intermediaries between an advertiser and a publisher to minimize fees, reduce latency, and increase transparency.

The same ad impression can often be purchased through multiple supply paths:

All three paths lead to the same impression, but Path A is most efficient. SPO is about identifying and preferring Path A.

How AdsDB Enables SPO

1. Map all available supply paths by reading a publisher's app-ads.txt
2. Identify DIRECT vs RESELLER — DIRECT paths are shorter and cheaper
3. Trace intermediary chains via INTERMEDIARY entries in sellers.json
4. Score supply paths based on transparency, hops, and authorization completeness
5. Build a global supply path graph across all 50,000+ domains

SPO Metrics You Can Calculate with AdsDB

📚 Programmatic Advertising Glossary

Core Concepts

Players in the Ecosystem

Transparency & Authorization

Fraud & Security

Mobile & App Specific

📐 IAB Tech Lab Standards & Specifications

AdsDB is built on top of the official specifications published by the IAB Tech Lab.

How These Specs Interconnect

❓ Frequently Asked Questions (FAQ)

General Questions

Technical Questions

Data Quality Questions

🤝 Contributing & Updates

The internet is constantly evolving. We strive to keep AdsDB as comprehensive and up-to-date as possible.

How to Contribute

1. Report a missing domain — Open an Issue on GitHub with the domain name.
2. Report outdated data — Let us know so we can re-crawl.
3. Submit a Pull Request — If you've crawled additional domains, submit a PR following our directory structure.
4. Suggest improvements — Ideas for new index files, better organization, or additional metadata are welcome.

⚖️ Legal & Compliance

Data Source

All data is sourced from publicly accessible URLs as intended by the IAB Tech Lab specifications. The entire purpose of ads.txt, app-ads.txt, and sellers.json is to be publicly available and machine-readable.

License

This project is licensed under the MIT License. You are free to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of this data and software.

Disclaimer

• AdsDB is provided "as-is" without warranty of any kind
• Not affiliated with or endorsed by the IAB Tech Lab
• Data reflects real-world state of publicly accessible files and may contain errors
• Users are responsible for their own compliance with applicable laws

Privacy

• No personal data is collected or stored
• All data is sourced from files intentionally made public by publishers and exchanges
• Confidential entries in sellers.json are stored as found

🙏 Acknowledgements

• IAB Tech Lab — For creating the ads.txt, app-ads.txt, sellers.json, and SupplyChain specifications
• Trustworthy Accountability Group (TAG) — For anti-fraud certification programs
• The entire AdTech community — For adopting transparency standards

🔍 Topics Covered in This Repository

Primary Topics

app-ads.txt database download, sellers.json database download, ads.txt database download, programmatic advertising transparency data, authorized digital sellers database, global app-ads.txt repository, sellers.json files for all SSPs, ad fraud prevention open source data, IAB Tech Lab compliance database, RTB supply chain data.

Related Search Terms

How to verify ads.txt, how to check app-ads.txt, sellers.json lookup tool, find sellers.json for any exchange, app-ads.txt for mobile apps, ads.txt for CTV and OTT, supply path optimization data, programmatic supply chain graph, list of all SSPs and ad exchanges, ad exchange sellers.json files, publisher ads.txt files database, authorized digital sellers list, app-ads.txt verification, sellers.json parser, ads.txt crawler data, bulk ads.txt download, bulk sellers.json download, programmatic advertising dataset, digital advertising supply chain data, ad tech transparency files.

Ad Networks and Platforms

Google AdMob sellers.json, Google Ad Exchange sellers.json, OpenX sellers.json, Index Exchange sellers.json, AppNexus Xandr sellers.json, Magnite Rubicon Project sellers.json, PubMatic sellers.json, Unity Ads sellers.json, IronSource sellers.json, InMobi sellers.json, Mintegral sellers.json, Liftoff Vungle sellers.json, Chartboost sellers.json, AppLovin sellers.json, RTB House sellers.json, Rakuten sellers.json, Roku sellers.json.

Industry Standards

IAB ads.txt specification, IAB app-ads.txt specification, IAB sellers.json specification, IAB OpenRTB 2.6 specification, IAB SupplyChain Object specification, TAG Trustworthy Accountability Group, TAG certification authority ID, TAG anti-fraud certification.