# Google Play Review Delta Monitor (`burnished_pigeonpea/google-play-review-delta-monitor`) Actor

Monitor new Google Play reviews and produce release incident briefs, complaint clusters, and churn signals.

- **URL**: https://apify.com/burnished\_pigeonpea/google-play-review-delta-monitor.md
- **Developed by:** [Landen](https://apify.com/burnished_pigeonpea) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 delta reports

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/platform/actors/running/actors-in-store#pay-per-event

## 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 Review Delta Monitor

> This is an unofficial tool and is not affiliated with or endorsed by Google.

This Actor converts public Google Play review data into structured product
intelligence:

- remembers previously seen review IDs;
- outputs only new reviews on scheduled runs;
- tags complaints by product theme;
- detects regression and churn language;
- compares recent app-version rating and complaint shifts with sample-size confidence;
- creates per-app issue summaries;
- emits comparable reports for a primary app and its competitors.

It uses deterministic classification so operating cost remains predictable. It
does not claim that keyword classification is a substitute for human product
research.

### Pricing

Each successful app/storefront/language check emits one of two mutually
exclusive events. The summary and selected review rows are included:

- `app-check`: **$0.005** when no new review is found.
- `delta-report`: **$0.05** when one or more new reviews are found.

Examples:

- 1 changed app: $0.05; 1 unchanged app: $0.005.
- 5 changed apps: $0.25; 5 unchanged apps: $0.025.
- 20 changed apps: $1.00; 20 unchanged apps: $0.10.

Invalid app IDs and upstream failures produce diagnostic rows and are not
charged as report events.

### Quick start

```json
{
  "apps": [
    {
      "appId": "com.spotify.music",
      "country": "us",
      "language": "en",
      "label": "Primary"
    },
    {
      "appId": "com.google.android.apps.youtube.music",
      "country": "us",
      "language": "en",
      "label": "Competitor"
    }
  ],
  "reviewsPerApp": 100,
  "onlyNew": true,
  "minimumRating": 1,
  "maximumRating": 5,
  "includeReviewRecords": true,
  "resetState": false
}
```

Run the same input on a schedule to turn the dataset into a review-change feed.
When `onlyNew` is enabled, each successful app report commits the latest public
review IDs to a named key-value store.

### Input reference

| Field | Purpose | Limits/default |
|---|---|---|
| `apps` | Package IDs, countries, languages, and optional labels. | 1-20 entries; required |
| `reviewsPerApp` | Newest reviews to inspect per app/storefront/language. | 10-500; default 100 |
| `onlyNew` | Include only reviews not seen on successful prior runs. | Default `true` |
| `resetState` | Ignore and replace saved review history. | Default `false` |
| `minimumRating` | Lowest included rating. | 1-5; default 1 |
| `maximumRating` | Highest included rating. | 1-5; default 5 |
| `includeReviewRecords` | Include normalized review rows with the report. | Default `true` |
| `includeReviewerNames` | Include public reviewer display names. | Default `false` |

The same package in two different country or language combinations counts as
two reports because Google Play can return different reviews for each.

### Output records

The default dataset contains three record types:

- `review`: normalized review, theme tags, severity, and regression/churn flags.
- `summary`: counts, negative share, average rating, leading complaint themes,
  and prioritized issue clusters. Non-request themes require a rating of three
  stars or lower or explicit churn/regression evidence, preventing positive
  mentions from being mislabeled as complaints.
- `diagnostic`: an uncharged error row for an invalid app or upstream failure.

Example summary:

```json
{
  "recordType": "summary",
  "appId": "com.spotify.music",
  "appName": "Spotify: Music and Podcasts",
  "country": "us",
  "language": "en",
  "generatedAt": "2026-07-28T12:00:00.000Z",
  "summary": {
    "reviewsAnalyzed": 50,
    "averageRating": 2.84,
    "negativeReviewShare": 46,
    "churnSignals": 5,
    "regressionSignals": 7,
    "priorityIssues": [],
    "versionBreakdown": [],
    "releaseIncident": {
      "currentVersion": "9.1.68.1888",
      "previousVersion": "9.1.52.1394",
      "currentSample": 24,
      "previousSample": 18,
      "averageRatingDelta": -0.62,
      "negativeShareDelta": 18.5,
      "confidence": "medium",
      "triggered": true
    }
  }
}
```

Example included review:

```json
{
  "recordType": "review",
  "reviewId": "1234567890",
  "appId": "com.spotify.music",
  "appName": "Spotify: Music and Podcasts",
  "country": "us",
  "language": "en",
  "rating": 1,
  "themes": ["ads", "update-regression"],
  "severity": 85,
  "regressionSignal": true,
  "churnSignal": false
}
```

Apify datasets can be exported as JSON, CSV, Excel, XML, HTML, RSS, or JSONL
and accessed through the dataset API.

### Pay-per-event setup

The source emits one custom event when it writes each successful app summary.
In Apify Console:

1. Set `app-check` to `$0.005`.
2. Set `delta-report` to `$0.05` and make it the primary event.
3. Do not add a custom start fee. If the synthetic `apify-actor-start` event is
   present, leave it at Apify's default `$0.00005`.
4. Remove `apify-default-dataset-item`; otherwise included dataset rows can be
   charged in addition to the report event.
5. Include platform usage in the event price.
6. Set the minimum maximum charge per run to `$0.051`.
7. Publish with Limited permissions and without Standby mode.

The Actor checks the `ChargeResult` after each summary and stops before
processing the next app when the user's limit is reached. Saved state advances
only after the corresponding summary and included review rows are written.

### Development

```powershell
npm install
npm test
npm run test:live
```

### Compliance

The Actor reads publicly accessible Google Play pages and review responses.
Storefront availability
varies by app and country. It does not access private accounts, submit reviews,
or automate engagement. Theme, severity, regression, and churn fields are
deterministic keyword/rating signals; they are not statistical forecasts or
human-reviewed product conclusions. Google can change or limit its public
surfaces, so callers should handle diagnostic rows and occasional upstream
failures.

# Actor input Schema

## `apps` (type: `array`):

Google Play package IDs, storefront countries, and review languages.

## `reviewsPerApp` (type: `integer`):

Maximum number of newest public reviews to inspect for each configured combination.

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

Remember review IDs and emit only newly discovered reviews on later runs.

## `resetState` (type: `boolean`):

Ignore previously seen IDs on this run and replace the saved history after each completed app.

## `minimumRating` (type: `integer`):

Exclude reviews below this star rating.

## `maximumRating` (type: `integer`):

Exclude reviews above this star rating.

## `includeReviewRecords` (type: `boolean`):

Include the selected review rows with each paid per-app report at no additional event charge.

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

Off by default for data minimization. Enable only when the display names are necessary for your use case.

## Actor input object example

```json
{
  "apps": [
    {
      "appId": "com.spotify.music",
      "country": "us",
      "language": "en",
      "label": "Primary app"
    }
  ],
  "reviewsPerApp": 100,
  "onlyNew": true,
  "resetState": false,
  "minimumRating": 1,
  "maximumRating": 5,
  "includeReviewRecords": true,
  "includeReviewerNames": false
}
```

# Actor output Schema

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

The default dataset containing summary, review, and diagnostic records.

# 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 = {
    "apps": [
        {
            "appId": "com.spotify.music",
            "country": "us",
            "language": "en",
            "label": "Primary app"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("burnished_pigeonpea/google-play-review-delta-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 = { "apps": [{
            "appId": "com.spotify.music",
            "country": "us",
            "language": "en",
            "label": "Primary app",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("burnished_pigeonpea/google-play-review-delta-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 '{
  "apps": [
    {
      "appId": "com.spotify.music",
      "country": "us",
      "language": "en",
      "label": "Primary app"
    }
  ]
}' |
apify call burnished_pigeonpea/google-play-review-delta-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,burnished_pigeonpea/google-play-review-delta-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/hQdDciTFfJsq7BpLz/builds/pFGpdgRoJnhJDXyWN/openapi.json