App Store scraper API

App stores · v1.1.0 · app_store_apps

$0.0008 / app

$0.80 / 1K · pay per delivered app

An App Store scraper API that searches Apple's store or resolves a list of app ids, bundle ids and store URLs — returning title, developer, category, rating and review count, price, version, release and update dates, content rating, size, icon and screenshots.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0008 per delivered app · $2 free every month · Failed runs never billed

What it does

What an App Store scraper API does

Apple publishes the store itself as a plain JSON endpoint, which makes this the cheapest kind of data we sell: no key, no browser, no HTML to parse, and a whole result set in one round trip.

Because the source is Apple's own, the fields are exactly what the store believes today — including the current-version rating alongside the all-time one, which is the pair that tells you whether a recent release went well.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`term`	string	no	What to search in the App Store. Omit when passing app_ids.
`app_ids`	array	no	Numeric app ids, bundle ids (com.spotify.client) or store URLs.
`country`	string	no	ISO 3166-1 alpha-2 code — picks the local site AND the proxy exit (default us).
`lang`	string	no	Interface language (hl), e.g. en, it, de.
`max_results`	integer	no	How many apps to deliver at most (1–200). You pay only for delivered apps.

Outputs — 35 fields, one row per app

What one app looks like

Every delivered app carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position.
`app_id`	string	Apple app id.
`bundle_id`	string · nullable	Bundle identifier.
`title`	string	App name.
`developer`	string · nullable	Seller/developer.
`developer_url`	string · nullable	Developer URL.
`category`	string · nullable	Primary genre.
`categories`	string[]	All genres.
`rating`	number · nullable	Average rating (all versions).
`reviews`	integer · nullable	Rating count.
`rating_current_version`	number · nullable	Average rating for the current version.
`price`	number · nullable	Numeric price (0 = free).
`price_formatted`	string · nullable	Price as shown.
`currency`	string · nullable	Currency code.
`version`	string · nullable	Current version.
`released_at`	string · nullable	First release date (ISO).
`updated_at`	string · nullable	Current version release date (ISO).
`content_rating`	string · nullable	Age rating.
`size_bytes`	number · nullable	Download size in bytes.
`icon`	string · nullable	Icon URL (512px when available).
`screenshots`	string[]	Up to 5 screenshot URLs.
`description`	string · nullable	Store description (trimmed).
`url`	string	Store URL.
`developer_id`	string · nullable	Apple developer id.
`developer_store_url`	string · nullable	The developer's page on the App Store.
`seller`	string · nullable	Legal seller name.
`category_id`	string · nullable	Primary genre id.
`reviews_current_version`	integer · nullable	Rating count for the current version.
`release_notes`	string · nullable	What's new in the current version (trimmed).
`minimum_os`	string · nullable	Minimum iOS version.
`languages`	string[]	Supported languages (ISO codes).
`devices`	string[]	Device families supported (iPhone, iPad, Mac, Watch…).
`game_center`	boolean	Game Center enabled.
`advisories`	string[]	Content advisories.
`ipad_screenshots`	string[]	iPad screenshot URLs (up to 5).

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/app_store_apps/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/app_store_apps/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"term":"podcast player","country":"us","max_results":20}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/app_store_apps/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "term": "podcast player",
        "country": "us",
        "max_results": 20
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/app_store_apps/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"term":"podcast player","country":"us","max_results":20}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the app_store_apps collector with term="podcast player" and country="us"

Example response

POST /v1/scraper/collectors/app_store_apps/run

$ curl $QD/app_store_apps/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"term": "podcast player", "country": "us", "max_results": 20}'
{ "status": "done", "count": 20,
  "results": [
    {
      "app_id": "…",
      "bundle_id": "…",
      "title": "…",
      "developer": "…" } ],
  "cost": 0.016 }
# 20 apps × $0.0008 · nothing delivered, nothing charged

Try it

App Store apps, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

App Store scraper API: from term and country, QuanticData reads the App Store results and returns one row per app with title, developer and category, at $0.0008 per delivered app. — You send term and app_ids; the run goes out through a residential exit and comes back as apps with rank, app_id and bundle_id — 35 fields on every row — and you are billed $0.0008 for each app actually delivered, nothing for a run that delivers none.

$0.0008 / app2,500 apps on the free $2 every month

Semantic inputterm, app_ids, country — no URL lists

Up to 200apps per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

App Store scraper API pricing

$0.0008 per delivered app. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,500 apps before you spend anything.

$0.0008per delivered app$0.8 per 1,000 delivered apps

2,500 appson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the App Store scraper API

Three shapes of work this endpoint was designed around.

App market research

Search a category and rank the field by rating and review count.

Release monitoring

Track version and update date for a watchlist of apps.

ASO benchmarking

Compare titles, categories and screenshot counts across competitors.

App Store scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Auth	Scraping the web store with proxies	Apple's public store endpoint
Ratings	All-time only	All-time and current version

What people search for

Live autocomplete demand around App Store apps, pulled with our own Keyword ideas collector.

Your own apps, or everyone else's

App Store Connect is for managing apps you publish: submissions, TestFlight, your own sales reports. It says nothing about anyone else's app, which rules it out for competitive datasets entirely.

Apple does expose a public store lookup endpoint, and it is generous — a whole result set in one response, which is why this collector is a tenth of the price of the Play equivalent. What a dataset needs on top of it is storefront coverage without per-IP rate limits and a typed schema over a response where fields are omitted rather than nulled.

Limits, storefronts and the legal bit

Up to 200 apps per run, the highest cap among the app-store collectors. Coverage means storefronts as much as apps: the App Store is a set of national catalogues with different apps, prices, currencies and ratings. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Keep rating and rating_current_version as separate columns. The gap between all-time and current-release sentiment is the most informative number on the page, and averaging them destroys it.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Apple's terms restrict automated access, and icons, screenshots and descriptions are the developer's copyrighted material. None of this is legal advice — get some for your actual use case.

App Store scraper API: the POST to the app_store_apps collector, 20 apps delivered and the bill, 20 × $0.0008 = $0.016 in usage.cost_usd; zero apps would cost $0. — The same call you would paste into a terminal: a Bearer key, term, country and app_ids in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many apps arrived and usage.cost_usd is $0.016, which is 20 × $0.0008. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the App Store scraper API.

Something else? Ask us

Can I look up by bundle id?

Yes. app_ids accepts numeric ids, bundle ids such as com.spotify.client, and full apps.apple.com URLs; ids that Apple does not know come back under failed.

Which country's store is queried?

country selects the storefront, so prices, availability and ranking match that market.

Is there a free App Store scraper API?

Every account gets $2 of credit every month with no card, which is about 2,500 delivered apps on this endpoint at $0.0008 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0008. A run capped at 200 apps — the maximum for this collector — costs $0.16 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Why is it cheaper than the Google Play collector?

Because Apple answers a whole result set in a single response while Play requires one page fetch per app. The price difference is the fetch count, not a judgement about the data.

Can I search and look up ids from the same endpoint?

Yes. Pass term to search the store or app_ids to resolve known apps — numeric ids, bundle identifiers and store URLs are all accepted, which means a mixed list from an existing database goes in unmodified.

Run the App Store scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (App Store results) turn into clean JSON with the fields title, developer and category; 35 fields on every row.