How to Scrape App Store & Google Play Reviews in 2026 (API & Python)

The fastest way to scrape App Store and Google Play reviews in 2026 is to call a structured API that returns normalized JSON — reviews, ratings, app metadata, and category rankings across both stores — instead of looping Apple's rate-limited RSS feed and fighting Google Play's anti-bot throttling. You can build a DIY scraper, but both stores cap and defend the data heavily, and the official APIs only cover apps you own. This guide covers all three approaches, what each returns, where each breaks, and the legal basics.

Why scrape app reviews?

App review and rating data drives a whole category of product and marketing work:

• Review monitoring & support — catch bugs, crashes, and complaints across versions and countries.
• App store optimization (ASO) — track ratings, rankings, and keyword presence for your apps and competitors.
• Product feedback & sentiment — quantify what users praise and hate, by feature and release.
• Market research — find category leaders, install ranges, and rising apps across both stores.

Is it legal to scrape app reviews?

Option 1: DIY in Python (and why it breaks)

The two stores work differently, so a DIY scraper is really two scrapers. Apple exposes an undocumented RSS reviews feed:

import requests

# Apple's undocumented RSS reviews feed: 50 reviews/page, JSON
r = requests.get(
    "https://itunes.apple.com/us/rss/customerreviews/page=1/id=389801252/sortby=mostrecent/json"
).json()
reviews = r["feed"].get("entry", [])

Google Play has no public reviews API, so DIY leans on the unofficial google-play-scraper:

from google_play_scraper import reviews, Sort

result, token = reviews("com.shopify.mobile", lang="en", country="us",
                        sort=Sort.NEWEST, count=200)  # 503s with a captcha under load

It demos and then breaks:

• Apple's ~500-review cap, per country. The RSS feed returns only ~10 pages (≈500 reviews) and exposes no global endpoint — and reviews are tied to a country, not a language — so getting an app's full review set means looping all 116 App Store countries and de-duplicating (the same review can appear in several). The total still won't match the count shown on the app page.
• Apple rate-limits hard. Hammer the feed and responses slow, then return timeouts and 403s; even clean residential IPs get blocked for minutes to hours, so you need proxy rotation.
• Google Play throttling. The unofficial library parses Google's internal endpoints and trips throttling — 503s with a captcha and ~1-hour IP bans (≈500–1,000 apps/IP/day without proxies) — and reviews are cursor-paginated and break when the internal RPC changes.
• Official APIs are your-apps-only. App Store Connect (JWT-signed) and the Google Play Developer API (≈60 review requests/hour) cover only apps you own — useless for competitor or market research.

Option 2: No-code tools

Visual extractors and marketplace "app review" actors export CSV/JSON and suit one-off pulls, but they're awkward in an in-product pipeline with predictable fields and they break on the same caps and throttling.

Option 3: A structured API (both stores)

For repeatable workflows, a structured App Store API and Google Play API return normalized JSON with no scraper to run. Pull App Store reviews:

curl "https://api.crawlora.net/api/v1/appstore/reviews?id=389801252&country=us&page=1" \
  -H "x-api-key: $CRAWLORA_API_KEY"

Both stores in Python — note how each app is addressed:

import requests
h = {"x-api-key": "YOUR_API_KEY"}

# Apple App Store — apps are addressed by numeric track id
ios = requests.get("https://api.crawlora.net/api/v1/appstore/reviews",
                   headers=h, params={"id": "389801252", "country": "us", "page": 1}).json()["data"]

# Google Play — apps are addressed by package name
android = requests.get("https://api.crawlora.net/api/v1/googleplay/reviews",
                       headers=h, params={"app_id": "com.shopify.mobile", "country": "us"}).json()["data"]

App Store reviews come back as normalized JSON (fields are illustrative — check the docs):

{
  "code": 200,
  "msg": "OK",
  "data": [
    { "id": "review-1", "title": "Helpful assistant", "score": 5, "author": "App Store User", "content": "Great for writing and research." }
  ]
}

