# Google Play Scraper - App Details, Search & Reviews (`datagleaner/google-play-scraper`) Actor

Google Play scraper in one Actor: app details by package name or URL, keyword search for apps, and user reviews with sort and country. Installs, rating, histogram, price, developer, version, update date. Plain HTTP, no login.

- **URL**: https://apify.com/datagleaner/google-play-scraper.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Automation, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 - App Details, Search & Reviews in One Actor

Monitor your app's reviews, track competitors and keywords, and pull Google Play data as clean JSON: **app details** by package name or URL, **keyword search** for apps, and **user reviews** with sort, star filter, country and language. One Actor does all three jobs, over plain HTTP with no browser, no login and no Google account.

It costs **$0.0003 per app** and **$0.0001 per review** ($0.30 per 1,000 apps, $0.10 per 1,000 reviews).

### What does Google Play Scraper do?

It returns the data a visitor sees on Google Play, through the Apify dataset and API as JSON, CSV or Excel. Typical uses:

- **App review monitoring:** pull the newest reviews of your app every day, or only the 1-star ones with `reviewScore: 1`, with text, stars, version, helpful votes and your reply. Send new complaints to Slack, email or a ticket system.
- **ASO and competitor tracking:** search a keyword and record which apps rank where (`position`), with installs bucket, rating, rating count, price, category and last update. Schedule it daily to see rank, rating and release-cadence changes over time.
- **Market and category research:** list the apps for `habit tracker`, `invoice maker` or `period tracker` with installs, rating histograms, price and monetisation flags (`offersInAppPurchases`, `containsAds`) before you build.
- **Voice of customer:** feed thousands of reviews of a competitor into your own analysis or an LLM to find what users ask for and complain about.
- **Release and pricing watch:** `version`, `updated`, `recentChanges` and `price` per app, per country.
- **AI agents and apps:** feed live Play Store data into an agent or product.

Need the developer's email, address or phone? Use [app-developer-email-finder](https://apify.com/datagleaner/app-developer-email-finder), which finds contact details for Google Play, App Store, Steam and Chrome Web Store developers. This Actor also returns `developerEmail` and `developerWebsite` when the store page shows them.

### Input

| Field | Meaning |
|---|---|
| `appIds` | **Details mode.** Package names (`com.spotify.music`) or Google Play URLs. One app record each. Apps that do not exist in the chosen country are skipped and not charged. |
| `searchQueries` | **Search mode.** Keywords as typed in the Play Store. Up to `maxItems` apps per keyword in store rank order. |
| `reviewAppIds` | **Reviews mode.** Apps whose reviews to fetch, up to `maxReviews` each. Returns review records only (no app record). |
| `maxItems` | Apps per search keyword, default 30. Google Play shows about 20 to 30 results per keyword. |
| `includeDetails` | Default on. One extra request per search result adds rating count, histogram, version, update date, developer ID and website, description and screenshots. Off gives a faster list from the search cards only. The price per app is the same. |
| `maxReviews` | Reviews per app, default 100, up to 100,000. |
| `reviewSort` | `newest` (default, best for monitoring), `relevant` or `rating`. |
| `reviewScore` | Optional, 1 to 5. Only reviews with exactly that many stars. |
| `country`, `language` | Store country (`US`, `GB`, `DE`, `JP`) and language (`en`, `de`, `pt-BR`). Country changes prices, availability and which reviews appear. |
| `requestDelaySecs` | Pacing between requests, default 0.5. |
| `proxyConfiguration` | Optional, off by default. |

With no input at all, the Actor runs a built-in example (1 app, 2 search results for `habit tracker`, 2 reviews) and says so in the run's status message. If you already call another Google Play Actor, these input names are also accepted: `startUrls`, `queries`, `searchTerms`, `countryCode`, `languageCode`, `maxResults`, `sortBy`, `maxReviewsPerApp`.

App details and a keyword search in one run:

```json
{
  "appIds": ["com.spotify.music", "https://play.google.com/store/apps/details?id=org.isoron.uhabits"],
  "searchQueries": ["habit tracker"],
  "maxItems": 30,
  "country": "US",
  "language": "en"
}
```

Reviews of two apps, newest first:

```json
{
  "reviewAppIds": ["com.spotify.music", "org.isoron.uhabits"],
  "maxReviews": 200,
  "reviewSort": "newest"
}
```

Only the 1-star reviews of an app:

```json
{ "reviewAppIds": ["org.isoron.uhabits"], "reviewScore": 1, "maxReviews": 100 }
```

### Output

Every record has `source` (`appIds`, `search` or `reviews`), `country`, `language` and `scrapedAt`. App records:

