How to Scrape Google Play Reviews: Ratings, Text, App Versions and App Data

To scrape Google Play reviews, give a ready-made Actor an app's package name (such as com.whatsapp) or its Play Store link, and it returns one row per review: stars, text, date, the app version the reviewer used and helpful votes. On Scrape.ly that's a preset and one click, or one API call, with no Google login and no developer account.

This guide covers the fields you get, the no-code steps, the same job in curl, Python, Node.js and through an AI agent, a real run from 27 October 2026 (the ten newest WhatsApp reviews), its log and exact cost, and how to add the app listing itself: installs, rating histogram, version and developer.

What data you can get from Google Play

The Google Play Reviews Scraper returns one row per review:

For the listing itself, the companion Google Play Scraper reads app pages, keyword searches and similar-app lists: title, install band, score, rating count, the 1-to-5-star histogram, price and in-app purchase range, current version, release notes, last update and developer details. It doesn't return review text, so the two Actors work as a pair: one for what users say, one for what the store page says.

How to scrape Google Play reviews without code

1. Open the Google Play Reviews Scraper in the Scrape.ly Store.
2. Pick the Newest WhatsApp reviews preset. It fills in this input:

{
  "appIdOrUrl": "https://play.google.com/store/apps/details?id=com.whatsapp",
  "maxReviews": 10,
  "sortBy": "newest",
  "deviceType": "mobile",
  "recentDays": 0,
  "uniqueOnly": true
}

3. Replace the link with your app's store link or package name and click Start. Our run took 4 seconds.
4. Open the dataset and export it as JSON, CSV or Excel.

The input fields that matter most:

• appIdOrUrl: a package name such as com.whatsapp, or the full play.google.com/store/apps/details?id=… link. You find the package after id= in any app's store URL.
• maxReviews: how many reviews to save. -1 reads until the reviews run out.
• sortBy: newest for monitoring, mostRelevant for what shoppers see first, rating to order by stars.
• rating or ratingFilter: keep only certain star ratings, for example [1, 2] for complaints.
• language: one or more codes such as ["en", "de", "fr"]; each is requested separately.
• keywords, appVersion, recentDays, endDate: keep reviews that mention a word, came from a given release or fall inside a date window.
• deviceType: mobile, tablet or chromebook. Each device has its own review list.
• pagesToScrape: 5 pages of 100 by default. Set it to -1 together with maxReviews: -1 for more than 500 reviews.

The rating filter preset shows star filtering by package name, and the tablet preset reads the tablet list.

How to scrape Google Play reviews with the API

Create a token under Settings → API & Integrations in the dashboard and store it as SCRAPELY_TOKEN. A run of a few hundred reviews finishes in seconds, well inside the synchronous endpoint's 45-second wait:

curl -X POST "https://api.scrape.ly/v2/actors/querystone~google-play-reviews-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $SCRAPELY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"appIdOrUrl": "com.whatsapp", "maxReviews": 200, "sortBy": "newest", "ratingFilter": [1, 2]}'

Add ?format=csv to the URL to get a CSV back. For a full history (the README puts a 10,000-review run at about 100 seconds), start the run asynchronously instead: POST /v2/actors/querystone~google-play-reviews-scraper/runs, poll /v2/actor-runs/RUN_ID?waitForFinish=60 until SUCCEEDED, then read /v2/actor-runs/RUN_ID/dataset/items?format=csv. The API docs cover the full flow.

In Python (pip install scrapely-client-python), this release check pulls the last week's 1- and 2-star reviews and counts them per app version, so you see at a glance whether the newest build made things worse:

import os
from collections import Counter

from scrapely_client import ScrapelyClient

client = ScrapelyClient(os.environ["SCRAPELY_TOKEN"], api_url="https://api.scrape.ly")

run = client.actor("querystone/google-play-reviews-scraper").call(
    run_input={
        "appIdOrUrl": "com.whatsapp",
        "maxReviews": 500,
        "sortBy": "newest",
        "ratingFilter": [1, 2],
        "recentDays": 7,
    }
)
per_version = Counter()
for r in client.dataset(run.default_dataset_id).iterate_items():
    per_version[r.get("appVersion") or "unknown"] += 1
