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

Scrape Android app reviews from Google Play without a login. Give it package ids or app links and get clean structured reviews: rating, text, author, date, app version, helpful votes, and developer replies. Walks pagination up to your chosen limit, with country and language controls.

- **URL**: https://apify.com/goat255/google-play-reviews-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 Reviews Scraper

Scrape Google Play Store app reviews at scale with no login and no API key. Give the scraper any Android package id or Play Store app link and it returns clean, structured reviews: star rating, full review text, author name, review date, app version, helpful votes, and the developer reply. Pagination is handled automatically up to the limit you set.

### What it does

- **Extract app reviews by package id or app URL.** Pull reviews for any public Android app on Google Play using its package id (for example `com.example.app`) or a full Play Store link.
- **Full review detail per row.** Every review row includes the star rating, review text, author name and avatar, review date, the app version reviewed, the helpful vote count, and the developer reply with the developer name and reply date when one exists.
- **Sort and localize.** Order reviews by newest, by rating, or by most helpful. Pick a country and language to control which reviews are returned, so you can pull the same app across multiple markets.
- **Bulk and concurrent.** Pass many apps at once and process them in parallel for fast, large exports.
- **Automatic pagination.** The scraper walks page after page until it reaches your requested count or the app's reviews run out, then stops cleanly.

No account, no password, no API key. Give it apps and it returns one clean row per review.

### Use cases

- **App reputation monitoring.** Track incoming reviews and ratings for your own apps and get alerted to drops in sentiment after a release.
- **Product and feature research.** Mine review text for feature requests, bugs, and recurring complaints to prioritize your roadmap.
- **Competitor analysis.** Pull reviews for apps in your category to understand what users praise and what frustrates them.
- **Customer support coverage audit.** Measure how many reviews receive a developer reply and how quickly, using the reply text and reply date fields.
- **Sentiment and NLP datasets.** Build a labeled corpus of app feedback across countries and languages for sentiment analysis or model training.

### Input

| Field | Type | Description |
|---|---|---|
| `appIds` | array | Android package ids or Google Play app links to pull reviews from. Example: `com.example.app` or `https://play.google.com/store/apps/details?id=com.example.app`. Required. |
| `sort` | string | Order reviews are returned in: `newest`, `rating`, or `helpfulness`. Default `newest`. |
| `country` | string | Two letter country code used to localize which reviews are returned. Example: `us`, `gb`, `in`, `de`. Default `us`. |
| `language` | string | Two letter language code for the reviews and developer replies. Example: `en`, `es`, `fr`, `de`. Default `en`. |
| `maxReviewsPerApp` | integer | Cap on reviews returned per app. Pagination is walked across multiple pages until this is reached or the app's reviews are exhausted. Default 100. |
| `concurrency` | integer | How many apps to process in parallel. Default 5. |
| `proxyConfig` | object | Proxy configuration. Residential proxy is the default and recommended option for the most reliable results. |

#### Example input

