Developer guide · App Store data, no API key

How to scrape the App Store and track keyword ranks

Apple never published a data API for reading the App Store. What it does have is a set of endpoints that its own web pages and iTunes clients call, and most of them need no key, no account and no token. This guide scrapes app details, reviews and category charts from those endpoints, then builds keyword rank tracking on top of them — and records exactly which endpoints still work, because several widely used ones no longer do.

terminal
curl "https://itunes.apple.com/lookup?id=389801252&country=us"
  • No API key, account or token
  • Five endpoints that still work
  • Copy-paste fetch examples
  • Keyword rank tracking included

Which App Store endpoints still work

Every endpoint below was called directly while writing this page, on October 27, 2026. Apple publishes no contract for any of them, so the status column is the honest part of this guide: two capabilities that tutorials still recommend are currently broken, and one is broken inside the library rather than at the source.

CapabilityEndpointStatus
App details and metadataThe workhorse. Returns 44 fields per app and accepts up to 100 ids in one call.itunes.apple.com/lookupWorks
Customer reviews50 reviews per page, pages 1 to 10. Page 11 is rejected by the feed.itunes.apple.com/{country}/rss/customerreviewsWorks
Category chartsTop free, paid and grossing charts per storefront, capped at 100 entries.rss.applemarketingtools.com/api/v2Works
Search resultsRoughly 250 apps per term. Returns ids only, so a lookup call must follow.search.itunes.apple.com/WebObjects/MZStore.woa/wa/searchWorks
Ratings histogramThe star distribution per version, served as HTML rather than JSON.itunes.apple.com/{country}/customer-reviews/id{id}Works
Search suggestionsThe feed still answers, but the library reads the wrong plist key and returns nothing.search.itunes.apple.com/WebObjects/MZSearchHints.woa/wa/hintsPartially broken
Version historyNeeds a bearer token that is no longer present in the app page. Without it, HTTP 401.amp-api-edge.apps.apple.com/v1/catalogBroken
Privacy detailsSame token problem as version history. Both paths fail before parsing the response.amp-api-edge.apps.apple.com/v1/catalogBroken

Why the official route is not an alternative

The App Store Connect API is real, but it is built for managing apps you own. It needs a paid developer account and a signed JWT, and it will not hand you a competitor’s listing, their reviews or their keyword positions. Reading public storefront data and managing your own apps are two different problems with two different access models, so the endpoints here are not a workaround for a paywall — they are the only route to this data.

Scrape App Store app details with the lookup endpoint

If you only ever learn one endpoint, learn lookup. It is a plain JSON GET with no headers, no signature and no rate-limit handshake, and every other capability on this page either feeds into it or is built on top of its output.

lookup.ts
/** The one endpoint you need: app, search and developer all rely on it */
async function lookupApp(id, country = 'us') {
  const url = new URL('https://itunes.apple.com/lookup');
  url.searchParams.set('id', id);
  url.searchParams.set('country', country);
  url.searchParams.set('entity', 'software');

  const response = await fetch(url);
  if (!response.ok) throw new Error('lookup failed: HTTP ' + response.status);

  const { results } = await response.json();
  if (!results.length) throw new Error('app not found in storefront ' + country);
  return results[0];
}

const app = await lookupApp(389801252, 'us');
console.log(app.trackName, app.averageUserRating, app.userRatingCount);

A real response is compact compared to what you might expect from a storefront API. One call for Instagram returns 44 fields, and the ones that matter for App Store analysis are these:

