# Google Play Reviews Scraper — Filters & Monitor (`zenomastro/google-play-reviews-reliable`) Actor

Google Play reviews scraper for Android feedback intelligence. Find apps by name or package, export ratings, dates, text, helpful votes and developer replies; use multi-keyword/date/rating filters, app metadata, version/month/topic insights, proxy fallback and only-new monitoring.

- **URL**: https://apify.com/zenomastro/google-play-reviews-reliable.md
- **Developed by:** [Rosario Vitale](https://apify.com/zenomastro) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 google play reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 API — Filters & Insights

### Why use this Actor?

Google Play reviews scraper for Android feedback intelligence. Find apps by name or package, export ratings, dates, text, helpful votes and developer replies; use multi-keyword/date/rating filters, app metadata, version/month/topic insights, proxy fallback and only-new monitoring.

### Features

- **Google Play apps** — Direct package IDs or Google Play app URLs. Can be combined with appQueries.
- **Maximum reviews per app** — Maximum successfully emitted review rows for each unique app.
- **Maximum total reviews** — Hard result cap across all apps to keep runtime and spend predictable.
- **Minimum rating** — Only return reviews at or above this star rating.
- **Maximum rating** — Only return reviews at or below this star rating.
- **Reviewed after** — Optional inclusive lower date boundary. Use YYYY-MM-DD or ISO 8601.
- **Reviewed before** — Optional inclusive upper date boundary. Use YYYY-MM-DD or ISO 8601.
- **Review text contains** — Optional case-insensitive substring filter. Filtered rows are not billed.
- **Minimum thumbs-up** — Only emit reviews with at least this many Google Play thumbs-up votes.
- **Developer reply** — Return any reviews, only reviews with a developer reply, or only reviews without one.
- **Maximum source pages per app** — Safety ceiling for source pagination. Google Play returns up to about 200 reviews per page.
- **Request timeout** — Maximum seconds for each Google Play HTTP request.

### Use cases

- Android app feedback research.
- Release monitoring.
- Support and product analytics.
- Review datasets for sentiment workflows.

### Example input

```json
{
  "appIdsOrUrls": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 1000,
  "maxTotalReviews": 5000,
  "minRating": 1,
  "maxRating": 5,
  "minThumbsUp": 0
}
```

### Pricing & cost control

Use the bounded input limits and filters to keep runs predictable. Pay-per-result Actors only charge primary result rows; summary, status and monitoring metadata are designed to add context without inflating result volume.

### FAQ

**What is this Actor for?**\
It is designed for Android app feedback research, release monitoring, support and product analytics.

**Can I run it on a schedule?**\
Yes. You can schedule Actor runs on Apify and send the resulting dataset into automations, webhooks, storage, or downstream APIs.

**How do I control cost and run size?**\
Use the input limits and filters shown in the Actor input form. The Actor applies bounded defaults and hard caps so large jobs remain predictable.

### Search keywords

google play reviews scraper, google play scraper reviews\_all, apify google play reviews scraper, outscraper google play reviews scraper, scrape google play store reviews, is google play trustworthy, does google play games save progress, play store reviews scraper, app store reviews scraper, google play store reviews scraper, google play store review scraper python, apple app store reviews scraper, scrape app store reviews, play

Extract public Google Play reviews from package IDs or app-detail URLs with clean normalized output, bounded retries, optional Apify Proxy fallback, deduplication, spend controls, and filters for stars, dates, text, thumbs-up votes, and developer replies.

The Actor is designed for production-style batches: one invalid or unavailable app produces a diagnostic row instead of crashing the entire run, duplicates are skipped, filtered reviews are not billed, and the run stops cleanly when the configured result or charge limit is reached.

### What you get

Each successful row contains the package ID and canonical Google Play URL, review ID, reviewer display name and profile image when exposed, 1–5 star rating, review text, thumbs-up count, app version, UTC review timestamp, developer reply text/timestamp, and source/fetch metadata.

### Input

`appIdsOrUrls` accepts package IDs such as `com.spotify.music` and Google Play app-detail URLs. Up to 100 apps can be submitted per run.

Useful controls include `maxReviewsPerApp`, `maxTotalReviews`, `minRating` / `maxRating`, `reviewedAfter` / `reviewedBefore`, `containsText`, `minThumbsUp`, `developerReply`, `maxPagesPerApp`, request timeout/retries, and proxy controls.

#### Example

```json
{
  "appIdsOrUrls": [
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.whatsapp"
  ],
  "maxReviewsPerApp": 500,
  "maxTotalReviews": 1000,
  "minRating": 1,
  "maxRating": 3,
  "reviewedAfter": "2026-01-01",
  "containsText": "",
  "minThumbsUp": 0,
  "developerReply": "any",
  "maxPagesPerApp": 25,
  "autoProxyFallback": true,
  "proxyConfiguration": {"useApifyProxy": false}
}
```

### Reliability behavior

Google Play's public review endpoint is unofficial and can change, so the Actor avoids unbounded requests and silent failures. HTTP rate limits, server failures, and transport errors use bounded retry/backoff. Direct access is attempted first; when it fails and automatic fallback is enabled, one retry path uses a fresh Apify Proxy session.

Duplicate package IDs and review IDs are removed. Invalid inputs and source failures create uncharged diagnostic rows instead of terminating the entire batch. Source-page, per-app, and global result ceilings prevent accidental unbounded crawling.

### Important note about country and language

Google Play public reviews are returned as a **global review corpus** by this source. The store presentation locale is not the reviewer's country, and this feed does not expose a trustworthy reviewer-country field.

For that reason this Actor intentionally does **not** offer a misleading "review country" filter or claim to infer a reviewer's location.

### Filtering and scan window

Star and date filters are applied while walking newest-first source pages. Text, thumbs-up, and developer-reply filters depend on fields in each returned review. When any of those filters is enabled, the Actor automatically scans beyond the requested output count, bounded by `maxPagesPerApp`, so selective filters still have room to find matches.

A very selective filter plus a small page ceiling can legitimately return fewer rows than `maxReviewsPerApp`.

### Output

Successful rows use `recordType: "review"` and include:

- `appId`, `appUrl`, `reviewId`
- `userName`, `userImageUrl`
- `rating`, `text`, `thumbsUpCount`
- `reviewCreatedVersion`, `reviewedAt`
- `hasDeveloperReply`, `developerReplyText`, `developerRepliedAt`
- `source`, `fetchedAt`, scan/runtime diagnostics

Failures use `recordType: "error"` and are not billed.

### Billing

The launch target is **$0.00009 per successful review** — about **$0.09 per 1,000 results** — plus the minimal Actor-start event configured in Apify.

Only successful review rows trigger the custom `review` charge event. Invalid inputs, retries, source failures, duplicate inputs, and reviews rejected by filters are not charged. The Actor checks the Apify charge limit while writing results and stops cleanly when the budget is exhausted.

### Limits

- 100 app inputs per run
- 50,000 emitted reviews per app
- 100,000 emitted reviews per run
- 250 source pages per app
- public Google Play review data only
- no login bypass, private-data access, or reviewer-location inference

Google Play can change its public web responses without notice. A successful scrape reflects the public data exposed at run time, not a guarantee that every historical review remains reachable indefinitely.

### Responsible use

Use public review data in accordance with applicable laws, privacy and data-protection requirements, and platform terms. Avoid using reviewer data for harassment, sensitive profiling, or attempts to identify people beyond what they publicly posted.

### Support

For a reproducible issue, provide the public package ID or Play Store URL, relevant filters, proxy mode, and Apify run ID. Never include API tokens or private proxy credentials.

### Extended capabilities

- Resolve apps by Google Play search query or accept package IDs / app URLs directly.
- Add public app metadata such as developer, category, price, version, rating, icon, and release/update dates.
- Sort reviews by newest, oldest, or rating and monitor unseen reviews with aggregate intelligence.

# Actor input Schema

## `appIdsOrUrls` (type: `array`):

Direct package IDs or Google Play app URLs. Can be combined with appQueries.

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

Maximum successfully emitted review rows for each unique app.

## `maxTotalReviews` (type: `integer`):

Hard result cap across all apps to keep runtime and spend predictable.

## `minRating` (type: `integer`):

Only return reviews at or above this star rating.

## `maxRating` (type: `integer`):

Only return reviews at or below this star rating.

## `reviewedAfter` (type: `string`):

Optional inclusive lower date boundary. Use YYYY-MM-DD or ISO 8601.

## `reviewedBefore` (type: `string`):

Optional inclusive upper date boundary. Use YYYY-MM-DD or ISO 8601.

## `containsText` (type: `string`):

Optional case-insensitive substring filter. Filtered rows are not billed.

## `minThumbsUp` (type: `integer`):

Only emit reviews with at least this many Google Play thumbs-up votes.

## `developerReply` (type: `string`):

Return any reviews, only reviews with a developer reply, or only reviews without one.

## `maxPagesPerApp` (type: `integer`):

Safety ceiling for source pagination. Google Play returns up to about 200 reviews per page.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds for each Google Play HTTP request.

## `retries` (type: `integer`):

Retries for rate limits, server errors, and transport failures.

## `autoProxyFallback` (type: `boolean`):

Try direct access first, then retry once through Apify Proxy when direct access fails.

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

Optional explicit proxy configuration. Leave disabled for fast direct-first mode with automatic fallback.

## `monitorKey` (type: `string`):

Reuse the same key on schedules to remember review IDs already observed.

## `onlyNew` (type: `boolean`):

With monitorKey, output and bill only reviews that were not seen in prior runs.

## `includeReviewInsights` (type: `boolean`):

Add a free per-app summary with average rating, reply rate, helpfulness and rating distribution.

## `appQueries` (type: `array`):

Resolve Google Play apps by name before collecting reviews, e.g. Duolingo or Spotify.

## `searchCountry` (type: `string`):

Two-letter storefront used only for app search and metadata presentation. Google Play review rows themselves are from the global public review corpus.

## `maxSearchResultsPerQuery` (type: `integer`):

Maximum app search matches to turn into review targets for each appQueries entry.

## `includeAppMetadata` (type: `boolean`):

Add free app\_metadata rows with app name, developer, category, price, version, rating, icon and release/update dates when available.

## `sortBy` (type: `string`):

Ordering supported by the underlying Google Play review source.

## `containsAny` (type: `array`):

Keep a review when at least one listed keyword or phrase appears in the review text. Combined with the other filters.

## `containsAll` (type: `array`):

Keep a review only when every listed keyword or phrase appears in the review text.

## `insightKeywords` (type: `array`):

Free review-insights rows count how many matched reviews mention each phrase, alongside rating, app-version and monthly distributions.

## Actor input object example

```json
{
  "appIdsOrUrls": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 1000,
  "maxTotalReviews": 5000,
  "minRating": 1,
  "maxRating": 5,
  "reviewedAfter": "",
  "reviewedBefore": "",
  "containsText": "",
  "minThumbsUp": 0,
  "developerReply": "any",
  "maxPagesPerApp": 25,
  "requestTimeoutSecs": 25,
  "retries": 3,
  "autoProxyFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "monitorKey": "",
  "onlyNew": false,
  "includeReviewInsights": true,
  "appQueries": [],
  "searchCountry": "US",
  "maxSearchResultsPerQuery": 1,
  "includeAppMetadata": true,
  "sortBy": "newest",
  "containsAny": [],
  "containsAll": [],
  "insightKeywords": [
    "crash",
    "bug",
    "support",
    "price"
  ]
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("zenomastro/google-play-reviews-reliable").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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zenomastro/google-play-reviews-reliable"
        }
    }
}
```

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/wOhBeBLegIDGwot6o/builds/59jFk6G4ZEPlcAGaP/openapi.json