# Google Play Scraper (`apilab/google-play-scraper`) Actor

Extract data from thousands of Google Play Store apps and user reviews, including app metadata, descriptions, developer details, category rankings, install counts, and ratings. Capture detailed user feedback including reviewer names, scores, and helpfulness counts across any language or country.

- **URL**: https://apify.com/apilab/google-play-scraper.md
- **Developed by:** [Apilab](https://apify.com/apilab) (community)
- **Categories:** AI, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 91 total users, 5 monthly users, 99.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📱 Google Play Scraper: Review-Focused App & Review Extractor

Get Google Play Store data in seconds. This Actor extracts slim **App Metadata** (ratings, installs, developer, versioning) and **User Reviews** for one or more apps, with customizable sorting, limits and localization — optimized for review analysis.

### ✨ Key Features

- **Review-First Output:** Clean review records with the fields analysts actually use — no media metadata noise.
- **Multiple Apps per Run:** Scrape up to 100 apps in one run; a failure in one app never stops the others.
- **Slim App Context:** A separate `appdetails` dataset with one listing record per app (rating, pricing, install and update context), displayed as its own App Details table.
- **Deep Review Scraping:** Collect up to 10,000 reviews per app — pagination across ~150-review pages is automatic.
- **Customizable Localization:** Scrape listings and reviews as seen in a specific language and country.
- **Smart Sorting:** Sort reviews by "Newest", "Helpfulness" or "Rating" to find the most relevant feedback.
- **Run Summary:** A `run-summary` key-value store record reports every app's success/failure for easy monitoring.

### 🛠 How to Use

1. **App IDs / URLs:** Enter Google Play package names (e.g. `com.spotify.music`), full store URLs (e.g. `https://play.google.com/store/apps/details?id=com.openai.chatgpt`), or a mix of both.
2. **Localization:** Pick your target **Language** and **Country** to see localized pricing, ranking and descriptions.
3. **Review Settings:**
   - Toggle **Include Reviews** if you need user feedback.
   - Set the **Sort Order** (e.g. Helpfulness) and the **Number of Reviews** to collect per app.
4. **Run & Export:** Click "Start". Once finished, download your data from the Output tab in JSON, CSV or Excel.

### 📥 Input Parameters

| Field                | Type    | Default                 | Description                                                                  |
| -------------------- | ------- | ----------------------- | ---------------------------------------------------------------------------- |
| `appIds`             | array   | `["com.spotify.music"]` | Google Play package names or store URLs (max 100 per run).                   |
| `lang`               | string  | `en`                    | Two-letter language code for localized data.                                 |
| `country`            | string  | `us`                    | Two-letter country code for store-localized prices and ranks.                |
| `includeReviews`     | boolean | `true`                  | Whether to also fetch user reviews for each app.                             |
| `reviewsSort`        | string  | `newest`                | Review sort order: `newest`, `rating` or `helpfulness`.                      |
| `reviewsNum`         | integer | `1000`                  | Maximum reviews per app (1–10,000), fetched in ~150-review pages.            |
| `proxyConfiguration` | object  | `useApifyProxy: false`  | Route requests through the Apify Proxy or your own proxies (see note below). |

> **Proxy tip:** Google Play frequently rejects requests coming from datacenter IP ranges with `404`/`403` errors, especially on cloud platforms. Enabling the Apify Proxy (`useApifyProxy: true`) makes runs far more reliable.

> The Actor also still accepts the legacy single `appId` field for backwards compatibility, but `appIds` is the recommended input.

**Example input**

```json
{
    "appIds": ["com.spotify.music", "https://play.google.com/store/apps/details?id=com.openai.chatgpt"],
    "lang": "en",
    "country": "us",
    "includeReviews": true,
    "reviewsSort": "helpfulness",
    "reviewsNum": 1000
}
```

### 📊 Output Data Structure

The run's **Output tab shows two tables**: the default dataset holds **review records** — the main output, so review exports stay clean — and the `appdetails` dataset holds a slim **app record** per scraped app with the listing context. A per-run summary lives under `run-summary` in the key-value store; the Output tab links all three.

#### App record (`appdetails` dataset)

Slim listing context with one record per scraped app.

```json
{
    "type": "app",
    "appId": "com.spotify.music",
    "lang": "en",
    "country": "us",
    "title": "Spotify: Music and Podcasts",
    "summary": "Listen to songs, play podcasts, create playlists...",
    "developer": "Spotify AB",
    "genre": "Music & Audio",
    "score": 4.35,
    "ratings": 35102532,
    "histogram": { "5": 21000000, "4": 6000000 },
    "installs": "1,000,000,000+",
    "minInstalls": 1000000000,
    "price": 0,
    "priceText": "Free",
    "updated": "2026-10-23T12:37:22.000Z",
    "version": "Varies with device",
    "url": "https://play.google.com/store/apps/details?id=com.spotify.music"
}
```

#### Review record example

The main output — one record per review.

```json
{
    "type": "review",
    "appId": "com.spotify.music",
    "id": "gp:AOqpTOF...",
    "userName": "Priya Ghosh",
    "date": "2025-08-29T17:08:00.483Z",
    "score": 1,
    "title": "Ads everywhere",
    "text": "Constant popups for premium, can't skip without long ads...",
    "thumbsUp": 35966,
    "version": "9.0.74.1121",
    "replyText": "Thanks for the feedback..."
}
```

#### Run summary (`run-summary` key-value record)

```json
{
    "requestedApps": 2,
    "appsScraped": 1,
    "appsFailed": 1,
    "reviewsCollected": 1000,
    "finishedAt": "2026-10-28T16:46:36.371Z",
    "succeeded": [{ "appId": "com.spotify.music", "reviews": 1000 }],
    "failed": [{ "appId": "com.does.not.exist", "error": "App not found (404)" }]
}
```

### 💡 Why use this Actor?

- **ASO Research:** Monitor how your competitors update their descriptions and what keywords they use.
- **Sentiment Analysis:** Export thousands of 1-star and 5-star reviews to analyze what users love or hate about an app.
- **Price Monitoring:** Track app pricing and in-app purchase availability across different countries.
- **Lead Gen for Devs:** Identify developers with high-traffic apps for partnership opportunities.

### 💻 Local Development

```bash
npm install          # install dependencies
apify run            # run the Actor locally (uses ./storage INPUT.json)
npm test             # run unit tests
npm run lint         # run ESLint
npm run format       # apply Prettier formatting
```

# Actor input Schema

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

Google Play app identifiers or full store URLs, one per line. Both <code>com.spotify.music</code> and <code>https://play.google.com/store/apps/details?id=com.spotify.music</code> work. Up to 100 apps per run.

## `lang` (type: `string`):

Two-letter language code used to fetch localized app data (e.g. <code>en</code>, <code>es</code>, <code>ja</code>).

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

Two-letter country code that decides which store is viewed (affects price, rank and availability).

## `includeReviews` (type: `boolean`):

Collect user reviews for each app in addition to the app details.

## `reviewsSort` (type: `string`):

How reviews are sorted: <code>newest</code> (most recent first), <code>helpfulness</code> (most up-voted first) or <code>rating</code> (grouped by star rating).

## `reviewsNum` (type: `integer`):

Maximum reviews collected per app. Reviews are fetched in ~150-review pages automatically; higher values simply take longer. Up to 10,000 reviews per app.

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

Routes all requests through the Apify Proxy or your own proxy URLs. Enable it to fetch from residential or rotating datacenter IPs, which helps when Google Play rejects requests from datacenter ranges.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.openai.chatgpt"
  ],
  "lang": "en",
  "country": "us",
  "includeReviews": true,
  "reviewsSort": "newest",
  "reviewsNum": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `appDetails` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "appIds": [
        "com.spotify.music",
        "https://play.google.com/store/apps/details?id=com.openai.chatgpt"
    ],
    "lang": "en",
    "country": "us",
    "includeReviews": true,
    "reviewsSort": "newest",
    "reviewsNum": 1000,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "appIds": [
        "com.spotify.music",
        "https://play.google.com/store/apps/details?id=com.openai.chatgpt",
    ],
    "lang": "en",
    "country": "us",
    "includeReviews": True,
    "reviewsSort": "newest",
    "reviewsNum": 1000,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "appIds": [
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.openai.chatgpt"
  ],
  "lang": "en",
  "country": "us",
  "includeReviews": true,
  "reviewsSort": "newest",
  "reviewsNum": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call apilab/google-play-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/s4RPF753e2gvINRMC/builds/ubOUP6kVv7sxjcqHa/openapi.json