FieldWhat it gives you
trackIdThe numeric id every other endpoint takes, not the bundle id
bundleIdOnly used for reverse lookups, by swapping the id parameter
averageUserRatingLifetime average as a float, not rounded to one decimal
userRatingCountTotal ratings, the field ASO uses to size an app
versionCurrent released version, useful for spotting competitor updates
currentVersionReleaseDateWhen that version shipped, pair it with version
minimumOsVersionOldest supported OS, which bounds the reachable audience
fileSizeBytesInstall size in bytes, returned as a string rather than a number
formattedPriceDisplay price, alongside price and currency for machines
languageCodesISO2ASupported languages, so you can judge localisation coverage
screenshotUrlsDirect screenshot links, for competitor creative analysis
trackViewUrlStore page address, from which the storefront can be read back
lookup response (trimmed)
{
  "resultCount": 1,
  "results": [
    {
      "trackId": 389801252,
      "bundleId": "com.burbn.instagram",
      "trackName": "Instagram",
      "sellerName": "Instagram, Inc.",
      "averageUserRating": 4.69053,
      "userRatingCount": 29642164,
      "version": "453.0",
      "currentVersionReleaseDate": "2026-10-26T12:40:24Z",
      "minimumOsVersion": "16.3",
      "fileSizeBytes": "671668224",
      "formattedPrice": "Free",
      "primaryGenreName": "Photo & Video",
      "contentAdvisoryRating": "12+",
      "languageCodesISO2A": ["BN", "HR", "CS", "DA", "NL", "EN", "..."],
      "screenshotUrls": ["https://is1-ssl.mzstatic.com/image/thumb/PurpleSource..."],
      "trackViewUrl": "https://apps.apple.com/us/app/instagram/id389801252"
    }
  ]
}

Batch lookups are what make this endpoint practical

The id parameter takes a comma-separated list, and testing confirmed 100 ids in a single request return 100 results. That matters more than it sounds: the search endpoint hands back nothing but ids, so without batching you would issue one request per result.

lookup-batch.ts
/** Up to 100 ids per call: this is what decides the request count for rank tracking */
const ids = ['389801252', '1232780281', '1607562761'];

const url = new URL('https://itunes.apple.com/lookup');
url.searchParams.set('id', ids.join(','));
url.searchParams.set('country', 'us');
url.searchParams.set('entity', 'software');

const { resultCount, results } = await (await fetch(url)).json();
console.log(resultCount); // 3

Two behaviours worth designing around. A lookup for an app that does not exist in the requested storefront returns an empty results array with HTTP 200, not a 404 — so check the array, not the status code. And country changes both the currency and the localised app name, which is why the same app can look different across storefronts.

Scrape App Store reviews, and the two parsing traps

Reviews come from an RSS feed rather than a JSON API, which is why most review scrapers written against it break in the same two places. Both are avoidable once you know the shape of the response.

reviews.ts
async function fetchReviews(id, country = 'us', page = 1) {
  if (page < 1 || page > 10) throw new Error('page must be 1-10');

  const url = 'https://itunes.apple.com/' + country +
    '/rss/customerreviews/page=' + page + '/id=' + id +
    '/sortby=mostRecent/json';

  const response = await fetch(url);
  if (!response.ok) throw new Error('reviews failed: HTTP ' + response.status);

  const feed = (await response.json()).feed;
  // A single review comes back as an object, not an array, so normalise it
  const entries = [].concat(feed.entry || []);

  return entries
    .filter((entry) => entry['im:rating'])   // the first entry is the app itself, with no rating
    .map((entry) => ({
      id: entry.id.label,
      author: entry.author.name.label,
      score: Number(entry['im:rating'].label),
      title: entry.title.label,
      text: entry.content.label,
      version: entry['im:version'].label,
      updated: entry.updated.label,
    }));
}

const page1 = await fetchReviews(389801252, 'us', 1);
console.log(page1.length); // 50
review entry (trimmed)
{
  "feed": {
    "entry": [
      {
        "im:rating": { "label": "5" },
        "im:version": { "label": "453.0" },
        "title": { "label": "Still the best" },
        "content": { "label": "Been using it for years and..." },
        "author": { "name": { "label": "Reypwns" } },
        "updated": { "label": "2026-10-25T09:12:04-07:00" }
      }
    ]
  }
}

What the feed actually guarantees

  • Exactly 50 reviews per page, with the page parameter accepting 1 through 10. Page 11 is rejected.
  • The first entry is the app itself and carries no im:rating, so it has to be filtered out.
  • A single review arrives as an object rather than an array, and mapping it directly throws.
  • sortBy accepts mostRecent and mostHelpful, the latter ordered by helpful votes.
  • Reviews are isolated per storefront: changing country returns different users and languages.

The 500-review ceiling, and how to get past it

Ten pages of fifty reviews is 500 reviews per app per storefront. For a popular app that is a thin slice of a multi-million review base, and there is no pagination trick around it: the feed simply stops answering past page 10.

