# 🤖 Google Play Reviews Scraper — Ratings, Text & Replies (`nexgenwatch/google-play-reviews`) Actor

Scrape public Google Play reviews for any app — rating, text, thumbs-up, version, developer response, and date. Watch mode returns only new reviews. Public, logged-out.

- **URL**: https://apify.com/nexgenwatch/google-play-reviews.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 review scrapeds

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/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 Reviews Scraper — Ratings, Text & Replies

Android teams pay for normalized competitor review data they can feed straight into product and reputation workflows — without maintaining a scraper themselves.

### What you get

- Public Google Play reviews: rating, title, text, thumbs-up count, author, date, and app version
- Developer replies and reply dates where present
- A normalized 15-field record per review with source URL and collection timestamp
- An isolated open-source adapter with a fresh process and proxy environment on every retry
- Optional watch mode that emits only new reviews and status changes on later runs

### Use cases by team

- **Product managers:** Track release reception on Android and catch complaint spikes early.
- **Competitive intel:** Monitor rival Android apps' reviews in a schema that matches your iOS feed.
- **Reputation / brand:** Quantify how sentiment moves across versions with clean, normalized data.
- **Data teams:** Skip scraper maintenance and get a stable contract you can pipe anywhere.

### Example inputs

*Single app*

```json
{
  "app_ids": [
    "com.spotify.music"
  ],
  "watchMode": false
}
```

*Several apps at once*

```json
{
  "app_ids": [
    "com.spotify.music",
    "com.netflix.mediaclient"
  ],
  "country": "us"
}
```

*Monitor for new reviews only*

```json
{
  "app_ids": [
    "com.spotify.music"
  ],
  "watchMode": true
}
```

### 📊 Sample Output

```json
{
  "store": "google_play",
  "app_id": "com.spotify.music",
  "review_id": "gp_84f21",
  "title": "Great",
  "review_text": "Fast and useful",
  "rating": 4,
  "thumbs_up": 12,
  "author_handle": "listener_us",
  "review_date": "2026-07-18",
  "version": "8.9.0",
  "developer_response": null,
  "country": "us",
  "source_url": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "collected_at": "2026-07-21T00:00:00Z"
}
```

### How it works

Give it one or more Google Play package IDs (e.g. `com.spotify.music`). An isolated open-source adapter collects the public reviews for each — a fresh process and proxy per retry — and normalizes them into one 15-field schema that mirrors the Apple reviews actor. Public, logged-out surfaces only.

### Pricing

| Event | FREE | BRONZE | SILVER | GOLD+ |
|---|---|---|---|---|
| Actor start (`apify-actor-start`) | $0.02 | $0.02 | $0.02 | $0.02 |
| Review scraped (`review-scraped`) | $0.00015 | $0.000135 | $0.00012 | $0.0001 |
| Watch check (`watch-check`) | $0.10 | $0.09 | $0.08 | $0.067 |

