# Google Play Reviews Scraper — App Data Ratings No Personal Data (`datamill.top/google-play-reviews-scraper`) Actor

Scrape Google Play reviews and full app metadata: review text, star scores, dates, app versions and developer replies. Filter by score or date for daily monitoring. No author names or avatars, GDPR-safe output. Free: you only pay Apify platform usage.

- **URL**: https://apify.com/datamill.top/google-play-reviews-scraper.md
- **Developed by:** [Alexandr Gobozov](https://apify.com/datamill.top) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Play Reviews Scraper — App Data & Ratings, No Personal Data

Scrape Google Play Store reviews, ratings, and full app metadata from any Android app.
This Google Play scraper extracts review text, star scores, dates, app versions, and
developer replies, plus complete app store listing data: installs, price, category,
release date, and rating histogram.

**Author names and profile images are never collected.** Every review is returned with
an irreversible pseudonymous hash instead of a display name, so you get the analysis you
need without holding personal data. See [Privacy and GDPR](#privacy-and-gdpr) below.

### Pricing

Currently **free** — you only pay Apify platform usage for the compute a run consumes.
No per-result fee on top.

### What this Google Play scraper extracts

**App data** — title, developer, description, summary, price, currency, in-app purchase
range, install count, exact install number, average score, rating count, rating
histogram, content rating, genre and category, app version, release date, last update
date, screenshots, icon, privacy policy URL, ads and IAP flags.

**Review data** — review text, star rating (1–5), review date, app version the review was
written on, helpful votes, developer reply text and reply date, pseudonymous author hash
with duplicate-name indicators.

### Why choose this Android app scraper

- **No personal data.** No user names, no avatars, no profile links, no developer email
  or postal address. Nothing in the output identifies a person.
- **Reliable dates.** Google Play returns release dates in the language you request:
  `Sep 6, 2013`, `06.09.2013`, `6 сент. 2013 г.` This scraper normalises every date to
  ISO 8601 so the column is always sortable, and keeps the original string in
  `releasedText`. Most scrapers hand you a mixed-format column you only discover is
  broken halfway through the analysis.
- **Handles messy input.** Paste a full Google Play URL, a `market://` link, or a bare
  package name. Duplicate entries are removed automatically, so you never pay twice for
  the same app.
- **Retries built in.** Four attempts with exponential backoff on every request. One
  unavailable app never kills the whole run — you get the rest of your data plus a clear
  warning in the log.
- **Incremental scraping.** Set `reviewsSince` to a date and the scraper stops paging as
  soon as it reaches older reviews. Ideal for daily review monitoring without re-reading
  the same rows every day.
- **Fast.** 5,000 reviews in under 30 seconds in testing. Ten apps in parallel with no
  rate limiting.

### Use cases

**App Store Optimization (ASO)** — track rating trends, install growth, and metadata
changes for your app and competitor apps.

**Review analysis and sentiment analysis** — export review text to your own pipeline,
LLM, or spreadsheet to find recurring complaints, feature requests, and bug reports.

**Competitor research** — monitor competitor app updates, pricing changes, and how users
react to each new version.

**Release monitoring** — filter reviews by `appVersion` to see exactly how sentiment
changed after a release.

**Support benchmarking** — developer replies carry their own timestamp, so you can
measure how fast a team answers negative reviews, yours or a competitor's.

**Fake review detection** — `authorHashCount` and `authorHashApps` reveal display names
appearing across multiple apps, without exposing who wrote what.

**Market research** — use `searchQuery` to pull an entire app category and compare
install counts, prices, and ratings across the market.

### Input

Give the scraper app IDs, a search query, or both.

```
{
  "appIds": [
    "com.whatsapp",
    "https://play.google.com/store/apps/details?id=com.spotify.music"
  ],
  "searchQuery": "habit tracker",
  "maxAppsFromSearch": 10,
  "scrapeAppDetails": true,
  "scrapeReviews": true,
  "maxReviewsPerApp": 500,
  "reviewsSort": "newest",
  "filterByScore": 1,
  "reviewsSince": "2026-01-01",
  "language": "en",
  "country": "us"
}
```

| Field | Description |
|---|---|
| `appIds` | Package names or Google Play URLs. Duplicates removed automatically. |
| `searchQuery` | Search the Play Store instead of listing IDs. |
| `maxAppsFromSearch` | How many search results to scrape. |
| `scrapeAppDetails` | Return the app listing data. |
| `scrapeReviews` | Return reviews. Set `maxReviewsPerApp` to 0 to skip. |
| `maxReviewsPerApp` | Reviews per app, up to 20,000. |
| `reviewsSort` | `newest`, `rating`, or `helpfulness`. |
| `filterByScore` | Only reviews with this star rating (1–5). |
| `reviewsSince` | `YYYY-MM-DD`. Stops early once older reviews are reached. |
| `language` / `country` | Two-letter codes. Prices and reviews are country specific. |
| `includeDescription` | Turn off for a lighter dataset without description and screenshots. |
| `annotateAuthorCollisions` | Adds duplicate-name indicators to reviews. |
| `maxConcurrency` | Apps scraped in parallel, 1–10. |

### Output

Results go to a single dataset. App rows have `"type": "app"`, review rows have
`"type": "review"`, so you can filter or split them after export to JSON, CSV, Excel, or
Google Sheets.

App record, shortened:

```
{
  "type": "app",
  "appId": "com.whatsapp",
  "title": "WhatsApp Messenger",
  "developer": "WhatsApp LLC",
  "installs": "10,000,000,000+",
  "realInstalls": 12279811078,
  "score": 4.6172466,
  "ratings": 242764611,
  "histogram": [10822617, 3393738, 8824605, 21797901, 197925672],
  "free": true,
  "price": 0,
  "genre": "Communication",
  "released": "2010-10-18T00:00:00+00:00",
  "releasedText": "Oct 18, 2010",
  "updated": "2026-09-02T23:17:08+00:00",
  "version": "Varies with device",
  "scrapedAt": "2026-09-05T00:53:24+00:00"
}
```

Review record:

```
{
  "type": "review",
  "appId": "com.spotify.music",
  "reviewId": "b0b0106e-f2e4-49ac-9d4d-91abcd378b31",
  "content": "current frustration with spotify is that often when I like a song it doesn't stick, it looks like it added to liked songs but it really didn't.",
  "score": 2,
  "thumbsUpCount": 44,
  "appVersion": "9.1.78.2218",
  "at": "2026-09-02T04:02:06+00:00",
  "replyContent": "Hi, thanks for your feedback. When you Like or Save an album, we add it to Your Library for fast access but we don't automatically add all songs to your Liked songs.",
  "repliedAt": "2026-09-02T17:48:19+00:00",
  "authorHash": "667312a54c6ae870",
  "authorHashCount": 1,
  "authorHashApps": 1,
  "scrapedAt": "2026-09-05T01:13:49+00:00"
}
```

### Privacy and GDPR

Google Play review author names are personal data under the GDPR. This scraper does not
return them.

Instead, each review carries `authorHash` — a salted SHA-256 hash of the display name,
truncated to 16 characters. The same display name always produces the same hash, so you
can still group reviews by author, but the name cannot be recovered from the hash.

Google Play does not expose a public user ID, so the hash is derived from the display
name. Two fields tell you how much to trust it:

- `authorHashCount` — how many reviews in this run share the hash. A large number means
  a very common name that should not be treated as one person.
- `authorHashApps` — how many different apps the hash appeared in.

One Google account can leave only one review per app. A repeated hash **within a single
app** therefore always means different people with the same display name. A repeat
**across different apps** may be the same reviewer, and is worth a closer look.

Developer email and postal address are excluded from app records for the same reason.

### Integrations

Run this Google Play scraper from the Apify API, schedule it to monitor app reviews
daily, or connect it to Make, Zapier, Google Sheets, Slack, or an MCP client. Results
export as JSON, CSV, Excel, XML, or RSS.

### FAQ

**How many reviews can I scrape from a Google Play app?**
Up to 20,000 per app per run. Google Play limits how far back its review feed goes, so
very old reviews may not be reachable for any scraper.

**Can I scrape reviews for a specific country or language?**
Yes. Set `country` and `language`. Reviews, prices, and availability differ by country,
and the same app may not exist in every store.

**Can I scrape only negative reviews?**
Set `filterByScore` to 1 or 2 to collect only low-rated reviews.

**How do I monitor new reviews daily?**
Schedule the actor and set `reviewsSince` to yesterday's date with `reviewsSort` set to
`newest`. The run stops as soon as it reaches older reviews.

**Does it work with Apple App Store apps?**
No. This actor covers Google Play and Android apps only.

**Why is the author name missing?**
By design — see [Privacy and GDPR](#privacy-and-gdpr). Use `authorHash` to group reviews
by author without storing personal data.

**Is scraping Google Play legal?**
This actor collects publicly visible listing and review content and does not access
private data or bypass authentication. You remain responsible for how you use the data
under the laws that apply to you. This is not legal advice.

# Actor input Schema

## `appIds` (type: `array`):

Package names, e.g. com.whatsapp. Find it in the Play Store URL after ?id=

## `searchQuery` (type: `string`):

Instead of listing app IDs, search the store. Results are added to App IDs above.

## `maxAppsFromSearch` (type: `integer`):

How many apps to take from the search results.

## `scrapeAppDetails` (type: `boolean`):

Title, developer, installs, rating, price, version, category, screenshots.

## `scrapeReviews` (type: `boolean`):

Review text, score, date, app version, developer reply. Author name and avatar are never returned.

## `maxReviewsPerApp` (type: `integer`):

Set 0 to skip reviews entirely.

## `reviewsSort` (type: `string`):

Newest is the usual choice for monitoring. Use Rating to sample the extremes.

## `filterByScore` (type: `integer`):

Leave empty for all. Set 1 to collect only the angriest reviews.

## `reviewsSince` (type: `string`):

Format YYYY-MM-DD. Works with Newest first. Useful for daily monitoring.

## `annotateAuthorCollisions` (type: `boolean`):

Adds authorHashCount and authorHashApps to each review. On Google Play one account can leave only one review per app, so a repeated hash within a single app means different people with the same display name. A repeat across different apps may mean the same reviewer. A high count means the name is too common to rely on.

## `language` (type: `string`):

Two-letter code, e.g. en, de, es.

## `country` (type: `string`):

Two-letter code, e.g. us, gb, de. Prices and availability differ per country.

## `includeDescription` (type: `boolean`):

Turn off for a lighter dataset when you only need numbers.

## `maxConcurrency` (type: `integer`):

Higher is faster but more likely to be rate limited.

## Actor input object example

```json
{
  "appIds": [
    "com.whatsapp"
  ],
  "searchQuery": "note taking",
  "maxAppsFromSearch": 10,
  "scrapeAppDetails": true,
  "scrapeReviews": true,
  "maxReviewsPerApp": 200,
  "reviewsSort": "newest",
  "reviewsSince": "2026-01-01",
  "annotateAuthorCollisions": true,
  "language": "en",
  "country": "us",
  "includeDescription": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "appIds": [
        "com.whatsapp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamill.top/google-play-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "appIds": ["com.whatsapp"] }

# Run the Actor and wait for it to finish
run = client.actor("datamill.top/google-play-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "appIds": [
    "com.whatsapp"
  ]
}' |
apify call datamill.top/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datamill.top/google-play-reviews-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DDU6T8FdZHMSTJ4G8/builds/PJcbBcGURZ7w62jWm/openapi.json