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

Extracts Google Play app reviews by package name or app URL; returns rating, text, date, app version, helpful votes, developer reply and reviewer name as JSON. Only-new mode for monitoring, star and keyword filters. Export data, run via API, schedule runs, or connect to AI agents through MCP.

- **URL**: https://apify.com/apifry/google-play-reviews-scraper.md
- **Developed by:** [apifry](https://apify.com/apifry) (community)
- **Categories:** Marketing, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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/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 extracts **app reviews from the Google Play Store** by package name or app URL. One row = one review: star rating, review text, date, app version, helpful votes, the developer's reply with its date, and the reviewer's public name. You pay **$0.15 per 1,000 reviews stored** (down to $0.105 on higher Apify plans) — reviews skipped by your date, star or keyword filters are free.

Built for **review monitoring**: set *Only new since the last run*, schedule it daily, and each run returns only the reviews posted since the previous one. App rating, total ratings and the 1–5 star distribution are saved once per app in a separate summary, so your review table stays clean.

### What data does Google Play Reviews Scraper extract?

| Field | Example | Notes |
|---|---|---|
| `targetId` | `com.whatsapp` | App package name |
| `targetName` | `WhatsApp Messenger` | App title |
| `reviewId` | `9c3e…` | Unique per app — use it to deduplicate across runs |
| `rating` | `2` | Stars, 1–5 |
| `text` | `Calls keep dropping since the update` | Full review text |
| `publishedAt` | `2026-11-04T08:13:22Z` | Posted or last edited, ISO 8601 UTC |
| `appVersion` | `2.25.23.75` | App version the reviewer used |
| `helpfulCount` | `14` | "Helpful" votes |
| `replyText` | `Hi, please update to …` | Developer reply, if any |
| `replyAt` | `2026-11-04T10:02:11Z` | When the developer replied |
| `authorName` | `Ann B` | Reviewer's public display name |
| `authorImageUrl` | `https://play-lh.googleusercontent.com/…` | Reviewer's avatar |
| `language`, `country` | `en`, `US` | The review list you asked for |
| `url` | `https://play.google.com/store/apps/details?id=com.whatsapp&reviewId=…` | Link to the review |
| `aspectRatings` | `[{"aspect": "vaf_games_graphics", "rating": 4}]` | Per-aspect values Google shows for some apps and games (mostly games); `null` otherwise |
| `scrapedAt` | `2026-11-05T01:00:00Z` | When the row was collected |

`source` (always `google_play`), `targetUrl`, `title`, `authorId` and `updatedAt` complete the shared Apifry reviews format: the same columns are used by our other review scrapers, so one parser handles them all. Google Play has no review titles or reviewer ids, so those three are always `null` here.

#### App summary (key-value store, record `SUMMARY`)

One entry per app: `rating` (average), `ratingsCount`, `reviewsCount`, `starsDistribution` (`{"1": …, "5": …}`), `reviewsScrapedThisRun` (reviews stored this run), `error` (why an app failed, if it did) and `note` (why an app returned nothing). It is free.

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

Pay per event: **$0.15 per 1,000 reviews** stored in the dataset on the Free plan, $0.135 on Starter, $0.12 on Scale and $0.105 on Business. There is no start fee and no charge for:

- reviews older than your *Only reviews newer than* date or your last run,
- reviews that don't match your keywords,
- duplicates (the same review found in two languages or two star filters),
- apps that are not found or fail.

| Reviews | Price |
|---|---|
| 1,000 | $0.15 |
| 10,000 | $1.50 |
| 50,000 (e.g. 100 daily runs of 500) | $7.50 |

The Apify free plan's $5 monthly credit covers about 33,000 reviews. You can also cap any run with *Maximum cost per run* in the run options; the scraper stops cleanly at the cap and charges nothing beyond it.

### Review analytics add-ons (optional)

Three paid add-ons turn the reviews of a run into answers. All are **off by default**, rule-based (dictionaries in English, German, French, Spanish, Portuguese, Italian and Russian — **not AI**), and priced on the Pricing tab.

- **Tag every review** — each review gets `topics` (crashes & bugs, login & account, ads, price & subscription, updates, speed & battery, interface, customer support), `sentiment` (positive, neutral, negative or mixed — stars plus words, negations handled), `isBugReport` and `isFeatureRequest`. Tagged reviews are charged *Review with tags* instead of *Review*; a review in another language stays untagged (`topics: null`) at the plain review price.
- **Insights per app** — key-value record `INSIGHTS`: complaint topics with their share of 1–2 star reviews and 2–3 quotes linking to the review, frequent words and phrases in 1–2 star reviews (stopwords and the app's own name removed), feature requests with examples, developer reply rate and median reply time. One charge per app.
- **Trends per app** — key-value record `TRENDS`: average rating, number of reviews and 1–2 star share per day, week or month, change to the previous period, a spike flag, and the same by app version. One charge per app.

What you will never pay for: an app with fewer than 30 reviews in the run, an app that failed, or a run that stopped at your maximum cost — the record is still written and says why it was free. Every record states how many reviews and which dates it is based on; the Google Play rating itself stays in the free `SUMMARY`. Star or keyword filters make a sample unrepresentative, so records say so and trends then show counts only. For a true trend, use *Newest first* and one language, or a limit large enough for every list to reach back the same distance.

### How to scrape Google Play reviews

1. Open the **Input** tab and add apps — `com.whatsapp` or the full app URL from your browser.
2. Set **Max reviews per app** (100 for a quick look, 10,000+ for a full export). The cap applies to each language and each selected star rating separately: 2 languages × 500 = up to 1,000 reviews per app.
3. Optional: pick star ratings (1 and 2 stars for complaints), keywords, languages, or a date.
4. Click **Start**. Reviews appear in the **Output** tab within seconds.
5. Download as JSON, CSV, Excel or HTML, or read the dataset via the API.

#### ⬇️ Input example

```json
{
  "apps": ["com.whatsapp", "https://play.google.com/store/apps/details?id=org.telegram.messenger"],
  "maxReviewsPerApp": 500,
  "sort": "newest",
  "onlyNewerThan": "7 days",
  "stars": ["1", "2"],
  "keywords": ["crash", "battery"],
  "languages": ["en", "de"],
  "country": "us"
}
```

#### ⬆️ Output example

```json
{
  "source": "google_play",
  "targetId": "com.whatsapp",
  "targetName": "WhatsApp Messenger",
  "targetUrl": "https://play.google.com/store/apps/details?id=com.whatsapp",
  "reviewId": "9c3e2f0a-…",
  "rating": 2,
  "title": null,
  "text": "Calls keep dropping since the update.",
  "language": "en",
  "country": "US",
  "authorName": "Ann B",
  "authorId": null,
  "authorImageUrl": "https://play-lh.googleusercontent.com/…",
  "publishedAt": "2026-11-04T08:13:22Z",
  "updatedAt": null,
  "appVersion": "2.25.23.75",
  "replyText": "Hi Ann, please update to the latest version …",
  "replyAt": "2026-11-04T10:02:11Z",
  "helpfulCount": 14,
  "url": "https://play.google.com/store/apps/details?id=com.whatsapp&reviewId=9c3e2f0a-…",
  "aspectRatings": null,
  "scrapedAt": "2026-11-05T01:00:00Z"
}
```

### Monitor new Google Play reviews every day

Turn on **Only new since the last run** and create a schedule (Apify Console → Schedules). The first run collects up to *Max reviews per app*; every next run keeps only reviews newer than the newest one the previous run saw, then stops — so a daily run on an app with 50 new reviews costs less than $0.01. The mark is stored per app, language and star filter in the key-value store `apifry-reviews-state` in your own account; delete that store to start over.

The mark moves only after the run's reviews are saved. If a run is interrupted (aborted, timed out, rate-limited by Google) or stops at your max charge limit, the mark is not moved and the next run picks up the gap. If *Max reviews per app* ends a list first, the mark moves to the newest review: each run then returns the newest N new reviews.

For a one-off window use **Only reviews newer than** with a date (`2026-10-01`) or a period (`7 days`, `12 hours`, `2 weeks`).

### Use cases

- **Product and app teams** — read 1–2 star reviews after each release; `appVersion` shows which build they hit.
- **Customer support** — find reviews without a developer reply (`replyText` is `null`) and answer them.
- **Competitor research** — compare complaints and praise across competing apps, languages and countries.
- **ASO and marketing** — track rating trends and the star distribution over time from `SUMMARY`.
- **Data teams and LLM apps** — feed fresh reviews into sentiment analysis, topic clustering or a support agent.

### Bulk export of Google Play reviews

Set *Max reviews per app* to 10,000 or more and add several apps; three apps are processed in parallel and each app's reviews are paged in batches of 200. Large apps hold hundreds of thousands of reviews per language. Duplicates are removed inside a run. Across runs, deduplicate on `targetId` + `reviewId`.

### Integrations

Run it from the Apify API, the Python or JavaScript client, n8n, Make, Zapier, Google Sheets or Slack, or let an AI agent call it through the Apify MCP server. Results can be pushed to a webhook when a run finishes.

### 🤖 For AI Agents & LLM Apps

**Purpose:** returns Google Play app reviews as structured rows, filtered by date, stars, keywords and language; built for monitoring an app's new reviews.

**Minimal input:** `{"apps": ["com.whatsapp"]}` — returns the 100 newest English reviews from the US store. Raise `maxReviewsPerApp` for more.

**Output fields (one row per review):** `source`, `targetId` (package name), `targetName`, `targetUrl`, `reviewId`, `rating` (1–5), `title` (null on Google Play), `text`, `language`, `country`, `authorName`, `authorId` (null), `authorImageUrl`, `publishedAt` (ISO UTC), `updatedAt` (null), `appVersion`, `replyText`, `replyAt`, `helpfulCount`, `url`, `aspectRatings` (per-aspect values with Google's aspect codes, mostly for games; null otherwise), `scrapedAt`. Per-app rating, ratings count and star distribution are in the key-value store record `SUMMARY`, not in the dataset.

**Behaviour:** `onlyNewerThan` and `onlyNewSinceLastRun` force newest-first order and stop paging once older reviews are reached. `stars` runs one pass per selected star. `languages` runs one pass per language; repeats are removed. `keywords` keeps reviews whose text contains any keyword; to keep runs fast it reads at most 20 × the cap (min 10,000) reviews per list, and `SUMMARY.note` says when that limit ended the search. `maxReviewsPerApp` (default 100, max 1,000,000) caps rows per app for each language × star list, so the most rows per app = cap × languages × selected stars. Apps that are not found or fail are listed in `SUMMARY.error` and the run status message; `SUMMARY.note` explains apps with zero reviews (filters matched nothing, empty language). The run fails only if no reviews were stored and Google Play itself failed; a mistyped app id or zero new reviews after a cut-off is a successful run.

**Limits:** `publishedAt` is the latest edit date as Google Play shows it. Reviews are public text; the data does not prove the reviewer actually used the app version shown.

**Billing:** only stored reviews are charged (event `review`); filtered, older, duplicate and failed items are free.

**Paid add-ons (off by default):** `includeTags` adds `topics`, `sentiment`, `isBugReport`, `isFeatureRequest` to each row (event `review-tagged` instead of `review`; untagged languages stay `review`). `includeInsights` writes key-value record `INSIGHTS` and `includeTrends` writes `TRENDS`, one list item per app with `charged`, `partial` and `notCharged` (the reason it was free); events `insights` and `trends`, one per app with 30+ reviews from a complete run. Rule-based, not AI.

### ❓ FAQ

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

The scraper collects only publicly visible reviews, without logging in. Reviews include reviewers' public display names, which may be personal data under GDPR and similar laws. Use the data for legitimate purposes and consult a lawyer if unsure.

#### Do I need a Google account or an API key?

No. Add the app's package name or URL and run.

#### How do I find an app's package name?

Open the app on play.google.com; it is the `id=` value in the address bar (`…/details?id=com.whatsapp` → `com.whatsapp`). You can paste the whole URL instead.

#### Why do I get fewer reviews than the app's review count?

Google Play counts star-only ratings as ratings, and lists written reviews per language. Add more languages to collect more, and check `reviewsCount` in `SUMMARY`.

#### Can I get only negative reviews?

Yes: select 1 and 2 stars in *Star ratings*. You pay only for the reviews returned.

#### Can I get reviews from several countries?

Google Play groups reviews mainly by language, not country. Use *Review languages* (`en`, `de`, `pt-BR` …) to cover markets; *Country* sets the store the app details come from.

#### Does it need a proxy?

No. Google Play is reachable without one. If you see rate-limit errors on very large runs, turn on *Use Apify Proxy (datacenter)*.

#### Can AI agents use it?

Yes. It runs through the Apify MCP server and the API; see the *For AI Agents* section above for the exact behaviour.

### Support

Open an issue on the **Issues** tab — we usually answer within a day. Tell us the app and what you expected to see.

### You might also like

- [Website Contact Scraper](https://apify.com/apifry/website-contact-extractor) — emails, phones and social profiles from company websites.

*Also known as: Google Play review scraper, Play Store reviews API, Android app reviews export, Google Play reviews to CSV.*

# Actor input Schema

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

Add Google Play apps as package names (com.whatsapp) or app URLs (https://play.google.com/store/apps/details?id=com.whatsapp). One app per line.

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

Enter the most reviews to keep per app for each language and each star rating you select (2 languages x 100 = up to 200 per app). You pay only for reviews stored in the dataset. Use 10000+ for a full export.

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

Choose the order Google Play returns reviews in. Date filters below always use Newest first.

## `onlyNewerThan` (type: `string`):

Enter a date (2026-10-01) or a relative period (7 days, 12 hours, 2 weeks). Older reviews are skipped and not charged; the run stops once it reaches them.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn on for scheduled monitoring: each run keeps only reviews newer than the newest one seen by your previous run (per app, language and star filter). The mark is kept in the key-value store 'apifry-reviews-state' in your account.

## `stars` (type: `array`):

Select the star ratings to keep, e.g. 1 and 2 for complaints. Leave empty for all ratings.

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

Add words or phrases; only reviews containing at least one of them are kept (case-insensitive). Reviews without a match are not charged. Leave empty to keep all.

## `languages` (type: `array`):

Add Google Play language codes (en, de, es, pt-BR, ja …). Each language is a separate list of reviews; duplicates across languages are removed. Default: en.

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

Enter the two-letter Google Play country code (us, gb, de, in …). It sets the store the app details are read from. Default: us.

## `includeTags` (type: `boolean`):

Adds topics (crashes, login, ads, price, updates, speed, interface, support), sentiment, isBugReport and isFeatureRequest to each review. Tagged reviews are charged the 'Review with tags' price instead of 'Review'. Reviews in languages other than EN, DE, FR, ES, PT, IT, RU stay untagged at the plain review price. Rule-based, not AI.

## `includeInsights` (type: `boolean`):

Writes record INSIGHTS: complaint topics with shares and quotes, frequent words and phrases in 1–2 star reviews, feature requests, developer reply rate and time. Charged once per app with at least 30 reviews in this run; failed, incomplete or tiny samples are free. Based on the reviews this run collected — the store rating stays in SUMMARY.

## `includeTrends` (type: `boolean`):

Writes record TRENDS: average rating, review count and 1–2 star share per week or month with change to the previous period, a spike flag, and the same by app version. Charged once per app with at least 30 reviews in this run. Use Newest first and no star or keyword filter for a true picture.

## `useApifyProxy` (type: `boolean`):

Turn on only if runs fail with rate-limit errors. Google Play is normally reachable without a proxy.

## Actor input object example

```json
{
  "apps": [
    "com.whatsapp"
  ],
  "maxReviewsPerApp": 100,
  "sort": "newest",
  "onlyNewSinceLastRun": false,
  "languages": [
    "en"
  ],
  "country": "us",
  "includeTags": false,
  "includeInsights": false,
  "includeTrends": false,
  "useApifyProxy": false
}
```

# Actor output Schema

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

No description

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

No description

## `insights` (type: `string`):

No description

## `trends` (type: `string`):

No description

# 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": 100
};

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

# Run the Actor and wait for it to finish
run = client.actor("apifry/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": 100
}' |
apify call apifry/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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