App Store ASO Keyword Scraper — Rankings, Difficulty & Metadata

This App Store ASO keyword scraper tracks where your iOS app ranks in Apple App Store search, scores how hard each keyword is to win, and pulls app metadata, reviews and top charts by country. Give it your app ID and a list of keywords like photo editor or habit tracker, and get one flat row per keyword and country with the exact rankPosition your app holds, plus a 0-100 keyword difficulty score so you know which terms are worth optimising for.

It is built for App Store SEO, competitor rank tracking, and AI agents. Three things set it apart from the usual App Store scrapers:

• It scores keyword difficulty, not just position. Every ranking row carries a keywordDifficulty value derived from the actual search results, so you see where you rank and whether the keyword is winnable — most App Store scrapers stop at the number.
• No API key, no browser, no proxy. It reads Apple's public iTunes / App Store JSON endpoints directly. That makes it fast, cheap, and reliable enough to run on a daily schedule.
• Pay per result. You pay for the rows you get (one per keyword/country pair in rankings mode), with no third-party API bill and no proxy cost on top.

What is an App Store ASO keyword scraper?

It is a tool that queries the Apple App Store the way a user does — a search phrase in a specific country storefront — and reports back, as structured data, where a given app appears in those results. App Store Optimization (ASO) is the App Store equivalent of SEO: the higher you rank for the phrases people actually type, the more organic installs you get. To improve that, you first have to measure it.

This Actor does the measuring. In rankings mode you hand it your app (by numeric App Store ID or iOS bundle ID), the keywords you want to be found for, and the countries you care about. It runs each keyword through App Store search, finds your app's position, and returns one row per keyword/country pair. Alongside the position it computes a keyword difficulty score from the strength of the apps already ranking, so a single run tells you both where you stand and where it's worth pushing.

It also does three related jobs from the same endpoints: pull full app metadata, export App Store reviews, and snapshot the top charts by country and genre.

What you get

Every row is a flat JSON object. The fields depend on the mode you run. Common to all rows are mode, checkedAt (ISO timestamp) and, if a request failed, error.

Rankings mode

Field	What it is
keyword	The search phrase checked
country	Two-letter storefront code (us, gb, de, ...)
rankPosition	Your app's position in App Store search, or null if not found
found	true when the app is within maxSearchResults, else false
keywordDifficulty	0-100 ASO difficulty score for the keyword
keywordResultCount	How many apps the keyword returns
topAppsAvgRatingCount	Average rating count of the top results (the number behind the score)
appId, bundleId	The app's numeric App Store ID and iOS bundle ID
title, developer, genre	App name, publisher, primary category
rating, ratingCount	Average star rating and total ratings
price, currency	Price and currency in that storefront
version, updated	Current version string and last update date
url, iconUrl	App Store link and 512px icon URL
screenshotUrls, ipadScreenshotUrls	iPhone and iPad screenshot URLs

Metadata mode

Returns the same app fields as above (appId, bundleId, title, developer, genre, rating, ratingCount, price, currency, version, updated, url, iconUrl, screenshotUrls, ipadScreenshotUrls) plus a found flag, for any app looked up by ID or bundle ID.

Reviews mode

Field	What it is
appId, country	Which app and storefront the review is from
reviewId	Apple's review identifier
title, content	Review headline and body text
author	Reviewer display name
rating	Star rating the reviewer gave (1-5)
version	App version the review was left on
updated	Review date

Charts mode

Field	What it is
chart	topfreeapplications, toppaidapplications or topgrossingapplications
country, genre	Storefront and optional genre ID
rankPosition	Position in the chart (1 = top)
appId, bundleId	The charting app's IDs
title, developer, category	App name, publisher, category label
price, currency	Price and currency
url, iconUrl	App Store link and icon URL

Example output row

One keyword in one country comes back as one flat object:

