# Google Play Reviews Scraper (`trakk/google-play-reviews-app-intelligence`) Actor

Scrape Google Play reviews by app URL, package ID, or search query. Extract review text, ratings, dates, app versions, developer replies, helpful votes, reviewer data, app metadata, countries, and review languages.

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

## Pricing

from $0.15 / 1,000 review 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 Reviews Scraper

Scrape Google Play reviews by package ID, Google Play URL, or search query. Collect review text, ratings, dates, app versions, helpful votes, developer replies, reviewer names, reviewer images, app icons, app metadata, countries, and review languages.

The Actor runs on requests and is built for app review monitoring, sentiment analysis, competitor tracking, support QA, localization research, and product feedback workflows.

### ✨ What You Can Collect

- 📝 Review text, rating, review ID, publish date, reviewer name, and reviewer image
- 🖼️ App icon, app title, package ID, Google Play URL, version, genre, installs, score, ratings count, and reviews count
- 👍 Helpful vote count (`thumbsUpCount`)
- 🏷️ App version / review-created version when Google Play provides it
- 💬 Developer reply text and reply date
- 🗣️ Detected review language (`detectedLanguage`) with strict language filtering
- 🌍 Multiple countries and multiple review languages in the same run
- 🔎 Apps discovered from Google Play search queries

### 🧭 How It Works

