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

Scrape Google Play app reviews by package name or store URL. Extract user name, score, review text, date, thumbs-up count, app version, and developer reply. Sort by newest or rating, filter by star, paginate to thousands per app. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/google-play-reviews-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.11 / 1,000 reviews

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 app reviews from $0.10 / 1,000 results, and pull 50,000+ reviews in one run.** Get user name, star score, review text, date, thumbs-up count, app version and developer reply as clean rows ready for CSV, Excel, JSON or the API. No HTML parsing, no maintenance - you pay only per review returned.

---

### What does the Google Play Reviews Scraper do?

The Google Play Reviews Scraper turns any Android app on the Google Play Store into a structured review dataset. Feed it one or more apps - by name (`Spotify`), package (`com.spotify.music`) or Play Store URL - and it returns each review as a flat row: who wrote it, the star score, the written review text, the date, how many users found it helpful, the app version reviewed and the developer's reply. Sort by newest, rating or relevance, narrow to a single star rating, and set **Max reviews per app** to any depth: 100, 10,000 or every review the app has - the Actor auto-paginates until it gets there. This is the fast, low-cost way to pull Google Play reviews at scale without touching a browser.

### What data can you get from a Google Play review?

Each review row carries the fields buyers ask for:

- 👤 **User name** - the reviewer's display name
- ⭐ **Score** - star rating from 1 to 5
- 📝 **Review text** - the written review content
- 📅 **Date** - when the review was posted (ISO 8601)
- 👍 **Thumbs-up count** - how many users marked it helpful
- 💬 **Developer reply** - the developer's response text and reply date
- 🔢 **App version** - the build the user reviewed
- 🆔 **Review ID** - a stable identifier for deduping
- 🖼 **Avatar** - the reviewer's profile image URL

The complete raw review object is also attached under `data`, so no field is ever lost.

### How to scrape Google Play reviews

1. Open the Google Play Reviews Scraper and click **Try for free**. The input form is prefilled with a working example app, so a first run returns real reviews with zero setup.
2. In **Apps**, paste one or more package names (`com.spotify.music`), Play Store URLs, or plain app names (`Spotify`). Mix freely.
3. Pick a **Sort** order - newest, rating or most relevant - and optionally set a **Star filter** to pull only 1 to 5 star reviews.
4. Set **Max reviews per app** to control depth and cost, then choose **Country** and **Language** for localized reviews.
5. Click **Start**, then export the results to CSV, Excel, JSON or the API.

#### Input example

