# Google Play Reviews Scraper - App Reviews & Ratings (`cirkit/google-play-reviews-scraper`) Actor

Scrape Google Play app reviews without a login or API key. Get review text, star rating, date, thumbs-up count, app version, developer replies and feature ratings, filtered by star rating, date, language and country. Up to 500 reviews per request.

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

## Pricing

from $0.07 / 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.

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

### What is Google Play Reviews Scraper?

**Google Play Reviews Scraper** lets you extract user reviews from the Google Play Store for any Android app, with the star rating, date, full review text, helpful votes, app version and the developer's reply, helping you track what users say about your app and your competitors, find bugs and feature requests fast, and feed real customer language into product, support and marketing work.

- ⭐️ **Pull only the reviews you care about:** filter to 1 and 2 star complaints, or to 5 star praise, and Google does the filtering, so you only pay for the reviews you asked for.
- 📅 **Monitor new reviews on a schedule:** set "Only reviews since" to `7d` and a weekly run collects exactly last week's reviews, no more.
- 🆚 **Benchmark competitors in one run:** add every app in your category and get their reviews side by side, each row tagged with the app's title, developer, overall rating and install band.
- 💬 **See how developers answer:** every developer reply comes with its text and timestamp, so you can measure response rate and response time.
- 🐞 **Tie feedback to releases:** each review carries the app version it was written on, which is how you spot a bad release within hours.
- 🌍 **Any language, any country:** reviews are grouped by language on Google Play, so choose German, Japanese or Portuguese reviews directly.

Google Play has no public reviews API for apps you do not own. Google Play Reviews Scraper reads the same reviews the Play Store website shows, with no login, no cookies, no Google account and no API key, and it fetches up to 500 reviews per request, so thousands of reviews take seconds, not minutes.

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

- 🆔 Review ID and a direct link to the review on Google Play (`reviewId`, `reviewUrl`)
- ⭐️ Star rating, 1 to 5 (`rating`)
- 📝 Full review text and its length (`text`, `textLength`)
- 📅 Date and time the review was posted, in UTC (`reviewedAt`)
- 👍 Helpful votes from other users (`thumbsUpCount`)
- 📦 App version the reviewer was using (`appVersion`)
- 💬 Developer reply text and reply date (`hasDeveloperReply`, `developerReplyText`, `developerReplyAt`)
- 🎛 Feature ratings some apps collect, for example "making playlists" or "offline listening" (`criteriaRatings`)
- 👤 Reviewer display name and profile picture, as shown publicly on Google Play (`userName`, `userImage`)
- 📱 App context on every row: package name, title, developer, category, icon, overall rating, number of ratings, number of written reviews and install band (`appId`, `appTitle`, `appDeveloper`, `appGenre`, `appIcon`, `appRating`, `appRatingCount`, `appReviewCount`, `appInstalls`)
- 🔎 The settings that produced the row: sort order, star filter, language, country, position and scrape time

### How to use Google Play Reviews Scraper

1. Click **Try for free** and open the Input tab.
2. Paste one or more apps. A package name such as `com.spotify.music` works, and so does the Play Store link, for example `https://play.google.com/store/apps/details?id=com.spotify.music`.
3. Choose how many reviews per app, the sort order and, if you like, a star rating filter or a date cutoff.
4. Click **Start**. Reviews appear in the Output tab as they are collected.
5. Download them as Excel, CSV, JSON or HTML, or read them through the Apify API.

### Input

| Field | What it does | Default |
|---|---|---|
| `appIds` | Package names or Play Store links. Required. | `com.spotify.music` |
| `maxReviewsPerApp` | Reviews per app. 0 means every review Google Play serves. | 200 |
| `sort` | `newest`, `relevance` or `rating` | `newest` |
| `starRatings` | Keep only these stars, for example `["1", "2"]`. Empty means all. | all |
| `reviewsSince` | `YYYY-MM-DD` or a number of days such as `30d`. Forces newest first. | none |
| `language` | Review language, for example `en`, `de`, `ja` | `en` |
| `country` | Store country, for example `us`, `gb`, `in` | `us` |
| `maxItems` | Hard cap on rows for the whole run, a spending limit. 0 means none. | 0 |

Example input for last month's complaints about three competing apps:

```json
{
    "appIds": ["com.spotify.music", "com.apple.android.music", "com.google.android.apps.youtube.music"],
    "starRatings": ["1", "2"],
    "reviewsSince": "30d",
    "maxReviewsPerApp": 0
}
```

### Output

One row per review. A trimmed example:

```json
{
    "appId": "com.spotify.music",
    "appTitle": "Spotify: Music and Podcasts",
    "appDeveloper": "Spotify AB",
    "appRating": 4.35,
    "appInstalls": "1,000,000,000+",
    "reviewId": "d5f1102f-3386-406a-8e91-4295bb08a2f9",
    "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=d5f1102f-3386-406a-8e91-4295bb08a2f9",
    "userName": "Alex M.",
    "rating": 2,
    "text": "The \"random\" option is not really random, you get the same songs over and over",
    "reviewedAt": "2026-09-28T13:11:50Z",
    "thumbsUpCount": 0,
    "appVersion": "9.1.84.2231",
    "hasDeveloperReply": true,
    "developerReplyText": "Hey there! We understand your concern with the app...",
    "developerReplyAt": "2026-09-28T15:32:51Z",
    "criteriaRatings": [{"criterion": "vaf_phase1_song_recommendations", "rating": 1}],
    "language": "en",
    "country": "us",
    "position": 1
}
```

The Output tab has three ready-made views: **Reviews** (the main table), **Developer replies** (review next to reply, with both dates) and **App context** (the app each review belongs to).