for version, n in per_version.most_common():
    print(version, n)

In JavaScript or Node.js (npm install scrapely-client), compare the newest reviews of two rival apps in one script:

import { ScrapelyClient } from 'scrapely-client';

const client = new ScrapelyClient({ token: process.env.SCRAPELY_TOKEN, baseUrl: 'https://api.scrape.ly' });

for (const app of ['com.whatsapp', 'org.telegram.messenger']) {
  const run = await client.actor('querystone/google-play-reviews-scraper').call({
    appIdOrUrl: app,
    maxReviews: 100,
    sortBy: 'newest',
  });
  const { items } = await client.dataset(run.defaultDatasetId).listItems();
  const avg = items.reduce((s, r) => s + r.rating, 0) / items.length;
  console.log(app, items.length, avg.toFixed(2));
}

The Google Play API page shows these Actors as a ready-made API, and the Python client docs cover paging through large datasets.

With an AI agent (MCP)

Scrape.ly runs a hosted MCP server at https://mcp.scrape.ly. In Cursor, add it to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "scrapely": {
      "url": "https://mcp.scrape.ly",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

In Claude Code, run claude mcp add --transport http scrapely https://mcp.scrape.ly, then /mcp to sign in with OAuth. Then ask: "Use scrapely to get the 300 newest 1-star Google Play reviews of com.whatsapp and group the complaints by topic, with the app version for each group." The MCP docs list ChatGPT, VS Code, Windsurf and the other clients.

A real run: WhatsApp's newest reviews

We ran the preset as-is on 27 October 2026. It saved 10 reviews in 4.1 seconds. Reviewers are private people, so we show them as [reviewer 1] to [reviewer 5]; one review whose entire text looked like a person's name is withheld:

2026-10-27T15:59:18.386Z [Scrapely] Container started (setup 1.0 s)
2026-10-27T15:59:19.663Z [scrapely.actor] INFO  Reading public reviews for com.whatsapp. limit=10 sort=newest device=mobile languages=en proxy=datacenter
2026-10-27T15:59:20.949Z [scrapely.actor] INFO  Review transport http.
2026-10-27T15:59:20.949Z [scrapely.actor] INFO  Saved 10 reviews. datacenter_bytes=7471 residential_bytes=0
2026-10-27T15:59:20.949Z [scrapely.actor] INFO  [Status message]: Saved 10 reviews for com.whatsapp.
2026-10-27T15:59:21.617Z [Scrapely] Container state: status=exited exitCode=0 oomKilled=false

What the ten rows show:

• Stars don't always match the text. Two of the ten were 1-star reviews whose whole text was "very good" and "good". If you chart the average rating, you miss that; if you run sentiment on body, you catch it. For an alert on bad reviews, check both.
• A 5-star review can be a support ticket. Reviewer 4 gave five stars and described a blocked account. Filtering only on low stars would drop it, which is why a keyword filter (keywords: ["not open", "banned", "blocked"]) is worth adding next to the star filter.
• Versions show the rollout. Six reviews came from 2.26.41.77, two from the older 2.26.40.76, and two had no version at all. Grouping by appVersion, as in the Python script, shows how fast a release reaches users and whether its reviews are worse.
• language is what you asked for, not what was written. We requested English, and one review was Hindi in Latin script. Detect the language of body yourself if that matters for your analysis.
• Reviews are short and very fresh. All ten were posted within three minutes of each other on 26 October (UTC), and half were under ten characters. A big app needs hundreds of reviews per day before patterns appear; at this price that's not a problem.

The whole job used 7.5 KB of datacenter proxy traffic over plain HTTP, with no browser. Review data is that light, which is what keeps the per-review price so low.

What it costs

The Actor charges one event, platform usage (compute and proxy) included. Price checked on the Store page on 27 October 2026: $0.000028 per review, which is $0.028 per 1,000 reviews.

Our run: 10 × $0.000028 = $0.00028 at list price.

At scale: 10,000 reviews cost 10,000 × $0.000028 = $0.28. The Free plan's $5 of monthly usage credit covers well over a hundred thousand reviews at list price. Adding app listings with the Google Play Scraper is just as cheap, so a weekly snapshot of your app and five competitors costs a fraction of a cent.