{
  "mode": "rankings",
  "keyword": "social network",
  "country": "us",
  "rankPosition": 42,
  "found": true,
  "keywordDifficulty": 78,
  "keywordResultCount": 50,
  "topAppsAvgRatingCount": 1840000,
  "appId": 284882215,
  "bundleId": "com.facebook.Facebook",
  "title": "Facebook",
  "developer": "Meta Platforms, Inc.",
  "genre": "Social Networking",
  "rating": 4.52,
  "ratingCount": 27000000,
  "price": 0,
  "currency": "USD",
  "version": "567.0.0",
  "updated": "2026-09-01T00:00:00Z",
  "url": "https://apps.apple.com/us/app/facebook/id284882215?uo=4",
  "iconUrl": "https://is1-ssl.mzstatic.com/image/thumb/.../512x512bb.png",
  "checkedAt": "2026-09-20T09:00:00.000Z"
}

How is keyword difficulty calculated?

keywordDifficulty is a 0-100 heuristic built from the search results themselves, so it reflects the real competitive landscape for that phrase in that country — not a generic guess:

• 80% competitor strength. The average rating count of the top results, on a log10 scale, where roughly 1,000,000 ratings saturates the score. Ten established apps with millions of ratings each push this near the maximum.
• 20% competition breadth. How many results the keyword returns relative to 50. Thin result sets are easier to break into.

Read it as a moat estimate, not a promise. Low scores mark keywords where a well-optimised title and subtitle can still move you; high scores mark keywords where the incumbents' review counts are the barrier. Because topAppsAvgRatingCount ships in the same row, you can always see exactly what drove the number.

How much does it cost?

Pricing is pay per result, so you pay for rows returned, not for run time. There is no third-party API key to buy and no proxy bill — the Actor reads Apple's public iTunes endpoints directly, which is also why it runs without browser automation and finishes fast.

A rank-tracking run costs one result per keyword/country pair, so 20 keywords across 3 countries is 60 rows. Because there is no per-run minimum, checking 5 keywords daily is as economical as checking 200 weekly. Metadata, reviews and charts modes bill per row returned in the same way.

How do I use it with an AI agent?

Every input field has a plain-language description in the schema, so an agent can fill the input from the schema alone. Like other Apify Actors, it is callable as a tool through the Apify MCP server, so an agent can discover it, run it, and read the flat JSON output with no nesting to unwrap:

{ "mode": "rankings", "appIds": ["284882215"], "keywords": ["social network", "messenger"], "countries": ["us", "gb"], "maxSearchResults": 50 }

Because output is one flat row per keyword/country pair, it drops straight into a spreadsheet, a database, or an agent's downstream reasoning step without post-processing.

Is it legal?

The Actor reads publicly available App Store data from Apple's public iTunes / App Store search, lookup, reviews and charts endpoints. It does not log in, access private data, or bypass any paywall, and it returns only information Apple already shows on the public storefront. As with any data tool, you are responsible for how you use the results: respect Apple's terms of service, follow the data and privacy law in your market, and keep review text and other user-generated content within fair use. The Actor does not estimate downloads or revenue — it returns public metadata, positions, reviews and chart placements only.

Why is it reliable?

It is built on Apple's stable, documented public JSON endpoints rather than a headless browser scraping rendered HTML. That means there is no page layout to break, no anti-bot wall to trip, and no proxy pool to rot — the same reasons API-based Actors like this hold near-100% run success and are safe to put on a schedule. Requests retry with backoff on transient errors (429/5xx), and a keyword that genuinely fails is written as an error row rather than silently dropped, so a scheduled run either returns data or tells you exactly what it skipped.

Rankings only mean something as a time series — one snapshot tells you nothing about whether your last release helped. Run rankings mode on an Apify Schedule (daily for keywords you are actively working, weekly for a broader watchlist), and because every row carries checkedAt, the dataset accumulates into a queryable trend line with no extra bookkeeping.

Coverage expectations

• Rankings depth is bounded by maxSearchResults (default 50, up to 200). An app below that depth comes back with found: false and rankPosition: null — never a guessed position. If you track a smaller app on a broad keyword, raise maxSearchResults so you can still see it.
• Reviews mode requires numeric App Store app IDs (not bundle IDs), and returns up to 500 recent or most-helpful reviews per app/country. Apple's public review feed does not expose the full historical archive, so treat this as a recent-reviews sample, not a complete export.
• Metadata and rankings modes accept both numeric App Store IDs and iOS bundle IDs.
• App Store search results move slowly, so daily checks are usually enough; hourly runs mostly add cost without adding signal.

Input

Choose one mode:

