Mobile supply verification

Verified in-app supply.

Stoqlab reads the app-ads.txt behind App Store and Google Play apps and checks every line against the network's own sellers.json, so you know which seller accounts are really authorised before you buy, sell or curate.

  • Seller IDs a network no longer lists
  • DIRECT lines on reseller accounts
  • Apps pulled from the store, files still live
  • Every app that declares your network
  • Reseller paths up to four hops deep
  • Each file's history, with dates
Top apps re-read
Daily
Reseller chain
Up to 4 hops
Use it from
Web, API, MCP
E

Example Puzzle Quest

Google Play · com.example.puzzle

app-ads.txt · Found
Declared supply tree developer → direct seller → reseller
Example Games Ltd developer
└ google.com Verified
└ applovin.com Verified
└ pubmatic.com Verified
└ rubiconproject.com Verified
└ ssp-one.example Seller ID not found
└ exchange-two.example DIRECT but intermediary

Reseller, intermediary not matched

└ video-net.example RESELLER but publisher
Illustrative example 7 lines · 3 levels · 3 problems

Live coverage

Counted 19 Nov 2026, 22:16 UTC, recounted every 10 minutes

Apps tracked
6.2M+
2.5M+ iOS · 3.6M+ Android
Developer sites checked
1.9M+
320k+ had an app-ads.txt
sellers.json files read
1,500+
Developers
2.4M+

Worked example

Four lines from one file, and what we found

Below is part of a developer's app-ads.txt. Every line looks fine on its own. Three of them fall apart once you open the network's sellers.json. The domains are made up; the checks are the ones Stoqlab runs on every line it reads.

  1. google.com, pub-1234567890123456, DIRECT, f08c47fec0942fa0

    sellers.json: Lists pub-1234567890123456 as PUBLISHER, “Example Games Ltd”.

    Verified

    DIRECT line, publisher account. Nothing to do.

  2. exchange-two.example, 88412, DIRECT

    sellers.json: Lists 88412 as INTERMEDIARY, “Mediation Partner Inc”.

    DIRECT but intermediary

    The file claims a direct account; the exchange says a reseller holds it. Buyers who check will price this path as resold.

  3. ssp-one.example, 540421, RESELLER

    sellers.json: No seller 540421. It was listed until 12 August, then removed.

    Seller ID not found

    A stale line. It still reads as an authorisation until the developer deletes it.

  4. video-net.example, vn-7731, RESELLER

    sellers.json: Lists vn-7731 as PUBLISHER, “Other Studio GmbH”.

    RESELLER but publisher

    Another publisher's own account in this app's file. Usually a line copied from someone else's template.

Every status we assign is defined on the methodology page.

Why this breaks

Two files, two owners, nobody keeping them in sync

The developer writes app-ads.txt. The network writes sellers.json. Each can be valid while the pair contradicts itself, and both get overwritten in place, so last month's version is simply gone. To catch the gaps you have to join the two for every app, then do it again tomorrow.

Lines that outlive the deal
SDK onboarding guides hand developers long blocks of RESELLER lines. Few people remove them when a partnership ends, so the file keeps authorising accounts nobody has used in a year.
Accounts that quietly disappear
A network closes a seller account and drops it from sellers.json. The publisher's file still lists it. Neither side is notified.
Apps pulled from the store
An app gets removed from the App Store or Google Play. Its app-ads.txt stays online, and the sellers declaring it keep going.
No record of what changed
Ask when a line was added or a seller removed and most teams can't answer. We keep every distinct version of each file with its dates.

Use cases

Who uses it, and for what

Same data, read from different ends of the chain. Where a feature needs a paid plan, the plan is named.

Supply-path optimisation

SSPs and exchanges

  • Every app that declares your domain, filtered by DIRECT or RESELLER
  • The intermediaries between an app and you, hop by hop Professional
  • Changes to the files that name you, in a daily feed or a webhook Professional
  • Your share of tracked files, week by week Business

Unauthorised reseller detection

DSPs and verification teams

  • Look up a seller ID: which apps list it, and does the network agree
  • Flag paths through missing, mistyped or confidential seller accounts Professional
  • Drop delisted apps and apps without app-ads.txt from your lists
  • Export the result as a bundle list, or pull it over the API

Watching your own app-ads.txt

Publishers and studios

  • The exact lines whose seller ID your partner no longer lists Professional
  • Check a new file with the domain checker before it goes live
  • Every version of your file, with what was added and removed Professional
  • A webhook when your file or a partner's sellers.json changes Professional

Auditing your sellers.json

