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

Scrape Google Play reviews for any app: rating, text, version, helpful votes and developer replies. Any country and language, no API key, no proxies. US$0.40 per 1,000 reviews.

- **URL**: https://apify.com/fabrikit/google-play-reviews-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** SEO tools, Automation, E-commerce
- **Features:** Limited permissions
- **Stats:** 10 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 review results

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 reviews for any Android app — no API key, no login** — and get them back as clean JSON: rating, review text, author, date, app version, helpful votes and the **developer's reply**. Paste package IDs, Play Store URLs or just app names, pick a country and language, and export to CSV, Excel, JSON or Google Sheets. Token-based pagination means you can pull thousands of reviews per app, at **US$0.40 per 1,000 reviews** — pay only for what you get.

What you get from a single run:

- **Any app on Google Play — competitors included**: Google's official Play Developer API only shows reviews of *your own* apps; this Actor reads the public Play Store, so any app is fair game.
- **The reviews that matter**: sort by `recent` to track what users say right now, or by `helpful` to surface the complaints users vote to the top — with the developer's reply and its date on every review that has one.
- **Any country's storefront and language** (`us`/`en`, `de`/`de`, `br`/`pt`, `jp`/`ja`, ...) — the same app reads completely differently per country, and this Actor lets you compare.

Example output item (real review from a live run):

```json
{
    "store": "google-play",
    "appId": "com.spotify.music",
    "appName": "Spotify: Music and Podcasts",
    "reviewId": "62512bdd-a771-43f9-9354-28d8399ab6e4",
    "rating": 3,
    "title": null,
    "text": "it keeps uninstalling by itself and iv tried reinstalling",
    "author": "Daz Nickalls",
    "date": "2026-08-19T14:36:40.581Z",
    "version": "9.1.72.1891",
    "helpfulCount": 0,
    "replyText": "Hello there! Have you tried to use a different device to check if the error still persists? ...",
    "replyDate": "2026-08-19T13:29:28.338Z",
    "country": "us",
    "language": "en",
    "url": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=62512bdd-...",
    "scrapedAt": "2026-08-21T02:03:41.905Z"
}
```

### How to scrape Google Play reviews

1. Add one entry per app to **appIds**. Three formats work:
   - The package ID — the `id=` in the Play URL, e.g. `com.whatsapp`.
   - The full Play Store URL — `https://play.google.com/store/apps/details?id=com.spotify.music`.
   - Just the app's name, e.g. `duolingo` — resolved to the top Google Play search match.
2. Pick a **country** storefront and **language**, and press **Start**. Reviews land in the dataset within seconds, ready to download as CSV, Excel or JSON, or to sync to Google Sheets, webhooks, Zapier or Make.

#### Example input

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

- **appIds** *(required)* — one entry per app: package ID, Play URL or app name.
- **country** — two-letter storefront code. Reviews are storefront-specific. Default `us`.
- **language** — two-letter language code for the reviews. Default `en`.
- **maxReviewsPerApp** — cap per app, `0` = unlimited (pagination is effectively unbounded).
- **sort** — `recent` (newest first) or `helpful` (most helpful first).

#### Example: competitor deep-dive, German storefront

```json
{
    "appIds": [
        "https://play.google.com/store/apps/details?id=com.spotify.music",
        "org.telegram.messenger"
    ],
    "country": "de",
    "language": "de",
    "maxReviewsPerApp": 500,
    "sort": "helpful"
}
```

Schedule it weekly in Apify Console and connect the dataset to Google Sheets — a rolling review feed with zero code.

### Google Play reviews API — without an API key

Google's official Play Developer Reply-to-Reviews API requires you to **own the app** and only returns reviews from the last week. This Actor instead reads the **public Play Store** over plain HTTP with token-based pagination — any app, full review history access, no API key, no Google account, no browser and no proxies. In testing it pulled 600 Spotify reviews in one run (4 paginated batches) without a hiccup; there is no fixed cap.

### Output fields

