Google Play Store Reviews Scraper — Android App Reviews API

⭐ Useful? Leave a review — it takes 10 seconds and is the single biggest thing that helps other app publishers, ASO teams and mobile product managers find this Google Play reviews scraper.

A fast, reliable Google Play Store reviews scraper that extracts user reviews, star ratings, reviewer names, review dates and app metadata from any public app listing on play.google.com. No Google account, no Play Console access, no API key, no quotas. Just pass a list of Android app IDs (for example com.slack, com.spotify.music, com.whatsapp) or full Play Store URLs and get back clean JSON or CSV reviews ready to drop into your data warehouse, BI dashboard or NLP pipeline.

Built for ASO (App Store Optimization) specialists, mobile product managers, indie Android developers, competitive-intelligence teams, QA engineers, localization analysts, sentiment-analysis startups and anyone who needs Android app review data at scale without fighting Google's rate limits.

What this Google Play reviews scraper does

Given a list of Android package IDs (com.example.app) or full Google Play URLs, this scraper loads each app's public listing page on the Play Store, clicks through to the full reviews view, scrolls to load additional reviews and extracts structured data for every review it can parse. Every run pulls fresh data from live Google Play pages — app reviews, star distributions and release notes change daily, so the scraper hits the real page each time.

Under the hood it uses Puppeteer driven by the puppeteer-extra-plugin-stealth package, rotating residential proxies from the Apify Proxy pool and multiple DOM extraction strategies that fall back gracefully when Google ships a layout change. The result: a stable Google Play review API surface that keeps working even when Play Store selectors drift.

Why use this Play Store scraper instead of the official API

Google doesn't offer a public API for reading Play Store reviews unless you own the app on the Play Console. Even then, the official Reviews API only returns reviews from the last 7 days and requires OAuth service accounts. This scraper bypasses all of that by reading exactly what any visitor would see in a browser at play.google.com/store/apps/details — publicly available review data, rendered by Google itself.

Compared with browser-based scrapers that need a constant stream of residential proxies and get flagged quickly, this actor uses a carefully tuned stealth Chromium build, pre-sets the CONSENT cookie to skip Google's GDPR banner, rotates viewports and user agents and retries gracefully when Google throws a captcha. That means higher success rates on long runs and fewer blocked IPs on your proxy budget.

Data fields the Google Play reviews scraper extracts

The scraper writes one item per review to the Apify dataset. Each item is flat JSON so it maps cleanly to a SQL table, Google Sheet column or BigQuery schema.

Review content

Field	Type	Description
text	string	Review body, trimmed to 2,000 characters (reviews shorter than 20 characters are filtered out as noise)
rating	integer	Star rating on a 1–5 scale, parsed from the aria-label on the review
author	string	Reviewer's display name as shown on the Play Store (may be null if Google hides it)
date	string	Review date as shown on the page, e.g. "March 15, 2026"

App and run metadata

Field	Type	Description
appId	string	Android package ID, e.g. com.slack, com.spotify.music, com.bbva.bbvacontigo
scrapedAt	string	ISO 8601 timestamp of when the review was extracted

The scraper uses multiple extraction strategies: first reading the stable data-review-id attribute, then falling back to DOM heuristics on jscontroller blocks that contain a star rating. If Google ships a layout change that breaks strategy 1, strategy 2 keeps the pipeline producing data until the selectors are fixed.

Use cases for this Google Play reviews API

• ASO (App Store Optimization) — monitor keyword sentiment and review velocity weekly. Track rating trends over time and correlate them with keyword rank changes in ASO tools like Sensor Tower, data.ai and AppTweak.
• Competitor monitoring — pull reviews from every competing app in your Play Store category. Identify unmet user needs, cross-app feature gaps and common complaints you can turn into your own differentiators.
• QA regression detection — schedule a daily run on your own app. When the ratio of 1-star reviews spikes after a release, an alert fires. Catch production regressions before the bad-review tide drowns your ranking.
• Sentiment analysis and LLM training — feed reviews into your NLP pipeline (HuggingFace, spaCy, OpenAI embeddings) to cluster complaints, detect sentiment drift and surface product opportunities. The 2,000-character truncation ensures tokens stay bounded.
• Localization insights — pass language=es, language=de, language=ja and scrape reviews in different locales. Compare pain points across markets before planning a new release or market expansion.
• Fintech and banking app due diligence — investment research teams pull reviews of consumer fintech apps to validate product-market fit before a round.
• Agency lead generation — identify apps with many 1–2 star reviews in a target vertical, reach out to their developer with a concrete "we saw these 30 complaints" audit.
• Academic and journalism — reproducible public review datasets for research on platform moderation, consumer-protection stories and longitudinal studies of app-market behavior.

