# Google Play Reviews Scraper & Monitor | $0.15/1k, No Login (`programmx/google-play-reviews-monitor`) Actor

Scrape Google Play app reviews for any app and language: stars, text, developer replies, app version and rating. Monitoring mode outputs only new or changed reviews for daily schedules. No login, no browser.

- **URL**: https://apify.com/programmx/google-play-reviews-monitor.md
- **Developed by:** [ProgrammX](https://apify.com/programmx) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 95.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Play Reviews Scraper & Monitor | $0.15/1k, No Login

**Keywords:** google play reviews scraper, google play review api, android app reviews, play store reviews export, app review monitoring, one star review alerts, developer replies, ASO, review analytics, competitor app reviews

Scrape Google Play reviews for **any Android app in any language**, newest first, with star filters, developer replies, app version and the app's overall rating and installs. Turn on **monitoring mode** and schedule it daily: each run outputs only the reviews that are **new or changed** since the last run, so you pay for fresh data, not for the same reviews again.

No browser, no Google login, no API key. One request returns up to 200 reviews, so runs are fast and cheap.

### Who it is for

- **ASO and app marketing agencies:** track client and competitor reviews per market, every day.
- **Product and support teams:** get a one-star feed into Slack, Zendesk or a sheet and catch regressions after a release (every review has `appVersion`).
- **Review-analytics and sentiment SaaS:** a stable, deduplicated review feed for thousands of apps without maintaining a scraper.
- **Researchers:** bulk export of reviews for any public app, including ones you do not own (the official Play Developer API only covers your own apps and the last 7 days).

### What you get

| Field | Description |
|---|---|
| `reviewId` | Stable review UUID, use it as your dedupe key |
| `score` | Stars, 1-5 |
| `text` | Review text |
| `publishedAt` | ISO 8601 UTC timestamp |
| `thumbsUpCount` | "Helpful" votes |
| `appVersion` | App version the reviewer used, when Google shows it |
| `replyAuthor`, `replyText`, `repliedAt` | Developer reply, if any |
| `userName`, `userAvatarUrl` | Public display name and avatar (`null` when `includeReviewerInfo` is off) |
| `changeType` | `new` or `changed` in monitoring mode |
| `appTitle`, `appDeveloper`, `appScore`, `appRatingsCount`, `appInstalls` | App details (when `includeAppDetails` is on) |
| `appId`, `language`, `country`, `sort`, `scoreFilter`, `url`, `scrapedAt` | Request context |

The full app record (rating histogram, genre, price, icon, last update, developer URL) is saved once per app to the key-value store record `APP_DETAILS`. Reviewers' internal Google account ids are never output.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `appIds` | string list | `["com.whatsapp"]` | Package ids or Play Store URLs (`...details?id=com.whatsapp`) |
| `language` | string | `en` | Review language (`hl`). Google Play groups reviews by language. |
| `country` | string | `us` | Country (`gl`). Affects app details; in our tests the reviews themselves follow the language. |
| `sort` | `newest` / `relevance` / `rating` | `newest` | Use `newest` for monitoring |
| `minRating`, `maxRating` | integer 1-5 | empty | Star filter, applied by Google. `1`/`1` gives a one-star feed. With a partial range, the per-app limit applies per star value. |
| `maxReviewsPerApp` | integer | `100` | Reviews per app per run |
| `maxItems` | integer | `50` | Hard cap on items for the whole run |
| `includeAppDetails` | boolean | `true` | Add app title, rating and installs (one `app-details` event per app) |
| `includeReviewerInfo` | boolean | `true` | Output the reviewer's public display name and avatar. Turn off to keep personal data out of your dataset (both fields become `null`). |
| `onlyNew` | boolean | `false` | Monitoring mode: output only new or changed reviews |
| `proxyConfiguration` | proxy | none | Optional. Works without a proxy in our tests. |

Example:

```json
{
  "appIds": ["com.whatsapp", "https://play.google.com/store/apps/details?id=com.spotify.music"],
  "language": "en",
  "country": "us",
  "sort": "newest",
  "maxReviewsPerApp": 25,
  "maxItems": 50,
  "includeAppDetails": true
}
```

### Output sample

A real record from a test run on 2026-10-03 (avatar URL truncated):

```json
{
  "appId": "com.whatsapp",
  "language": "en",
  "country": "us",
  "sort": "newest",
  "scoreFilter": null,
  "reviewId": "1c0f31e8-eb66-471d-9035-2c01181ec8cf",
  "userName": "amanat ali",
  "userAvatarUrl": "https://play-lh.googleusercontent.com/a-/ALV-UjXB-kNdfrUruXcDi7fprcqXt2OIQCSNBfVOtG_Q7wsMF...",
  "score": 5,
  "text": "unban my WhatsApp account",
  "publishedAt": "2026-10-02T15:14:37.000Z",
  "thumbsUpCount": 0,
  "appVersion": "2.26.37.73",
  "replyAuthor": null,
  "replyText": null,
  "repliedAt": null,
  "changeType": null,
  "appTitle": "WhatsApp Messenger",
  "appDeveloper": "WhatsApp LLC",
  "appScore": 4.617302,
  "appRatingsCount": 244966389,
  "appInstalls": "10,000,000,000+",
  "url": "https://play.google.com/store/apps/details?id=com.whatsapp&hl=en&gl=us&reviewId=1c0f31e8-eb66-471d-9035-2c01181ec8cf",
  "scrapedAt": "2026-10-03T15:17:27.724Z"
}
```

### Pricing (pay per event)

You pay only for results. Apify adds its standard small actor-start charge.

| Event | Free plan | Bronze | Silver | Gold |
|---|---|---|---|---|
| Review (`result`), per review | $0.00015 | $0.00013 | $0.00011 | $0.00010 |
| App details (`app-details`), per app per run | $0.002 | $0.0018 | $0.0016 | $0.0015 |

That is **$0.15 per 1,000 reviews** on the Free plan and $0.10 on Gold. In monitoring mode you are charged only for new or changed reviews. Set `maxItems` or a maximum charge per run to cap spend; the actor stops cleanly when the limit is reached.

### How to schedule daily (monitoring mode)

1. Create a task from this actor with your `appIds`, `language`, `sort: "newest"` and **`onlyNew: true`**. Set `maxReviewsPerApp` to cover a busy day (for example 500 for large apps, 50 for small ones).
2. In Apify Console open **Schedules > Create new**, choose the task, and use a daily cron such as `0 7 * * *` (07:00 UTC).
3. Add an integration (Slack, email, webhook, Google Sheets, Make or Zapier) on "Run succeeded" to forward the new reviews.
4. For a one-star alert feed, create a second task with `minRating: 1`, `maxRating: 2`.

How it works: review ids and a short fingerprint (stars, text, reply) are stored in the named key-value store `google-play-reviews-monitor-state`, separately per app, language, sort and star filter. On the next run the actor reads the newest page, outputs anything unseen or changed, and stops paging as soon as it reaches reviews it already knows. The first run of a new app outputs up to `maxReviewsPerApp` reviews as the baseline. To reset monitoring, delete that key-value store.

Google Play shows new reviews with roughly a 24-hour delay (measured on 2026-10-03), so a daily schedule captures everything; running hourly adds no fresher data.

### Use it from the API, n8n, Make, Zapier or an AI agent

- **API:** start a run and get the results in one call:
  ```bash
  curl -X POST "https://api.apify.com/v2/acts/programmx~google-play-reviews-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"appIds": ["com.whatsapp"], "sort": "newest", "maxReviewsPerApp": 100, "maxItems": 100}'
  ```
  The response is the dataset as JSON; add `&format=csv` for CSV. This endpoint waits up to 5 minutes; for longer runs, start the run asynchronously and read the dataset when it finishes.
- **n8n, Make and Zapier:** use the Apify node or app, choose *Run Actor*, pick this actor and paste the input JSON.
- **Google Sheets, Slack, email and webhooks:** add an integration on the actor or task in Apify Console.
- **AI agents:** add this actor to Apify's MCP server (`https://mcp.apify.com`) and call it from any MCP client.

### FAQ

#### Do I need a Google account or API key?

No. The actor reads the same public data the Play Store website shows to logged-out visitors.

#### Can I get reviews for apps I do not own?

Yes, any public app. The official Google Play Developer API only covers apps you own, and only the last 7 days.

#### Why do I get the same reviews for `us` and `gb`?

Google Play groups reviews by language, not country. To cover several markets, run once per language (en, de, fr, pt, ja, ...).

#### How many reviews can I get?

Pagination follows Google's continuation token. In tests we followed 5,000 reviews of one app (BitLife, newest first, reaching back about 8 months) without the token running out. Google may stop returning older pages at some point.

#### Does it need a proxy?

Our tests had zero blocks without one. If you run at very high volume, select Apify Proxy (datacenter is enough) in the input.

#### Is `rating` sort documented?

No. `newest` and `relevance` were tested. `rating` returns reviews, and in our test it put 5-star reviews first, but Google does not document the exact ordering.

#### How much does a daily review monitor cost?

Example on the Free plan: 3 apps with app details on and about 20 new reviews per app per day cost 3 × $0.002 + 60 × $0.00015 = **$0.015 a day**, about $0.45 a month. For large monitors, turn `includeAppDetails` off to drop the per-app charge.

#### Can I export Google Play reviews to CSV or Excel?

Yes. Every run's dataset downloads as CSV, Excel, JSON, XML or HTML from the run's Storage tab, or through the API with `format=csv`.

#### Can I get only 1-star or 2-star reviews?

Yes. Set `minRating` and `maxRating` (for example 1 and 2). Results come one star value at a time.

#### Can I use it for ASO or competitor research?

Yes. Collect reviews for your own app and for competitors' apps, then group them by star rating, `appVersion` or keyword to find recurring bugs and feature requests.

#### Can an AI agent use this actor?

Yes. Apify's MCP server (`https://mcp.apify.com`) can expose this actor as a tool to Claude, Cursor, VS Code and other MCP clients, so an agent can fetch fresh reviews on request.

### Limitations

- The data source is an undocumented internal Google Play endpoint. If Google changes it, the actor fails with a clear "no UsvDTd payload" error rather than returning bad data.
- With a partial star range, results come one star value at a time and are not merged into one newest-first list.
- Monitoring mode detects edits and new developer replies only on the pages it reads in that run. A reply added to a very old review is not picked up.
- Reviews appear on Google Play about 24 hours after posting, so this is a daily feed, not real time.
- `appInstalls` is Google's public bucket (for example "10,000,000,000+"), not an exact count.

# Actor input Schema

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

Package ids (com.whatsapp) or full Google Play URLs (https://play.google.com/store/apps/details?id=com.whatsapp). Duplicates are removed.

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

Two-letter language code, e.g. en, de, pt, ja. Google Play partitions reviews by language, so this decides which reviews you get. Run once per language for multi-market monitoring.

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

Two-letter country code, e.g. us, gb, de. Affects app details (price, availability). In our tests the review set itself depends on language, not country.

## `sort` (type: `string`):

newest = most recent first (required for efficient monitoring). relevance = Google's 'most relevant'. rating = Google's rating order.

## `minRating` (type: `integer`):

Only reviews with at least this many stars (1-5). Set min=max=1 for a one-star alert feed. Leave empty for all.

## `maxRating` (type: `integer`):

Only reviews with at most this many stars (1-5). Leave empty for all.

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

Upper bound of reviews collected per app in this run (pages of up to 200 are followed via the continuation token). With a partial star range (e.g. 1-2) the limit applies per star value.

## `maxItems` (type: `integer`):

Hard cap on dataset items across all apps. Each item is one billed 'result' event.

## `includeAppDetails` (type: `boolean`):

Fetch the app page once per app and add title, developer, star rating, ratings count and installs to every review (full details go to the APP_DETAILS key-value record). Billed as one 'app-details' event per app.

## `includeReviewerInfo` (type: `boolean`):

Output the reviewer's public display name and avatar URL. Turn off to minimise personal data (both fields become null). Google account ids are never output.

## `onlyNew` (type: `boolean`):

Remember review ids in the named key-value store 'google-play-reviews-monitor-state' and output only reviews that are new or whose text, stars or developer reply changed since the last run. Use with a daily schedule and sort=newest.

## `proxyConfiguration` (type: `object`):

Optional. Google Play's review endpoint worked without a proxy in our tests. If Apify Proxy is not selected, the actor uses Decodo credentials from secret env vars (DECODO_USER / DECODO_PASS) when present, otherwise it connects directly.

## Actor input object example

```json
{
  "appIds": [
    "com.whatsapp"
  ],
  "language": "en",
  "country": "us",
  "sort": "newest",
  "maxReviewsPerApp": 100,
  "maxItems": 50,
  "includeAppDetails": true,
  "includeReviewerInfo": true,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

One row per review: star rating, review text, date, thumbs up count, app version and the developer reply when there is one, plus the app title and rating. In monitoring mode only new or changed reviews are returned. Use Export to download as CSV, Excel or JSON.

## `appDetails` (type: `string`):

App metadata per app id (title, developer, rating, ratings histogram, installs, price), saved when includeAppDetails is on.

## `runStats` (type: `string`):

Summary of the run: rows emitted and charged, requests, retries, proxy mode, errors and duration.

# 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"
    ],
    "language": "en",
    "country": "us",
    "maxReviewsPerApp": 100,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("programmx/google-play-reviews-monitor").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"],
    "language": "en",
    "country": "us",
    "maxReviewsPerApp": 100,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("programmx/google-play-reviews-monitor").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"
  ],
  "language": "en",
  "country": "us",
  "maxReviewsPerApp": 100,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call programmx/google-play-reviews-monitor --silent --output-dataset

```

## MCP server setup

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

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/Sk8iEOo3ZiJmZmvD4/builds/j15j0YeFMP5PiE6qJ/openapi.json