App Store Scraper Python: DIY Script vs Hosted Tool for Localization

You can build an App Store scraper in Python on top of Apple's public iTunes Search and Lookup endpoints, which return app metadata, including the languages each app declares, as JSON. A DIY script is a good fit for a one-off pull. If you want one clean row per app, with the missing languages for the markets you care about and country-specific review evidence, a hosted tool called from Python with apify-client saves you the parsing, deduplication and error handling.

Is there an official App Store API?

It depends on what you need.

• For your own apps, Apple offers the App Store Connect API. It requires a developer account and only covers apps you manage.
• For any public app, Apple runs the iTunes Search and Lookup endpoints (itunes.apple.com/search and itunes.apple.com/lookup). They take a search term or an App ID plus a two-letter country code, and need no API key.
• For reviews, Apple exposes a public customer-review RSS feed per storefront.

There is no official API we could confirm that returns a ready-made "localization gap" report, or that tells you which apps users want in another language. That part you have to compute yourself, or let a tool compute it.

The fields that matter for localization research are already in the lookup response: the app name, developer, primary genre, average rating, rating count for that storefront, latest release date, and a list of declared language codes (languageCodesISO2A). That last list is the answer to "app store localization languages list" for a specific app: it is what the developer declared, not proof that every screen is translated.

Your options for getting App Store data

1. By hand

Open an app page on the App Store, scroll to "Languages", and copy them into a spreadsheet. Fine for five competitors. Painful for fifty apps across several countries.

2. A DIY Python script

The public endpoints make a first script short. Here is a minimal version with requests:

import requests

resp = requests.get(
    "https://itunes.apple.com/search",
    params={"term": "meditation", "country": "us", "media": "software", "limit": 25},
    timeout=15,
)
resp.raise_for_status()

for app in resp.json().get("results", []):
    langs = [code.lower() for code in app.get("languageCodesISO2A", [])]
    print(app["trackId"], app["trackName"], "fr" in langs)

That works, and it is free to run. What you still have to build on top:

• retries and timeouts, so an Apple error does not look like "no apps found",
• deduplication when you combine several searches,
• normalization of language codes (Apple returns uppercase codes, some with regions),
• the review feed, which is a separate endpoint per country and per page,
• matching reviews against keywords in several languages,
• a way to rank hundreds of apps instead of reading raw JSON.

The GitHub results for "app store scraper github" are mostly libraries that wrap these same endpoints. They help with the fetching, not with the analysis.

3. A hosted tool with an API

A hosted actor runs the same public requests in the cloud and returns a dataset you can export to JSON, CSV or Excel, or read from Python. The App Store Scraper for Localization Gaps is built for this angle: it reads search results, app metadata, declared languages and country-specific reviews, then returns one scored row per app showing which of your target languages it does not support.

Step by step with the hosted tool

1. Create an Apify account and open the App Store localization gap scraper.
2. Choose a workflow: Search a market (a keyword), Analyze reviews (App IDs) or Check known apps (App IDs).
3. For a search, enter a niche such as habit tracker and keep the App Store country as us.
4. Add the languages you want to check, for example fr, de and es. Codes such as pt-BR, ja or ko also work, up to 20 languages.
5. Keep 25 apps for a first run (the maximum is 200).
6. Leave review analysis off for the first scan, then click Start.
7. Open the dataset and sort by opportunityScore. Read missingLanguages, ratingsCount, confidenceLevel and caveats before drawing conclusions.

If you send an empty input, the tool uses its defaults: it searches meditation in the US App Store, analyzes up to 25 apps, and checks whether French is missing.

Python example with apify-client

Install the client with pip install apify-client, then run the actor with the default input:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

# Empty input = defaults: "meditation", US storefront, French, up to 25 apps
run = client.actor("kazkn/apple-app-store-localization-scraper").call(run_input={})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        item["name"],
        item["opportunityScore"],
        item["opportunityVerdict"],
        item["missingLanguages"],
    )

To target another market, pass the fields explicitly, for example:

{
  "mode": "search",
  "searchTerm": "habit tracker",
  "country": "us",
  "targetLanguages": ["fr", "de", "es"],
  "maxResults": 25,
  "includeReviews": false
}

To pull reviews from another storefront, set includeReviews to true and add reviewCountry (for example fr) and your own filterKeywords. Review collection is bounded by reviewPages (up to 3 per app) and maxReviewRequests (default 25, maximum 100 per run).

What the output looks like

Each dataset row is one unique app. These are the main fields:

Rows also carry the store description and release notes as Apple returns them for the chosen storefront, which helps when you compare what a listing shows in different storefronts. Here is part of a real row from a run:

{
  "name": "Insight Timer: Meditate, Sleep",
  "price": "0",
  "currency": "USD",
  "rating": "4.9",
  "ratingsCount": "448,962",
  "genre": "Health & Fitness",
  "developer": "Insight Network Inc",
  "releaseDate": "2009-11-05T18:55:12Z",
  "currentReleaseDate": "2026-11-06T01:51:23Z",
  "contentRating": "12+"
}

The score adds up five parts: rating volume (up to 25), rating quality (up to 15), missing target languages (up to 25), localization pain found in reviews (up to 25) and release freshness (up to 10). It is a way to rank apps for further research. It does not estimate downloads, revenue or product-market fit.

What a run costs

The tool is billed per analyzed app: $5 per 1,000 apps, or $0.005 per app, plus a start event of $0.00005 per run.

Reviews do not add paid rows. They are stored as supporting evidence in the run's key-value store and referenced from the app row. Apple can return fewer apps than requested, and you only pay for the rows you get. Check the price card on the actor page before a run, since it is the source of truth if pricing changes.

Is it legal?

This is not legal advice, but here is how to think about it.

• Public data. The tool reads Apple's public search, lookup and customer-review feeds, the same data anyone sees on the App Store without logging in. It does not use your Apple account or any private developer data.
• The site's terms. Apple sets terms for its services and for these endpoints. Read them, keep request volumes reasonable, and do not republish store content as if it were your own. The tool caps review requests per run for this reason.
• Personal data and GDPR. App metadata is about products and companies. Reviews are different: they are written by people and can include a nickname. If you store reviews, treat them as personal data under GDPR, keep only what you need for your analysis, and avoid building profiles of individual reviewers.

If your use is commercial or large-scale, ask a lawyer who knows your jurisdiction.

FAQ

Is there an App Store scraper API I can call from Python?

Yes. Apple's iTunes Search and Lookup endpoints return JSON without a key, and you can call them with requests. A hosted actor adds scoring, deduplication and run reports, and you call it with apify-client as shown above.

How do I get the list of languages an app supports?

The lookup response includes languageCodesISO2A, the language codes the developer declared. The hosted tool returns them as languages and compares them with your targets in missingLanguages.

Can I check localization by country?

Yes. Set country for the storefront used to find apps and reviewCountry for the reviews you want to analyze, for example US apps with French reviews.

Does a declared language mean the app is fully translated?

No. It only means the developer declared it on the App Store. Screens, support pages or onboarding can still be in another language, so treat missingLanguages as a lead to check, not a verdict.

How much does a first test cost?

With the default input, up to 25 apps are analyzed, which costs up to $0.125 plus the $0.00005 start event.