# Google Play Reviews Scraper - App Reviews API (`glasswing/google-play-reviews-scraper`) Actor

Scrape public Google Play app reviews by package name or link: stars, text, date, thumbs-up, app version and the developer's reply. Sort, filter by stars, any country and language. No reviewer names. JSON, CSV, Excel.

- **URL**: https://apify.com/glasswing/google-play-reviews-scraper.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** Developer tools, SEO tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.14 / 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

### What does Google Play Reviews Scraper do?

Google Play Reviews Scraper reads the **public reviews of any Android app** on Google Play and delivers them as clean JSON, CSV or Excel: star rating, review text, date, thumbs-up count, app version and the developer's reply. Give it a package name such as `com.spotify.music` or a Play Store link, pick how many reviews you want, and get one row per review in seconds. No Google account, no API key, no browser.

Typical use cases:

- **Review monitoring:** schedule a daily run sorted by newest with `Reviews since` = `2 days` and get only the new reviews of your app or a competitor's.
- **Sentiment and topic analysis:** export thousands of reviews per app and feed them to your own text analysis, filtered to 1-star or 5-star reviews.
- **Release tracking:** `appVersion` ties every review to the app version it was written for, so you can see whether a release made things better or worse.

It does **not** log in, solve challenges or collect reviewer names, profile pictures or account ids.

#### Result status (tri-state output)

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | A review was found and extracted. | Yes |
| `not_found` | Google Play has no such app, or no reviews for your star and date filter. | No |
| `error` | Google Play could not be read after retries (network error, block, or layout change). `error` says why. | No |

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

| Field | Description |
|---|---|
| `appId` | Android package name, e.g. `com.spotify.music`. |
| `reviewRating` | Stars given, 1 to 5. |
| `reviewText` | The review text. E-mail addresses and phone numbers are masked as `[email]` and `[phone]`. |
| `reviewDate` | When the review was written (ISO 8601). |
| `appVersion` | App version the reviewer used, when Google Play shows it. |
| `thumbsUp` | Number of helpful votes. |
| `replyText` | The developer's public reply, if any. A reviewer's first name greeted in the reply is replaced by "there". |
| `replyDate` | When the developer replied. |
| `hasReply` | True when the developer replied. |
| `reviewId` | Google Play's id of the review, handy for de-duplication. |
| `title`, `developer` | The app's name and publisher. |
| `country`, `language` | The store country and review language of the run. |
| `url`, `playStoreUrl` | Link to the review and to the app page. |
| `status`, `error`, `scrapedAt` | Tri-state status, the reason for non-ok rows, and the extraction time. |

### How to scrape Google Play reviews with Google Play Reviews Scraper

1. Open the Actor in Apify Console and click **Try for free**.
2. Paste one or more package names or Play Store app links into **App IDs or Google Play URLs**.
3. Set **Max reviews per app** (start with the default 20 to see the output), and optionally sort order, star rating, country and language.
4. Click **Start**. The default input finishes in well under a minute.
5. Open the **Output** tab or **Export** the dataset as JSON, CSV, Excel, XML or HTML.

To automate it, use the **API** tab (Node.js, Python, curl examples) or add a **Schedule**.

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

This Actor uses **pay-per-event** pricing:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Review (`status: ok` row) | $0.00023 per review on the Free plan, lower on paid Apify plans |

Example: 1,000 reviews cost about $0.24 on the Free plan. Rows with `status` `not_found` or `error` are never billed. You can cap spending per run with **Max reviews per app**, **Maximum reviews in total** and the run's **Max total charge** option.

### Input

| Field | What it does |
|---|---|
| `appIds` | Package names or Play Store app links, one per line. |
| `maxReviewsPerApp` | Reviews to read per app, 1 to 10,000 (default 20). |
| `sort` | `newest` (default), `mostRelevant` or `rating`. |
| `starRating` | Keep only 1, 2, 3, 4 or 5 star reviews. Empty = all. |
| `reviewsSince` | Skip older reviews: `2026-01-31`, `30 days`, `6 months`. With newest sort the run stops at the first older review. |
| `country` | Store country code, e.g. `us`, `gb`, `de` (default `us`). |
| `language` | Review language, e.g. `en`, `de`, `pt-BR` (default `en`). |
| `maxItems` | Hard cap on rows in the whole run (default 100,000). |
| `proxyConfiguration` | Optional. Google Play answers Apify's datacenter IPs directly. |

Example input:

```json
{
    "appIds": ["com.spotify.music"],
    "maxReviewsPerApp": 20,
    "sort": "newest",
    "country": "us",
    "language": "en"
}
```

### Output