What to watch out for

• Default page limit. The Actor reads 5 pages of 100 reviews unless you change pagesToScrape. For a full history, set both maxReviews and pagesToScrape to -1.
• Each device and language is its own list. Tablet and Chromebook reviews don't show up in the mobile list, and each language code is a separate request. Run the lists you need and merge them on reviewId.
• Empty versions. appVersion is only filled when Google shows it; two of our ten rows had none. Treat it as a strong signal, not a complete one.
• No rows isn't an error. An unknown package, or filters nothing matches, gives a successful run with an empty dataset. Check the item count in your pipeline.
• Store changes. Google can change the Play Store at any time. The Actor is maintained by its publisher, and a failed run in your schedule is your signal rather than silently wrong data.
• Names in text. Reviews sometimes name the reviewer, a friend or a support agent. Remove names before you publish or share excerpts, as we did above.

Google's own route is the Google Play Developer API's Reply to Reviews endpoint. Its documentation says it lets you "view user feedback for your app", and notes: "You can retrieve only the reviews that users have created or modified within the last week." That's the right tool for replying to your own app's reviews from a support system. For competitor apps, for history beyond seven days, or for apps you don't publish, the Actor is the way in.

Is it legal to scrape Google Play reviews?

The Actor reads only the public reviews that any visitor to an app's Play Store page can see, without logging in. Google's Terms of Service (effective July 30, 2026, read on 27 October 2026) prohibit "using automated means to access content from any of our services in violation of the machine-readable instructions on our web pages (for example, robots.txt files that disallow crawling, training, or other activities)". Read those terms and the site's robots.txt before a commercial project; our web scraping best practices explain how to read one.

Reviews are personal data: a display name, a profile picture and a review history can identify a person, so the GDPR and similar laws apply once you store them. Keep only the fields you need (often rating, body, date and appVersion are enough), pseudonymise reviewers in anything you publish, and don't republish review text at scale. Our guide to whether web scraping is legal covers the basics, including the GDPR. This is not legal advice; for a commercial project, ask a lawyer about your case.

Why Scrape.ly for Google Play reviews

• No developer account, any app. The official API covers your own apps and the last week. The Actor reads any public app's reviews, as far back as the list goes.
• Filters built in. Stars, languages, keywords, app versions, devices and date windows are input fields, so a scheduled run returns exactly the reviews you'd otherwise filter by hand.
• Reviews and listings together. The same token runs the review Actor and the Google Play Scraper for installs, rating histogram and release notes, plus G2 reviews, Trustpilot reviews, Google Maps reviews and TikTok comments for the rest of your brand's footprint.
• Ready for monitoring and agents. Schedules send new 1-star reviews to Slack, Sheets or a webhook; our review monitoring guide shows the full setup, and the hosted MCP server puts it all in front of your AI agent.

FAQ

Can you scrape Google Play reviews for free?

Yes. The Free plan includes $5 of usage credit every month with no credit card, and at $0.028 per 1,000 reviews that covers far more reviews than most projects need.

How do I get all reviews of an app?

Set maxReviews and pagesToScrape to -1. The Actor then reads until Google's list runs out. Run the tablet and Chromebook lists and other languages separately if you need them, and merge on reviewId.

Can I get only new reviews every day?

Yes. Use sortBy: "newest" with recentDays: 1, save the input and schedule it daily. Each run then saves only the reviews from the last day.

Does the scraper return developer replies?

No. The documented output covers the review itself: stars, text, date, version, helpful votes and reviewer. To reply to reviews of your own app, use the Google Play Developer API.

Can I scrape app details like installs and ratings too?

Yes, with the Google Play Scraper. It returns the install band, score, rating count, star histogram, version, release notes and developer details for any app, plus keyword searches and similar-app lists.

Can I scrape Google Play reviews with Python?

Yes. Install scrapely-client-python and call querystone/google-play-reviews-scraper, as in the release-check script above. The scraping runs in the cloud, so you don't manage proxies or Google's internal review endpoint.