# Google Play Store Review Scraper (`crawl_craft/google-playstore-review-scraper`) Actor

Reading Google Play reviews one by one hides why users leave. Scrape reviews for any Android app: stars, text, date, app version, helpful votes and developer replies, with star, date, language and device filters plus topics like crashes and ads.

- **URL**: https://apify.com/crawl_craft/google-playstore-review-scraper.md
- **Developed by:** [Crawl Craft](https://apify.com/crawl_craft) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🚀 What is Google Play Store Review Scraper?

Google Play Store Review Scraper is an Apify Actor that collects public reviews for any Android app on Google Play. Every review arrives with its stars, text, date, app version, helpful votes and developer reply, plus app details such as category and install count, as structured data you can download or pass on to your own tools.

Reading reviews one by one hides why users leave, so this Actor turns them into rows you can sort, filter and compare. A Google Play reviews scraper like this one is useful for product teams, app marketers and analysts who need the raw feedback rather than a dashboard summary.

- ⭐ **Star, date and device filters:** keep only the star ratings you choose, set a start date and pick phone, tablet, Chromebook, watch, TV or car reviews.
- 🌍 **Language and country choice:** read the review set of each language you pick, from the store country you select.
- 💬 **Developer replies:** reply text, reply date and the hours until the reply sit next to each review, with their own table.
- 📊 **App details:** rating, rating count, installs and category are added to every review, and one summary row per app and language is saved.
- 🧩 **Topic tags:** reviews written in English carry keyword topics such as ads, which helps when you sort complaints.

Click **Try for free**, paste an app link and press **Start**. No Google account or login is asked for in the input.

![Google Play Store Review Scraper input form with app links and star filters](IMAGE_URL_PLACEHOLDER "google-play-store-review-scraper-input-form.png")

### 📊 What data can you extract from Google Play reviews?

The main table holds one row per review. Field names below match the output schema, and the examples are the example values from that schema.

| Field | Description | Example |
|---|---|---|
| `id` | Unique ID of the review | `e76d3ab9-b18b-4e8b-86aa-0553edd0ea0a` |
| `appId` | Package name of the app | `com.spotify.music` |
| `appTitle` | Name of the app on Google Play | `Spotify: Music and Podcasts` |
| `language` | Review language feed | `en` |
| `country` | Store country used | `us` |
| `device` | Device type the review was written for | `phone` |
| `userId` | Stable ID of the reviewer | `101137149062416713420` |
| `userName` | Display name of the reviewer | `allen TEXAS` |
| `userImage` | Reviewer profile picture link | `https://play-lh.googleusercontent.com/a-/example` |
| `date` | Review date (UTC) | `2026-10-21T18:24:12Z` |
| `timestamp` | Review time as unix seconds | `1792607052` |
| `score` | Star rating from 1 to 5 | `5` |
| `scoreText` | Label Google Play shows for the stars | `Loved it` |
| `url` | Link to the review on Google Play | `https://play.google.com/store/apps/details?id=com.spotify.music&hl=en&reviewId=e76d3ab9` |
| `text` | Text of the review | `absolutely works!` |
| `textLength` | Number of characters in the review | `17` |
| `thumbsUp` | Number of helpful votes | `0` |
| `version` | App version the reviewer used | `9.1.92.3058` |
| `isLatestVersion` | True when the review is for the current app version | `true` |
| `replyText` | Reply from the developer | `Thanks for the feedback!` |
| `replyDate` | Date of the developer reply (UTC) | `2026-10-22T09:00:00Z` |
| `replyAuthor` | Who wrote the reply | `Spotify AB` |
| `replyLatencyHours` | Hours between review and reply | `12.5` |
| `editedAfterReply` | True when the review was rewritten after the developer replied | `false` |
| `criterias` | Per-topic ratings given with the review | `[{"criteria": "vaf_phase1_streaming_music", "label": "streaming music", "rating": 3}]` |
| `topics` | Keyword topics found in English reviews (null for other languages) | `["ads"]` |
| `developer` | App developer | `Spotify AB` |
| `genre` | App category | `Music & Audio` |
| `appScore` | Average rating of the app | `4.349` |
| `appRatingsCount` | Total number of ratings of the app | `36522573` |
| `appReviewsCount` | Total number of written reviews of the app | `1856904` |
| `appInstalls` | Install count shown on Google Play | `1000000000` |
| `appCurrentVersion` | Current app version when Google Play shows one | `9.1.92.3058` |
| `appUpdated` | Last app update (UTC) | `2026-10-21T13:18:12Z` |
| `position` | Position of the review in this run for the app and language | `1` |
| `scrapedAt` | When the review was collected (UTC) | `2026-10-22T18:26:09Z` |
| `input` | Failed input (only on error rows) | `com.unknown.app` |
| `error` | Why the input failed (only on error rows) | `app not found on Google Play (404) - check the package name` |

Three more tables are filled in the same run: developer replies, rating details and an app summary. A short run summary record is saved as well. The Output section below shows each one.

### 💡 Use cases for Google Play review data

- **Monitor app reviews after a release:** set `since` to the release date and keep `reviewsSort` on newest, then read `score`, `text` and `version` for the first days of feedback. You can monitor app reviews this way for any Android app you add to `urls`.
- **Track reviews after an app update:** compare `isLatestVersion` and `version` to see whether reviews for the newest build are better or worse than before.
- **Compare reviews across app versions:** group rows by `version` and look at average `score` and `thumbsUp` per release.
- **Run an app review competitor analysis:** add your app and its rivals to `urls` in one run, then compare `appScore`, `appRatingsCount` and the stars in `score` side by side.
- **Collect competitor app reviews:** filter `stars` to 1 and 2 on a rival app to see what its users complain about, using `text` and `topics`.
- **Find app crashes from user reviews:** keep low stars and read the English `topics` tags and the `text` of each row to spot problems such as crashes and ads.
- **Start a low star review analysis:** pick `stars` 1 and 2 only, then rank the rows by `thumbsUp` to see which complaints other users agree with.
- **Track developer replies to reviews:** use `replyText`, `replyDate` and the separate developer replies table to see which reviews get answered.
- **Measure developer response time:** `replyLatencyHours` per review and `medianReplyLatencyHours` in the app summary show how fast a team answers.
- **Prepare Google Play reviews sentiment analysis:** export `text`, `score` and `language` and feed them to the sentiment tool you already use. The Actor does not score sentiment itself.
- **Run a play store app review analysis in a spreadsheet:** download the table as CSV or Excel and filter by `score`, `device` and `date`.
- **Do user feedback analysis for a roadmap:** combine `text`, `topics` and the per-topic `criterias` ratings to decide what to fix first.
- **Support customer feedback analysis for Android apps:** collect several languages in one run and compare what each market says.
- **Build a Google Play reviews dataset:** save large sets of rows with unique `id` values, app details and review dates for later study.
- **Do app market research:** `genre`, `appInstalls` and `appRatingsCount` give context for each app next to its reviews.

### 🧩 What do people call a Google Play reviews scraper?

The same job goes by many names. This table maps each name to what Google Play Store Review Scraper does.

| Name people use | What it does here |
|---|---|
| Google Play store reviews scraper | Reads public reviews for each app you list, one row per review. |
| Google Play review scraper | Handles many apps in one run, and every row carries `appId` and `appTitle`. |
| Play Store reviews scraper | Accepts package names such as `com.whatsapp` as well as app links. |
| Google Play app review scraper | Keeps each language as its own list, labelled in `language`. |
| Android app review scraper | Covers phone, tablet, Chromebook, watch, TV and car device types. |
| Google Play review extractor | Returns the full field set from the table above for each review. |
| Google Play reviews extractor | Adds app details such as `genre` and `appInstalls` to every row. |
| Play Store review extractor | Turns pages you would read by eye into rows you can sort. |
| Google Play review downloader | Applies your filters first, so you download only the rows you need. |
| Google Play reviews downloader | Saves results to a dataset you can download as JSON, CSV or Excel. |
| Google Play reviews exporter | Hands finished runs to other tools through the API, webhooks and integrations. |
| Google Play review collector | Collects reviews for many apps and languages in one run. |
| Google Play review crawler | Starts from the Console or the API, so you do not write or host one yourself. |
| Google Play reviews tool | Asks for no Google account or login in its input. |
| Google Play review data | Includes stars, text, dates, app versions and developer replies. |
| Play Store review scraper tool | Saves a short run summary with counts and timing after each run. |

### 🛠️ How to scrape Google Play reviews step by step

1. Create a free Apify account and open Google Play Store Review Scraper.
2. Add your apps under **Apps to scrape**, one per line. Use Google Play links or package names such as `com.whatsapp`.
3. Set **Max reviews per app**. The form starts at 10, and 0 means all available reviews.
4. Optionally pick star ratings, a start date, review languages, a store country and device types.
5. Click **Start** and wait for the run to finish.
6. Open the **Output** tab to export Google Play reviews as JSON, CSV or Excel.

To scrape Play Store reviews for several apps at once, put every app on its own line in step 2. Each language you pick is read as its own review list for each app.

### 💰 How much does it cost to scrape Google Play reviews?

Google Play Store Review Scraper uses tiered pay-per-event pricing: $0.5 per 1,000 results on the Free plan, and less on paid plans. Each saved review is one result, billed as the `main_result` event that the Console shows as Results.

| Apify plan | Price per 1,000 results |
|---|---|
| Free | $0.5 |
| Bronze | $0.4 |
| Silver | $0.3 |
| Gold / Platinum / Diamond | $0.2 |

A small Actor Start event of $0.00005 is also charged for each run start. On the Free plan, a run that saves 1,000 reviews therefore costs $0.5 for the results plus the start event.

The developer replies, rating details and app summary tables come from the same reviews and are not billed as extra results. If you set a maximum spend for a run, the Actor stops cleanly when that limit is reached. See the **Pricing** tab for current rates.

### ⬇️ Input

The only required field is **Apps to scrape** (`urls`), which needs at least one entry. Every other field has a default. Open the **Input** tab to see all options with their descriptions.

| Field | Type | What it does | Default |
|---|---|---|---|
| `urls` | array | Google Play app links or package names, one per line. Duplicates are removed | prefilled with the WhatsApp link |
| `maxReviewsPerApp` | integer | Reviews to collect for each app and language. 0 means all available, up to 10,000,000 | `10` |
| `reviewsSort` | string | `newest`, `most_relevant` or `rating`. A date limit always uses newest first | `newest` |
| `stars` | array | Keep only these star ratings (`"1"` to `"5"`). Empty keeps all | empty |
| `since` | string | Only reviews posted on or after this date are kept | no date limit |
| `languages` | array | Review languages, each collected separately. 66 language codes are offered | `["en"]` |
| `country` | string | Store country. One of 97 country codes | `us` |
| `devices` | array | `phone`, `tablet`, `chromebook`, `watch`, `tv` or `car` | `["phone"]` |
| `proxyConfiguration` | object | Optional proxy settings | proxy off |

Example input (schema defaults and prefill, plus a star filter):

```json
{
  "urls": ["https://play.google.com/store/apps/details?id=com.whatsapp"],
  "maxReviewsPerApp": 10,
  "reviewsSort": "newest",
  "stars": ["1", "2"],
  "languages": ["en"],
  "country": "us",
  "devices": ["phone"]
}
```

#### How to download Google Play reviews for one app

Paste one link into `urls`, leave `stars` empty and raise `maxReviewsPerApp`. The Actor saves each review as a row, so you can download Google Play store reviews as a spreadsheet once the run ends.

#### How to see Google Play reviews in other languages

Add language codes to `languages`, for example `de` and `fr`. Google Play serves a different set of reviews per language, so each code is collected as its own list and every row carries its `language`.

#### How to keep only complaints

Set `stars` to `["1", "2"]` and `reviewsSort` to `newest`. Add `since` to ignore older feedback.

#### How to read only reviews from one device type

Set `devices` to `["tablet"]` or any other device type from the list. Each device type has its own reviews, and `device` in the output tells you which one a row came from.

### ⬆️ Output

Results are stored in the run's dataset. Open the **Output** or **Storage** tab to browse them; the table view does not show every field, so download the data for the full set. Export formats include JSON, CSV, Excel, XML and HTML. Pick a Google Play reviews CSV for spreadsheets. Choose a Google Play reviews JSON export when the data goes into code.

![Google Play review dataset table with stars, review text and developer replies](IMAGE_URL_PLACEHOLDER "google-play-review-dataset-output-table.png")

Several views are available on the main dataset: Reviews, All fields, App context and Problems. Runs on different days can be merged into one Google Play store reviews dataset by joining on `id`. Below is an example of one review row. The values are the schema example values, not a captured run.

```json
{
  "id": "e76d3ab9-b18b-4e8b-86aa-0553edd0ea0a",
  "appId": "com.spotify.music",
  "appTitle": "Spotify: Music and Podcasts",
  "language": "en",
  "country": "us",
  "device": "phone",
  "userId": "101137149062416713420",
  "userName": "allen TEXAS",
  "userImage": "https://play-lh.googleusercontent.com/a-/example",
  "date": "2026-10-21T18:24:12Z",
  "timestamp": 1792607052,
  "score": 5,
  "scoreText": "Loved it",
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music&hl=en&reviewId=e76d3ab9",
  "text": "absolutely works!",
  "textLength": 17,
  "thumbsUp": 0,
  "version": "9.1.92.3058",
  "isLatestVersion": true,
  "replyText": "Thanks for the feedback!",
  "replyDate": "2026-10-22T09:00:00Z",
  "replyAuthor": "Spotify AB",
  "replyLatencyHours": 12.5,
  "editedAfterReply": false,
  "criterias": [
    {
      "criteria": "vaf_phase1_streaming_music",
      "label": "streaming music",
      "rating": 3
    }
  ],
  "topics": ["ads"],
  "developer": "Spotify AB",
  "genre": "Music & Audio",
  "appScore": 4.349,
  "appRatingsCount": 36522573,
  "appReviewsCount": 1856904,
  "appInstalls": 1000000000,
  "appCurrentVersion": "9.1.92.3058",
  "appUpdated": "2026-10-21T13:18:12Z",
  "position": 1,
  "scrapedAt": "2026-10-22T18:26:09Z"
}
```

#### Developer replies output

Reviews that received a developer reply are also saved in their own table, with the review text next to the reply. Example values from the schema:

```json
{
  "reviewId": "e76d3ab9",
  "appId": "com.spotify.music",
  "appTitle": "Spotify: Music and Podcasts",
  "userName": "allen TEXAS",
  "score": 2,
  "reviewText": "Keeps crashing",
  "reviewDate": "2026-10-21T18:24:12Z",
  "replyText": "Sorry to hear that.",
  "replyDate": "2026-10-22T09:00:00Z",
  "replyAuthor": "Spotify AB",
  "replyLatencyHours": 12.5,
  "editedAfterReply": false,
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=e76d3ab9"
}
```

#### Rating details output

The rating details table has one row per topic rating that a reviewer gave, so one review can produce several rows. Example values from the schema:

```json
{
  "reviewId": "f444ca6e",
  "appId": "com.spotify.music",
  "appTitle": "Spotify: Music and Podcasts",
  "userName": "Johnny Reyes",
  "reviewDate": "2026-10-21T18:24:08Z",
  "criteria": "vaf_app_quality_ads_intrusiveness",
  "label": "ads intrusiveness",
  "rating": 2
}
```

#### App summary output

The app summary table has one row per app and language, with app details and statistics of the reviews collected in the run. Example values from the schema:

```json
{
  "appId": "com.spotify.music",
  "appTitle": "Spotify: Music and Podcasts",
  "language": "en",
  "developer": "Spotify AB",
  "genre": "Music & Audio",
  "appScore": 4.349,
  "appRatingsCount": 36522573,
  "appReviewsCount": 1856904,
  "appInstalls": 1000000000,
  "appCurrentVersion": "9.1.92.3058",
  "appUpdated": "2026-10-21T13:18:12Z",
  "reviewsCollected": 300,
  "avgScoreCollected": 4.1,
  "developerReplyRate": 0.12,
  "medianReplyLatencyHours": 18.4,
  "topComplaintTopics": {"ads": 12},
  "devices": {"phone": 300}
}
```

#### Error rows output

An input that cannot be read becomes one error row with `appId`, `language`, `input` and `error`, so nothing fails silently. Example values from the schema:

```json
{
  "appId": "com.unknown.app",
  "language": "en",
  "input": "com.unknown.app",
  "error": "app not found on Google Play (404) - check the package name"
}
```

### ⚠️ Limitations and error handling

- Only public reviews are collected. Private data is not available.
- Google Play publishes reviews with about one day of delay, so a very recent `since` date can return nothing.
- The number of reviews you get depends on what Google Play shows for each app, language and device type. If fewer exist than your limit, you receive fewer.
- `topics` are only filled for English reviews and are null for other languages.
- `appCurrentVersion` is filled only when Google Play shows a current version, so `isLatestVersion` can be empty for some apps.
- Duplicate reviews are removed within each app and language list.
- The developer replies table only contains reviews that have a reply.
- If an input fails, the Actor saves an error row for it and continues with the other apps. Error rows are not billed as results.

Messages you may see in the `error` field:

| Message | What to do |
|---|---|
| `app not found on Google Play (404) - check the package name` | Check the link or package name and run again |
| `could not open the app page: ...` | Run again later; the text after the colon says what went wrong |
| `the app page could not be loaded` | Run again later |
| `review data could not be read` | Run again later |
| `unexpected problem while reading this app` | Rows collected before the problem are kept; run again |

If you run out of budget, a run with a maximum spend set stops cleanly and keeps everything saved so far. If no valid app is given, the run stops with the message asking for at least one Google Play app link or package name.

### 🔌 Integrations and API

Every run can be started, scheduled and read through the Apify API, and the **API** tab shows ready-made snippets for JavaScript, Python and the command line. That makes the Actor usable as a Google Play review API for your own scripts and dashboards.

A Google Play store reviews API style feed is just the dataset items of the latest run. A Google Play app review API request can be an Actor run started with your own input.

#### Scrape Google Play store reviews Python example

Start the Actor with the Apify Python client, pass an input like the one in the Input section and read the dataset items as JSON. The **API** tab has the exact snippet for your Actor.

Connect finished runs to Make, Zapier, Google Sheets, Slack or your own endpoint through webhooks and integrations. See the Apify documentation for [integrations](https://docs.apify.com/platform/integrations), [schedules](https://docs.apify.com/platform/schedules) and [webhooks](https://docs.apify.com/platform/integrations/webhooks).

#### How to run it on a schedule

Save your input as a Task, add a schedule in Apify, and each run collects reviews again. This Actor has no mode that remembers earlier runs, so a repeated run returns reviews it has returned before. Use the stable `id` to remove duplicates in your own storage, and pass a newer `since` date through the API or Task input for each run to keep the results small.

### 🔗 Other app review scrapers by crawl_craft

Two Actors from the same Apify account read reviews of iPhone apps from the Apple App Store, while this Actor reads Android apps from Google Play.

| Actor | What it extracts | When to use it |
|---|---|---|
| [Apple App Store Review Scraper](https://apify.com/crawl_craft/apple-app-store-review-scraper) | App Store reviews with stars, text, app version, helpful votes and developer replies, filtered by rating, date or keyword. | When your apps are on iOS. Its input also lists `keywords` and an `incremental` option for returning only newer reviews on repeated runs, which this Actor's input does not list. |
| [App Store Reviews Scraper API](https://apify.com/crawl_craft/app-store-reviews-scraper-api) | Public App Store reviews for any iPhone app in any country, with rating, title, text, author, app version, votes and developer replies. | When you need iOS reviews with star and date filters. Pair it with this Actor for a cross-platform comparison of the same product. |

### ⚖️ Is it legal to scrape Google Play reviews?

Google Play Store Review Scraper reads only reviews that people have posted publicly on Google Play. It does not collect private data. The results can still hold personal data, such as reviewer display names, reviewer IDs and profile picture links. Have a legitimate reason before you collect it, think about the GDPR (Regulation (EU) 2016/679) and Google Play's terms, and ask a lawyer if you are unsure. Apify's guides on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/) are a good starting point.

### ❓ FAQ

#### How much does it cost to run Google Play Store Review Scraper?

It uses pay-per-event pricing at $0.5 per 1,000 results in the Free row of the table above, with lower rates in the other rows, plus a $0.00005 Actor Start event per run. See the **Pricing** tab for current rates.

#### Do I need a Google account or an API key?

No. The input asks only for the apps and your filters. You need an Apify account to run the Actor.

#### How many reviews can I get?

Set `maxReviewsPerApp` between 1 and 10,000,000, or 0 for all available reviews. The limit applies to each app and language. The real number depends on what Google Play shows for that app.

#### Can I get reviews in several languages at once?

Yes. Add several codes to `languages` and each one is collected as its own list. The store country is a single value per run, set with `country`.

#### Can I use it with Python?

Yes. See the Python example in the Integrations section: start the Actor with the Apify Python client and read the dataset items.

#### Can I scrape private data?

No. Only public reviews and public app details are collected.

#### Do I need proxies?

No. The proxy field is optional and is off by default.

#### Can I filter by star rating or date?

Yes. Use `stars` to keep chosen star ratings and `since` to keep reviews posted on or after a date.

### 💬 Your feedback

Found a bug or missing a feature? Open an issue in the **Issues** tab of this Actor. For custom solutions, email hello.crawlcraft@gmail.com.

# Actor input Schema

## `urls` (type: `array`):

Google Play app links or package names, one per line (for example https://play.google.com/store/apps/details?id=com.whatsapp or com.spotify.music). Duplicates are removed.

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

Reviews to collect for each app and language. Use 0 for all available reviews (big apps have millions).

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

Newest first, most relevant first (Google's helpfulness ranking) or by rating. A date limit always uses newest first.

## `stars` (type: `array`):

Keep only these star ratings, for example 1 and 2 for complaints. Leave empty for all stars.

## `since` (type: `string`):

Pick a date: only reviews posted on or after it are kept. Leave empty for no date limit. Google publishes reviews with about one day delay.

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

Google Play serves a different set of reviews per language. Each language you pick is collected separately.

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

Google Play store country. It changes the most-relevant ranking and the app details.

## `devices` (type: `array`):

Each device type has its own reviews. Choose phone, tablet, chromebook, watch, tv or car.

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

Optional. Leave the default if you are unsure. Choose your own proxy setup here if you need one.

## Actor input object example

```json
{
  "urls": [
    "https://play.google.com/store/apps/details?id=com.whatsapp"
  ],
  "maxReviewsPerApp": 10,
  "reviewsSort": "newest",
  "stars": [],
  "languages": [
    "en"
  ],
  "country": "us",
  "devices": [
    "phone"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per review.

## `developerReplies` (type: `string`):

Reviews that received a developer reply, with reply time.

## `ratingDetails` (type: `string`):

Per-topic ratings that reviewers gave, one row per topic.

## `appSummary` (type: `string`):

One row per app and language with app details and review statistics.

## `summary` (type: `string`):

Counts and timing of the run.

# 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 = {
    "urls": [
        "https://play.google.com/store/apps/details?id=com.whatsapp"
    ],
    "languages": [
        "en"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawl_craft/google-playstore-review-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 = {
    "urls": ["https://play.google.com/store/apps/details?id=com.whatsapp"],
    "languages": ["en"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawl_craft/google-playstore-review-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 '{
  "urls": [
    "https://play.google.com/store/apps/details?id=com.whatsapp"
  ],
  "languages": [
    "en"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawl_craft/google-playstore-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawl_craft/google-playstore-review-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/dfubhBieFCwFyxGz1/builds/XdVEv0Z0N90VYnNnH/openapi.json