# Google Play Store Review Scraper (`fastdataapi/google-play-store-review-scraper`) Actor

Google Play Store Review Scraper — Extract Google Play Store reviews including ratings, review text, usernames, dates, app versions, helpful votes, developer replies, and app details. Useful for app research, user feedback analysis, sentiment analysis, and competitor monitoring.

- **URL**: https://apify.com/fastdataapi/google-play-store-review-scraper.md
- **Developed by:** [Fast Data API](https://apify.com/fastdataapi) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.67 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Store Reviews Scraper — Ratings, Text, Reviewer, Dates

Google Play Store Reviews Scraper collects public reviews for any Android app on Google Play: star rating, full review text, reviewer name and avatar, helpful-vote count, review date and a direct link to each review. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a Google Play review sentiment analysis pipeline. **No Google account or login is needed.** Add one app or many, filter by star, keyword, app version or date, and start tracking how real users rate every release.

![Google Play Store Review Scraper output: rating, review text, reviewer and date as JSON](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/i-play-reviews-hero.webp)

***

### What data can I extract with Google Play Store Reviews Scraper?

Using this Google Play reviews API, you will be able to extract the following Google Play review data:

| 🆔 Review ID | ⭐ Star rating | 👤 Reviewer name | 📅 Review date |
|---|---|---|---|
| 🌍 Storefront language | 📝 Review text | 🖼️ Reviewer avatar | 🔢 Row position (per app) |
| 👍 Helpful vote count | 📱 App package name | 🕒 Unix timestamp | 🌐 Storefront language code |
| 🔑 Google user ID | 🔗 Review link | ⏱️ ISO review time | 📦 Scraped-at time |

***

### How to use Google Play Store Reviews Scraper

Anyone who wants to know what real users say about an Android app — a product manager watching a release, a support team triaging complaints, or an ASO agency comparing competitors — gets one row per review from a single run.

**Copy to your AI assistant:**

```text
Google Play Store Reviews Scraper (Apify Actor ID: fastdataapi/google-play-store-review-scraper, https://apify.com/fastdataapi/google-play-store-review-scraper) is an Apify Actor that returns public Google Play reviews for one or more Android apps as structured JSON: star rating, review text, reviewer name and avatar, helpful vote count, review date and a direct link to each review. Use it whenever someone needs Google Play review data without cookies, a login, or a browser - watching how users react right after a release, triaging 1 and 2 star complaints that mention a specific word, or comparing ratings across competing apps. Inputs: startUrls (array of Google Play app links or package names, required), deviceType ("mobile"|"tablet"|"chromebook", default "mobile"), sortBy ("mostRelevant"|"newest"|"rating", default "mostRelevant"), rating (single star 1-5, optional), ratingFilter (array of "1"-"5", optional), keywords (array of strings, optional), appVersion (array of strings, optional), endDate (date "YYYY-MM-DD", optional), recentDays (integer, 0 = no limit), uniqueOnly (boolean, default true), maxReviews (-1 for up to 10000, or 1-10000, default 100), reviewsPerPage (1-1000, default 200), pagesToScrape (-1 for no limit, or >=1, default -1), startPage (>=1, default 1), proxyConfiguration. When exactly one star is chosen, Google Play itself returns only that star, so no pages are wasted reading other ratings.
```

#### Google Play Store Reviews Scraper MCP Server: use these Actors from ChatGPT, Claude or Cursor

Point your AI assistant at Apify's MCP server and it can read Google Play review data on its own: it calls this Actor with the app links or package names you give it, then hands back the reviews it collected. No glue code, no scraping logic written into your prompts, and no separate API client to maintain.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fastdataapi/google-play-store-review-scraper"
```

#### Step by step

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open [Google Play Store Reviews Scraper](https://apify.com/fastdataapi/google-play-store-review-scraper) in the Apify Store.
3. Enter the Google Play app links or package names, one per line.
4. Click **Start** (or send your API request).
5. Export Google Play reviews to CSV, or download JSON or Excel.

#### How to scale Google Play Store Reviews Scraper to bulk

Add more lines to `startUrls` to scrape many apps in the same run — every app is read concurrently (up to 8 apps at once) and gets its own `maxReviews` cap, independent of the others. An app listed twice is scraped once. This collects bulk Google Play reviews by package name across many apps at once, lets you run the same list on a schedule to export fresh reviews every day, and lets you compare ratings and complaints across several competing apps in one run.

***

### ✨ Features

Google Play Store Reviews Scraper fetches clean, structured reviews from Google Play ⚡, working as a Google Play store review extractor, an Android app reviews scraper and a Google Play reviews scraper for one app or many apps in the same run. It's ideal for release monitoring, support-ticket triage, competitor research and feeding app-review text into an AI pipeline.
It extracts, per review:

- **Star rating and review text** – the 1-5 star score and the full written review
- **Reviewer** – display name, avatar and Google user ID
- **Helpful vote count** – how many people marked the review as helpful
- **Review date, ISO time and Unix timestamp** – three ready-to-use time formats
- **Review link** – a direct URL to the review on the app's Google Play page

⚡ A single star rating filter is sent straight to Google Play's own review feed, so a one-star search never wastes a page reading other ratings.

***

### Use cases 💡

- **Product manager** — sort by newest with recent-days low to see reactions right after a release.
- **Support lead** — keep 1 and 2 star reviews mentioning a word like "crash" for the ticket queue.
- **ASO agency** — run a client's app and its competitors together and compare ratings and complaints.
- **QA / rollout owner** — filter by app version to check ratings before and after a staged rollout.
- **AI agent builder** — feed review text and star rating into a RAG pipeline.

Building an AI agent? [Connect Google Play Store Reviews Scraper over MCP](#google-play-store-reviews-scraper-mcp-server-use-these-actors-from-chatgpt-claude-or-cursor) and let it call the actor on its own.

***

### Why choose this actor?

- **Reviews saved while the run is still going.** A recorded run returned 30 reviews from 3 apps, sorted newest first, in 1.2 seconds. A second recorded run returned 50 of the most-relevant reviews for one app in 1.0 second.
- **Real reviewer signal, not just a star count.** A recorded review for that app carried 8,935 helpful votes alongside its full text, rating, date and reviewer avatar.
- **Six filters, three sort orders, one Actor.** Star rating, multi-star filter, keywords, app version, end date and recent-days can all run together, on phone, tablet or Chromebook reviews, sorted by relevance, newest or rating.

***

### ⬇️ Input

![Google Play Store Review Scraper input form with app links, sort order and max reviews](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/i-play-reviews-input.webp)

This Actor accepts one or more Google Play app links or bare package names (`startUrls`) — this is the only required field. Every other field narrows down which reviews are kept or how they're read.

| Parameter | Required | Type | Description | Example value |
|---|---|---|---|---|
| `startUrls` | Yes | Array of strings | Google Play app links (e.g. `https://play.google.com/store/apps/details?id=com.supercell.brawlstars`) or bare package names, one per line. An app listed twice is scraped once. | `["com.spotify.music"]` |
| `deviceType` | No | String | Which device's reviews to read: `mobile`, `tablet` or `chromebook`. Default `mobile`. | `"mobile"` |
| `sortBy` | No | String | Review order: `mostRelevant`, `newest` or `rating`. Default `mostRelevant`. | `"newest"` |
| `rating` | No | Integer | Keep only this single star, 1-5. Leave empty for all ratings. | *(empty)* |
| `ratingFilter` | No | Array of strings | Keep any of these stars (`"1"`-`"5"`); combined with `rating` when both are set. | `["1", "2"]` |
| `keywords` | No | Array of strings | Keep reviews whose text contains any of these words or phrases, not case-sensitive. | `["crash", "update"]` |
| `appVersion` | No | Array of strings | Keep reviews written on these app versions (a value also matches any version that starts with it). | *(empty)* |
| `endDate` | No | String | Keep reviews posted on or before this date, `YYYY-MM-DD` UTC. | *(empty)* |
| `recentDays` | No | Integer | Keep reviews from the last N days; `0` means no limit. | `0` |
| `uniqueOnly` | No | Boolean | Skip a review that shows up again on a later page of the same app. Default `true`. | `true` |
| `maxReviews` | No | Integer | Maximum reviews saved per app, counted after the filters. `-1` for up to 10000. Default `100`. Free plan: up to 20 per run (all listed apps together) and 200 per month. | `5` |
| `reviewsPerPage` | No | Integer | Reviews read per page, 1-1000. Default `200`. | `50` |
| `pagesToScrape` | No | Integer | Maximum pages per app from `startPage`. `-1` for no limit (default). | `10` |
| `startPage` | No | Integer | Page to start saving from; earlier pages are read and skipped. Default `1`. | `1` |
| `proxyConfiguration` | No | Object | Apify Proxy settings; on = every request through it, off = direct first, proxy after a block. | `{"useApifyProxy": false}` |

#### Free plan limits

Users on the Apify free plan can fetch up to 20 reviews per run (all listed apps together) and 200 reviews per month. When the limit is reached, the run finishes successfully with a status message explaining the limit. Upgrade to any paid Apify plan to remove these limits.

#### Example input

This is the real input used for one of the recorded runs quoted throughout this page:

```json
{
  "startUrls": [
    "https://play.google.com/store/apps/details?id=com.supercell.brawlstars",
    "com.spotify.music"
  ],
  "deviceType": "mobile",
  "sortBy": "newest",
  "rating": null,
  "ratingFilter": ["1", "2"],
  "keywords": ["crash", "update"],
  "appVersion": [],
  "endDate": "",
  "recentDays": 0,
  "uniqueOnly": true,
  "maxReviews": 5,
  "reviewsPerPage": 50,
  "pagesToScrape": 10,
  "startPage": 1,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

***

### ⬆️ Output

![Google Play Store Review Scraper output fields: rating, body, helpfulCounts and reviewedAt](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/i-play-reviews-output.webp)

Every review is one typed, normalized JSON item with the same schema on every run — reviews are saved to the dataset page by page as each page is filtered, never held back to the end of the run. Export your results as JSON, CSV or Excel.

#### Example output

A real row from one of the recorded runs above (review text shortened):

```json
{
  "reviewId": "eb18667a-e0fb-4622-9a8e-67e12c05af81",
  "rating": 2,
  "reviewer": "Drake M.",
  "date": "2026-10-07",
  "reviewedIn": "en",
  "body": "Ever since the update, the forced new giant widget for your home screen just goes black with a spinning circle most of the time. Says it is \"Offline\" and has a hard time reconnecting. …",
  "userImage": "https://play-lh.googleusercontent.com/a-/ALV-UjWS-AlQaimOaXUL5OB5C6PCSsYRws2syR2A2rhRK9Qv6q_zSzSh",
  "position": 1,
  "helpfulCounts": 0,
  "appId": "com.spotify.music",
  "timestamp": 1791362103,
  "language": "en",
  "userId": "112063709926433165913",
  "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=eb18667a-e0fb-4622-9a8e-67e12c05af81",
  "reviewedAt": "2026-10-07T08:35:03Z",
  "scrapedAt": "2026-10-08T08:59:41Z"
}
```

***

### How does it work?

Google Play Store Reviews Scraper reads the same public app page and review feed any visitor's browser loads — no browser window is opened and no Google account is used. Requests run through a direct connection by default, and when Google Play blocks one, the rest of that app's requests switch automatically to a residential proxy so the run keeps going; a blocked or slow request is retried with growing waits before the actor tries again a little later. Only data any visitor can see without logging in is ever returned — reviews are read from the English-language US storefront, so `reviewedIn` and `language` are always `en`. The output fields stay the same shape on every run, so your code never has to change when Google Play changes how its pages work internally.

***

### How do you integrate Google Play Store Reviews Scraper into your stack?

It works with what you already use: call it from any language over REST, connect it to an AI agent through MCP, or wire it into a no-code workflow tool.

#### MCP integration for AI agents

Register Apify's MCP server as a callable tool for your AI agent using the command below.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fastdataapi/google-play-store-review-scraper"
```

This registers Google Play Store Reviews Scraper as a tool your agent can call directly — the server starts with this Actor already added as a tool, so no search or add step is needed on your side. It can run the actor with the app links you give it, all without you writing any scraping logic into your prompts. Compatible with Claude Code, Cursor and Windsurf.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node's "Run an Actor" action pointed at this Actor, then follow it with a "Get Dataset Items" step to pull the reviews. In Make, the Apify app's "Run an Actor" module starts the run, and "Get Dataset Items" reads the results back into your scenario. In LangChain, install `langchain-apify` and wrap this Actor with `ApifyActorsTool`, passing your app links the same way you would through the API.

***

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

Scraping publicly available data from the web is generally lawful, though Google's own Terms of Service restrict automated access to its site. As a Google Play app reviews scraper, it returns only review data that any visitor without a Google account can see — nothing from behind a login. Under GDPR, scraping public data is generally permissible, but storing and using it must still comply with local data-protection law; a reviewer's display name, avatar and Google user ID can count as personal data. Consult legal counsel if your use case involves bulk storage of personal data.

***

### Frequently asked questions

#### What fields does Google Play Store Reviews Scraper return?

Every review comes back with its star rating, full review text, reviewer name and avatar, helpful vote count and review date, plus a direct link to the review. See [the data fields section](#what-data-can-i-extract-with-google-play-store-reviews-scraper) for the complete list.

#### Does Google Play Store Reviews Scraper require a Google account or login?

No. Only review data that any visitor can see without logging in is extracted — no credentials are needed.

#### How fast does Google Play Store Reviews Scraper run?

A recorded run returned 30 reviews from 3 apps, sorted newest first, in 1.2 seconds; another returned 50 reviews for one app in 1.0 second. Every review is live data, read at run time — nothing is cached.

#### What happens if an app is private or doesn't exist?

An app that doesn't exist on Google Play is skipped and reported in the log and the run's status message, while every other app in the same run keeps going. An entry that isn't a Google Play app link or package name is skipped and named in the log the same way.

#### Can I scrape multiple Google Play apps at once?

Yes. `startUrls` takes an array, so you can scrape many apps in a single run — every app is read concurrently (up to 8 at once) and capped at `maxReviews` independently of the others.

#### Does Google Play Store Reviews Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes — Google Play Store Reviews Scraper is reachable through Apify's MCP server. Run `claude mcp add --transport http apify "https://mcp.apify.com?tools=fastdataapi/google-play-store-review-scraper"` to register it as a callable tool in Claude Code, Cursor or Windsurf. Any agent that can call an HTTP endpoint can use the REST API directly.

#### Does Google Play Store Reviews Scraper return data in a format LLMs can use directly?

Yes. Every response is typed, normalized JSON with the same field names on every run. There's no HTML to parse and no selectors to maintain — pass the response straight to an LLM, index it into a vector store, or feed it to an agent tool with no transformation step.

#### What happens when Google Play changes its layout or anti-bot system?

This actor is maintained and updated when Google Play changes its pages, so your calls keep returning the same JSON fields with no changes needed on your end.

#### Can I use Google Play Store Reviews Scraper without managing proxies or browser infrastructure?

Yes. Proxy handling runs on the actor's side, switching from a direct connection to a residential proxy automatically when needed. You send one request and get structured JSON back — no proxy accounts and no browser setup to maintain.

#### Which Google Play review fields work best for AI training data and RAG indexing?

For RAG indexing: the review text carries the richest context for a review. For training data: the star rating, helpful vote count and timestamp are the most structurally consistent numeric fields across reviews. All fields are typed primitives — strings, integers, booleans — with no normalization needed.

***

### Your feedback

Found a bug or a field that doesn't match what Google Play shows? Let us know so the actor can be kept accurate as Google Play changes. Every report is read and fixes are shipped as they're found.

# Actor input Schema

## `startUrls` (type: `array`):

One per line: a Google Play app link (https://play.google.com/store/apps/details?id=com.supercell.brawlstars) or just the package name (com.supercell.brawlstars). Several apps are scraped at the same time and all reviews go into one dataset. An app listed twice is scraped once, entries that are not app links or package names are skipped and named in the log, and an app that does not exist is reported in the log and the status message.

## `deviceType` (type: `string`):

Which device's reviews to read: phone, tablet or Chromebook. Google Play keeps separate reviews per device, so tablet and Chromebook reviews differ from phone reviews.

## `sortBy` (type: `string`):

Order in which Google Play returns the reviews: most relevant, newest first, or by rating.

## `rating` (type: `integer`):

Only keep reviews with this star rating (1-5). When a single star is chosen, Google Play returns only reviews with that star, so no pages are wasted. Leave empty for all ratings.

## `ratingFilter` (type: `array`):

Only keep reviews with any of these star ratings (e.g. 1, 2 and 5). When Star rating is also set, only the stars chosen in both are kept. Leave empty for all ratings.

## `keywords` (type: `array`):

Only keep reviews whose text contains at least one of these words or phrases (not case-sensitive). Leave empty for no keyword filter.

## `appVersion` (type: `array`):

Only keep reviews written on these app versions. A value matches that exact version or any version that starts with it, so 69 matches 69.414 and 69.414 matches 69.414.2. Reviews without a recorded version are skipped while this filter is set. Leave empty for all versions.

## `endDate` (type: `string`):

Only keep reviews posted on or before this date (YYYY-MM-DD, UTC). Leave empty for no limit.

## `recentDays` (type: `integer`):

Only keep reviews from the last N days (0 = no limit). With Sort by set to Newest, an app stops as soon as a whole page is older, which makes this the fastest way to get recent reviews.

## `uniqueOnly` (type: `boolean`):

Skip a review that shows up again on a later page of the same app.

## `maxReviews` (type: `integer`):

Maximum reviews saved per app, counted after the filters. Use -1 for up to 10000, or any value from 1. An app with fewer matching reviews gives all it has. Free plan: up to 20 reviews per run (all listed apps together) and 200 per month; paid plans have no limit.

## `reviewsPerPage` (type: `integer`):

How many reviews to read per page (1-1000). Bigger pages mean fewer requests; 200 is a good balance.

## `pagesToScrape` (type: `integer`):

Maximum pages per app, counted from the start page. Use -1 (default) for no page limit, or any value from 1. Without a page limit an app stops at Max reviews per app or when it has no more reviews.

## `startPage` (type: `integer`):

Page to start saving from (1 = the first page). Earlier pages are still read and then skipped, so a later start page takes longer; it does not save requests.

## `proxyConfiguration` (type: `object`):

With Apify Proxy on, every request goes through it (the residential group when no group is chosen; US unless you pick a country). With it off, requests start on a direct connection and an app switches to the residential proxy as soon as Google Play blocks it. If the proxy refuses the connection, the run continues directly.

## Actor input object example

```json
{
  "startUrls": [
    "https://play.google.com/store/apps/details?id=com.supercell.brawlstars"
  ],
  "deviceType": "mobile",
  "sortBy": "mostRelevant",
  "rating": null,
  "endDate": "",
  "recentDays": 0,
  "uniqueOnly": true,
  "maxReviews": 100,
  "reviewsPerPage": 200,
  "pagesToScrape": -1,
  "startPage": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped reviews, one row per review. Rows appear page by page while the run goes on.

# 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 = {
    "startUrls": [
        "https://play.google.com/store/apps/details?id=com.supercell.brawlstars"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fastdataapi/google-play-store-review-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 = {
    "startUrls": ["https://play.google.com/store/apps/details?id=com.supercell.brawlstars"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fastdataapi/google-play-store-review-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 '{
  "startUrls": [
    "https://play.google.com/store/apps/details?id=com.supercell.brawlstars"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fastdataapi/google-play-store-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fastdataapi/google-play-store-review-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/boz516gqWXWgfAbau/builds/f55oGA4gyIFNEn422/openapi.json