The way to widen coverage is horizontal rather than vertical. The same app carries a separate review set in every storefront, so iterating us, gb, de, jp and so on multiplies the ceiling while also surfacing localisation-specific complaints — which is usually the more interesting signal anyway.

Getting the star distribution

The feed gives you individual reviews but not the histogram of how ratings are distributed across one to five stars. That number lives on a different URL, itunes.apple.com/{country}/customer-reviews/id{id}?displayable-kind=11, which returns HTML. The page is small and stable enough to read with a regular expression against the vote totals, which is what a headless browser would be doing here at a hundred times the cost.

That URL also responds to the X-Apple-Store-Front header, so the histogram follows the storefront you select rather than your server’s location.

App Store category charts and top chart scraping

Charts are the easiest data to get and the easiest to misread. The feed is a static JSON file behind a CDN, which means it is fast and predictable, but also that it returns a snapshot with no history and no ranking metadata.

charts.ts
/** Category charts: top-free, top-paid and top-grossing, per storefront */
async function fetchChart(country = 'us', kind = 'top-free', limit = 100) {
  const url = 'https://rss.applemarketingtools.com/api/v2/' + country +
    '/apps/' + kind + '/' + limit + '/apps.json';

  const { feed } = await (await fetch(url)).json();
  return feed.results.map((app, index) => ({
    position: index + 1,
    id: app.id,
    name: app.name,
    artist: app.artistName,
    genres: app.genres,
    releaseDate: app.releaseDate,
  }));
}

const topFree = await fetchChart('us', 'top-free', 100);
console.log(topFree[0].name); // the app at chart position 1

The limit is 100, not 200

Setting limit to 200 makes the endpoint return HTTP 502. 100 is the largest value verified to work; above it the feed fails outright instead of truncating.

The position is the array index

Results come back in ranked order but carry no rank field, so the position has to be assigned by sequence as you read the list.

The two chart domains disagree

The older ax.itunes host returns only 100 entries when asked for 200, and reports no error at all. The newer marketing tools host fails loudly instead.

Charts carry no ratings

Only the name, developer, genres and artwork come back. Ratings and review counts still require a lookup call per id.

Category charts are not the same as search rank

This is the distinction that catches people building their first rank tracker. A chart position answers “how popular is this app in its category right now”, while a keyword position answers “where does this app appear when someone searches this term”. An app can sit at chart position 3 and rank 60 for a term it does not target, or chart position 200 and rank 1 for a long-tail term it owns. If your goal is keyword rank tracking, charts are context, not the metric.

legacy chart endpoint
# The legacy host still answers, but caps the result count differently
curl "http://ax.itunes.apple.com/WebObjects/MZStoreServices.woa/ws/RSS/topfreeapplications/limit=100/json?s=143441"

The older ax.itunes.apple.com path still answers and is what most existing libraries call. It works, but it enforces its own lower ceiling silently, so a request for 200 entries returns 100 with no indication that anything was dropped. The rss.applemarketingtools.com path fails loudly instead, which is easier to debug.

App Store rank tracking with the search endpoint

This is the part most App Store scraping guides skip. Reading app data is a solved problem; knowing whether your keyword moved up or down this week is the thing people actually pay for. It is also built entirely on the endpoints above, which means you can do it without a subscription.

The distinction that matters: an app store rank tracker is not a scraper with a chart on top. It is a scraper plus a time series. Once you keep every run as a row, the tracker falls out of the data on its own, and these three steps are the whole pipeline.

Step one: get the search result list

The search endpoint is the foundation of keyword rank tracking, and it has one quirk that shapes everything downstream: it returns identifiers only.

search.ts
/** Search returns ids only, with no app names, so a batched lookup must follow */
async function searchAppIds(term, country = 'us', storefrontId = '143441') {
  const url = 'https://search.itunes.apple.com/WebObjects/MZStore.woa/wa/search' +
    '?clientApplication=Software&media=software&term=' + encodeURIComponent(term);

  const response = await fetch(url, {
    headers: {
      // This header picks the storefront; without it you get the server's own region
      'X-Apple-Store-Front': storefrontId + ',24 t:native',
      'Accept-Language': 'en-us',
    },
  });
  if (!response.ok) throw new Error('search failed: HTTP ' + response.status);

  const bubbles = (await response.json()).bubbles || [];
  return (bubbles[0]?.results || []).map((item) => String(item.id));
}