| Field | Type | Description |
|---|---|---|
| `store` | string | Always `google-play` (compatible with our App Store + Google Play scraper's schema) |
| `appId` | string | Google Play package ID |
| `appName` | string | App display name (localized to your storefront) |
| `reviewId` | string | Unique review ID — stable, perfect for deduping across runs |
| `rating` | number | 1–5 stars |
| `title` | string | null | Review title (Google Play reviews rarely have one) |
| `text` | string | null | Review body |
| `author` | string | null | Reviewer's display name |
| `date` | string | null | ISO 8601 review date |
| `version` | string | null | App version the review was written for |
| `helpfulCount` | number | null | Thumbs-up count |
| `replyText` | string | null | Developer's reply, when there is one |
| `replyDate` | string | null | ISO 8601 date of the developer reply |
| `country` | string | Storefront country the review came from |
| `language` | string | Requested review language |
| `url` | string | null | Direct link to the review |
| `scrapedAt` | string | ISO 8601 timestamp of this run |

A per-app run summary (reviews found, errors) is stored in the run's key-value store under `SUMMARY`.

### What can you do with Google Play reviews data?

- **ASO (App Store Optimization):** mine review text for the keywords real users use, spot the complaints that drag your rating down, and watch how each release's `version` field scores.
- **Competitor analysis:** pull any competitor's reviews — where their users are unhappy is your roadmap.
- **Sentiment analysis:** feed `text` + `rating` straight into an LLM or sentiment model — one flat schema, one prompt.
- **Product management:** track incoming reviews after each release (`sort: recent`) or triage the top pain points (`sort: helpful`), and audit which complaints got a `replyText` and which are still unanswered.
- **Market research per country:** run one input per storefront and compare `us`, `de` and `br`.

### Pricing — how much does it cost to scrape Google Play reviews?

This Actor uses Apify's **pay-per-event** model and charges **per review delivered** (event `review-result`) plus a tiny run-start fee. Platform usage is included: no subscription, no rental fee, no proxy costs. 1,000 reviews cost US$0.40 on the Apify Free plan, and the same per-review price applies on paid plans — see the **Pricing** tab for the current rate. At that rate, 10,000 reviews cost US$4. You only pay for reviews actually pushed to your dataset.

### Integrations

Run the Actor and read results from your own code with the Apify API — or connect the dataset to **Google Sheets, n8n, Zapier, Make, Slack or webhooks** directly from Apify Console with no code at all. **Schedule** it daily for release monitoring, and use **LangChain or LlamaIndex** through their Apify integrations for sentiment and summary pipelines. AI agents in **Claude, ChatGPT, Cursor** and other MCP clients can find and run it through **Apify's MCP server**. Downloads come as JSON, CSV or Excel.

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("fabrikit/google-play-reviews-scraper").call(run_input={
    "appIds": ["com.spotify.music"],
    "country": "us",
    "maxReviewsPerApp": 1000,
    "sort": "recent",
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review["text"][:80])
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('fabrikit/google-play-reviews-scraper').call({
    appIds: ['com.spotify.music'],
    country: 'us',
    maxReviewsPerApp: 1000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} reviews, avg ${items.reduce((s, r) => s + r.rating, 0) / items.length}`);
```

### Performance & limits

- **Speed**: reviews are fetched in batches of 150 over plain HTTP — 600 reviews took a few seconds in testing; thousands per app are routine.
- **No fixed cap**: Google Play's pagination is token-based; `maxReviewsPerApp: 0` keeps going as long as the store serves reviews.
- **No proxies, no browser**: minimal platform usage and nothing to configure.
- **Storefront scope**: reviews are served per country — to cover several markets, run once per `country` (or schedule one run per storefront).

### Tips for best results

- Start with the prefilled input (WhatsApp, 50 recent reviews) to see the schema, then raise `maxReviewsPerApp`.
- Match `language` to the `country` (e.g. `de`/`de`) — mismatched pairs return fewer reviews.
- `sort: "helpful"` is the fastest way to the pain points that matter; `sort: "recent"` is the one to schedule for release monitoring.
- `reviewId` is stable — dedupe across scheduled runs on it and you get a clean incremental feed.
- Need iPhone coverage too? Use our [App Reviews Scraper — App Store & Google Play](https://apify.com/fabrikit/app-reviews-unified): both stores in one run, same schema as this Actor.

### FAQ

**How do I scrape Google Play reviews without an API key?**
Just paste the app's package ID (or its Play URL) and press Start. This Actor reads the public Play Store directly — no Google Cloud project, no OAuth, no Play Console access needed.

**Can I scrape reviews of apps I don't own?**
Yes — that's the point. Google's official API only serves your own apps' reviews; the public store serves everyone's.

**How many reviews can I get per app?**
There is no fixed cap: pagination is token-based and this Actor has been tested pulling hundreds of reviews per run in seconds and thousands per app. Set `maxReviewsPerApp: 0` for everything the store will serve.

**Does it get developer replies?**
Yes — `replyText` and `replyDate` are filled whenever the developer answered a review. In a 600-review test run, 101 reviews carried a reply.

**Can I get reviews in a specific country or language?**
Yes — `country` selects the storefront and `language` the review language. The same app often has a completely different rating story per market.

**Can I export Google Play reviews to CSV or Excel?**
Yes — one click in Apify Console, or automatically via the Google Sheets integration, webhooks, Zapier, Make or the Apify API.

**Is it legal to scrape Google Play reviews?**
See *Is it legal to scrape Google Play reviews?* below.

**What's a package ID?**
The `id=` parameter in the Play URL: `play.google.com/store/apps/details?id=com.whatsapp` → `com.whatsapp`. Or skip the lookup entirely and pass the app's name — the Actor resolves it via Play search.

**Why is a review missing that I can see in the store?**
Google serves a per-country selection. Make sure `country` matches the storefront you're looking at (and `language` the review's language).

**Does it also do Apple App Store reviews?**
Not this Actor — it's deliberately Google Play only, priced accordingly. For both stores in one run and one schema, use our [App Reviews Scraper — App Store & Google Play](https://apify.com/fabrikit/app-reviews-unified).

### Support

Found an issue or need a field this Actor doesn't return yet? Open an issue on the Actor's **Issues tab** — we aim to answer issues **within 24 hours**.

### Is it legal to scrape Google Play reviews?

The Actor only reads reviews that Google publishes on the public Play Store pages, without logging in. Collecting public review data is standard practice for ASO and market-research tooling, but reviewer display names (`author`) are personal data, so laws such as the EU GDPR, Chile's Ley 21.719 or the California CCPA apply to how you store and use them; you are responsible for a lawful purpose and can drop the `author` column if you do not need it. Review texts belong to their authors, so do not republish them wholesale, and respect Google's terms of service. This is general information, not legal advice.

### Use with AI agents

Use this actor to get public Google Play reviews of any Android app (package ID, Play URL or app name) for a given country and language, sorted by most recent or most helpful.

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

Main output fields: `appName`, `rating`, `text`, `author`, `date`, `version`, `helpfulCount`, `replyText`, `replyDate`, `country`, `language`, `url`. It is pay-per-event: an agent pays a small start fee plus a fixed price per review saved, not for compute time.

### Related actors

- **[App Reviews Scraper — App Store & Google Play](https://apify.com/fabrikit/app-reviews-unified)** — need App Store reviews too? Both mobile stores in one run and one schema: this Actor's fields, plus iOS.
- **[Chrome Web Store Reviews Scraper](https://apify.com/fabrikit/chrome-web-store-reviews-scraper)** — reviews of browser extensions, with developer replies.
- **[Shopify App Store Reviews Scraper](https://apify.com/fabrikit/shopify-app-store-reviews-scraper)** — reviews of Shopify apps.
- **[TrustRadius Reviews Scraper](https://apify.com/fabrikit/trustradius-reviews-scraper)** — B2B software reviews with buyer context.
- **[Greenhouse Jobs Scraper](https://apify.com/fabrikit/greenhouse-jobs-scraper)** — job postings from any company's Greenhouse board.

#### Ready-made examples

- [Most helpful Google Play reviews of an app](https://apify.com/fabrikit/google-play-reviews-scraper/examples/google-play-most-helpful-reviews)

### Technical details

- Source: the public Google Play web store over plain HTTP with token-based pagination (batches of 150), via the battle-tested `google-play-scraper` engine — no browser, no proxies.
- Accepts package IDs, full Play URLs (the `id` parameter is extracted) and free-text names (resolved via Play search, top match).
- Items are unique per `appId:reviewId` within a run.
- A per-app run summary is stored in the key-value store under `SUMMARY`.
- Output schema is identical to the Google Play rows of our [App Reviews Scraper](https://apify.com/fabrikit/app-reviews-unified) — you can switch or mix the two without changing downstream code.

### Changelog

- **2026-10-16** — README: legal notes, AI-agent usage, related actors, example task and more integrations added; pricing text updated.
- **2026-08-26** — Published on the Apify Store with pay-per-event pricing.
- **2026-08-21** — Build 0.1.1: initial release — package IDs, Play URLs or app names; any country and language; `recent` or `helpful` sort; developer replies.

# Actor input Schema

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

One entry per app: a Play package ID (the `id=` in the Play URL, e.g. `com.whatsapp`), a full Play Store URL (e.g. `https://play.google.com/store/apps/details?id=com.spotify.music`), or an app name (e.g. `duolingo`) — a name is resolved to the top Google Play search match.

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

Two-letter store country code (e.g. `us`, `gb`, `de`, `br`, `jp`). Reviews are storefront-specific: the same app has different reviews per country.

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

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

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

Stop after this many reviews per app. 0 = no limit — Google Play pagination is token-based and effectively unlimited.

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

`recent` = newest first. `helpful` = most helpful first (Google Play's helpfulness ranking).

## Actor input object example

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

# Actor output Schema

## `reviews` (type: `string`):

All Google Play reviews collected during the run

# 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("fabrikit/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("fabrikit/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 fabrikit/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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