Real rows from a run (shortened):

```json
{
    "status": "ok",
    "appId": "com.spotify.music",
    "title": "Spotify: Music and Podcasts",
    "developer": "Spotify AB",
    "reviewRating": 4,
    "reviewText": "its perfect but just need more ads that you can skip",
    "reviewDate": "2026-11-01T05:33:01Z",
    "appVersion": "9.1.94.1929",
    "thumbsUp": 0,
    "hasReply": true,
    "replyText": "Hey! We hear you and we'll pass your feedback along to the Ads team. ...",
    "replyDate": "2026-11-01T18:33:39Z",
    "country": "us",
    "language": "en"
}
```

### Tips

- Put all your apps in **one run**: you pay the start fee once.
- For monitoring, schedule a daily run with sort `newest` and `reviewsSince` `2 days`; de-duplicate on `reviewId`.
- Google Play shows reviews in the run's `language` first: set `language` to `de` for German reviews from `de`.
- Reviews appear on Google Play with a delay, so the newest review can be several hours old.

### Limitations

- **No reviewer identity.** Rows never include the reviewer's name, profile picture or account id.
- Up to 10,000 reviews per app and country per run. Google Play decides how many reviews it lists for a filter.
- One country and language per run; start a second run for another market.
- Google changes its page data now and then; when it does, rows come back as `error` (never as silently wrong data) and the Actor is updated; report it in the **Issues** tab.

### FAQ

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

No. The Actor reads Google Play's public pages, which need no key and no login.

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

The Actor reads only public data and collects no reviewer names or contact details. Review text is written by the public and can itself mention people; handle it accordingly. See the legal notice below.

#### Can I use this Actor from an AI agent or MCP client?

Yes. Called with no arguments it returns 20 reviews of a well-known app; every input is a plain string or list and every row explains itself with `status` and `error`.

#### Why is an app `not_found`?

The package does not exist, is not offered in that country, or has no reviews for your star and date filter. `not_found` rows are free.

#### Why did I get fewer rows than `maxReviewsPerApp`?

The app has fewer reviews for that filter, language and country than you asked for.

### Legal and data-protection notice

This Actor reads only data that Google publishes publicly on its Google Play store pages: the public text of app reviews with the developer's replies. It does not extract reviewer names, profile pictures or account ids, e-mail addresses, phone numbers or other contact data, and it does not log in or get around any access control. Review text is written by the public and can itself mention people. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. You are responsible for complying with Google's terms and applicable law when using the extracted data.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google LLC. Google Play is a trademark of Google LLC. All trademarks belong to their respective owners.

# Changelog

This Actor's version history is a separate document: https://apify.com/glasswing/google-play-reviews-scraper/changelog.md

# Actor input Schema

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

Apps to read reviews for, one per line: package names (com.spotify.music) or Google Play app links (https://play.google.com/store/apps/details?id=com.spotify.music). A package that does not exist gives one free `not_found` row.

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

Hidden alias of App IDs for API callers that use this name. Same format: package names or Play app links.

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

How many reviews to read per app (up to 10,000). Each review row with status `ok` is one billable result.

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

Newest first (best for monitoring), most relevant (Google Play's default order) or rating.

## `starRating` (type: `string`):

Keep only 1-star, 2-star ... 5-star reviews. Leave empty for every rating.

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

Skip reviews older than this date: `2026-01-31`, or relative such as `30 days`, `2 weeks`, `6 months`. With Newest sort the run stops reading an app as soon as it reaches older reviews, which makes scheduled monitoring runs cheap.

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

Google Play store country as a two-letter code: `us`, `gb`, `de`, `jp`, `br`. Reviews shown and the app's availability depend on the country.

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

Review language as a code: `en`, `de`, `es`, `fr`, `ja`, `pt-BR`. Google Play lists reviews written in this language first.

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

Hard cap on review rows saved in the whole run, across all apps. Leave the default unless you want a lower overall limit.

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

Optional. Google Play's public store pages answer Apify's datacenter IPs directly, so no proxy is needed. If a very large run meets rate-limit errors, enable Apify Proxy (datacenter). Residential proxies are not needed.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music"
  ],
  "startUrls": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 20,
  "sort": "newest",
  "country": "us",
  "language": "en",
  "maxItems": 100000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "appIds": [
        "com.spotify.music"
    ],
    "startUrls": [
        "com.spotify.music"
    ],
    "maxReviewsPerApp": 20,
    "country": "us",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/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"],
    "startUrls": ["com.spotify.music"],
    "maxReviewsPerApp": 20,
    "country": "us",
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/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"
  ],
  "startUrls": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 20,
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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