# 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
- **Stats:** 2 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?

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

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 — US$0.40 per 1,000 reviews

This Actor uses Apify's **pay-per-event** model and charges **per review delivered** (event `review-result`, **US$0.0004 per review = US$0.40 per 1,000 reviews**) on top of standard Apify platform usage. No subscription, no rental fee, no proxy costs. Scraping 10,000 reviews costs US$4 in events — cheaper than any comparable reviews scraper on the Store. 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, Zapier, Make, Slack, webhooks or MCP** directly from Apify Console with no code at all.

**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?**
The Actor only reads reviews that Google publishes on the public Play Store pages. Collecting public review data is standard practice for ASO and market-research tooling; how you use the data is up to your own compliance requirements.

**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** — issues are answered in **less than 24 hours**, and reasonable feature requests usually ship within days.

### More scrapers by Fabrikit

- **[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.
- **[Greenhouse Jobs Scraper](https://apify.com/fabrikit/greenhouse-jobs-scraper)** — job postings from any company's Greenhouse board.
- **[ATS Jobs Scraper — Greenhouse, Lever, Ashby & SmartRecruiters](https://apify.com/fabrikit/ats-jobs-api)** — jobs from the four biggest ATS platforms, normalized.
- **[Portal Inmobiliario Scraper — Chile Real Estate](https://apify.com/fabrikit/portal-inmobiliario-scraper)** — property listings from Chile's largest real estate marketplace.

### 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.

# 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/CC3gmFdkmXvTdgkpf/openapi.json