Prices are the filed pay-per-event amounts per plan tier (PLATINUM/DIAMOND match GOLD). Worked example (FREE tier): 1,000 × `review-scraped` = $0.02 start + 1,000 × $0.00015 = **$0.17**. Blocked or zero-result runs do not intentionally charge; watch runs with no delta charge only the watch check. New to Apify? [Start free](https://apify.com/fpr=2ayu9b).

### Run it — API, CLI, MCP

API:

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgenwatch~google-play-reviews/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" -d @input.json
```

CLI:

```bash
apify call nexgenwatch/google-play-reviews -i @input.json
```

MCP: expose `nexgenwatch/google-play-reviews` through Apify's MCP server, select it as a tool, and pass the same input object.

### Related actors — App Intelligence cluster

| Actor | What it does |
|---|---|
| [Review Sentiment Analyzer](https://apify.com/nexgenwatch/review-sentiment-analyzer?fpr=2ayu9b) | Turn any review set into themes, complaints, sentiment % and trends. |
| [Apple App Store Reviews](https://apify.com/nexgenwatch/ios-app-reviews?fpr=2ayu9b) | Scrape public Apple App Store reviews for any app. |
| [App Metadata Scraper](https://apify.com/nexgenwatch/app-store-metadata?fpr=2ayu9b) | Pull app metadata from Apple & Google Play in one schema. |
| [App Rankings Tracker](https://apify.com/nexgenwatch/app-rankings-tracker?fpr=2ayu9b) | Track Apple App Store top-chart rankings by country. |
| [ASO Keyword Tracker](https://apify.com/nexgenwatch/aso-keyword-tracker?fpr=2ayu9b) | Track keyword rankings across App Store & Google Play. |

### Compliance & honest limits

- Public Google Play review surfaces only — no login, CAPTCHA, paywall, or access-control defeating.
- Google Play exposes a bounded review window per app and country; full lifetime history is not reconstructed.
- A source-confirmed empty result is `SUCCEEDED-0: GENUINE_EMPTY`; exhausted block retries fail and truncated runs are `PARTIAL`.

### FAQ

**Which app ID do I use?**

The Google Play package name (e.g. `com.spotify.music`), found in the store URL's `id=` parameter.

**Does the schema match the iOS actor?**

Yes — deliberately, so iOS and Android feeds line up field-for-field (Android adds `thumbs_up`).

**Does zero mean blocked?**

No. A confirmed-empty feed is `GENUINE_EMPTY`; only exhausted retries fail, and truncated runs are `PARTIAL`.

**How does watch mode work?**

Set `watchMode: true`. The first run seeds a KV baseline and emits nothing; later runs emit only new reviews and changes.

**Can I collect several apps at once?**

Yes — pass multiple package IDs in `app_ids`.

**How is it priced?**

$0.02 per run start plus $0.00065 per review scraped; watch checks with no change cost $0.05.

**Can I feed this into sentiment analysis?**

Yes — pass the output dataset ID into the Review Sentiment Analyzer.

### Troubleshooting

- **No reviews returned?** Check the exact package name and that the app has public reviews in the chosen country.
- **Wrong country?** Set `country` (e.g. `us`, `gb`); it defaults to US.
- **Watch mode emitting everything?** The first run seeds the baseline and emits zero — deltas start on the second run.
- **Run marked PARTIAL?** Retries were exhausted mid-collection; re-run to continue.
- **Need iOS too?** Use the Apple App Store Reviews Scraper — matching schema.

### About

Part of the NexGenData App Intelligence cluster, sharing one honest contract across iOS and Android. Built by NexGenData. Questions or need a custom feed? Open an issue on the Actor page.

# Actor input Schema

## `app_ids` (type: `array`):

Google Play package IDs.

## `app_urls` (type: `array`):

Google Play URLs containing an id query parameter.

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

Two-letter storefront country code.

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

Two-letter result language code.

## `max_items` (type: `integer`):

Hard cap on records delivered by this run.

## `watchMode` (type: `boolean`):

Seed a named KV baseline on first run, then emit only new or changed records.

## `proxy_configuration` (type: `object`):

Optional Apify proxy settings; a fresh session is requested for every retry.

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

Google review order.

## `search_terms` (type: `array`):

Resolve apps from Google Play search before collecting reviews.

## `date_from` (type: `string`):

Optional inclusive ISO start date for the review window.

## `date_to` (type: `string`):

Optional inclusive ISO end date for the review window.

## Actor input object example

```json
{
  "app_ids": [
    "com.spotify.music"
  ],
  "app_urls": [],
  "country": "us",
  "language": "en",
  "max_items": 100,
  "watchMode": false,
  "proxy_configuration": {
    "useApifyProxy": true
  },
  "sort": "newest",
  "search_terms": [],
  "date_from": "",
  "date_to": ""
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/google-play-reviews").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/google-play-reviews").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 '{}' |
apify call nexgenwatch/google-play-reviews --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgenwatch/google-play-reviews",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/DJeAg7SdBlNIix9ND/builds/p3EEhQmT1dLhRkxxw/openapi.json