```json
{
  "appId": "org.isoron.uhabits",
  "title": "Loop Habit Tracker",
  "summary": "Create good habits and track their progress over time",
  "description": "Loop helps you create and maintain good habits...",
  "developer": "Álinson S Xavier",
  "developerId": "7792440048329025379",
  "developerUrl": "https://play.google.com/store/apps/developer?id=%C3%81linson+S+Xavier",
  "developerWebsite": null,
  "developerEmail": "dev@loophabits.org",
  "installs": "5,000,000+",
  "minInstalls": 5000000,
  "realInstalls": 7892890,
  "rating": 4.72,
  "ratingCount": 63451,
  "reviewsCount": 3423,
  "histogram": {"1": 1860, "2": 881, "3": 1762, "4": 4126, "5": 54793},
  "price": 0,
  "currency": "USD",
  "free": true,
  "offersInAppPurchases": false,
  "containsAds": false,
  "genre": "Productivity",
  "genreId": "PRODUCTIVITY",
  "released": "Feb 22, 2016",
  "updated": "2025-09-14T22:56:06+00:00",
  "version": "2.3.1",
  "contentRating": "Everyone",
  "recentChanges": "Loop 2.3.1: ...",
  "url": "https://play.google.com/store/apps/details?id=org.isoron.uhabits",
  "icon": "https://play-lh.googleusercontent.com/...",
  "screenshots": ["https://play-lh.googleusercontent.com/..."],
  "privacyPolicyUrl": null,
  "source": "search",
  "searchQuery": "habit tracker",
  "position": 1,
  "inputUrl": null,
  "country": "US",
  "language": "en",
  "scrapedAt": "2026-10-12T08:00:00+00:00"
}
```

Review records:

```json
{
  "reviewId": "aa37a247-402b-4d90-a8a8-d113d330fabf",
  "appId": "com.spotify.music",
  "userName": "Jon T.",
  "userImage": "https://play-lh.googleusercontent.com/a/...",
  "text": "constantly crackling, pausing and jumping for podcasts I've downloaded",
  "score": 1,
  "thumbsUp": 0,
  "version": "9.1.90.2270",
  "at": "2026-10-10T23:25:10+00:00",
  "replyText": "Hi. Thanks for sharing this with us. ...",
  "repliedAt": "2026-10-11T00:12:57+00:00",
  "reviewSort": "newest",
  "source": "reviews",
  "inputUrl": "com.spotify.music",
  "country": "US",
  "language": "en",
  "scrapedAt": "2026-10-12T08:00:00+00:00"
}
```

The dataset has an **Apps** view and a **Reviews** view with the main columns.

#### Which fields are filled

- **Always, on every app record:** `appId`, `title`, `developer`, `installs`, `minInstalls`, `price`, `currency`, `free`, `genre`, `contentRating`, `url`, `icon`, `source`, `scrapedAt`. `rating` is empty for apps without ratings yet.
- **Details and search with `includeDetails` on (default):** `ratingCount`, `reviewsCount`, `histogram`, `developerId`, `developerUrl`, `released`, `updated`, `recentChanges`, `description`, `screenshots`, `offersInAppPurchases`, `containsAds`.
- **Sometimes empty by nature:** `version` is empty for apps whose store page says "Varies with device" (Spotify, many large apps). `developerWebsite`, `developerEmail` and `privacyPolicyUrl` are empty when the developer did not list them. `realInstalls` is empty when the store page does not carry it.
- **Reviews:** `reviewId`, `userName`, `score`, `thumbsUp`, `at` are always there. `text` is empty for star-only ratings. `version` is empty on some older reviews. `replyText` and `repliedAt` are only set when the developer replied, which is most often a small share of reviews.

### Pricing

Pay per result, two events: **$0.0003 per app record** and **$0.0001 per review record**. You pay only for records pushed to the dataset. Apps that do not exist cost nothing. The run stops at your maximum charge.

Worked example: tracking 3 keywords at 30 apps each (90 apps) and the 200 newest reviews of 5 of your own and competitors' apps (1,000 reviews) costs 90 x $0.0003 + 1,000 x $0.0001 = **$0.127**. Run daily for 30 days that is about $3.80. A 10-app test run costs $0.003.

#### How this compares

Other Google Play Actors on the Apify Store price between about $0.0001 and $0.001 per result, and most do only one job: app details, or search, or reviews. A few single-purpose Actors charge as little as $0.0001 per item, so if you only need one thing in very large volume, compare. This Actor's case is one input format, one dataset schema and one bill for details, search and reviews, at a price in the same range as the cheapest of them.

### Use it from the API

Run it synchronously and get the records back as JSON. Replace `<YOUR_APIFY_TOKEN>` with your token.

```bash
curl -X POST "https://api.apify.com/v2/acts/datagleaner~google-play-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"reviewAppIds": ["com.spotify.music"], "maxReviews": 50, "reviewSort": "newest"}'
```

It also works from n8n, Make or Zapier through the Apify integrations, since the output is a flat JSON record.

### Use with Python