```mermaid
flowchart LR
    A["Package IDs, app URLs, or search queries"] --> B["Discover Google Play app IDs"]
    B --> C["Fetch app metadata"]
    C --> D["Fetch review pages"]
    D --> E["Detect review text language"]
    E --> F["Apply language, rating, keyword, date, reply, and version filters"]
    F --> G["Save reviews, apps, errors, and summary datasets"]
````

### 🚀 Quick Start

#### 📱 Scrape Reviews From One App

```json
{
  "appIdsOrUrls": ["com.supercell.brawlstars"],
  "countries": ["us"],
  "reviewLanguages": ["en"],
  "maxReviewsPerApp": 100,
  "sort": "newest"
}
```

#### 🔗 Scrape Reviews From a Google Play URL

```json
{
  "appIdsOrUrls": [
    "https://play.google.com/store/apps/details?id=com.spotify.music"
  ],
  "countries": ["us"],
  "reviewLanguages": ["en"],
  "maxReviewsPerApp": 50
}
```

#### 🔎 Find Apps by Search Query

```json
{
  "searchQueries": ["fitness app", "habit tracker"],
  "maxAppsPerSearch": 5,
  "countries": ["us"],
  "reviewLanguages": ["en"],
  "maxReviewsPerApp": 50
}
```

#### 🗣️ Scrape Several Review Languages

```json
{
  "appIdsOrUrls": ["com.whatsapp"],
  "countries": ["us"],
  "reviewLanguages": ["en", "ru", "es", "de", "fr"],
  "customReviewLanguages": ["sv"],
  "strictReviewLanguage": true,
  "maxReviewsPerApp": 100
}
```

#### ⭐ Monitor Negative Reviews

```json
{
  "appIdsOrUrls": ["com.supercell.brawlstars"],
  "countries": ["us", "gb"],
  "reviewLanguages": ["en"],
  "ratings": ["1", "2"],
  "recentDays": 30,
  "maxReviewsPerApp": 200,
  "sort": "newest"
}
```

#### 🐞 Find Reviews About Bugs or Subscriptions

```json
{
  "appIdsOrUrls": ["com.spotify.music"],
  "countries": ["us"],
  "reviewLanguages": ["en"],
  "keywords": ["bug", "crash", "subscription", "payment"],
  "maxReviewsPerApp": 100
}
```

#### 🧩 Collect App Details Only

```json
{
  "searchQueries": ["budget planner"],
  "maxAppsPerSearch": 10,
  "countries": ["us"],
  "reviewLanguages": ["en"],
  "maxReviewsPerApp": 0,
  "outputMode": "apps"
}
```

### ⚙️ Input Schema

| Field | Type | Description |
| --- | --- | --- |
| `appIdsOrUrls` | array | Google Play package IDs or full app URLs. Use this for exact app targets. |
| `searchQueries` | array | Google Play search terms used to discover app IDs before scraping reviews. |
| `maxAppsPerSearch` | integer | Number of apps to take from each search query. |
| `countries` | array | Google Play country codes such as `us`, `gb`, `de`, `fr`, `br`, `jp`. |
| `reviewLanguages` | array | Review text languages to collect, such as `en`, `ru`, `es`, `de`, `fr`, `pt-BR`. |
| `customReviewLanguages` | array | Extra Google Play language codes not shown in the dropdown. |
| `strictReviewLanguage` | boolean | Detects review text language and skips reviews written in other languages. Enabled by default. |
| `maxReviewsPerApp` | integer | Maximum matching reviews per app, country, and review language. Use `0` for app details only. |
| `sort` | string | Review order: `newest`, `relevant`, or `rating`. |
| `ratings` | array | Keep only selected star ratings. Leave empty for all ratings. |
| `keywords` | array | Keep reviews containing at least one word or phrase. Case-insensitive. |
| `excludeKeywords` | array | Skip reviews containing any listed word or phrase. Case-insensitive. |
| `dateFrom` / `dateTo` | string | Keep reviews inside a date range. Format: `YYYY-MM-DD`. |
| `recentDays` | integer | Keep only reviews from the last N days. Use `0` to disable. |
| `onlyWithDeveloperReply` | boolean | Keep only reviews with a developer reply. |
| `onlyWithoutDeveloperReply` | boolean | Keep only reviews without a developer reply. |
| `appVersions` | array | Keep reviews from exact app versions. |
| `outputMode` | string | Default dataset content: `reviews`, `apps`, or `both`. |
| `includeAppDetails` | boolean | Adds app title, icon, score, installs, developer, genre, version, and URL. |
| `dedupe` | boolean | Removes duplicate reviews across repeated app/country/language combinations. |
| `fetchPageSize` | integer | Number of reviews requested per page before local filters are applied. |
| `maxPagesPerApp` | integer | Pagination safety limit for strict filters. |
| `maxConcurrency` | integer | Number of app/country/language jobs running in parallel. |
| `requestDelayMs` | integer | Optional delay between review page requests. |

### 📦 Output Schema

#### 📝 Review Item

```json
{
  "itemType": "review",
  "reviewId": "fae2f69e-3186-4248-b322-01a24f56c1d1",
  "appId": "com.supercell.brawlstars",
  "appTitle": "Brawl Stars",
  "appUrl": "https://play.google.com/store/apps/details?id=com.supercell.brawlstars&hl=en&gl=us",
  "appIcon": "https://play-lh.googleusercontent.com/...",
  "country": "US",
  "language": "en",
  "detectedLanguage": "en",
  "rating": 5,
  "text": "Great game...",
  "publishedAt": "2026-07-01T11:26:12+00:00",
  "timestamp": 1782905172,
  "appVersion": "68.250",
  "reviewCreatedVersion": "68.250",
  "thumbsUpCount": 0,
  "developerReplyText": "Thanks for your feedback!",
  "developerReplyDate": "2026-07-01T13:10:00+00:00",
  "reviewerName": "Alex",
  "reviewerImage": "https://play-lh.googleusercontent.com/...",
  "position": 1,
  "crawledAt": "2026-07-02T09:00:00+00:00"
}
```

#### 📱 App Item

```json
{
  "itemType": "app",
  "appId": "com.spotify.music",
  "appTitle": "Spotify: Music and Podcasts",
  "appUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&hl=en&gl=us",
  "appIcon": "https://play-lh.googleusercontent.com/...",
  "developer": "Spotify AB",
  "genre": "Music & Audio",
  "score": 4.3,
  "ratingsCount": 32500000,
  "reviewsCount": 1200000,
  "installs": "1,000,000,000+",
  "version": "Varies with device",
  "country": "US",
  "language": "en"
}
```

### 🗂️ Datasets

```mermaid
flowchart TD
    A["Default dataset"] --> B["Reviews only"]
    A --> C["Apps only"]
    A --> D["Apps and reviews"]
    E["apps dataset"] --> F["App metadata"]
    G["errors dataset"] --> H["Invalid inputs or failed app/language jobs"]
    I["summary dataset"] --> J["Counters, filters, runtime, duplicates, empty locales"]