Google Play reviews use the store's own field names (docs):

{
  "code": 200,
  "msg": "OK",
  "data": [
    { "id": "review-1", "user_name": "Play User", "score": 5, "content": "Very useful for daily work.", "thumbs_up_count": 42 }
  ]
}

Reviews are only part of it — the same key reaches ratings, app metadata, rankings, and search:

base = "https://api.crawlora.net/api/v1"

hist = requests.get(f"{base}/appstore/ratings", headers=h,
                    params={"id": "389801252", "country": "us"}).json()["data"]            # star histogram
app = requests.get(f"{base}/appstore/app", headers=h,
                   params={"id": "389801252", "country": "us"}).json()["data"]             # title, developer, score, version
top = requests.get(f"{base}/googleplay/list", headers=h,
                   params={"collection": "TOP_FREE", "category": "PRODUCTIVITY", "country": "us"}).json()["data"]  # rankings
hits = requests.get(f"{base}/appstore/search", headers=h,
                    params={"term": "shopify", "country": "us"}).json()["data"]            # find an app id by name

App Store reviews paginate via page and sort via sort; Google Play reviews are cursor-paginated — pass the returned next_pagination_token back via paginate. Pass country (and lang) per store, store one row per review, and re-pull on a schedule to track ratings and sentiment over time.

What you can collect

• App Store: app metadata (title, developer, score, ratings count, version, url), the star-rating histogram, reviews (id, title, score, author, content), search, top-chart lists, similar apps, version history, and privacy labels.
• Google Play: app metadata (title, description, installs), reviews (id, user_name, score, content, thumbs_up_count), search, top-chart lists, similar apps, data-safety, and permissions.

Everything is scoped by store and country — stick to public, factual fields.

Limitations and common challenges

• No public reviews API for arbitrary apps. Apple's RSS feed caps at ~500 reviews per country with no global endpoint, and the official App Store Connect and Google Play Developer APIs cover only apps you own — so public research means scraping, which a structured API handles behind one key.
• Reviews are a per-country subset. The displayed review count won't match what any feed returns, and Apple ties reviews to a country, not a language — collect the countries you care about and de-duplicate.
• Rate limits and bans. Direct scraping draws 403s on Apple and 503s with a captcha plus ~1-hour IP bans on Google Play; a structured API absorbs proxies and throttling.
• Reviews and names are personal data. Treat author and user names and review text as personal under GDPR/CCPA — collect public, factual fields with a lawful basis.

Where this gets used

• Review & reputation monitoring — watch ratings and review sentiment across both stores. See the review & reputation monitoring use case.
• App store optimization (ASO) — track competitor ratings, rankings, and version cadence.
• Product feedback — route complaints and feature requests from reviews into your backlog.

Sources

Start collecting

Try it first, free: run any public URL through the Free Web Scraper, or check whether a site blocks bots with the Anti-Bot Checker — no signup.

Test the reviews endpoints in the Playground, check the schema in the API docs, and review pricing. Browse the full catalog — 4.1M apps across the App Store and Google Play — in our mobile app dataset, or skip the crawl entirely with our app-review sentiment dataset: millions of already-scraped reviews of the top apps, queryable over the API. See also how to scrape Trustpilot reviews for the web-review side and how to scrape TripAdvisor for travel and venue reviews. For the other public Apple catalog built on the same iTunes lookup pattern, see how to scrape Apple Podcasts. When the apps you are rating are streaming services, the JustWatch API supplies the catalog behind the rating — what each provider actually carries, by country. When the thing being rated is a game rather than an app, how to scrape Google Play covers the Android storefront's own ratings and review stream, and how to scrape Steam covers the PC side, where the review text is the product signal. For the broader toolkit, how to choose a web scraping API, and is web scraping legal.

Part of our how-to-scrape guide series — every platform we cover, in one index.