const ids = await searchAppIds('meditation timer', 'us', '143441');
console.log(ids.length); // around 250

Step two: turn the list into a position

A rank is just the index of your app inside that list. The important design decision is what to return when the app is absent: null and 0 mean different things, and collapsing them will silently corrupt your tracking history.

rank.ts
/**
 * Keyword rank: the index of the target app inside the search results.
 * Returns null when the app is beyond the returned range - that is not rank 0,
 * it is "not observable".
 */
async function getKeywordRank(appId, term, country = 'us', storefrontId = '143441') {
  const ids = await searchAppIds(term, country, storefrontId);
  const index = ids.indexOf(String(appId));
  return index === -1 ? null : index + 1;
}

const rank = await getKeywordRank(389801252, 'photo sharing', 'us', '143441');
console.log(rank); // 1 = first place, null = beyond position 250

The storefront is set by a header

X-Apple-Store-Front takes a market id (143441 for the US, 143465 for China, 143462 for Japan). Without it you get results for wherever the server sits, so a local test and a production run can disagree.

Search returns identifiers only

Each result is just { type, id, entity } with no app name, so rendering a readable ranking list requires a batched lookup call afterwards.

The observable ceiling is about 250

A broad term returns roughly 250 apps. A position below that is unobservable, and a report should separate "not ranked" from "outside the range" rather than recording both as zero.

Positions themselves are stable

Three consecutive requests for the same term returned identical ordering, which is what makes position tracking usable. The total result count does drift slightly between calls.

Step three: store snapshots, not rankings

A rank on its own is a number with no meaning. The useful artefact is a time series, which means every run should append a row rather than overwrite one. Storing the result count next to the rank is what lets you tell a real ranking change apart from the feed returning a slightly different result set that day.

track.ts
/**
 * Rank tracking: one snapshot row per app, per term, per storefront.
 * A rank on its own means nothing; the change over time is the signal.
 */
async function trackKeyword({ appId, term, country, storefrontId }) {
  const rank = await getKeywordRank(appId, term, country, storefrontId);

  return {
    appId,
    term,
    country,
    rank,
    // The total drifts slightly, so store it with the rank to explain movement
    resultCount: (await searchAppIds(term, country, storefrontId)).length,
    checkedAt: new Date().toISOString(),
  };
}

const snapshot = await trackKeyword({
  appId: 389801252,
  term: 'photo sharing',
  country: 'us',
  storefrontId: '143441',
});

What to track, if you want the numbers to mean something

  • Pick terms with search intent, not app names. Ranking first for your own app name is guaranteed and useless. Track the problem your app solves.
  • Track one storefront per series. A rank in the US says nothing about the Japanese storefront, and mixing them produces noise that looks like volatility.
  • Poll on a schedule you can defend. Rankings do not move meaningfully every hour, and every poll is a request against an undocumented endpoint. Daily is usually enough; weekly is enough for most apps.
  • Record the app version alongside the rank. Metadata changes are a common cause of a ranking move, and without the version number you cannot tell whether your keyword work or someone else’s release caused it.

Three patterns for real App Store jobs

Single calls are easy; the useful work is combining them on a schedule. These three cover most of what an App Store data pipeline ends up doing.

Watch a competitor release

The version number and release date are the two most stable fields and both come from a single lookup, which makes this a cheap daily check.

monitor.ts
/** Competitor release watch: alert when version or release date changes */
async function watchCompetitor(appId, country = 'us') {
  const app = await lookupApp(appId, country);

  return {
    id: app.trackId,
    name: app.trackName,
    version: app.version,
    releasedAt: app.currentVersionReleaseDate,
    rating: app.averageUserRating,
    ratingCount: app.userRatingCount,
  };
}

// Store one row per run and diff the version field against the previous row

Sweep reviews across storefronts

One storefront caps at 500 reviews, so spreading across markets both raises the ceiling and surfaces localisation-specific feedback.