```

- 📋 Default dataset: controlled by `outputMode`
- 📱 `apps`: app-level metadata
- ⚠️ `errors`: invalid inputs or failed app/country/language jobs
- 📊 `summary`: run counters, filters, runtime, duplicate count, and empty locale count

### 💡 Notes

Google Play may return ratings without written text. This Actor saves written reviews returned by Google Play. Reviewer images are shown when Google Play provides them; sometimes Google returns a default profile image instead of a personal avatar.

Strict review language filtering is enabled by default. The Actor requests a Google Play locale and also checks the detected language of each review text before saving it.

### 🙋 Feature Requests and Bug Reports

If you need a new field, filter, export format, language, country setup, or workflow, message me on Apify or open an issue on the Actor page.

If you find a bug, please include:

- 📱 App package ID or Google Play URL
- 🌍 Country and review language
- ⚙️ Input settings
- 🧾 Run ID
- ✅ What you expected to get
- ❌ What you received instead

I use this information to reproduce issues faster and ship fixes cleanly.

# Actor input Schema

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

Use this for exact targets. Examples: `com.supercell.brawlstars` or `https://play.google.com/store/apps/details?id=com.spotify.music`.

## `searchQueries` (type: `array`):

Use this when you know the app name or niche, but not the package ID. Examples: `Brawl Stars`, `fitness app`, `habit tracker`.

## `maxAppsPerSearch` (type: `integer`):

How many apps to take from each search query before scraping reviews.

## `countries` (type: `array`):

Google Play country codes. Examples: `us`, `gb`, `de`, `fr`, `br`, `jp`.

## `reviewLanguages` (type: `array`):

Select one or many review text languages in the same run. The Actor checks the detected language of each review before saving it.

## `customReviewLanguages` (type: `array`):

Optional. Add extra Google Play language codes that are not in the dropdown. Examples: `is`, `ga`, `eu`, `gl`, `iw`.

## `strictReviewLanguage` (type: `boolean`):

Detect the language of every review text and skip reviews written in other languages. Recommended for clean datasets.

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

Deprecated. Use Review languages instead. This field is kept only for old tasks and API clients.

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

Maximum matching reviews to save for each app/country/review-language combination. Set `0` to collect app details only.

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

Order used by Google Play before rating, text, date, reply, and language filters are applied.

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

Return only selected star ratings. Leave empty to collect all ratings.

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

Return only reviews containing at least one of these words or phrases. Case-insensitive.

## `excludeKeywords` (type: `array`):

Skip reviews containing any of these words or phrases. Case-insensitive.

## `dateFrom` (type: `string`):

Return reviews published on or after this date. Format: YYYY-MM-DD.

## `dateTo` (type: `string`):

Return reviews published on or before this date. Format: YYYY-MM-DD.

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

Return only reviews from the last N days. Set 0 to disable.

## `onlyWithDeveloperReply` (type: `boolean`):

Return only reviews that have a developer reply.

## `onlyWithoutDeveloperReply` (type: `boolean`):

Return only reviews that do not have a developer reply.

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

Return only reviews created for selected app versions. Exact match.

## `outputMode` (type: `string`):

Reviews only is best for sentiment analysis. Apps only is useful for discovery. Apps and reviews is best for QA.

## `includeAppDetails` (type: `boolean`):

Fetch app metadata such as title, icon, developer, score, installs, genre, version, screenshots, and Google Play URL.

## `dedupe` (type: `boolean`):

Skip duplicate reviews across repeated apps, countries, and review languages.

## `fetchPageSize` (type: `integer`):

How many reviews to request from Google Play per page before local filters are applied.

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

Safety limit for pagination. Increase if strict filters need more pages to find enough matching reviews.

## `maxConcurrency` (type: `integer`):

How many app/country/review-language combinations can run in parallel.

## `requestDelayMs` (type: `integer`):

Optional delay in milliseconds after each review page request.

## Actor input object example

```json
{
  "appIdsOrUrls": [
    "com.supercell.brawlstars"
  ],
  "searchQueries": [],
  "maxAppsPerSearch": 1,
  "countries": [
    "us"
  ],
  "reviewLanguages": [
    "en"
  ],
  "customReviewLanguages": [],
  "strictReviewLanguage": true,
  "languages": [],
  "maxReviewsPerApp": 1,
  "sort": "newest",
  "ratings": [],
  "keywords": [],
  "excludeKeywords": [],
  "dateFrom": "",
  "dateTo": "",
  "recentDays": 0,
  "onlyWithDeveloperReply": false,
  "onlyWithoutDeveloperReply": false,
  "appVersions": [],
  "outputMode": "reviews",
  "includeAppDetails": true,
  "dedupe": true,
  "fetchPageSize": 200,
  "maxPagesPerApp": 25,
  "maxConcurrency": 1,
  "requestDelayMs": 0
}
```