```json
{
  "appIds": ["Spotify", "com.whatsapp", "https://play.google.com/store/apps/details?id=com.instagram.android"],
  "sort": "newest",
  "filterScore": 5,
  "maxReviewsPerApp": 2000,
  "country": "us",
  "lang": "en"
}
````

#### Output example

```json
{
  "query": "com.spotify.music",
  "row_type": "review",
  "review_id": "8c4e1f2a9b...",
  "user_name": "Jordan M.",
  "score": 5,
  "content": "Best music app I have used. The offline mode works great on my commute.",
  "at": "2026-06-09T14:32:11Z",
  "thumbs_up_count": 128,
  "reply_content": "Thanks for the kind words! Glad offline mode is working for you.",
  "replied_at": "2026-06-10T09:15:00Z",
  "app_version": "8.9.74.123",
  "user_image": "https://play-lh.googleusercontent.com/a/...",
  "data": { "...": "complete review object" }
}
```

Each run also writes a summary record to the `OUTPUT` key with the review count, error count and estimated cost. Error rows carry an `error_code` and are free - you pay only for real reviews.

### How much does it cost to scrape Google Play reviews?

Reviews are billed at **$0.10 per 1,000 results** ($0.0001 each). The math is simple:

- **$5** in free Apify trial credits = roughly **50,000 reviews** ($5 / $0.0001)
- **1,000 reviews** = **$0.10**
- **50,000 reviews** = **$5.00**
- **100,000 reviews** = **$10.00**

You are charged only for review rows actually returned. Errors and empty results cost nothing, so a misconfigured run never burns your budget. Live per-event pricing is shown on this actor's Apify Store page.

### What can you use Google Play reviews for?

- **Sentiment analysis** - track how users feel about an app release over time.
- **Product feedback mining** - surface bugs, feature requests and pain points at scale.
- **Competitor CX intelligence** - read how rival apps handle complaints in their developer replies.
- **App Store Optimization (ASO)** - find the keywords and phrases real users repeat in reviews.
- **Release monitoring** - watch scores and themes shift right after each app version ships.
- **Support automation** - feed reviews into an LLM to auto-tag issues and route them to teams.
- **Churn research** - read 1 and 2 star reviews to learn why users uninstall.
- **Market research** - benchmark ratings and review volume across a category of apps.
- **Brand monitoring** - get a heads-up when negative reviews spike on your app.

### Is it legal to scrape Google Play?

Scraping publicly available data, including public app reviews on Google Play, is broadly legal in the US and EU and has been upheld in cases such as hiQ v. LinkedIn. This actor collects only public review data that any visitor can see, never private accounts or hidden content. You are responsible for using the output in line with Google's terms, GDPR/CCPA and your local laws - for compliance-sensitive projects, consult your legal team.

### Related scrapers

Part of the **Data Forge** Google Play suite:

- **Google Play Scraper** - the umbrella actor for app search, app details and reviews in one place.
- **Google Play App Scraper** - pull rich app metadata: title, developer, installs, rating, price, screenshots and description.

Need Amazon, Walmart, TripAdvisor, Booking or Google Maps data too? The broader Data Forge fleet covers those.

### FAQ

**How many reviews can I pull per app?**
As many as the app has. Set **Max reviews per app** to 100, 10,000 or 1,000,000 - the Actor keeps pulling the review feed until it reaches your number or runs out of reviews, and you pay only per review returned.

**Which apps and countries are supported?**
Any public app on the Google Play Store, in any country and language. Set **Country** and **Language** for localized reviews.

**Can I call this from the API or an integration?**
Yes. Each Apify actor ships a REST API, scheduler, webhooks and an MCP server, so you can run the Google Play Reviews Scraper from your own code, Make, Zapier or an AI agent.

**Can I filter by star rating?**
Yes. Set the **Star filter** to pull only 1, 2, 3, 4 or 5 star reviews, and **Sort** by newest, rating or relevance.

**Do I pay for failed runs?**
No. Error and empty rows are free - you are billed only for real review results.

### Support

I personally support customers directly - reach out on any channel.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Apps to pull reviews for - package name (com.whatsapp), Play URL, or just the app name (WhatsApp).

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

How deep to go per app - 100, 10,000 or every review the app has. The Actor pulls reviews until it reaches this number or runs out. Each review is one paid result.

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

Order reviews are pulled in (newest, by rating, or most relevant).

## `filterScore` (type: `string`):

Keep only reviews with this star rating (1-5). Leave blank for all.

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

2-letter country code.

## `lang` (type: `string`):

2-letter language code.

## Actor input object example

```json
{
  "appIds": [
    "WhatsApp"
  ],
  "maxReviewsPerApp": 100,
  "sort": "newest",
  "filterScore": "",
  "country": "us",
  "lang": "en"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; one flat row per review, full payload under data.

## `summary` (type: `string`):

OUTPUT key: reviews, apps, errors, total\_rows, estimated\_cost\_usd, limit\_reached, actor\_version.

# 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": [
        "WhatsApp"
    ],
    "maxReviewsPerApp": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/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": ["WhatsApp"],
    "maxReviewsPerApp": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/google-play-reviews-scraper").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 '{
  "appIds": [
    "WhatsApp"
  ],
  "maxReviewsPerApp": 100
}' |
apify call jdtpnjtp/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Reviews Scraper",
        "description": "Scrape Google Play app reviews by package name or store URL. Extract user name, score, review text, date, thumbs-up count, app version, and developer reply. Sort by newest or rating, filter by star, paginate to thousands per app. Pay per result.",
        "version": "1.0",
        "x-build-id": "WZ4EGTRzNpePyUD35"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~google-play-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-google-play-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jdtpnjtp~google-play-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-google-play-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jdtpnjtp~google-play-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-google-play-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "appIds": {
                        "title": "Apps",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Apps to pull reviews for - package name (com.whatsapp), Play URL, or just the app name (WhatsApp).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "How deep to go per app - 100, 10,000 or every review the app has. The Actor pulls reviews until it reaches this number or runs out. Each review is one paid result.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "rating",
                            "most_relevant"
                        ],
                        "type": "string",
                        "description": "Order reviews are pulled in (newest, by rating, or most relevant).",
                        "default": "newest"
                    },
                    "filterScore": {
                        "title": "Star rating filter",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Keep only reviews with this star rating (1-5). Leave blank for all.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "2-letter country code.",
                        "default": "us"
                    },
                    "lang": {
                        "title": "Language",
                        "type": "string",
                        "description": "2-letter language code.",
                        "default": "en"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
