# Google Play Reviews Scraper & New Review Monitor (`signalgrid/google-play-reviews-monitor`) Actor

Track Google Play reviews for your app or competitors. Get newest reviews with rating, text, version and developer reply, plus a per-app summary. Repeat runs return and charge only new reviews.

- **URL**: https://apify.com/signalgrid/google-play-reviews-monitor.md
- **Developed by:** [Signal Grid](https://apify.com/signalgrid) (community)
- **Categories:** Marketing, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / 1,000 review returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Monitor: track new app reviews (Google Play reviews scraper)

Monitor **Google Play Store reviews** for your own app or your competitors' apps. Each run returns the newest reviews with **star rating, review text, app version, date, helpful votes and the developer's reply**, plus one **summary row per app** covering the rating distribution, the 7-day average, new 1–2★ reviews and unreplied complaints.

Schedule it with `onlyNew: true` and every run returns, and charges for, **only reviews you haven't seen yet**. It works as a review alert feed for Slack, Sheets, Zapier, Make, n8n or an AI agent.

No login, no cookies and no proxies. Data comes from the public Google Play Store. By Signalgrid.

### Use cases

- **App teams and support:** get every new 1★ or 2★ review each morning (`minRating: 1`, `maxRating: 2`). Use `unrepliedLowRatingFetched` to see which complaints still need a reply.
- **Competitor research:** track what users praise or complain about in rival apps after each release (`appVersion`).
- **Product and UX research, sentiment analysis, LLM pipelines:** clean JSON reviews by country and language.
- **Agencies:** monitor app ratings for many clients with one Task per client (`monitorId`).

### Input examples

Daily complaint alert:

```json
{"targets": ["com.spotify.music", "https://play.google.com/store/apps/details?id=com.hubspot.android"],
 "onlyNew": true, "monitorId": "daily-complaints", "minRating": 1, "maxRating": 2, "maxItemsPerTarget": 200}
```

One-off export of the latest 1,000 German reviews:

```json
{"targets": ["com.spotify.music"], "country": "de", "language": "de", "maxItemsPerTarget": 1000}
```

### Long backfill mode (full review history, no duplicates)

Need an app's entire review history, for example 80,000+ reviews for research or model training? Set `backfill: true` and a high `maxItemsPerTarget` (up to 100,000). On deep pagination, Google often re-serves earlier pages or repeats the same page token, which is why many scrapers return duplicates or loop forever. In this mode the Actor:

- **deduplicates by `reviewId`**, so you never pay twice for the same review
- **detects repeated pagination tokens** and pages with only duplicates, and stops cleanly
- reports `pagesFetched`, `duplicateReviewsSkipped`, `repeatedTokenDetected` and `stoppedBecause` in the app summary row

```json
{"targets": ["com.spotify.music"], "backfill": true, "maxItemsPerTarget": 50000}
```

Set a maximum charge on the run to cap the cost: 50,000 reviews × $0.00008 ≈ $4. After the backfill, switch to `onlyNew: true` with the same `monitorId` to get only new reviews.

### Output

Review row:

```json
{"type":"review","appName":"Spotify: Music and Podcasts","rating":5,"text":"Excellent","appVersion":"9.1.92.3058",
 "date":"2026-10-19T04:50:13Z","helpfulVotes":0,"developerReply":null,"isNewSinceLastRun":true,
 "reviewId":"bbfc4a3d-...","appId":"com.spotify.music","country":"us","language":"en","author":null}
```

App summary row: `storeAverageRating`, `storeRatingCount`, `reviewsFetched`, `itemsDeliveredThisRun`, `ratingDistribution`, `averageRatingLast7Days`, `newSinceLastRun`, `newLowRatingSinceLastRun`, `unrepliedLowRatingFetched`.

### Pricing and fair charging (pay per event)

- **$0.08 per 1,000 reviews**, plus **$0.001 per app summary** per run.
- **Error rows are free.** That covers unknown package IDs, invalid URLs and temporary store outages.
- **Max charge respected:** when your per-run limit is reached, the Actor stops cleanly and still returns the summary. Reviews it couldn't deliver stay "unseen", so your next run returns them, and you never pay twice for a review.
- Duplicate apps are removed automatically. If the store is down for every app, the run fails and charges nothing.

Example: a daily check of 5 apps that finds 30 new reviews costs 5 × $0.001 + 30 × $0.00008 = **$0.0074**.

### FAQ

**Does it need a Google account or API key?** No.
**Are reviewer names included?** Not by default, to keep personal data to a minimum. You can turn on `includeReviewerNames` if you have a lawful reason to need them.
**How far back can it go?** As far back as Google Play serves reviews, up to 5,000 per app per run.
**App Store (iOS)?** Not in this Actor.

### Limits

Public data only, and it isn't affiliated with Google. Review availability varies by country and language.

### Changelog

- 0.2 (Oct 20 2026): long backfill mode (up to 100k reviews) with reviewId dedupe and repeated-token detection.
- 0.1 (Oct 2026): first version.

# Actor input Schema

## `targets` (type: `array`):

Google Play package IDs (e.g. com.spotify.music) or Play Store URLs.

## `maxItemsPerTarget` (type: `integer`):

Newest first. You pay per review returned. Up to 5,000 normally; up to 100,000 with Long backfill mode.

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

Schedule daily/weekly with the same Monitor ID; repeat runs return and charge only for reviews you have not seen.

## `monitorId` (type: `string`):

Runs sharing a Monitor ID share 'seen reviews' memory.

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

2-letter country code (us, gb, de, in…).

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

Review language, e.g. en, de, pt-br.

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

Only output reviews with at least this many stars (e.g. 1 with Max 2 for complaints).

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

Only output reviews with at most this many stars.

## `includeReviewerNames` (type: `boolean`):

Off by default to minimise personal data.

## `backfill` (type: `boolean`):

Page deep into an app's history (up to 100,000 reviews). Deduplicates by reviewId, detects Google's repeated pagination tokens and stops cleanly instead of returning duplicates. The app summary reports pages fetched, duplicates skipped and why it stopped. Set a max charge on the run to cap cost.

## Actor input object example

```json
{
  "targets": [
    "com.spotify.music"
  ],
  "maxItemsPerTarget": 20,
  "onlyNew": false,
  "monitorId": "default",
  "country": "us",
  "language": "en",
  "includeReviewerNames": false,
  "backfill": false
}
```

# Actor output Schema

## `items` (type: `string`):

No description

## `summaries` (type: `string`):

No description

## `errors` (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 = {
    "targets": [
        "com.spotify.music"
    ],
    "maxItemsPerTarget": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalgrid/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 = {
    "targets": ["com.spotify.music"],
    "maxItemsPerTarget": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("signalgrid/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 '{
  "targets": [
    "com.spotify.music"
  ],
  "maxItemsPerTarget": 20
}' |
apify call signalgrid/google-play-reviews-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,signalgrid/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/kMZDca3jjayLa0WQ7/builds/FOk2sRMWH0HqhLy6F/openapi.json