sweep.ts
/** Multi-storefront review sweep: each market returns its own language */
const STOREFRONTS = [
  { country: 'us', name: 'United States' },
  { country: 'gb', name: 'United Kingdom' },
  { country: 'de', name: 'Germany' },
  { country: 'jp', name: 'Japan' },
];

const collected = [];
for (const store of STOREFRONTS) {
  for (let page = 1; page <= 3; page++) {
    const reviews = await fetchReviews(appId, store.country, page);
    collected.push(...reviews.map((r) => ({ ...r, country: store.country })));
    // Sequential with a gap: these endpoints publish no quota, so do not fan out
    await new Promise((resolve) => setTimeout(resolve, 500));
  }
}

console.log(collected.length); // up to 4 x 3 x 50

Build a daily keyword rank board

Batch-resolve the ids that search returns into app names, but only for the apps you track, to keep the request count down.

rank-board.ts
/** Rank board: batch-resolve ids to readable names, then build a daily table */
async function buildRankBoard(appIds, terms, country = 'us', storefrontId = '143441') {
  const rows = [];

  for (const term of terms) {
    const ids = await searchAppIds(term, country, storefrontId);

    // Look up only the apps we care about, not all 250 results
    const wanted = appIds.filter((id) => ids.includes(String(id)));
    if (!wanted.length) {
      rows.push({ term, apps: [] });
      continue;
    }

    const url = new URL('https://itunes.apple.com/lookup');
    url.searchParams.set('id', wanted.join(','));
    url.searchParams.set('country', country);
    const { results } = await (await fetch(url)).json();

    rows.push({
      term,
      apps: results.map((app) => ({
        name: app.trackName,
        rank: ids.indexOf(String(app.trackId)) + 1,
        rating: app.averageUserRating,
      })),
    });
  }

  return rows;
}

Limits, and scraping the App Store responsibly

This approach works, and it keeps working only as long as people use it like guests rather than like a crawler. These are the boundaries to design around before putting any of it into production.

None of this is a documented API

Every endpoint here is an internal path that Apple happens to expose to its own clients. There is no version negotiation, no deprecation window and no support channel. Two capabilities documented on this page broke without any announcement, which is the normal failure mode, not an exception.

There is no rate limit you can read

Apple publishes no quota for these endpoints, so you cannot know your headroom. Assume your traffic is unwelcome until proven otherwise: serialise requests, keep an interval between calls, cache what you already fetched, and never fan out a hundred parallel requests at a chart.

Charts have no history

The chart feed returns a current snapshot only. If you want a trend line, you have to store every snapshot yourself from the day you start. There is no way to backfill a chart position for last month.

Search rank is storefront-bound

Ranks differ per country, and Apple personalises results to some degree. Two people querying the same term from different locations can see different ordering. The storefront header makes results reproducible, but it does not make them universally true.

Reviews are a sample, not a corpus

500 reviews per storefront is what the feed will give you, regardless of how many million an app has. Any sentiment analysis built on it describes the recent tail of reviewers, not the user base.

The ratings histogram is parsed HTML

That one endpoint returns markup, not data. A layout change breaks the parse silently and can yield wrong star counts rather than an error, so validate the numbers you extract against the totals in lookup before trusting them.

Before you ship it

  • Check that your use complies with Apple’s terms and with local law. Public availability of an endpoint is not the same as permission to build a product on it.
  • Record when every row was collected. An App Store rank without a timestamp cannot be verified or compared, which makes it worthless for tracking.
  • Do not present scraped figures as official Apple data, and do not resell the dataset as if it were licensed. Say where the numbers came from.
  • Make breakage loud. Treat an unexpected response shape as an error rather than as an empty result, because a rank tracker that quietly reports “no data” is worse than one that fails.

App Store scraping and rank tracking: common questions

What developers ask about credentials, the broken endpoints, and the limits of the data.

There is an official route, but it is not a data API. The App Store Connect API is built for managing your own apps and requires a paid developer account plus a signed JWT. Reading a competitor listing, its reviews or its keyword position is not part of it. The public endpoints documented here are separate from it and need no credentials.

Check the storefront. Then check the data.

App Store listings, charts and keyword ranks all change with the storefront you query from. If you need to see the listing your users in another country actually see, FortVPN is free on Android with no sign-up.