How to use this Play Store reviews scraper

Mode 1 — scrape reviews by Android app ID

The simplest input. Pass an array of package IDs and a max review count.

{
    "appIds": ["com.slack", "com.spotify.music"],
    "maxReviews": 50,
    "language": "en"
}

Mode 2 — scrape reviews using full Play Store URLs

If you already have URLs from a spreadsheet or a CRM, drop them in directly. The scraper parses out the package ID automatically.

{
    "appIds": [
        "https://play.google.com/store/apps/details?id=com.whatsapp",
        "https://play.google.com/store/apps/details?id=com.instagram.android"
    ],
    "maxReviews": 100,
    "language": "en"
}

Mode 3 — scrape Spanish-language reviews for a banking app

Pass a language code to retrieve reviews in that locale. The scraper sets the Play Store hl parameter so Google returns localized review text, dates and sort order.

{
    "appIds": ["com.bbva.bbvacontigo"],
    "maxReviews": 30,
    "language": "es"
}

Mode 4 — batch monitor a portfolio of apps

Publishers and agencies commonly scrape 20–50 apps in one run. Each app takes ~15–30 seconds, so a 20-app portfolio completes in about 10 minutes.

{
    "appIds": [
        "com.slack",
        "com.microsoft.teams",
        "com.discord",
        "com.zoom.us",
        "us.zoom.videomeetings"
    ],
    "maxReviews": 200,
    "language": "en"
}

Input parameters

Parameter	Type	Default	Description
appIds	array	—	Android package IDs or full Google Play URLs (required)
maxReviews	integer	50	Max reviews returned per app (1–500)
language	string	en	ISO language code (en, es, de, fr, ja, pt, it, ru…)

Supported language codes match Google Play's hl parameter — any valid IETF BCP-47 tag that Google honors will work.

Output example (JSON)

{
    "text": "Great app but notifications are broken on Android 14. Have to force close and reopen to get them working again. Please fix — this worked fine on Android 13.",
    "rating": 3,
    "author": "Sarah M",
    "date": "March 15, 2026",
    "appId": "com.slack",
    "scrapedAt": "2026-04-22T10:00:00.000Z"
}

Export the full dataset as CSV, Excel, XML, HTML table or JSONL directly from the Apify console run page, or programmatically via the Apify API.

How to call this scraper from your code

curl

curl -X POST 'https://api.apify.com/v2/acts/makework36~play-store-reviews-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "appIds": ["com.slack"],
    "maxReviews": 100,
    "language": "en"
  }'

