# App Review Scraper & Monitor — App Store + Google Play (`vertaizen/app-review-monitor`) Actor

App review scraper for the Apple App Store & Google Play in one run — rating, text, author, version, date. Monitor mode returns only NEW reviews; add a webhook for instant 1-star alerts, reputation monitoring & competitor analysis. Pay per review, MCP-ready.

- **URL**: https://apify.com/vertaizen/app-review-monitor.md
- **Developed by:** [Diego Moragues](https://apify.com/vertaizen) (community)
- **Categories:** AI, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## App Store & Google Play Review Scraper — Both Stores in One Run + Alerts

This **app review scraper** extracts customer reviews from the **Apple App Store and Google Play** in a single run — no login, no proxies, no browser. Point it at any app (URL, Apple app ID or Android package name) and get clean, structured **app review data**: rating, title, text, author, app version and date. Turn on **monitor mode** and it becomes an **app review monitor with alerts**: scheduled runs return only the reviews posted since the last run — perfect for **reputation monitoring**, **1-star review alerts** and **competitor analysis**.

Most review scrapers cover **one store only**, forcing you to run and reconcile two separate tools. This one reads **both the App Store and Google Play in the same run**, auto-detecting each app's platform — so your reputation dashboard is complete, not half the picture.

### Why this app review scraper beats single-store tools

| | **This scraper (both stores)** | Single-store App Store scraper | Single-store Google Play scraper |
|---|---|---|---|
| Apple App Store reviews | ✅ | ✅ | ❌ |
| Google Play reviews | ✅ | ❌ | ✅ |
| One run, one dataset | ✅ Mixed apps + platforms | ❌ Two tools to reconcile | ❌ |
| Monitor mode (only NEW reviews) | ✅ Built in | Sometimes | Sometimes |
| 1-star webhook alerts | ✅ `maxRating` + webhook | Rare | Rare |
| Per-country storefronts | ✅ `us`, `gb`, `de`, `es`… | Varies | Varies |
| Pay-per-result | ✅ | Varies | Varies |

- **Both stores in one run** — mix Apple app IDs and Android package names freely; the platform is auto-detected.
- **Fresh and reliable** — reads Apple's public reviews feed and Google Play's public review data. No fragile HTML scraping, no login walls.
- **Reviews = the voice of your users.** A spike in 1-star reviews after a release is an incident. A competitor's complaints are your roadmap.
- **AI-agent ready** — flat input, clean JSON output. Works out of the box via MCP for AI agents and LLM pipelines.

### What you get for each review

```json
{
  "app": "com.whatsapp",
  "platform": "googleplay",
  "country": "us",
  "reviewId": "b2b7c9a1-4f3e-4d2a-9c8e-1a2b3c4d5e6f",
  "rating": 1,
  "title": null,
  "content": "The latest update keeps crashing on startup...",
  "author": "Jane D",
  "appVersion": "2.26.11.75",
  "reviewedAt": "2026-07-01T14:23:05.000Z",
  "isNew": true,
  "url": "https://play.google.com/store/apps/details?id=com.whatsapp&gl=us"
}
````

### How to use it

1. **Add apps** — App Store URLs (`https://apps.apple.com/us/app/whatsapp-messenger/id310633997`), numeric Apple IDs (`310633997`), Google Play URLs, or package names (`com.whatsapp`).
2. **(Optional) Pick countries** — reviews are fetched per storefront (`us`, `gb`, `de`, `es`, ...).
3. **(Optional) Filter by rating** — set `maxRating: 2` to get only 1-2 star reviews for alerting.
4. **(Optional) Enable monitor mode** — and schedule the actor (e.g. hourly or daily). Each run returns only NEW reviews. Combine with a webhook to push negative reviews to Slack, email or your ticketing system.

### Use cases

Each of these maps to a real search buyers make:

- **"Monitor app reviews for reputation management"** — track every new review across both stores and all your markets in one place, so nothing about your app's public perception slips by.
- **"Get a Slack alert for 1-star app reviews"** — schedule + `maxRating: 2` + webhook = a 1-star review lands in Slack minutes after it's posted, tagged with the app version that caused it.
- **"Scrape competitor app reviews for feature ideas"** — mine rivals' 1-2 star reviews for the pain points, missing features and churn triggers your product can win on.
- **"Track reviews after an app release"** — watch the rating distribution shift the moment a new build ships, and catch a regression before the store rating drops.
- **"Feed app reviews to an AI sentiment pipeline"** — stream structured reviews to an LLM workflow (sentiment, clustering, auto-triage) via the Apify MCP server.

#### Reputation monitoring & 1-star review alerts

The flagship workflow: set `maxRating: 2`, enable `monitorMode`, schedule hourly, and wire a webhook. Every new 1-2 star review across the App Store and Google Play is pushed to Slack (or your helpdesk) in near real time, with the offending app version attached — so support and product respond while the review is still fresh and the reviewer might still update their rating.

### Pricing

Pay per review delivered — no subscription, no minimum. You only pay for results. Apps that can't be found are not charged.

### FAQ

#### Which platforms are supported?

The Apple App Store (via Apple's public customer-reviews feed) and Google Play. You can mix both in a single run — the actor auto-detects the platform from each app entry.

#### Can I scrape both the App Store and Google Play in one run?

Yes — that's the core differentiator. Add Apple IDs and Android package names to the same input list; each is routed to the right store automatically and all reviews land in one dataset.

#### How do I get Slack alerts for 1-star reviews?

Set `maxRating: 2` and `monitorMode: true`, schedule the actor (e.g. every hour), and attach an Apify [webhook or integration](https://docs.apify.com/platform/integrations) (Slack, email, Zapier, Make) to the run. Each new 1-2 star review triggers your alert with full review data, including the app version.

#### How does monitor mode work?

The actor keeps a per-app, per-country record of previously seen review IDs in a persistent named store. On each run it compares current reviews against that record and outputs only new ones (`isNew: true`). The first run outputs everything and initializes the state.

#### How many reviews can I get per app?

Up to 500 of the most recent reviews per app per country per run (the App Store feed exposes at most 10 pages of 50). For continuous coverage beyond that, use monitor mode on a schedule — you'll capture every review over time.

#### Is scraping app reviews legal?

The actor only reads publicly available review data — the same content anyone sees on the app's store page. No login, no personal data beyond the public reviewer display name, no rate-limit abuse. Review each store's terms and your local regulations for your specific use case. Apple documents its public feed via the [RSS Feed Generator](https://rss.applemarketingtools.com/).

#### Can AI agents use this actor?

Yes — the input schema is flat and agent-friendly, and every Apify actor is consumable via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), so agents can call it as a tool.

#### What happens if an app isn't found?

You get an `APP_NOT_FOUND` item for that app (not charged), and the rest of the list continues processing.

# Actor input Schema

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

App Store URLs (`https://apps.apple.com/us/app/whatsapp-messenger/id310633997`), numeric Apple app IDs (`310633997`), Google Play URLs (`https://play.google.com/store/apps/details?id=com.whatsapp`) or Android package names (`com.whatsapp`). The platform is auto-detected.

## `countries` (type: `array`):

Two-letter country codes. Used as the App Store storefront and as the Google Play `gl` parameter. Reviews are fetched per app per country.

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

Cap on the number of most-recent reviews returned per app per country.

## `monitorMode` (type: `boolean`):

When enabled, the actor remembers previously seen review IDs per app+country and only outputs reviews that appeared since the last run. Ideal for scheduled runs (review alerts).

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

Only return reviews with a star rating greater than or equal to this value (1-5).

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

Only return reviews with a star rating less than or equal to this value (1-5). Example: set to 2 to alert only on 1-2 star reviews.

## Actor input object example

```json
{
  "apps": [
    "310633997",
    "com.whatsapp"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 100,
  "monitorMode": false
}
```

# 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": [
        "310633997",
        "com.whatsapp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vertaizen/app-review-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": [
        "310633997",
        "com.whatsapp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vertaizen/app-review-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "310633997",
    "com.whatsapp"
  ]
}' |
apify call vertaizen/app-review-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=vertaizen/app-review-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Review Scraper & Monitor — App Store + Google Play",
        "description": "App review scraper for the Apple App Store & Google Play in one run — rating, text, author, version, date. Monitor mode returns only NEW reviews; add a webhook for instant 1-star alerts, reputation monitoring & competitor analysis. Pay per review, MCP-ready.",
        "version": "1.0",
        "x-build-id": "d7IRpq3bYb4CZltG1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vertaizen~app-review-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vertaizen-app-review-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/vertaizen~app-review-monitor/runs": {
            "post": {
                "operationId": "runs-sync-vertaizen-app-review-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/vertaizen~app-review-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-vertaizen-app-review-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "apps"
                ],
                "properties": {
                    "apps": {
                        "title": "Apps",
                        "type": "array",
                        "description": "App Store URLs (`https://apps.apple.com/us/app/whatsapp-messenger/id310633997`), numeric Apple app IDs (`310633997`), Google Play URLs (`https://play.google.com/store/apps/details?id=com.whatsapp`) or Android package names (`com.whatsapp`). The platform is auto-detected.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter country codes. Used as the App Store storefront and as the Google Play `gl` parameter. Reviews are fetched per app per country.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on the number of most-recent reviews returned per app per country.",
                        "default": 100
                    },
                    "monitorMode": {
                        "title": "Monitor mode — only NEW reviews",
                        "type": "boolean",
                        "description": "When enabled, the actor remembers previously seen review IDs per app+country and only outputs reviews that appeared since the last run. Ideal for scheduled runs (review alerts).",
                        "default": false
                    },
                    "minRating": {
                        "title": "Min rating (optional)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with a star rating greater than or equal to this value (1-5)."
                    },
                    "maxRating": {
                        "title": "Max rating (optional)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with a star rating less than or equal to this value (1-5). Example: set to 2 to alert only on 1-2 star reviews."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
