How to Scrape Google Play Apps & Rankings in 2026 (API & Python)

The fastest way to scrape Google Play in 2026 is to call a structured API that returns normalized JSON — app metadata, category top-charts, search, similar apps, a developer's full catalog, and data-safety labels — instead of rendering the store's client-side pages and fighting its anti-bot throttling. You can build a DIY scraper, but Google Play defends the data heavily and its official API only covers apps you own. This guide covers all three approaches, what each returns, where each breaks, and the legal basics.

Why scrape Google Play?

Google Play app and listing data drives a whole category of product, marketing, and research work:

• App store optimization (ASO) — track rankings, ratings, install ranges, and keyword presence for your apps and competitors.
• Competitor & market research — map who leads a category, which apps are rising, and how a rival's whole portfolio is doing.
• Privacy & compliance auditing — collect data-safety declarations and permissions across an app set.
• Review & sentiment analysis — quantify what users praise and complain about, by version and country.
• AI / LLM pipelines — feed app metadata and reviews into retrieval and analysis workflows.

Is it legal to scrape Google Play?

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

Google Play has no public data API, so a DIY scraper either parses the client-side listing page or leans on the unofficial google-play-scraper:

from google_play_scraper import app, reviews, Sort

info = app("com.openai.chatgpt", lang="en", country="us")            # title, installs, score, developer
result, token = reviews("com.openai.chatgpt", lang="en", country="us",
                        sort=Sort.NEWEST, count=200)                  # capped at ~200 per request

It demos, then breaks:

• No official public API. The Google Play Developer API (Android Publisher) only returns data for apps you own — useless for competitor or market research — so any other app means scraping.
• Client-side rendering. Listing pages hydrate from an internal batchexecute RPC, so requests + BeautifulSoup gets a shell; you have to reverse the internal endpoints, which change without notice and break the parser.
• Throttling and IP bans. Direct requests trip Google's anti-bot defenses — 503s with a captcha and ~1-hour IP bans (roughly 500–1,000 apps per IP per day without proxies) — so you need residential proxy rotation.
• Review and ranking caps. Reviews return ~200 per request behind a cursor token you have to loop, and top-charts and search are paginated and locale-specific — every country is a separate crawl.

Option 2: No-code tools

Visual extractors and marketplace "Google Play" 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 client-side rendering, throttling, and caps.

Option 3: A structured Google Play API

For repeatable workflows, a structured Google Play API returns normalized JSON with no scraper to run. Find an app, then pull its listing:

curl "https://api.crawlora.net/api/v1/googleplay/search?term=chatgpt&country=us" \
  -H "x-api-key: $CRAWLORA_API_KEY"

In Python — note how each app is addressed by package name:

import requests
h = {"x-api-key": "YOUR_API_KEY"}
base = "https://api.crawlora.net/api/v1"

# 1) Search to find an app_id (package name)
hits = requests.get(f"{base}/googleplay/search", headers=h,
                    params={"term": "chatgpt", "country": "us", "lang": "en"}).json()["data"]

# 2) Full listing detail for that package name
info = requests.get(f"{base}/googleplay/app", headers=h,
                    params={"app_id": "com.openai.chatgpt", "country": "us", "lang": "en"}).json()["data"]

Search returns lightweight app records (fields are illustrative — check the docs):

{
  "code": 200,
  "msg": "OK",
  "data": [
    { "app_id": "com.openai.chatgpt", "title": "ChatGPT", "developer": "OpenAI", "score": 4.8, "price_text": "FREE", "free": true }
  ]
}

The same key reaches rankings, similar apps, a developer's whole catalog, and privacy labels:

top = requests.get(f"{base}/googleplay/list", headers=h,
                   params={"collection": "TOP_FREE", "category": "PRODUCTIVITY", "country": "us"}).json()["data"]   # category top-chart
similar = requests.get(f"{base}/googleplay/similar", headers=h,
                       params={"app_id": "com.openai.chatgpt", "country": "us"}).json()["data"]                     # competitors
portfolio = requests.get(f"{base}/googleplay/developer/7577165439232992817", headers=h,
                         params={"country": "us"}).json()["data"]                                                  # every app by a developer
safety = requests.get(f"{base}/googleplay/datasafety", headers=h,
                      params={"app_id": "com.openai.chatgpt"}).json()["data"]                                      # data_shared / data_collected

Reviews come back cursor-paginated — pass the returned next_pagination_token back via paginate to page through them:

reviews = requests.get(f"{base}/googleplay/reviews", headers=h,
                       params={"app_id": "com.openai.chatgpt", "country": "us", "sort": "newest"}).json()["data"]
# reviews["data"] -> list of { id, user_name, date, score, text, version, thumbs_up }
# reviews["next_pagination_token"] -> pass back via paginate to continue

Pass country (and lang) on every call — rankings, pricing, and availability differ by country — store one row per app or review, and re-pull on a schedule to track rankings and sentiment over time. For the deep reviews playbook across both stores, see how to scrape App Store & Google Play reviews.

What you can collect

• App listing — title, description, summary, install range (installs, min_installs), score, developer, and version.
• Rankings & discovery — category top-chart lists (list), search results, query suggestions, and categories.
• Competitive graph — similar apps and a developer's full catalog by developer id.
• Privacy — data-safety declarations (data shared / collected) and requested permissions.
• Reviews — id, user_name, date, score, text, version, and thumbs_up, cursor-paginated.

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

Limitations and common challenges

• No public API for arbitrary apps. The official Play Developer API covers only apps you own, so public research means scraping — which a structured API handles behind one key.
• Everything is locale-scoped. Rankings, availability, and pricing are per-country; the same app can differ across markets, so collect the countries you care about.
• Reviews are capped and cursor-paginated. Each request returns ~200 reviews behind a token; the displayed total won't match a single pull, so loop until the token is empty.
• Rate limits and bans. Direct scraping draws 503s with a captcha and ~1-hour IP bans; a structured API absorbs proxies and throttling.
• Reviews and names are personal data. Treat reviewer names and review text as personal under GDPR/CCPA — collect public, factual fields with a lawful basis.

Where this gets used

• App store optimization (ASO) — track competitor rankings, ratings, and version cadence across categories and countries.
• App review analysis — mine review sentiment and complaints by version. See the app review analysis use case.
• Review & reputation monitoring — watch ratings and sentiment over time. See review & reputation monitoring.

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 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. See also how to scrape App Store & Google Play reviews for the reviews deep dive, how to scrape Steam when the catalog you care about is games — Play and Steam are the two ends of the same title on mobile and PC, with their own prices, ratings, and review cultures — and how to scrape the Chrome Web Store for the third storefront, browser extensions. 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.