If an app cannot return anything, for example a mistyped package name or a filter nothing matches, the run still succeeds and writes one row with `noResults: true` and a plain English `message` explaining why, so a scheduled pipeline never breaks on an empty answer.

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

**$0.07 per 1,000 reviews**, flat, plus $0.00005 per run start. No monthly rental, no tiers.

| Reviews | Cost |
|---|---|
| 1,000 | $0.07 |
| 10,000 | $0.70 |
| 100,000 | $7.00 |
| 1,000,000 | $70.00 |

Apify's free plan includes monthly credit, which covers tens of thousands of reviews at this price. Use `maxItems` as a hard spending cap.

### Measured performance

Measured on 2026-09-29 through the default Apify proxy:

- 600 Spotify reviews in 11 seconds; 991 Netflix reviews from the last three days in 3 seconds.
- 100% of rows carry review ID, rating, text, date, reviewer name and every app context field.
- About 80% of reviews include the app version, and 6% of Spotify's newest reviews had a developer reply. Those are Google's numbers, not gaps: a review has no version when the reviewer's device did not report one.

### FAQ

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

The scraper only collects reviews that Google Play publishes openly to anyone, with no login. Reviews include public display names, and personal data is protected by laws such as GDPR in the EU, so only collect what you have a legitimate reason to process, and ask a lawyer if you are unsure. Read Apify's post on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for more.

#### How much does Google Play Reviews Scraper cost?

$0.07 per 1,000 reviews plus $0.00005 per run. A 10,000 review competitor study costs about 70 cents.

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

No. It works without logging in and without the Google Play Developer API, which only covers apps you publish yourself.

#### Can I get every review an app has?

You get every review Google Play serves for the language and country you pick. Set `maxReviewsPerApp` to 0. Google groups reviews by language, so a global app has separate English, Spanish and Hindi pools; run one language per run, or several runs, to cover them all.

#### How do I monitor new reviews every day?

Save a task with `reviewsSince` set to `1d` and schedule it daily in Apify. Each run collects only the previous day's reviews, and an integration can post them to Slack, a Google Sheet or your support tool.

#### Can I only get negative reviews?

Yes. Set `starRatings` to `["1", "2"]`. The filter is applied by Google, so the run does not page through five-star reviews to find them.

#### Can I use Google Play Reviews Scraper as an API?

Yes. Every run is available through the Apify API, and there are official clients for JavaScript and Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("cirkit/google-play-reviews-scraper").call(
    run_input={"appIds": ["com.spotify.music"], "maxReviewsPerApp": 500}
)
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review["text"])
```

#### Can I integrate it with other apps?

Yes, through Apify integrations with Make, Zapier, Google Sheets, Google Drive, Slack, Airbyte, webhooks and more.

#### Why did I get fewer reviews than I asked for?

Either the app has fewer reviews in that language, or your star filter or date cutoff removed the rest. The run log says how many reviews each app returned. Very popular apps can also show a short delay before their newest reviews appear on Google's public feed.

#### Does it scrape Apple App Store reviews?

No, this actor covers Google Play only.

### You might also like

- [Google Play Store Scraper](https://apify.com/cirkit/google-play-store-scraper) for app details, charts and search results
- [App Store Search Scraper](https://apify.com/cirkit/app-store-search-scraper) for iOS apps

### Changelog

- **0.1** (2026-09-29): first release. Star filter, date cutoff, 500 reviews per request, developer replies, feature ratings and app context on every row.

# Actor input Schema

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

Google Play apps to pull reviews for. Use the package name (com.spotify.music) or paste the app's Play Store link (https://play.google.com/store/apps/details?id=com.spotify.music). Add as many as you like; they run in parallel.

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

Stop after this many reviews for each app. 0 means every review Google Play will serve. When you filter to several star ratings, the limit applies to each rating separately.

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

Order Google Play returns reviews in. 'Newest' is best for monitoring and is required for the date cutoff below. 'Most relevant' matches what shoppers see first on the app page.

## `starRatings` (type: `array`):

Keep only reviews with these star ratings, for example 1 and 2 stars for complaints. Leave empty for all ratings. Filtering happens on Google's side, so you only pay for the reviews you asked for.

## `reviewsSince` (type: `string`):

Stop at reviews older than this date. Use YYYY-MM-DD, or a number of days such as 30d for 'the last 30 days' so a scheduled run keeps working. Forces newest-first sorting. Leave empty for no date limit.

## `language` (type: `string`):

Two-letter language code (en, de, es, pt, fr, ja...). Google Play groups reviews by the language they were written in, so this decides which reviews you get.

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

Two-letter country code (us, gb, de, in, br...) of the Play Store to read from. Matters for region-locked apps.

## `maxItems` (type: `integer`):

Hard cap on rows written across all apps, useful as a spending limit. 0 means no cap.

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

The default Apify proxy works well. Google Play serves datacenter IPs normally, so residential proxy is not needed.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 100,
  "sort": "newest",
  "starRatings": [],
  "language": "en",
  "country": "us",
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

Every review this run collected as the Reviews table.

## `replies` (type: `string`):

Reviews alongside the developer's public reply and its date.

## `reviewsCsv` (type: `string`):

The full result set as CSV, ready for a spreadsheet or a BI tool.

## `consoleRun` (type: `string`):

The Apify Console page for this run, including the live log.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "appIds": [
        "com.spotify.music"
    ],
    "maxReviewsPerApp": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/google-play-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "appIds": ["com.spotify.music"],
    "maxReviewsPerApp": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/google-play-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "appIds": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cirkit/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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