# Google Play Store Reviews Scraper (`solidcode/google-play-store-reviews-scraper`) Actor

\[💰 $0.2 / 1K] Extract reviews from any app on Google Play — reviewer, rating, text, date, helpful votes, app version, device, and developer replies. Accepts app package names or full Play Store URLs.

- **URL**: https://apify.com/solidcode/google-play-store-reviews-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Store Reviews Scraper

Extract user reviews from any Android app on the Google Play Store at scale. Get reviewer names, star ratings, full review text, publish dates, helpful votes, app versions, device types, and developer replies — plus app metadata like title, publisher, overall rating, and install count. Built for app developers, product teams, researchers, and agencies.

### Why This Scraper?

- **Batch multiple apps in one run** — paste a list of package names or Play Store URLs and get every review in a single dataset
- **Developer replies included** — `ownerReplyText` and `ownerReplyAt` on every review that has one, so you can audit response rate and quality
- **App metadata on every row** — title, publisher, overall rating, total review count, installs, and icon URL attached to each review for instant filtering and grouping
- **Flexible sorting** — Most Relevant, Newest First, Highest Rating First, or Lowest Rating First
- **Rich filters** — star ratings (1–5, multi-select), keywords, date range, recent-days shortcut, app version, device type, and language
- **Global reach** — select any of 55 countries and 30 languages to pull region-specific reviews
- **Both URL and package ID accepted** — paste `com.spotify.music`, `https://play.google.com/store/apps/details?id=com.spotify.music`, or mix both in the same list
- **Efficient recent-only runs** — combine "Newest First" sort with a start date or recent-days filter and the run stops automatically once older reviews are reached
- **Resilient** — invalid package names are skipped with a warning so one bad entry never breaks a batch run

### Use Cases

**Product & App Development**
- Track sentiment and recurring complaints across app versions
- Monitor new reviews after a release to catch regressions early
- Compare user reactions across competing apps in your category
- Build custom in-house dashboards for review trends and rating drops

**Market Research & Competitive Intelligence**
- Benchmark your app against direct competitors on rating, volume, and reply rate
- Surface feature requests and pain points mentioned in 1★ and 2★ reviews
- Map review sentiment across countries to guide localization priorities

**Marketing, ASO & Agencies**
- Mine top-rated reviews for testimonials and store-listing copy
- Identify which app versions drove rating spikes or drops
- Audit client apps for unanswered negative reviews ripe for a reply strategy
- Pull multilingual reviews to inform international ad creative

**Customer Support & Community**
- Alert on new negative reviews with specific keywords (crash, bug, refund, etc.)
- Build a reply workflow by feeding unreplied low-rated reviews into your ticketing tool
- Measure developer reply rates over time

**Data Science & Research**
- Train sentiment and topic models on large multilingual review corpora
- Study review dynamics across categories, countries, and app sizes
- Analyze correlation between app version releases and rating movements

### Getting Started

#### Simple — One App, Latest Reviews

