# Google Play Reviews Scraper (`foo121/google-play-reviews-scraper`) Actor

Scrape Google Play Store app reviews at scale: star rating, review text, author, date, app version and thumbs-up count. No API key required.

- **URL**: https://apify.com/foo121/google-play-reviews-scraper.md
- **Developed by:** [ziv shay](https://apify.com/foo121) (community)
- **Categories:** Developer tools, Marketing, Social media
- **Features:** Limited permissions
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.20 / 1,000 result items

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 Scraper

**Scrape Google Play Store app reviews at scale — star rating, review text, author, date and app version. No API key, no anti-bot wall.**

Export every public review for any Android app on the Google Play Store by package name. Built for **ASO (app store optimization), app developers, product teams and sentiment analysis** — point it at your app (or a competitor's) and get a clean, structured review dataset ready for CSV/JSON/Excel or an AI pipeline.

Reads directly from Google Play's public `batchexecute` endpoint — **no API key required**, no login, no proxy needed for most volumes.

***

### What you get

For every app you give it, the actor returns **one row per review**:

| Field | Description |
|---|---|
| `appId` | Play Store package name (e.g. `com.spotify.music`) |
| `reviewId` | Unique review ID |
| `author` | Reviewer display name |
| `avatarUrl` | Reviewer profile photo URL |
| `score` | Star rating, 1–5 |
| `text` | Full review text |
| `date` | Review date (`YYYY-MM-DD`) |
| `timestamp` | Review time (ISO 8601) |
| `thumbsUp` | "Helpful" count |
| `appVersion` | App version the review was left on |
| `criteria` | Structured app-quality tags Google attaches to some reviews — `[{aspect, rating}]`, e.g. `ads_frequency`, `battery_heat`, `ads_presence`, `stability` |
| `replyText` | Developer reply text, if any |
| `replyDate` | Developer reply date, if any |
| `url` | App's Play Store URL |

***

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `appIds` | array (required) | — | Play Store package names, e.g. `com.whatsapp`. Find it in the Play URL after `?id=`. |
| `country` | string | `us` | Two-letter storefront code (`us`, `gb`, `de`…). |
| `language` | string | `en` | Two-letter review language code. |
| `sort` | string | `newest` | `newest`, `rating`, or `helpfulness`. |
| `maxReviewsPerApp` | integer | `200` | Cap per app (1–100000). |

#### Example input

```json
{
  "appIds": ["com.spotify.music"],
  "country": "us",
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 500
}
```

***

### Example run output

One dataset item per review:

```json
{
  "appId": "com.spotify.music",
  "reviewId": "gp:AOqpTOG...",
  "author": "Ben Alvarez",
  "score": 1,
  "text": "App constantly crashes since the last update.",
  "date": "2026-06-18",
  "timestamp": "2026-06-18T14:22:07.000Z",
  "thumbsUp": 42,
  "appVersion": "9.1.58.1567",
  "criteria": [
    { "aspect": "ads_frequency", "rating": 2 },
    { "aspect": "battery_heat", "rating": 2 }
  ],
  "replyText": "",
  "replyDate": "",
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music"
}
```

Export to CSV / Excel / JSON from the run's **Dataset** tab or via the API.

***

### How this compares

The most-installed Play-reviews actors on the Store fall into two camps, and each gives up something this one keeps:

- **The user-base leader scrapes one app at a time** with a thin ~11-field schema — **no developer replies and no per-aspect quality criteria.** This actor takes a **list of apps** (`appIds[]`) in a single run and returns both.
- The one rich competitor that matches the field depth has a notably lower Store rating.

So the wedge is honest and concrete: **multi-app batch in one run + developer replies + the structured `criteria` quality tags + reviewer `avatarUrl`** — the leader has none of the last three, and is single-app on top of that. `criteria` (Google's own ad-frequency / battery / stability flags per review) is the single most useful signal for ASO and is missing from almost every alternative.

***

### Use cases

- **ASO / app store optimization** — track review sentiment, ratings trend and version-by-version feedback.
- **Competitor research** — pull a rival app's reviews to find feature gaps and complaint themes.
- **Product & QA** — surface crash/bug reports tied to specific `appVersion` values.
- **Sentiment analysis / AI** — feed clean review text + scores into an LLM or BI pipeline.

***

### Pricing

Pay per result (per review). High-volume by design and priced to stay cheap at scale, so pulling tens of thousands of reviews stays affordable.

### Notes

No API key needed. For very large pulls, enable Apify Proxy in the run options. One bad/missing app never kills the run — it logs a warning and moves on.

# Actor input Schema

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

One or more Google Play app package names, e.g. com.whatsapp, com.spotify.music. Find it in the Play Store URL after ?id=.

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

Two-letter country code for the review storefront (e.g. us, gb, de).

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

Two-letter language code for the reviews (e.g. en, es, fr).

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

How to order reviews before fetching.

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

Maximum number of reviews to fetch per app.

## Actor input object example

```json
{
  "appIds": [
    "com.whatsapp"
  ],
  "country": "us",
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 200
}
```

# 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"
    ]
};

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

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

```

## MCP server setup

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

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/oZBVW28dEwTR122ed/builds/I2hnm5dD1rI2AQ6Km/openapi.json