# 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"
    ],
    "searchQueries": [],
    "maxAppsPerSearch": 1,
    "countries": [
        "us"
    ],
    "reviewLanguages": [
        "en"
    ],
    "maxReviewsPerApp": 1,
    "sort": "newest",
    "outputMode": "reviews",
    "maxConcurrency": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/google-play-reviews-app-intelligence").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"],
    "searchQueries": [],
    "maxAppsPerSearch": 1,
    "countries": ["us"],
    "reviewLanguages": ["en"],
    "maxReviewsPerApp": 1,
    "sort": "newest",
    "outputMode": "reviews",
    "maxConcurrency": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("trakk/google-play-reviews-app-intelligence").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"
  ],
  "searchQueries": [],
  "maxAppsPerSearch": 1,
  "countries": [
    "us"
  ],
  "reviewLanguages": [
    "en"
  ],
  "maxReviewsPerApp": 1,
  "sort": "newest",
  "outputMode": "reviews",
  "maxConcurrency": 1
}' |
apify call trakk/google-play-reviews-app-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Reviews Scraper",
        "description": "Scrape Google Play reviews by app URL, package ID, or search query. Extract review text, ratings, dates, app versions, developer replies, helpful votes, reviewer data, app metadata, countries, and review languages.",
        "version": "0.2",
        "x-build-id": "tSk4ErXO00aHDQCKP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~google-play-reviews-app-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-google-play-reviews-app-intelligence",
                "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/trakk~google-play-reviews-app-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-trakk-google-play-reviews-app-intelligence",
                "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/trakk~google-play-reviews-app-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-google-play-reviews-app-intelligence",
                "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": "📱 App package IDs or URLs",
                        "type": "array",
                        "description": "Use this for exact targets. Examples: `com.supercell.brawlstars` or `https://play.google.com/store/apps/details?id=com.spotify.music`.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "searchQueries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "Use this when you know the app name or niche, but not the package ID. Examples: `Brawl Stars`, `fitness app`, `habit tracker`.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxAppsPerSearch": {
                        "title": "🎯 Max apps per search query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many apps to take from each search query before scraping reviews.",
                        "default": 5
                    },
                    "countries": {
                        "title": "🌎 Countries",
                        "type": "array",
                        "description": "Google Play country codes. Examples: `us`, `gb`, `de`, `fr`, `br`, `jp`.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "reviewLanguages": {
                        "title": "🗣️ Review languages",
                        "type": "array",
                        "description": "Select one or many review text languages in the same run. The Actor checks the detected language of each review before saving it.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en",
                                "ru",
                                "es",
                                "de",
                                "fr",
                                "pt-BR",
                                "pt-PT",
                                "it",
                                "nl",
                                "pl",
                                "tr",
                                "uk",
                                "hi",
                                "id",
                                "ja",
                                "ko",
                                "zh-CN",
                                "zh-TW",
                                "ar",
                                "vi",
                                "th",
                                "cs",
                                "sk",
                                "hu",
                                "ro",
                                "bg",
                                "el",
                                "he",
                                "sv",
                                "da",
                                "fi",
                                "no",
                                "ms",
                                "fil",
                                "bn",
                                "ta",
                                "te",
                                "mr",
                                "ur",
                                "fa",
                                "sw",
                                "af",
                                "ca",
                                "hr",
                                "sr",
                                "sl",
                                "lt",
                                "lv",
                                "et"
                            ],
                            "enumTitles": [
                                "English",
                                "Russian",
                                "Spanish",
                                "German",
                                "French",
                                "Portuguese (Brazil)",
                                "Portuguese (Portugal)",
                                "Italian",
                                "Dutch",
                                "Polish",
                                "Turkish",
                                "Ukrainian",
                                "Hindi",
                                "Indonesian",
                                "Japanese",
                                "Korean",
                                "Chinese (Simplified)",
                                "Chinese (Traditional)",
                                "Arabic",
                                "Vietnamese",
                                "Thai",
                                "Czech",
                                "Slovak",
                                "Hungarian",
                                "Romanian",
                                "Bulgarian",
                                "Greek",
                                "Hebrew",
                                "Swedish",
                                "Danish",
                                "Finnish",
                                "Norwegian",
                                "Malay",
                                "Filipino",
                                "Bengali",
                                "Tamil",
                                "Telugu",
                                "Marathi",
                                "Urdu",
                                "Persian",
                                "Swahili",
                                "Afrikaans",
                                "Catalan",
                                "Croatian",
                                "Serbian",
                                "Slovenian",
                                "Lithuanian",
                                "Latvian",
                                "Estonian"
                            ]
                        },
                        "default": [
                            "en"
                        ]
                    },
                    "customReviewLanguages": {
                        "title": "➕ Custom review language codes",
                        "type": "array",
                        "description": "Optional. Add extra Google Play language codes that are not in the dropdown. Examples: `is`, `ga`, `eu`, `gl`, `iw`.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "strictReviewLanguage": {
                        "title": "✅ Only selected review languages",
                        "type": "boolean",
                        "description": "Detect the language of every review text and skip reviews written in other languages. Recommended for clean datasets.",
                        "default": true
                    },
                    "languages": {
                        "title": "Legacy language codes",
                        "type": "array",
                        "description": "Deprecated. Use Review languages instead. This field is kept only for old tasks and API clients.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxReviewsPerApp": {
                        "title": "🔢 Max reviews per app",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum matching reviews to save for each app/country/review-language combination. Set `0` to collect app details only.",
                        "default": 100
                    },
                    "sort": {
                        "title": "↕️ Sort reviews by",
                        "enum": [
                            "newest",
                            "relevant",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Order used by Google Play before rating, text, date, reply, and language filters are applied.",
                        "default": "newest"
                    },
                    "ratings": {
                        "title": "⭐ Star ratings",
                        "type": "array",
                        "description": "Return only selected 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"
                            ]
                        },
                        "default": []
                    },
                    "keywords": {
                        "title": "🔍 Text must contain",
                        "type": "array",
                        "description": "Return only reviews containing at least one of these words or phrases. Case-insensitive.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "excludeKeywords": {
                        "title": "🚫 Text must not contain",
                        "type": "array",
                        "description": "Skip reviews containing any of these words or phrases. Case-insensitive.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "dateFrom": {
                        "title": "📅 Published from",
                        "type": "string",
                        "description": "Return reviews published on or after this date. Format: YYYY-MM-DD.",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "📅 Published until",
                        "type": "string",
                        "description": "Return reviews published on or before this date. Format: YYYY-MM-DD.",
                        "default": ""
                    },
                    "recentDays": {
                        "title": "⏱️ Only recent reviews",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Return only reviews from the last N days. Set 0 to disable.",
                        "default": 0
                    },
                    "onlyWithDeveloperReply": {
                        "title": "💬 Only with developer reply",
                        "type": "boolean",
                        "description": "Return only reviews that have a developer reply.",
                        "default": false
                    },
                    "onlyWithoutDeveloperReply": {
                        "title": "🙊 Only without developer reply",
                        "type": "boolean",
                        "description": "Return only reviews that do not have a developer reply.",
                        "default": false
                    },
                    "appVersions": {
                        "title": "🏷️ App versions",
                        "type": "array",
                        "description": "Return only reviews created for selected app versions. Exact match.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "outputMode": {
                        "title": "📋 Default dataset content",
                        "enum": [
                            "reviews",
                            "apps",
                            "both"
                        ],
                        "type": "string",
                        "description": "Reviews only is best for sentiment analysis. Apps only is useful for discovery. Apps and reviews is best for QA.",
                        "default": "reviews"
                    },
                    "includeAppDetails": {
                        "title": "🧩 Include app details",
                        "type": "boolean",
                        "description": "Fetch app metadata such as title, icon, developer, score, installs, genre, version, screenshots, and Google Play URL.",
                        "default": true
                    },
                    "dedupe": {
                        "title": "🧹 Remove duplicate reviews",
                        "type": "boolean",
                        "description": "Skip duplicate reviews across repeated apps, countries, and review languages.",
                        "default": true
                    },
                    "fetchPageSize": {
                        "title": "📄 Reviews fetched per request",
                        "minimum": 1,
                        "maximum": 4500,
                        "type": "integer",
                        "description": "How many reviews to request from Google Play per page before local filters are applied.",
                        "default": 200
                    },
                    "maxPagesPerApp": {
                        "title": "🧱 Max review pages per app",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety limit for pagination. Increase if strict filters need more pages to find enough matching reviews.",
                        "default": 25
                    },
                    "maxConcurrency": {
                        "title": "⚡ Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many app/country/review-language combinations can run in parallel.",
                        "default": 5
                    },
                    "requestDelayMs": {
                        "title": "🐢 Delay between review pages",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Optional delay in milliseconds after each review page request.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