Python (apify-client)

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("makework36/play-store-reviews-scraper").call(run_input={
    "appIds": ["com.slack", "com.spotify.music", "com.discord"],
    "maxReviews": 100,
    "language": "en",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["appId"], item["rating"], item["text"][:80])

Node.js (apify-client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('makework36/play-store-reviews-scraper').call({
  appIds: ['com.whatsapp', 'com.instagram.android'],
  maxReviews: 150,
  language: 'en',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((r) => ({ app: r.appId, rating: r.rating, author: r.author })));

Export reviews to CSV

From the run page click Export → CSV. Or via API:

https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN

Stream reviews into BigQuery

from apify_client import ApifyClient
from google.cloud import bigquery

client = ApifyClient("YOUR_APIFY_TOKEN")
bq = bigquery.Client()

run = client.actor("makework36/play-store-reviews-scraper").call(run_input={
    "appIds": ["com.slack"], "maxReviews": 500, "language": "en"
})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
bq.insert_rows_json("project.dataset.play_reviews", rows)

Performance & cost

• ~15–30 seconds per app — depends on how many reviews are available and how many pages Google loads
• Up to 500 reviews per app per run — capped by the maxReviews parameter
• Residential proxies — rotated automatically by Apify Proxy to avoid captchas
• Fallback extraction — two DOM strategies so selector churn doesn't blow up the pipeline
• Typical run on 10 apps × 100 reviews finishes in ~4 minutes

Google Play reviews scraper comparison

There are a handful of Google Play review scrapers on the Apify Store. Here's how this one stacks up on the metrics that actually matter in review-monitoring workflows.

Feature	This scraper	Alternative A	Alternative B	Alternative C
Bypasses Play Store bot detection	Stealth Chromium	Basic Puppeteer	HTTP only (fragile)	Playwright
Language / locale support	Any Google hl code	Partial	English only	Yes
Max reviews per app	500	200	100	500
Multi-app per run	Yes (array)	Yes	Single only	Yes
Full URL or package ID input	Both	Package ID only	URL only	Both
Fallback DOM strategies	2	None	None	1
Residential proxy rotation	Built-in	Manual setup	No	Built-in
Export formats	JSON / CSV / Excel / XML	JSON only	JSON / CSV	JSON / CSV
Code examples in README	Python / Node / curl / BigQuery	None	None	None
Price per review	Mid-market	Higher	Cheaper, less reliable	Higher

The honest take: if raw cost per review is your only constraint, a pure-HTTP scraper will be cheaper. If you want consistent extraction when Google ships a layout change and a scraper that doesn't die mid-run from captchas, this actor is the better fit.

Step-by-step tutorial — your first run in 3 minutes

1. Sign up for Apify — visit apify.com and create a free account. New users get a $5 trial credit.
2. Open the actor — click Google Play Reviews Scraper → "Try for free".
3. Fill the input form — paste Android package IDs (for example com.slack) into the appIds field. Set maxReviews to 50 to start and leave language as en.
4. Click "Start" — the actor runs. Each app takes roughly 20 seconds.
5. View the dataset — the Dataset tab shows a table with review text, rating, author and date. Click Export to download JSON, CSV or Excel.
6. Automate — click Schedules → Create new schedule to run the same scrape daily. Every run writes to a fresh dataset you can pull via API.

That's it. No Google account, no Play Console access, no API keys.

Advanced usage patterns

Pattern 1 — daily regression monitoring

Schedule this actor daily on your own app. Push the data into Postgres keyed by (appId, author, date). Compute a 7-day rolling ratio of 1–2 star reviews. When the ratio jumps by more than 30%, fire a Slack alert — your release probably broke something.

Pattern 2 — ASO keyword sentiment tracking

Pull 200 reviews weekly for your app and your top 5 competitors. Run them through an LLM prompt that extracts mentioned features. Track which features are rising and which are decaying in your category — a leading indicator for ASO keyword strategy.

Pattern 3 — localization dashboard

Run the same app through 10 locales (en, es, pt, fr, de, it, ja, ko, zh, ar) weekly. Visualize rating distribution per market in Looker Studio. Spot under-performing locales to prioritize localization fixes.

Pattern 4 — agency lead mining

Pull reviews for every app in a Play Store vertical (for example com.bank.* for Mexican fintech). Rank by count of 1–2 star reviews. Send a personalized audit email to the developer of each app at the top of the list. Turn complaints into conversations.

Pattern 5 — feeding a product insights LLM

Pipe the text field into an OpenAI, Anthropic or Mistral prompt template: "Extract feature requests and bug reports from this review as JSON." Push the structured output into your product backlog. Turn the voice of the customer into actionable tickets.

Troubleshooting

Empty dataset — no reviews returned

• Verify the package ID is correct and the app is live on Google Play.
• If the app is region-locked, try a language that matches one of its release countries.
• The app may genuinely have fewer than 20 reviews — very short reviews are filtered out.

Fewer reviews than maxReviews Google Play only loads a limited number of reviews in the web view, even after clicking See all reviews and scrolling. If your app has only 120 reviews, setting maxReviews: 500 still caps at ~120.

author or date is null Google periodically ships layout changes that move author or date to a new DOM position. The scraper's fallback strategy keeps returning review text and rating even when these fields can't be parsed. Open the issues tab with an example app ID and we'll update selectors.

Runs slower than expected Puppeteer + residential proxy adds 10–15 seconds per app compared with HTTP scraping. That's the trade-off for stealth. Run apps in parallel by splitting across multiple concurrent runs if you need higher throughput.

Captcha or bot-detection page The stealth plugin bypasses Google's default detection, but a small fraction of requests still trip the challenge. The actor retries up to 5 times with fresh residential IPs — most transient blocks recover silently.

Pricing

Pay-per-result model:

Plan	Price per review	Example: 1K reviews	Example: 10K reviews	Example: 100K reviews
FREE trial	$0 (up to $5 credit)	free	N/A	N/A
BRONZE	$0.005	$5	$50	$500
SILVER	$0.004	$4	$40	$400
GOLD	$0.003	$3	$30	$300
DIAMOND	$0.002	$2	$20	$200

Apify gives every new user a $5 trial credit — enough for ~1,000 reviews while you evaluate. No subscription, no minimums, no egress fees.

FAQ

Do I need a Google account or the Play Console? No. This scraper reads the public Play Store page, the same page any visitor sees. No OAuth, no service accounts, no Play Console access.

Does it work for paid apps? Yes. Paid apps have publicly readable review pages exactly like free apps.

Can I scrape reviews older than 6 months? Google's web view paginates backward but eventually stops loading older reviews. In practice you can usually reach 300–500 of the most recent reviews per app. For deeper history you'd need to schedule the actor regularly and accumulate reviews over time.

Why are reviews shorter than 20 characters skipped? They're almost always emoji-only or a single word with no analytical value. Filtering them keeps signal-to-noise high in NLP pipelines.

Can I get developer replies to reviews? Not in v1. The Play Store web view hides developer replies behind an extra click. Drop a feature request on the issues tab and we'll prioritize.

Is scraping Google Play legal? This actor only reads publicly visible data on play.google.com, the same data any user sees in a browser. Review Google's Terms of Service and consult legal counsel for your jurisdiction and use case. We don't bypass logins or paywalls.

Can I filter by star rating? Not in the input. Filter post-run on the rating field — much faster than making Google sort them.

Does it work with App Store (iOS) reviews? No. This is Google Play only. For iOS check the Apple App Store reviews scraper on the same author account.

Can I scrape reviews for my own app even if it's private or in closed testing? No. Closed testing tracks aren't publicly visible. Use the official Google Play Developer Reporting API for internal data.

Changelog

• v1.0 (2026-04-22) — Full SEO rewrite, multi-language examples, Python/Node/curl/BigQuery snippets, pricing table, tutorial, advanced patterns.
• v0.2 (2026-03-22) — Fallback DOM extraction strategy for Google layout changes.
• v0.1 (2026-02-10) — Initial release with Puppeteer + stealth plugin.

Related scrapers from the same author

• YouTube Shorts Scraper — trending Shorts with engagement metrics and comments
• Google Maps Lead Scraper — business phone, website, emails and reviews
• Fast Airbnb Price Scraper — pure-HTTP Airbnb listings, prices and coordinates
• Telegram Channel Scraper — public Telegram channel messages and metadata
• Apple App Store Reviews Scraper — the iOS equivalent of this scraper
• Reddit MCP Server — Reddit posts, comments and subreddits via MCP tools

Legal & ethics note

This scraper reads publicly available pages on play.google.com. It does not bypass logins, paywalls, rate limits or captchas beyond the browser-level stealth configuration that any user could install. The data schema follows open conventions described at schema.org/Review and schema.org/SoftwareApplication. Please review Google's Terms of Service, Android Developer Distribution Agreement and your local privacy laws (GDPR, CCPA, LGPD) before using scraped data in production. Don't store personally identifying author information longer than you need it.

---

🙏 Ran this scraper successfully? Leaving a review helps the algorithm surface this to other ASO teams and Android developers. Much appreciated.