`pip install apify-client`, set the `APIFY_TOKEN` environment variable, and run. This input returns 20 reviews, about $0.002.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("datagleaner/google-play-scraper").call(run_input={
    "reviewAppIds": ["com.spotify.music"],
    "maxReviews": 20,
    "reviewScore": 1,
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["at"], review["score"], review["text"])
```

### Use with JavaScript / Node.js

`npm install apify-client`, set `APIFY_TOKEN`, and run it as an ES module (`.mjs`).

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/google-play-scraper').call({
    searchQueries: ['habit tracker'],
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const app of items) console.log(app.position, app.title, app.installs, app.rating);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/google-play-scraper`

Minimal input:

```
{"searchQueries": ["habit tracker"], "maxItems": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/google-play-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/google-play-scraper`. In Claude Code:

  ```
  claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/google-play-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Get the 50 newest 1-star reviews of com.spotify.music and summarise the top complaints." An agent without the Actor preloaded can find it with Apify's `search-actors` tool by searching "google play".
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/google-play-scraper")
result = tool.invoke({"run_input": json.loads('{"reviewAppIds": ["com.spotify.music"], "maxReviews": 20}')})
```

### Limits

- **Search returns one page.** Google Play shows about 20 to 30 apps per keyword, and this Actor returns them in store rank order. For wider coverage, search several related keywords.
- **Installs are buckets.** The store shows `5,000,000+`, not an exact number. `minInstalls` is that bucket as a number.
- **Reviews are what Google Play shows.** Deep pagination worked to 6,000 reviews of one app in testing. Reviews are filtered by the store country and language you set, so the same app can show different reviews in `US` and `DE`. Reviewer names are the public display names Google Play shows.
- **Prices and ratings depend on country.** Set `country` to the market you care about.
- **Rankings and numbers change by the minute.** Schedule runs and compare `scrapedAt`.
- At very high volume Google may start refusing requests. The Actor backs off, refreshes its connection and finishes what it has. Enable `proxyConfiguration` if that happens.
- Google Play changes its page structure now and then. If a field starts coming back empty, report it and it will be fixed.

### FAQ

**Is there an official Google Play API for this?** The Google Play Developer API only gives you data about your own apps. This Actor reads the public store pages instead, so it works for any app, yours or a competitor's.

**How do I monitor new reviews?** Schedule the Actor daily with `reviewSort: "newest"` and a small `maxReviews` (say 100), and use `reviewId` to skip the ones you have seen. Add `reviewScore: 1` to watch only complaints.

**How do I track keyword rankings?** Run `searchQueries` daily for your keywords and store `position` for your app and its rivals. `position` is the 1-based store rank for that keyword.

**Can I get the developer's email?** `developerEmail` is filled when the app's store page shows a contact email. For addresses, phone numbers and other stores, use [app-developer-email-finder](https://apify.com/datagleaner/app-developer-email-finder).

**Do I need a proxy?** No, it works without one on Apify in testing. A proxy option is there for very high volume.

### Responsible use

This Actor reads publicly visible Google Play pages without logging in. Use the data in line with Google Play's terms. App records are business data. Reviews contain the display names and text that users posted publicly; if you store or combine them with other data about individuals, the data-protection obligations are yours.

# Actor input Schema

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

Details mode: package names (`com.spotify.music`) or Google Play URLs (`https://play.google.com/store/apps/details?id=com.spotify.music`). Each returns one app record. Apps that do not exist in the chosen country are skipped and not charged.

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

Search mode: keywords as you would type them in the Play Store, e.g. `habit tracker`. Each returns up to `maxItems` apps in store rank order (Google Play shows one page of about 20 to 30 results per query).

## `reviewAppIds` (type: `array`):

Reviews mode: apps whose user reviews to fetch, as package names or URLs. Returns review records only (no app record), up to `maxReviews` each.

## `maxItems` (type: `integer`):

Stops after this many apps for each keyword in `searchQueries`. Google Play returns at most about 30 results per keyword, so use several related keywords for wider coverage.

## `includeDetails` (type: `boolean`):

One extra request per search result adds rating count, histogram, version, update date, developer ID and website, full description and screenshots. Turn off for a faster list from the search cards only (title, developer, installs, rating, price, category, icon). The price per app is the same.

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

Reviews to fetch for each app in `reviewAppIds`. Reviews are pulled 200 per request.

## `reviewSort` (type: `string`):

Order of the reviews: newest first (best for monitoring), most relevant, or by rating.

## `reviewScore` (type: `integer`):

Optional. Keep only reviews with exactly this star rating, e.g. `1` to monitor complaints. Leave empty for all ratings.

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

Two-letter country code of the Play Store to read, e.g. `US`, `GB`, `DE`, `JP`. It changes prices, availability, ratings shown and which reviews appear.

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

Language code for store text, e.g. `en`, `de`, `ja`, `pt-BR`.

## `requestDelaySecs` (type: `number`):

Polite pacing. Lower is faster and raises the chance of being blocked.

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

Optional. Off by default: Google Play answered Apify datacenter IPs in testing. Enable a proxy if runs start getting blocked at high volume.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music"
  ],
  "maxItems": 30,
  "includeDetails": true,
  "maxReviews": 100,
  "reviewSort": "newest",
  "country": "US",
  "language": "en",
  "requestDelaySecs": 0.5
}
```

# Actor output Schema

## `apps` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `results` (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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/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"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/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/Dq3MEFeOKFrc1r6CA/builds/udGbwapqowSbQFwIi/openapi.json