# Google Play Reviews Scraper (Free) (`transparent_locket/google-play-reviews-scraper`) Actor

Free Google Play Store reviews scraper. App metadata + reviews (rating, body, version, thumbs-up, developer reply, dates). Sweep multiple countries x languages for the global picture. Google's web JSON endpoints; no API key, no auth.

- **URL**: https://apify.com/transparent\_locket/google-play-reviews-scraper.md
- **Developed by:** [casper smartwater](https://apify.com/transparent_locket) (community)
- **Categories:** Developer tools, E-commerce, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 — Free, No API Key

**Pull app reviews + metadata from the Google Play Store for any Android app, across any country, in any language.** No Google API key. No service account. No auth.

### ✨ Why this Actor

- **Free** — competing Play Store scrapers on Apify charge $15-30/mo. This one is $0.
- **No API key** — Google's official Play Console API requires a Service Account + developer access to the app. This Actor works for **any** public app.
- **Multi-country, multi-language** — most scrapers do one locale at a time. This one sweeps `countries × languages` so you get the full global picture in one run.
- **Includes developer replies** — track how quickly devs respond to reviews and what they say.

### 🚀 Quick start

**Scrape recent Spotify reviews across 3 countries:**

```json
{
  "appId": "com.spotify.music",
  "countries": ["us", "gb", "in"],
  "languages": ["en"],
  "sort": "newest",
  "maxReviews": 200
}
````

**Scrape Notion reviews in English + Spanish:**

```json
{
  "appId": "notion.id",
  "countries": ["us", "mx", "es"],
  "languages": ["en", "es"],
  "maxReviews": 500
}
```

**Just get app metadata (no reviews):**

```json
{
  "appId": "com.spotify.music",
  "countries": ["us"],
  "maxReviews": 0,
  "includeAppMeta": true
}
```

### 📦 Output schema

Each run produces:

- **1 app\_meta row** (`_kind: "app_meta"`) — app-level data
- **N review rows** (`_kind: "review"`) — one per review

#### App metadata row

| Field | Type | Notes |
|---|---|---|
| `id` | str | Package name (input) |
| `name` | str | App title |
| `developer`, `developer_id` | str | Studio / publisher |
| `score`, `ratings` | float, int | Lifetime average + total rating count |
| `reviews_count` | int | Total reviews written |
| `installs`, `real_installs` | str, int | "1B+" display + precise install count |
| `price`, `free` | float, bool | |
| `genre`, `genre_id` | str | Play Store category |
| `content_rating` | str | "Everyone" / "Teen" / "Mature 17+" / "Adults Only 18+" |
| `released`, `updated` | str/int | Release date + last-update timestamp |
| `current_version`, `size` | str | |
| `icon`, `url` | str | Logo + Play Store URL |
| `description` | str | Full app description |

#### Review row

| Field | Type | Notes |
|---|---|---|
| `id` | str | Stable Google review ID |
| `country`, `lang` | str | The sweep that produced this row |
| `user_name`, `user_image` | str | Reviewer |
| `content` | str | Review body |
| `rating` | int | 1-5 |
| `thumbs_up` | int | Helpfulness votes |
| `review_created_version` | str | App version at time of review |
| `at` | iso8601 | When review was posted |
| `reply_content`, `reply_at` | str, iso8601 | Developer response (if any) |

### 🎯 Use cases

- **Competitor intelligence** — track competitor app rating trends + spot feature complaints
- **Product launch monitoring** — sweep daily after a release, catch regressions fast
- **Sentiment analysis** — feed reviews into an LLM, surface top complaint themes
- **Investor research** — install counts + rating velocity = real revenue signal
- **Localization QA** — pull reviews per language, see what users in each market complain about
- **Customer support backlog** — pipe reviews into your support ticketing tool
- **App Store SEO** — see which keywords appear most often in 5-star vs 1-star reviews
- **Acquisition due diligence** — pull every review for an app you're acquiring; reviewer sentiment + dev-response speed reveal a lot

### ⚙️ Input parameters

| Parameter | Type | Default | Notes |
|---|---|---|---|
| `appId` | str | — | **Required.** Android package name. e.g. `com.spotify.music`. Visible in the Play URL as `?id=<package>` |
| `countries` | array<str> | `["us","gb","ca","au","in","de","fr","jp","br","mx"]` | ISO 2-letter codes |
| `languages` | array<str> | `["en"]` | ISO 639-1 codes. Each (country × language) pair = one sweep |
| `sort` | str | `newest` | `newest` / `rating` / `helpfulness` |
| `maxReviews` | int | 200 | Per (country × language) combo. Total = countries × languages × maxReviews |
| `includeAppMeta` | bool | true | Prepend the app\_meta row |

### 🛠️ How it works

This Actor uses [`google-play-scraper`](https://pypi.org/project/google-play-scraper/), which hits the same undocumented JSON endpoints the Play Store web client uses. No HTML parsing, no anti-bot fragility — same calls Google's own frontend makes.

### ⚠️ Tips & caveats

- **Use multiple countries** — Google personalises results per locale. Different countries reveal different reviews.
- **Pagination tokens expire** — fetching 10,000+ reviews from one (country × language) sometimes drops the tail. If you need the full archive, run nightly with `sort: newest` and dedupe by `id` over time.
- **Some countries return fewer reviews** than the Play Store shows in the UI — this is a Google-side rate limit, not a scraper bug.
- **The `at` timestamp is in UTC.**

### 🔗 Related Actors

- **[iOS App Store Metadata](https://apify.com/transparent_locket/ios-app-store-reviews-scraper)** — for the Apple side of the same app
- **[Reddit Subreddit + Search](https://apify.com/transparent_locket/reddit-subreddit-search-scraper)** — search `r/<app-name>` for organic discussion
- **[YouTube Channel + Video Scraper](https://apify.com/transparent_locket/youtube-channel-video-scraper)** — for video reviews of the same app

### 💬 Support

Bugs or custom request? Email **caspersmartwater@gmail.com**.

⭐ Star this Actor if it saves you time.

# Actor input Schema

## `appId` (type: `string`):

Android package name from the Play URL. e.g. 'com.spotify.music', 'com.zhiliaoapp.musically' (TikTok).

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

ISO 2-letter country codes to sweep. Reviews are localised per country.

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

ISO 639-1 language codes. Each (country x language) pair is a separate sweep.

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

newest = freshest first. rating = by score. helpfulness = Google's relevance ordering.

## `maxReviews` (type: `integer`):

Cap per (country x language) sweep. Total = countries x languages x maxReviews.

## `includeAppMeta` (type: `boolean`):

Prepend an \_kind='app\_meta' row with title, developer, installs, score, etc.

## Actor input object example

```json
{
  "countries": [
    "us",
    "gb",
    "ca",
    "au",
    "in",
    "de",
    "fr",
    "jp",
    "br",
    "mx"
  ],
  "languages": [
    "en"
  ],
  "sort": "newest",
  "maxReviews": 200,
  "includeAppMeta": true
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Reviews Scraper (Free)",
        "description": "Free Google Play Store reviews scraper. App metadata + reviews (rating, body, version, thumbs-up, developer reply, dates). Sweep multiple countries x languages for the global picture. Google's web JSON endpoints; no API key, no auth.",
        "version": "0.1",
        "x-build-id": "f7cObbad7VefbOjw0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/transparent_locket~google-play-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-transparent_locket-google-play-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/transparent_locket~google-play-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-transparent_locket-google-play-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/transparent_locket~google-play-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-transparent_locket-google-play-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",
                "required": [
                    "appId"
                ],
                "properties": {
                    "appId": {
                        "title": "App package name",
                        "type": "string",
                        "description": "Android package name from the Play URL. e.g. 'com.spotify.music', 'com.zhiliaoapp.musically' (TikTok)."
                    },
                    "countries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "ISO 2-letter country codes to sweep. Reviews are localised per country.",
                        "default": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "in",
                            "de",
                            "fr",
                            "jp",
                            "br",
                            "mx"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "languages": {
                        "title": "Language codes",
                        "type": "array",
                        "description": "ISO 639-1 language codes. Each (country x language) pair is a separate sweep.",
                        "default": [
                            "en"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "newest",
                            "rating",
                            "helpfulness"
                        ],
                        "type": "string",
                        "description": "newest = freshest first. rating = by score. helpfulness = Google's relevance ordering.",
                        "default": "newest"
                    },
                    "maxReviews": {
                        "title": "Max reviews per (country x language)",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap per (country x language) sweep. Total = countries x languages x maxReviews.",
                        "default": 200
                    },
                    "includeAppMeta": {
                        "title": "Include app metadata row",
                        "type": "boolean",
                        "description": "Prepend an _kind='app_meta' row with title, developer, installs, score, etc.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