```json
{
    "appIdsOrUrls": ["com.supercell.brawlstars"],
    "maxReviewsPerApp": 500,
    "sortBy": "newest"
}
````

#### Multiple Apps at Once

Mix package names and full URLs in the same list:

```json
{
    "appIdsOrUrls": [
        "com.spotify.music",
        "com.whatsapp",
        "https://play.google.com/store/apps/details?id=com.instagram.android"
    ],
    "maxReviewsPerApp": 1000,
    "sortBy": "newest"
}
```

#### Only 1★ and 2★ Reviews With Keywords

Perfect for support teams hunting for specific issues:

```json
{
    "appIdsOrUrls": ["com.asana.app"],
    "maxReviewsPerApp": 500,
    "sortBy": "newest",
    "ratings": ["1", "2"],
    "keywords": ["crash", "bug", "refund", "login"]
}
```

#### Recent Reviews Only (Last 7 Days)

Combine with "Newest First" for the fastest, cheapest recent-only run — collection stops automatically once reviews fall outside the window:

```json
{
    "appIdsOrUrls": ["com.duolingo"],
    "maxReviewsPerApp": 2000,
    "sortBy": "newest",
    "recentDays": 7
}
```

#### Localized Reviews — Germany, German Language

```json
{
    "appIdsOrUrls": ["com.spotify.music"],
    "maxReviewsPerApp": 500,
    "sortBy": "newest",
    "language": "de",
    "countryCode": "DE"
}
```

#### Tablet-Only Reviews for a Specific App Version

```json
{
    "appIdsOrUrls": ["com.supercell.brawlstars"],
    "maxReviewsPerApp": 1000,
    "sortBy": "highest",
    "deviceType": "tablet",
    "appVersions": ["65.165", "64.226"]
}
```

### Input Reference

#### Apps

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `appIdsOrUrls` | string\[] | `[]` | App package names (e.g. `com.supercell.brawlstars`) or full Google Play URLs. Add as many as you like. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxReviewsPerApp` | integer | `1000` | Maximum reviews to collect per app. Set to `0` for all reviews available on Google Play. |
| `sortBy` | string | `"mostRelevant"` | Order reviews are returned in: `mostRelevant`, `newest`, `highest`, `lowest`. |
| `deviceType` | string | `"phone"` | Only include reviews from this device type: `phone`, `tablet`, `chromebook`. |
| `language` | string | `"en"` | Language used by Google Play and review text. 30 languages supported (en, de, fr, es, ja, zh-CN, ar, hi, pt, ru, and more). |
| `countryCode` | string | `"US"` | Country Google Play uses to resolve region-specific reviews. 55 countries supported. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `ratings` | string\[] | `[]` | Only keep reviews with these star ratings (`"1"` through `"5"`, multi-select). Empty = all ratings. |
| `keywords` | string\[] | `[]` | Only keep reviews containing any of these words or phrases (case-insensitive). |
| `reviewsStartDate` | string | | Only reviews posted on or after this date. Format: `YYYY-MM-DD`. |
| `reviewsEndDate` | string | | Only reviews posted on or before this date. Format: `YYYY-MM-DD`. |
| `recentDays` | integer | `0` | Convenience filter — only reviews from the last N days. `0` disables. Overrides start date when greater than 0. |
| `appVersions` | string\[] | `[]` | Only keep reviews reported from these app versions (e.g. `65.165`). |
| `uniqueOnly` | boolean | `true` | Drop duplicate reviews (matched by review ID) across the run. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `proxyConfiguration` | object | Apify proxy on | Default (Apify proxy) is recommended. |

### Output

Each row is one review with the app metadata attached. Example:

```json
{
    "reviewId": "a2c4e8f0-1234-5678-90ab-cdef12345678",
    "appId": "com.supercell.brawlstars",
    "appTitle": "Brawl Stars",
    "appUrl": "https://play.google.com/store/apps/details?id=com.supercell.brawlstars",
    "developer": "Supercell",
    "appOverallRating": 4.2,
    "appReviewCount": 25666604,
    "appInstalls": "500M+",
    "appIconUrl": "https://play-lh.googleusercontent.com/...",
    "reviewerName": "Jane D.",
    "reviewerAvatarUrl": "https://play-lh.googleusercontent.com/a/...",
    "rating": 5,
    "reviewText": "Great game, lots of fun with friends. The new brawler is amazing!",
    "publishedAt": "2026-04-18T14:22:31Z",
    "timestamp": 1776261751,
    "language": "en",
    "helpfulCount": 42,
    "appVersion": "65.165",
    "deviceType": "phone",
    "ownerReplyText": "Thanks for the love! Glad you're enjoying the new brawler.",
    "ownerReplyAt": "2026-04-19T09:11:02Z",
    "position": 1,
    "scrapedAt": "2026-04-20T16:04:12Z"
}
```

#### All Available Fields

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Unique review identifier |
| `appId` | string | App package name (e.g. `com.supercell.brawlstars`) |
| `appTitle` | string | Human-readable app title |
| `appUrl` | string | Canonical Google Play URL |
| `developer` | string | App publisher / developer name |
| `appOverallRating` | number | Current overall star rating of the app (1.0–5.0) |
| `appReviewCount` | number | Total number of reviews the app has on Google Play |
| `appInstalls` | string | Install count label (e.g. `500M+`, `10B+`) |
| `appIconUrl` | string | URL of the app's icon |
| `reviewerName` | string | Display name of the reviewer |
| `reviewerAvatarUrl` | string | URL of the reviewer's profile image |
| `rating` | integer | Star rating, 1–5 |
| `reviewText` | string | Full review body text |
| `publishedAt` | string | Review publish date (ISO 8601, UTC) |
| `timestamp` | integer | Unix epoch seconds for the review |
| `language` | string | Language code used for the review |
| `helpfulCount` | integer | Number of "helpful" votes the review received |
| `appVersion` | string | App version the reviewer was using (may be empty for older versions) |
| `deviceType` | string | Device type filter in effect: `phone`, `tablet`, or `chromebook` |
| `ownerReplyText` | string | Developer's reply text (present only when the developer responded) |
| `ownerReplyAt` | string | Developer's reply date (ISO 8601, UTC) |
| `position` | integer | 1-indexed order within this app's collection |
| `scrapedAt` | string | ISO 8601 timestamp of when the row was collected |

### Tips for Best Results