```json
{
  "appIds": [
    "com.example.app",
    "https://play.google.com/store/apps/details?id=com.example.other"
  ],
  "sort": "newest",
  "country": "us",
  "language": "en",
  "maxReviewsPerApp": 500,
  "concurrency": 5
}
````

### Output

Each review is one clean row in the dataset. Example:

```json
{
  "type": "review",
  "reviewId": "abc123de-4567-89ab-cdef-0123456789ab",
  "appId": "com.example.app",
  "url": "https://play.google.com/store/apps/details?id=com.example.app&reviewId=abc123de-4567-89ab-cdef-0123456789ab",
  "rating": 4,
  "thumbsUp": 12,
  "userName": "Jane Doe",
  "text": "Works well, would love a dark theme.",
  "replyText": "Thanks for the feedback. A dark theme is on the way.",
  "developerName": "Acme Co",
  "repliedAt": "2026-06-02T09:00:00.000Z",
  "userImage": "https://example.com/avatar.jpg",
  "appVersion": "9.1.0",
  "reviewedAt": "2026-06-01T12:00:00.000Z",
  "scrapedAt": "2026-06-18T08:00:00.000Z"
}
```

Key fields:

- **`rating`** is the star rating from 1 to 5.
- **`thumbsUp`** is the number of users who marked the review helpful at scrape time.
- **`text`** is the full review body. It is null when the user left a star rating with no written text.
- **`replyText`, `developerName`, `repliedAt`** describe the developer reply. They are null when the developer has not replied, which is the case for most reviews.
- **`appVersion`** is the app version the user reviewed. It is null when the store does not record a version for that review.
- **`reviewedAt`** and **`repliedAt`** are ISO 8601 timestamps in UTC.

### FAQ

**Do I need a Google login or API key?**
No. The scraper needs no account, no password, and no API key. You provide app ids or links and it returns reviews.

**How much does it cost?**
You are charged per review returned, so you pay only for the data you actually receive. See the pricing tab on the actor's page for the current rate.

**How many reviews can I get per app?**
Set `maxReviewsPerApp` to any number you need. The scraper paginates through multiple pages automatically until it reaches your target or the app has no more reviews. Some apps have a large but finite pool of accessible reviews, so a very high cap can return fewer rows once the app is exhausted.

**Can I scrape several apps at once?**
Yes. Put many package ids or links in `appIds` and they are processed in parallel. Use the `concurrency` field to control how many run at the same time.

**Can I get reviews in a specific country or language?**
Yes. Set `country` and `language` to the two letter codes you want. The same app can return different reviews per locale, which is useful for multi market analysis.

**How fast is it?**
Reviews are fetched in pages of up to 100 at a time and apps run in parallel, so large exports complete quickly. Actual speed depends on the number of apps, your requested count, and proxy performance.

**Does it return developer replies?**
Yes. When a developer has replied to a review, the reply text, developer name, and reply date are included. Most reviews have no reply, so those fields are commonly null.

### Related actors

Part of the scraper suite by goat255:

- [App Store Reviews Scraper](https://apify.com/goat255/app-store-reviews-scraper) - the iOS equivalent: app reviews from the Apple App Store.

# Actor input Schema

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

Android package ids or Google Play app links to pull reviews from. Example: com.example.app, https://play.google.com/store/apps/details?id=com.example.app.

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

Order reviews are returned in. Newest first, by rating, or by how helpful other users found them.

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

Two letter country code used to localize which reviews are returned. Example: us, gb, in, de.

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

Two letter language code for the reviews and developer replies. Example: en, es, fr, de.

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

Cap on reviews returned per app. Pagination is walked across multiple pages until this is reached or the app's reviews are exhausted.

## `concurrency` (type: `integer`):

How many apps to process in parallel. Higher is faster but puts more load on proxies.

## `proxyConfig` (type: `object`):

Apify proxy. RESIDENTIAL is the default and recommended option for the most reliable results.

## Actor input object example

```json
{
  "appIds": [
    "com.android.chrome"
  ],
  "sort": "newest",
  "country": "us",
  "language": "en",
  "maxReviewsPerApp": 100,
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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.android.chrome"
    ],
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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 = {
    "appIds": ["com.android.chrome"],
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/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 '{
  "appIds": [
    "com.android.chrome"
  ],
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call goat255/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Reviews Scraper",
        "description": "Scrape Android app reviews from Google Play without a login. Give it package ids or app links and get clean structured reviews: rating, text, author, date, app version, helpful votes, and developer replies. Walks pagination up to your chosen limit, with country and language controls.",
        "version": "0.1",
        "x-build-id": "eIcSFfbatxNAQ9ESp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~google-play-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-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/goat255~google-play-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-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/goat255~google-play-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-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": [
                    "appIds"
                ],
                "properties": {
                    "appIds": {
                        "title": "Apps (package ids or links)",
                        "type": "array",
                        "description": "Android package ids or Google Play app links to pull reviews from. Example: com.example.app, https://play.google.com/store/apps/details?id=com.example.app.",
                        "default": [
                            "com.android.chrome"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "newest",
                            "rating",
                            "helpfulness"
                        ],
                        "type": "string",
                        "description": "Order reviews are returned in. Newest first, by rating, or by how helpful other users found them.",
                        "default": "newest"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two letter country code used to localize which reviews are returned. Example: us, gb, in, de.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two letter language code for the reviews and developer replies. Example: en, es, fr, de.",
                        "default": "en"
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Cap on reviews returned per app. Pagination is walked across multiple pages until this is reached or the app's reviews are exhausted.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many apps to process in parallel. Higher is faster but puts more load on proxies.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. RESIDENTIAL is the default and recommended option for the most reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