Networks and mediation platforms

  • IDs publishers declare for you that your sellers.json doesn't list Business
  • How many lines call your INTERMEDIARY accounts DIRECT
  • Each of your seller accounts, and how often publishers declare it
  • Changes to your sellers.json, seller by seller, in the change feed Professional

How it works

From a store listing to a checked supply path

  1. 1

    Find the apps

    We walk the App Store and Google Play sitemaps and the public top charts, and read each listing: developer, website, installs, ratings, version, and whether the app is still up.

  2. 2

    Fetch app-ads.txt

    From the website the store lists, following the IAB redirect rules. Every record and variable is parsed, bad lines are flagged, and each new version is stored.

  3. 3

    Look up sellers.json

    For each network a file names, we read its sellers.json and test every line: is the account there, does its type match DIRECT or RESELLER, is it confidential.

  4. 4

    Follow and record

    When the seller is an intermediary that runs its own sellers.json, we follow it, up to four hops, never in a loop. Every change becomes a dated event.

Top apps have their app-ads.txt re-read daily, apps with ads weekly, the long tail monthly; a file that just changed is read again within 24 hours. A line counts as verified when the network's sellers.json lists its account with the type the line declares. Full schedule and status definitions

Product

What you get

One record per app, joining its store listing, its app-ads.txt and the sellers.json of every network in it, refreshed on a published schedule, with every earlier version kept.

Supply tree

Read the way buyers do: the developer, its direct sellers, and the resellers buying from each of them, matched through sellers.json, up to four hops.

Seller checks

Every line against the network's sellers.json: IDs that aren't there, DIRECT lines on reseller accounts, RESELLER lines on publisher accounts, confidential sellers.

Change history

Each distinct app-ads.txt version with first- and last-seen dates and a line diff. sellers.json changes per seller. A daily feed of both.

Store data

Exact Google Play install counts, ratings, versions, chart positions, related apps, privacy labels, and per-country availability for top apps.

Delistings

An app that vanishes from its store is marked delisted, with the date, after misses on separate days. You can see which sellers still declare it.

Domain checker

Enter any developer domain, tracked or not. The crawler reads its app-ads.txt, usually within a couple of minutes, and checks each line.

Lists and exports

Save a filter (store, category, installs, network, relationship, file health, delisted) and it refreshes daily. Export CSV, JSON Lines or a bundle list.

Alerts and webhooks

Watch apps, domains or networks. When a file, a seller or a listing changes, you get an in-app alert or a signed webhook.

API and MCP

Everything in the dashboard is in the API

Create a key in the dashboard and call api.stoqlab.com/v1 with it as a bearer token. Responses are plain JSON with one pagination and error format throughout. List endpoints also stream CSV, and there is an OpenAPI 3.1 spec to generate a client from.

  • GET /v1/apps/{store}/{store_id}/supply-tree The declared tree, nested
  • GET /v1/apps/{store}/{store_id}/appads-history Every version of the file
  • GET /v1/networks/{domain}/apps Apps that declare a network
  • GET /v1/networks/{domain}/stale-sellers Declared IDs missing from sellers.json
  • GET /v1/sellers/{domain}/{seller_id}/apps Apps selling through one account
  • GET /v1/changes Change feed, cursor-based

MCP server for AI assistants

Ask Claude "which apps list exchange-two.com as RESELLER?" or "what changed in sellers.json files this week?". The tools are read-only, MCP keys expire on their own, and the API rate limits apply.

claude mcp add --transport http stoqlab https://api.stoqlab.com/mcp \
  --header "Authorization: Bearer $STOQLAB_TOKEN"

Read the API reference · MCP guide

supply-tree (sample response, shortened)
$ curl -s "https://api.stoqlab.com/v1/apps/android/com.example.puzzle/supply-tree?view=forward" \
    -H "Authorization: Bearer $STOQLAB_TOKEN"

{
  "data": {
    "view": "forward",
    "direct_sellers": [{
      "level": 1,
      "ad_system": { "domain": "applovin.com" },
      "relationship": "DIRECT",
      "seller": { "type": "PUBLISHER", "domain": "example.com" },
      "resellers": 3,
      "children": [{
        "level": 2,
        "ad_system": { "domain": "pubmatic.com" },
        "relationship": "RESELLER",
        "match": { "by": "seller_domain" },
        "children": [ … ]
      }]
    }]
  }
}

Method

Every status traces back to a file and a date

Nothing on Stoqlab is modelled or estimated. Each status points to the app-ads.txt line it came from, the sellers.json entry it was checked against, and when we read both.

