# Google Play Reviews Scraper - Android App Reviews $0.10/1K (`santhej/google-play-reviews-scraper`) Actor

Scrape Google Play reviews for any Android app: star rating, review text, ISO-8601 date, app version, reviewer name and avatar, developer replies and a direct review permalink. Includes an app-level summary with the store rating and total review count. $0.10 per 1,000 reviews.

- **URL**: https://apify.com/santhej/google-play-reviews-scraper.md
- **Developed by:** [Santhej Kallada](https://apify.com/santhej) (community)
- **Categories:** Marketing, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 — $0.10 per 1,000 Reviews

**Pull the newest Google Play reviews for any list of apps — rating, full text, ISO-8601 date, helpful votes, app version, reviewer avatar, a permalink to each review and the developer's reply — as clean JSON or CSV.**

Reviews are where users tell you exactly what to build, what to fix, and why they churn. They are also the fastest competitive intel there is: your rival's 1-star reviews are your roadmap. This Actor takes package IDs or Play Store URLs in bulk, scrapes the newest reviews from any of 190+ country storefronts, and returns one tidy row per review plus a summary row per app.

No API keys, no proxies, no setup — paste app IDs and run.

### What you get per review

| Field | What it tells you |
|---|---|
| `rating` | Star rating (1-5) the reviewer gave |
| `text` | The review itself, in full |
| `date` | When it was posted — **strict ISO 8601 UTC** (`2026-08-24T04:53:25.000Z`), so pandas, BigQuery, Sheets and `datetime.fromisoformat` parse it with no clean-up step |
| `date_raw` | The store's original timestamp string, kept verbatim so nothing is lost |
| `helpful_count` | How many users up-voted the review — always a number, `0` when nobody has, never null |
| `app_version` | Which release the reviewer was on — pin a complaint to a build |
| `author` | Reviewer's public profile name |
| `author_avatar_url` | Reviewer's profile picture |
| `review_url` | Permalink straight to that review on the Play Store |
| `review_id` | Stable id for deduping across scheduled runs |
| `developer_reply_text` / `developer_reply_author` / `developer_reply_date` | The developer's public response, who posted it, and when — when one exists |
| `title` | Kept for schema compatibility. Google Play retired review titles, so this is `null` on modern reviews |
| `country` / `language` | The storefront the review was read from |

Every run also emits one `app_summary` row per app — store rating, total review count on the store, reviews scraped — plus a run summary in the key-value store. That app-level context is not something most review scrapers give you.

### Use cases

- **Review mining** — feed thousands of reviews to an LLM and extract feature requests, bugs and churn reasons.
- **Competitor analysis** — scrape rivals' newest reviews and read their roadmap in their 1-star complaints.
- **ASO monitoring** — track rating trends and review velocity per release, per country.
- **Release regression alerts** — a spike of 1-star reviews pinned to `app_version` is your earliest crash signal.
- **Reputation management** — find reviews with no developer reply and answer them before they age.
- **Market research** — compare what users praise in each of 190+ country storefronts before you localize.

### Pricing

Pay per result. No monthly fee, no setup fee, no minimum.

| Event | Price |
|---|---|
| Actor start | $0.001 per run |
| Review scraped | **$0.0001 — that is $0.10 per 1,000 reviews** |

Scraping the newest 150 reviews for 10 apps costs about **$0.15**. You are billed only for reviews actually returned — an app that fails or returns nothing is not charged.

### Input example

```json
{
  "apps": [
    "com.whatsapp",
    "https://play.google.com/store/apps/details?id=org.telegram.messenger"
  ],
  "maxReviewsPerApp": 150,
  "countryCode": "us",
  "languageCode": "en"
}
```

### Output example

```json
{
  "record_type": "review",
  "app_id": "com.whatsapp",
  "review_id": "7f143ed2-6b9b-4256-b242-9c7980bbeeb8",
  "review_url": "https://play.google.com/store/apps/details?id=com.whatsapp&reviewId=7f143ed2-6b9b-4256-b242-9c7980bbeeb8",
  "rating": 2,
  "title": null,
  "text": "Latest update broke photo downloads — nothing appears in my gallery anymore.",
  "date": "2026-08-23T15:52:46.000Z",
  "date_raw": "2026-08-23 15:52:46 +00:00",
  "helpful_count": 41,
  "app_version": "2.26.32.83",
  "author": "Jake Garcia",
  "author_avatar_url": "https://play-lh.googleusercontent.com/a/ACg8ocI5xenvPdv7auNMld6HXLF1CcYza8gtecfFjA25mdAzOUFcKw=mo",
  "developer_reply_text": "Sorry about that! Please update to the latest version and let us know at support@example.com if it persists.",
  "developer_reply_author": "WhatsApp LLC",
  "developer_reply_date": "2026-08-23T18:04:11.000Z",
  "country": "us",
  "language": "en",
  "scraped_at": "2026-08-24T16:00:00.000Z"
}
```

Plus one `app_summary` row per app:

```json
{
  "record_type": "app_summary",
  "app_id": "com.whatsapp",
  "app_title": "WhatsApp Messenger",
  "app_rating": 4.2,
  "total_reviews_on_store": 194318472,
  "reviews_scraped": 150,
  "reviews_requested": 150,
  "country": "us",
  "language": "en",
  "scraped_at": "2026-08-24T16:00:00.000Z"
}
```

### FAQ

**Do I need an API key or proxies?** No. Everything is handled for you — no API keys, no proxies required. Paste app IDs and run.

**What can I put in the `apps` field?** Either a bare package id (`com.whatsapp`) or any full Play Store URL — the `id=` parameter is parsed out automatically. Up to 100 apps per run.

**Which reviews come back?** The newest first, up to your `maxReviewsPerApp` (10-1000). Run it on a schedule and dedupe on `review_id` to build a complete history.

**What format are the dates in?** Strict ISO 8601 UTC — `2026-08-24T04:53:25.000Z`. That means `pd.to_datetime`, `datetime.fromisoformat`, BigQuery, Postgres and Google Sheets all read them directly, with no string surgery first. The store's original timestamp string is still there in `date_raw` if you want it.

**Why is `title` always empty?** Google Play retired per-review titles. The field is kept so the schema stays stable, but modern Play Store reviews genuinely have no title — any tool that shows one for Google Play is showing you an empty column too.

**Which countries work?** 190+ storefronts — pass any two-letter country code (`us`, `gb`, `de`, `in`, `br`, `jp`, ...). Reviews differ per storefront, so scrape each market you care about.

**What happens if one app fails?** It gets an `error` row, is not billed, and the rest of the run continues. One bad app id never kills the batch.

**Can I export it?** Yes — JSON, CSV, Excel, or straight into n8n, Make or Zapier via the Apify API.

### Related actors

- [App Store Reviews Scraper](https://apify.com/santhej/app-store-reviews-scraper) — the exact same output for iOS apps; run both and diff sentiment across platforms.
- [ASO Rank Tracker](https://apify.com/santhej/aso-rank-tracker) — track where your app ranks for its keywords on both stores.

***

*Tags: google play reviews scraper, play store reviews, app reviews api, google play scraper, app review export, review mining, aso tool, app store optimization, app feedback analysis, competitor app reviews, android app reviews, bulk review scraper*

# Actor input Schema

## `apps` (type: `array`):

The Google Play apps to scrape reviews for. Accepts a bare package id (com.whatsapp) or a full Play Store URL (https://play.google.com/store/apps/details?id=com.whatsapp). Up to 100 apps per run.

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

How many of the newest reviews to fetch for each app (10-1000). You are billed only for reviews actually returned.

## `countryCode` (type: `string`):

Two-letter ISO 3166-1 country code of the Play Store storefront to read reviews from, e.g. us, gb, de, in, br. 190+ countries supported.

## `languageCode` (type: `string`):

Two-letter interface language code (ISO 639-1), e.g. en, de, es. Controls which language edition of the store the reviews are read from.

## Actor input object example

```json
{
  "apps": [
    "com.whatsapp"
  ],
  "maxReviewsPerApp": 50,
  "countryCode": "us",
  "languageCode": "en"
}
```

# Actor output Schema

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

One row per review, plus one app\_summary row per app.

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

Apps scraped, review counts, billing breakdown and net margin for 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 = {
    "apps": [
        "com.whatsapp"
    ],
    "maxReviewsPerApp": 50,
    "countryCode": "us",
    "languageCode": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("santhej/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 = {
    "apps": ["com.whatsapp"],
    "maxReviewsPerApp": 50,
    "countryCode": "us",
    "languageCode": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("santhej/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 '{
  "apps": [
    "com.whatsapp"
  ],
  "maxReviewsPerApp": 50,
  "countryCode": "us",
  "languageCode": "en"
}' |
apify call santhej/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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