- **Use "Newest First" with a date filter for recent-only runs.** Collection stops automatically once reviews fall outside the date window — the fastest and cheapest path to fresh reviews.
- **Pick "Highest Rating First" or "Lowest Rating First"** when you want stratified coverage. They fan out across all five star buckets and return reviews in predictable rating order.
- **"Most Relevant" is limited by Google.** Google's own UI caps "Most Relevant" at roughly 50–150 reviews per app regardless of cap. For deep scans, use "Newest First".
- **Keyword, app version, and end-date filters apply after collection.** Your final row count may be below Max Reviews Per App when few reviews match — widen the cap or relax the filter to get more.
- **Set the right country and language.** Google Play returns region-specific reviews, so `countryCode=DE` + `language=de` returns a very different dataset than `countryCode=US` + `language=en`.
- **Batch many apps in one run.** The actor loops over every app in `appIdsOrUrls` and skips invalid package names with a warning — no need to split runs.

### Pricing

**$0.40 per 1,000 reviews** — pay only for results delivered, no platform surprises.

| Reviews | Cost |
|---------|------|
| 500 | $0.20 |
| 1,000 | $0.40 |
| 10,000 | $4.00 |
| 100,000 | $40.00 |

Platform fees (compute, proxy, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation and alerts on new reviews
- **Google Sheets** — Direct spreadsheet export for review dashboards
- **Slack** / **Email** — Notifications when new low-rated reviews appear
- **Webhooks** — Trigger your own backend when a run completes
- **Apify API** — Full programmatic access for pipelines and data warehouses

### Legal & Ethical Use

This actor is designed for legitimate product research, market intelligence, and customer insight. Users are responsible for complying with applicable laws, Google's Terms of Service, and any privacy regulations that apply to their region. Review text and reviewer names are public data on Google Play — do not use the collected data for spam, harassment, targeted advertising to individual reviewers, or any unlawful purpose.

# Actor input Schema

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

App package names (e.g. `com.supercell.brawlstars`) or full Google Play URLs (e.g. `https://play.google.com/store/apps/details?id=com.supercell.brawlstars`). Add as many as you like.

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

Maximum number of reviews to collect per app. Set to 0 for all reviews available on Google Play. Recommended: 100–1000 to keep runs quick and affordable.

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

Choose the order Google Play returns reviews in.

## `deviceType` (type: `string`):

Only include reviews posted from this device type.

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

Language used by Google Play and the review text returned when available.

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

Country Google Play uses to resolve region-specific review data.

## `ratings` (type: `array`):

Only keep reviews matching these star ratings. Leave empty to collect all ratings.

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

Only keep reviews whose text contains any of these words or phrases (case-insensitive). Applied after reviews are collected — final count may be below Max Reviews Per App if few reviews match.

## `reviewsStartDate` (type: `string`):

Only collect reviews posted on or after this date. Format: YYYY-MM-DD (for example 2025-01-15). Combine with sort order "Newest First" for an efficient recent-only run (collection stops when older reviews are reached).

## `reviewsEndDate` (type: `string`):

Only collect reviews posted on or before this date. Format: YYYY-MM-DD. Applied after reviews are collected — final count may be lower than expected.

## `recentDays` (type: `integer`):

Convenience filter: only reviews from the last N days. Set to 0 to disable. Overrides the Reviews Start Date when greater than 0. Most efficient with sort order "Newest First".

## `appVersions` (type: `array`):

Only keep reviews reported from these app versions (e.g. 65.165, 64.226). Applied after reviews are collected — final count may be below Max Reviews Per App if few reviews match.

## `uniqueOnly` (type: `boolean`):

Drop duplicate reviews (matched by review ID) across the run.

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

Proxy settings. Default (Apify proxy) is recommended.

## Actor input object example

```json
{
  "appIdsOrUrls": [
    "com.supercell.brawlstars"
  ],
  "maxReviewsPerApp": 1000,
  "sortBy": "mostRelevant",
  "deviceType": "phone",
  "language": "en",
  "countryCode": "US",
  "ratings": [],
  "keywords": [],
  "recentDays": 0,
  "appVersions": [],
  "uniqueOnly": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Table of scraped reviews with key fields.

## `details` (type: `string`):

Detailed review data including developer replies and app metadata.

# 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 = {
    "appIdsOrUrls": [
        "com.supercell.brawlstars"
    ],
    "maxReviewsPerApp": 1000,
    "sortBy": "mostRelevant",
    "deviceType": "phone",
    "language": "en",
    "countryCode": "US",
    "ratings": [],
    "keywords": [],
    "recentDays": 0,
    "appVersions": [],
    "uniqueOnly": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/google-play-store-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 = {
    "appIdsOrUrls": ["com.supercell.brawlstars"],
    "maxReviewsPerApp": 1000,
    "sortBy": "mostRelevant",
    "deviceType": "phone",
    "language": "en",
    "countryCode": "US",
    "ratings": [],
    "keywords": [],
    "recentDays": 0,
    "appVersions": [],
    "uniqueOnly": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "appIdsOrUrls": [
    "com.supercell.brawlstars"
  ],
  "maxReviewsPerApp": 1000,
  "sortBy": "mostRelevant",
  "deviceType": "phone",
  "language": "en",
  "countryCode": "US",
  "ratings": [],
  "keywords": [],
  "recentDays": 0,
  "appVersions": [],
  "uniqueOnly": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/google-play-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/google-play-store-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Store Reviews Scraper",
        "description": "[💰 $0.2 / 1K] Extract reviews from any app on Google Play — reviewer, rating, text, date, helpful votes, app version, device, and developer replies. Accepts app package names or full Play Store URLs.",
        "version": "1.0",
        "x-build-id": "1aIoTOFegvvnzja8T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~google-play-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-google-play-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~google-play-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-google-play-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~google-play-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-google-play-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "appIdsOrUrls": {
                        "title": "Apps",
                        "type": "array",
                        "description": "App package names (e.g. `com.supercell.brawlstars`) or full Google Play URLs (e.g. `https://play.google.com/store/apps/details?id=com.supercell.brawlstars`). Add as many as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max Reviews Per App",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per app. Set to 0 for all reviews available on Google Play. Recommended: 100–1000 to keep runs quick and affordable.",
                        "default": 1000
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "mostRelevant",
                            "newest",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "Choose the order Google Play returns reviews in.",
                        "default": "mostRelevant"
                    },
                    "deviceType": {
                        "title": "Device Type",
                        "enum": [
                            "phone",
                            "tablet",
                            "chromebook"
                        ],
                        "type": "string",
                        "description": "Only include reviews posted from this device type.",
                        "default": "phone"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "nl",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "pl",
                            "cs",
                            "da",
                            "sv",
                            "no",
                            "fi",
                            "el",
                            "tr",
                            "ar",
                            "he",
                            "ja",
                            "ko",
                            "zh-CN",
                            "zh-TW",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "hi",
                            "ru",
                            "uk",
                            "ro",
                            "hu"
                        ],
                        "type": "string",
                        "description": "Language used by Google Play and the review text returned when available.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BE",
                            "AT",
                            "CH",
                            "PT",
                            "LU",
                            "DK",
                            "FI",
                            "IS",
                            "NO",
                            "SE",
                            "PL",
                            "CZ",
                            "SK",
                            "HU",
                            "RO",
                            "BG",
                            "GR",
                            "TR",
                            "JP",
                            "KR",
                            "CN",
                            "HK",
                            "TW",
                            "SG",
                            "MY",
                            "TH",
                            "ID",
                            "PH",
                            "VN",
                            "IN",
                            "BR",
                            "MX",
                            "AR",
                            "CL",
                            "CO",
                            "PE",
                            "ZA",
                            "EG",
                            "IL",
                            "AE",
                            "SA",
                            "RU",
                            "UA"
                        ],
                        "type": "string",
                        "description": "Country Google Play uses to resolve region-specific review data.",
                        "default": "US"
                    },
                    "ratings": {
                        "title": "Star Ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only keep reviews matching these star ratings. Leave empty to collect all ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Only keep reviews whose text contains any of these words or phrases (case-insensitive). Applied after reviews are collected — final count may be below Max Reviews Per App if few reviews match.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reviewsStartDate": {
                        "title": "Reviews Start Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only collect reviews posted on or after this date. Format: YYYY-MM-DD (for example 2025-01-15). Combine with sort order \"Newest First\" for an efficient recent-only run (collection stops when older reviews are reached)."
                    },
                    "reviewsEndDate": {
                        "title": "Reviews End Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only collect reviews posted on or before this date. Format: YYYY-MM-DD. Applied after reviews are collected — final count may be lower than expected."
                    },
                    "recentDays": {
                        "title": "Recent Days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Convenience filter: only reviews from the last N days. Set to 0 to disable. Overrides the Reviews Start Date when greater than 0. Most efficient with sort order \"Newest First\".",
                        "default": 0
                    },
                    "appVersions": {
                        "title": "App Versions",
                        "type": "array",
                        "description": "Only keep reviews reported from these app versions (e.g. 65.165, 64.226). Applied after reviews are collected — final count may be below Max Reviews Per App if few reviews match.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "uniqueOnly": {
                        "title": "Unique Reviews Only",
                        "type": "boolean",
                        "description": "Drop duplicate reviews (matched by review ID) across the run.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Default (Apify proxy) is recommended."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