Public files only
Store listings, plus the files sites publish for machines: app-ads.txt, sellers.json, robots.txt. We never log in, fill in forms or run scripts.
A crawler with a name
StoqlabBot says who it is in its user agent, obeys robots.txt on every host and redirect, honours Retry-After, and sends only a few requests per site.
What we keep
The lines each file declares and the dates they changed. We don't republish pages, images or app descriptions.
What we can't see
Auctions, bids and impressions. The files say who may sell an app's inventory; we have no bidstream, device panel or SDK data to say who did.

FAQ

Common questions

Not covered here? Ask us.

What is Stoqlab?

Stoqlab checks the supply chain of mobile apps. It reads the app-ads.txt file behind App Store and Google Play apps, looks up every line in the sellers.json of the network it names, and follows resellers up to four hops. Every change to either file is kept with its date. You can use it in a web dashboard, over a REST API, or from an AI assistant through a read-only MCP server.

What is app-ads.txt?

A plain-text file, defined by IAB Tech Lab, that an app developer hosts on the website listed in the store. Each line names a network, the developer's account ID at that network, and DIRECT or RESELLER. Buyers read it to tell an authorised seller of the app's inventory from one that isn't.

What is sellers.json?

The network's side of the same agreement. Each network publishes a list of its seller accounts, each with a type (PUBLISHER, INTERMEDIARY or BOTH) and usually a name and domain. A DIRECT line in app-ads.txt should match a PUBLISHER account there, a RESELLER line an INTERMEDIARY. When they don't match, one of the two files is wrong.

What is a stale seller?

An app-ads.txt line whose account ID is not in the network's sellers.json. Usually the account was closed or the ID has a typo. The line still reads as an authorisation, and a buyer can't tell it from a valid one without checking. Publishers should remove it; buyers should treat that path as unverified.

How many apps does Stoqlab cover?

As of 19 November 2026, Stoqlab tracks 6.2M+ live apps (2.5M+ iOS, 3.6M+ Android), has checked the app-ads.txt of 1.9M+ developer hosts (320k+ files found) and reads the sellers.json of 1,500+ networks. Apps come from the App Store and Google Play sitemaps and public top charts. Apple TV apps are included on Professional and above.

How fresh is the data?

It depends on the app. Top apps (on a store chart in the past week, or with a million installs or 50,000 ratings) have their app-ads.txt read daily, apps with ads or an app-ads.txt weekly, and the long tail monthly. A file that just changed is read again within a day. sellers.json is read daily for networks named in 20 or more files and weekly for the rest. The methodology page has the details.

Where does the data come from?

Public files only: App Store and Google Play listings, the app-ads.txt on the developer's website, and each network's sellers.json. Our crawler, StoqlabBot, identifies itself and follows robots.txt. We have no SDK, no device panel and no bidstream feed.

Can I check a domain you don't track yet?

Yes, with any account, including the free one. Type the developer domain into the domain checker. The crawler fetches its app-ads.txt, usually within a couple of minutes, and you get every line with its sellers.json result.

How is this different from an app-ads.txt validator?

A validator checks that one file is well formed. Stoqlab checks each line against the network's own sellers.json, follows resellers past the first hop, keeps every version of both files, and does it across the whole catalogue, so a network can ask the reverse question: which apps declare us, and which of those account IDs no longer exist? It is also not a download or revenue estimator. We report what the files say.

How do the API and MCP server work?

The REST API lives at https://api.stoqlab.com/v1. Create a key in the dashboard and send it as a bearer token. You get JSON with the same pagination and error format on every endpoint, CSV streaming on list endpoints, and an OpenAPI 3.1 spec. The MCP server at https://api.stoqlab.com/mcp (Streamable HTTP) exposes the same data as read-only tools for Claude and other assistants, under the same rate limits.

Do you have impression or bidstream data?

No. We see what publishers and networks declare and when that changes. We don't see auctions, bids, impressions or SDK traffic, so we can't tell you how much a path is actually used.

Why is there no self-serve checkout?

For now we set up every account by hand. You tell us what you need covered, we confirm we have it, then we create your users and send an invoice, annual or monthly. API keys you create yourself in the dashboard.

Who operates Stoqlab?

Stoqlab is operated by ARHAI LLC, registered at 8 The Green, Suite A, Dover, Delaware 19901, United States. Requests go through the contact form on stoqlab.com.

Can we license the full dataset?

Yes, on Enterprise Data: daily CSV and Parquet files of apps, app-ads.txt lines, sellers and changes, delivered on a schedule, plus coverage of the storefronts, apps and hosts you name. Talk to sales.

Tell us which apps or networks you need checked

We'll confirm we cover them, suggest a plan, and set up your account.