• rankings — checks where each target app ranks for each keyword/country pair, with a difficulty score.
• metadata — extracts app details by numeric App Store app ID or iOS bundle ID.
• reviews — extracts App Store reviews by numeric app ID and country.
• charts — extracts top free, paid, or grossing app charts.

Example keyword ranking input:

{
  "mode": "rankings",
  "appIds": ["284882215"],
  "keywords": ["social network", "messenger"],
  "countries": ["us", "gb"],
  "maxSearchResults": 50
}

Example metadata input:

{
  "mode": "metadata",
  "appIds": ["284882215"],
  "bundleIds": ["com.instagram.ios"],
  "countries": ["us"],
  "metadataBatchSize": 50
}

Example reviews input:

{
  "mode": "reviews",
  "appIds": ["284882215"],
  "countries": ["us"],
  "maxReviews": 100,
  "reviewSortBy": "mostrecent"
}

Example top charts input:

{
  "mode": "charts",
  "countries": ["us"],
  "chart": "topfreeapplications",
  "genre": "6014",
  "maxChartResults": 100
}

To find a numeric app ID, take the number after id in any App Store URL — for example 284882215 in apps.apple.com/us/app/facebook/id284882215. Use maxSearchResults to control ranking depth, metadataBatchSize (up to 200 IDs per lookup) to keep large metadata runs cheap, and requestDelayMs to slow very large runs.

Common use cases

• App Store keyword rank tracking — monitor your app's position on a keyword set over time and see whether a release moved the needle.
• Keyword research before you write your title/subtitle — score a candidate keyword list by difficulty and pick the winnable terms.
• Competitor rank tracking — appIds takes a list, so add three or four rivals against the same keyword set and turn each run into a share-of-search snapshot.
• App metadata and screenshot audits — pull titles, ratings, versions, icons and screenshots for a competitor set by ID or bundle ID.
• Review mining — export recent or most-helpful reviews for sentiment analysis or to harvest the phrasing real users apply to your category.
• Top charts research — snapshot top free/paid/grossing charts by country and genre on a schedule to build a chart-movement dataset nobody publishes for free.

App Store country codes

Use two-letter App Store storefront codes such as us (United States), gb (United Kingdom), de (Germany), fr (France), es (Spain), br (Brazil) and jp (Japan). Rankings, charts and prices differ per storefront, so us and de are two separate answers to the same question.

FAQ

How do I track App Store keyword rankings?

Run rankings mode with your appIds (or bundleIds) and a list of keywords. Each row returns the app's rankPosition in App Store search for that keyword and country, plus a keywordDifficulty score for ASO prioritisation.

Do I need an App Store API key?

No. Unlike RapidAPI-based App Store APIs, this scraper calls Apple's public iTunes / App Store endpoints directly — no key, no login, no proxy.

What is the keyword difficulty score?

A 0-100 signal estimating how hard a keyword is to rank for: 80% from the rating strength of the top apps on a log10 scale, 20% from how many apps compete for the term. Raw App Store scrapers do not provide this. The topAppsAvgRatingCount field shows the number behind the score.

Can I track competitor apps as well as my own?

Yes. appIds takes a list, and competitors are just more IDs. A common setup is your app plus three or four rivals against the same keyword set, which makes each run a share-of-search snapshot.

Does it support iOS bundle IDs?

Yes. metadata and rankings modes accept both numeric App Store app IDs and iOS bundle IDs (for example com.instagram.ios). Reviews mode requires numeric app IDs.

How often should I check rankings?

Daily for keywords you are actively working, weekly for a broader watchlist. App Store search moves slowly enough that hourly checks mostly add cost, and every row is timestamped with checkedAt so a daily schedule builds a clean trend line.

Can I export the data to CSV or Google Sheets?

Yes. Results land in a standard Apify dataset, downloadable as CSV, JSON, XML or Excel, and pushable to Google Sheets, S3 or a webhook through Apify integrations.

How is this different from App Store Connect?

App Store Connect reports on apps you own, after the fact, through impression and install counts. This Actor reads the public storefront, so it covers any app in any country — including competitors — and answers the ranking question directly.

Does it scrape Google Play too?

No — this Actor covers the Apple App Store / iOS only.