# Google Play Store Scraper — Reviews, Apps & Charts | $0.50/1k (`glasswing/google-play-scraper`) Actor

Google Play Store data without an API key: apps by package name or URL, keyword search with rank, a developer's apps, top free, paid and grossing charts in any country, plus public app reviews (rating, text, date, thumbs-up, version, developer reply; no reviewer names). JSON, CSV, Excel.

- **URL**: https://apify.com/glasswing/google-play-scraper.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Features:** Limited permissions
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 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

### What does Google Play Scraper do?

Google Play Scraper turns **Google Play Store apps, keywords, developers and top charts into clean app data**: title, developer, category, price and currency, star rating, rating count, review count, the 1-5 star breakdown, installs (the bracket and Google's own approximate count), age rating, contains-ads and in-app-purchase flags, version, minimum Android version, release and last-update dates, summary, full description, what's new, icon, feature graphic, screenshots and promo video. Paste a package name or Play Store link, type a keyword, name a developer or pick a chart, and a few seconds later you have one row per app as JSON, CSV or Excel. It also reads **Google Play reviews**: star rating, review text, date, thumbs-up count, app version and the developer's reply, one row per review, without reviewer names.

It works as a **Google Play API and Play Store API alternative** with no API key, no Google account and no browser. The Actor reads the public Google Play store pages and the same public data calls Google Play's own website uses for its charts, so it is fast and cheap.

Five ways in, freely combined in one run, in any country and language:

- **Look up apps** by package name (`com.whatsapp`) or Play Store link.
- **Search Google Play** by keyword and get each app's `searchRank`, the position Google shows it at: an ASO keyword-ranking check.
- **List every app of a developer** by developer name, numeric developer ID or developer link.
- **Read the top charts**: top free, top paid and top grossing, for all apps, all games or one category such as Games - Puzzle, with `chartPosition` and the full app data.
- **Scrape Google Play reviews** of any app: newest, most relevant or by rating, filtered by star rating and date, up to 10,000 per app and country, with the developer's reply.

Typical use cases:

- **App store optimization (ASO).** Track where your app and your competitors rank for your keywords, country by country, on a schedule.
- **Market and competitor research.** Pull the top grossing games of 10 countries, compare prices, ratings, installs and update frequency, and spot fast climbers.
- **Price and monetization research.** See what an app costs in every country, whether it shows ads and what its in-app purchases cost.
- **Publisher and partner research.** List all apps of a publisher with category, installs, rating count and the developer's website.
- **Review monitoring and sentiment analysis.** Pull every new 1-star review of your app (or a competitor's) each morning, with the app version it was written for and whether the developer answered.
- **Data for AI agents and apps.** Give an agent a tool that answers "what is this Android app, how is it rated, how many installs, when was it last updated" from Google Play's own data.

It does **not** collect reviewer names, profile pictures or account ids, nor developer e-mail addresses, phone numbers or postal addresses.

### Why use Google Play Scraper?

- **Cheap.** $0.50 per 1,000 apps and $0.30 per 1,000 reviews, Apify platform usage included, with no per-search, per-developer or per-chart surcharges.
- **Fast.** No browser. On Apify, 25 app lookups plus 6 keyword searches (85 apps) finished in 10 seconds, 2 top charts plus 3 developers in 2 countries (133 apps) in 25 seconds, and the US top 200 free and top 200 grossing charts (400 apps) in about 2 minutes, every request answered on the first try.
- **Complete rows.** Search, developer and chart rows are not thin list entries: every row is completed from the app's own Google Play page, so a chart row has the same installs, version, dates and description as a lookup.
- **Honest results.** Every row carries `status` (`ok`, `not_found`, `error`). A package that does not exist or is not sold in a country, an unknown developer or a keyword with no match is a `not_found` row that you are never charged for, and the run still ends successfully.
- **Built for agents.** Call it with no input and it returns data; plain strings everywhere; developer names, country names and chart names such as "top free" are understood.

### What data can Google Play Scraper extract?

| Field | Type | Description |
|---|---|---|
| `appId` | string | Android package name, e.g. `com.whatsapp` |
| `title` | string | App name as shown on Google Play |
| `developer` | string | Developer (publisher) name |
| `developerId` | string | Google Play's numeric developer ID |
| `developerUrl` | string | The developer's Google Play page |
| `developerWebsite` | string | The developer's website, when listed |
| `category` | string | Main category, e.g. `Communication`, `Arcade` |
| `categoryId` | string | Category ID, e.g. `COMMUNICATION`, `GAME_ARCADE` |
| `price` | number | Price in the country's currency (0 = free) |
| `currency` | string | ISO 4217 currency code, e.g. `USD`, `EUR` |
| `priceText` | string | Price as Google Play displays it (paid apps) |
| `free` | boolean | True when the app is free to install |
| `rating` | number | Average star rating 0-5 |
| `ratingCount` | integer | Number of star ratings |
| `reviewCount` | integer | Number of written reviews (the count only) |
| `ratingHistogram` | object | Number of 1- to 5-star ratings |
| `installs` | string | Install bracket as displayed, e.g. `50,000,000+` |
| `minInstalls` | integer | Lower bound of the install bracket |
| `realInstalls` | integer | Google Play's own approximate install count |
| `contentRating` | string | Age rating, e.g. `Everyone`, `Teen`, `PEGI 12` |
| `contentRatingDescription` | string | Reasons for the age rating, e.g. `Fantasy Violence, In-Game Purchases` |
| `released` | string | First release date (ISO 8601) |
| `lastUpdated` | string | Date of the latest update (ISO 8601) |
| `version` | string | Current version, or `Varies with device` |
| `androidVersion` | string | Minimum Android version, or `Varies with device` |
| `containsAds` | boolean | Google Play's "Contains ads" label |
| `offersIAP` | boolean | Whether the app sells in-app purchases |
| `iapPriceRange` | string | In-app purchase price range, e.g. `$0.99 - $49.99 per item` |
| `summary` | string | Short description |
| `description` | string | Full description as plain text |
| `recentChanges` | string | What's new in the latest update |
| `iconUrl` | string | App icon |
| `headerImage` | string | Feature graphic |
| `screenshotUrls` | array | Screenshot links |
| `videoUrl` | string | Promo video link, when the listing has one |
| `privacyPolicyUrl` | string | The app's privacy policy |
| `playStoreUrl` | string | The app's Google Play page for this country and language |
| `source` | string | How the row was found: `app`, `search`, `developer` or `chart` |
| `searchTerm` | string | Keyword that found the app |
| `searchRank` | integer | Position in Google Play's search results for that keyword (1 = first) |
| `chart` | string | `topFree`, `topPaid` or `topGrossing` |
| `chartCategory` | string | Category of the chart, e.g. `APPLICATION` (all apps), `GAME` |
| `chartPosition` | integer | Position in that chart (1 = number one) |
| `developerQuery` | string | The developer name or ID you asked for |
| `country` | string | Google Play country of the data (two-letter code) |
| `language` | string | Language of the texts |
| `detailsError` | string | Only when an app's own page could not be read after retries: the row then holds the list data (title, developer, rating, price) |
| `url` | string | Same as `playStoreUrl` on `ok` rows; what was asked for on other rows |
| `status` | string | `ok`, `not_found` or `error` (see below) |
| `error` | string | Reason when `status` is not `ok` |
| `scrapedAt` | string | ISO 8601 time of extraction |

Prices, ratings, availability, search rankings and charts are per country: the same app has different numbers in `us` and `de`. App size is not included because Google Play no longer shows it on its website.

#### Review rows (reviews mode)

Each review is one row with `source` = `review`, the app's `appId`, `title`, `developer`, `playStoreUrl`, `country` and `language`, plus:

| Field | Type | Description |
|---|---|---|
| `reviewId` | string | Google Play's id of the review; `url` links to it |
| `reviewRating` | integer | Stars the reviewer gave, 1-5 |
| `reviewText` | string | The review text |
| `reviewDate` | string | When the review was written or last edited (ISO 8601, UTC) |
| `thumbsUp` | integer | How many users marked the review helpful |
| `appVersion` | string | App version the review was written for, when Google Play shows it |
| `hasReply` | boolean | Whether the developer replied |
| `replyText` | string | The developer's public reply (a greeting by name such as "Hi Sarah," is shown as "Hi there,") |
| `replyDate` | string | When the developer replied (ISO 8601, UTC) |

Reviewer names, profile pictures and account ids are never collected. When a developer reply greets the reviewer by name, the name is replaced ("Hi Sarah," becomes "Hi there,"). Personal e-mail addresses and phone numbers in review and reply text are replaced with `[email]` and `[phone]`; the app's own support addresses are kept.

#### Result status (tri-state output)

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | The app was found; the row holds its data. | Yes |
| `not_found` | Google Play answered, but there is no such app in that country (it does not exist or is region-locked), no such developer, a keyword or chart has no apps, or an app has no reviews for your filter. `error` says which. | No |
| `error` | Google Play could not be read after retries, or an input entry was not a package name or Google Play link. `error` says why. | No |

### How to use Google Play Scraper

1. Open the Actor and click **Try for free**.
2. Fill in any of the inputs: **Apps** (package names or links), **Search keywords**, **Developers**, **Top charts** (plus **Chart category**), or **Reviews: apps to read reviews for** (plus **Reviews per app**, sort, star and date filters).
3. Pick the **Countries** (default `us`) and the **Language** (default `en`).
4. Set **Maximum results** (default 20) and, for keywords, developers and charts, **Results per search, developer or chart** (default 50).
5. Click **Start**. Rows appear in the dataset as they arrive; export them as JSON, CSV, Excel, XML or HTML, or read them through the API.

To run it on a schedule (daily ranking or chart tracking), add a **Schedule** in Apify Console. To call it from code, use the **API** tab (Node.js, Python, curl) or the Apify MCP server.

#### Which input finds what

| You give | You get |
|---|---|
| `com.whatsapp`, `https://play.google.com/store/apps/details?id=com.whatsapp`, `market://details?id=com.whatsapp` | That app |
| `Google LLC` or `5700313618786177705` (in Developers), or a developer link | Every app of that developer |
| `Rovio` (in Developers) | The apps of the developer whose name starts with it (Rovio Entertainment Oy) |
| `habit tracker` (in Search keywords) | Google Play's search results with `searchRank` |
| Top free / Top paid / Top grossing | Up to 200 apps per chart with `chartPosition` |
| `com.whatsapp` (in Reviews: apps to read reviews for) | That app's reviews, one row each |

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

This Actor uses **pay-per-event** pricing. Apify platform usage is included in these prices.

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Result (`status: ok` app row) | $0.0005 per app |
| Review (`status: ok` review row) | $0.0003 per review |

Each row is billed once: an app row as a result, a review row as a review. Examples: the default run (5 apps) costs $0.0075. 1,000 reviews of one app cost $0.305. The US top 100 free chart costs $0.055. 1,000 apps cost $0.505, 10,000 apps $5.005. Rows with `status` `not_found` or `error` are never billed. You can cap spending with **Maximum results** and the run's **Max total charge** option; the Actor stops gracefully when your run's maximum charge is reached.

### Input

See the **Input** tab for the full schema. The main options:

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of strings | 5 well-known apps | Package names, Play Store app, developer or search links |
| `searchTerms` | array of strings | - | Keywords to search |
| `developerIds` | array of strings | - | Developer names, numeric IDs or links |
| `charts` | array | - | `topFree`, `topPaid`, `topGrossing` |
| `chartCategory` | string | `APPLICATION` (all apps) | Chart category, e.g. `GAME`, `GAME_PUZZLE`, `HEALTH_AND_FITNESS` |
| `countries` | array of strings | `["us"]` | Two-letter country codes (or country names) |
| `language` | string | `en` | Language of the texts, e.g. `de`, `ja`, `pt-BR` |
| `resultsPerSource` | integer | `50` | Apps kept per keyword (max 30), developer and chart (max 200) |
| `reviewApps` | array of strings | - | Apps whose reviews you want (package names or links) |
| `reviewsPerApp` | integer | `100` | Reviews per app and country, up to 10,000 |
| `reviewSort` | string | `newest` | `newest`, `mostRelevant` or `rating` |
| `reviewRating` | string | all | Only `1`, `2`, `3`, `4` or `5`-star reviews |
| `reviewsSince` | string | - | Skip older reviews: `2026-01-31` or `30 days` |
| `maxItems` | integer | `20` | Stop after this many rows in total (reviews included) |

When you use keywords, developers, charts or reviews and leave **Apps** at its built-in example, the example apps are skipped automatically.

Example input: the 1-star reviews of two apps from the last 30 days, in the US and UK.

```json
{
    "reviewApps": ["com.calm.android", "com.headspace.android"],
    "reviewRating": "1",
    "reviewsSince": "30 days",
    "reviewsPerApp": 1000,
    "countries": ["us", "gb"],
    "maxItems": 4000
}
```

Example input: the top 100 grossing games in the US and Germany, plus two keywords.

```json
{
    "charts": ["topGrossing"],
    "chartCategory": "GAME",
    "searchTerms": ["budget planner", "habit tracker"],
    "countries": ["us", "de"],
    "resultsPerSource": 100,
    "maxItems": 1000
}
```

The default input (what an AI agent gets when it calls the Actor with no arguments):

```json
{
    "startUrls": [
        "com.whatsapp",
        "com.spotify.music",
        "https://play.google.com/store/apps/details?id=com.duolingo",
        "com.mojang.minecraftpe",
        "org.telegram.messenger"
    ],
    "countries": ["us"],
    "language": "en",
    "maxItems": 20
}
```

### Output

You can download the dataset as JSON, CSV, Excel, XML or HTML. A real row from a run on Apify (long texts and lists shortened here):

```json
{
    "url": "https://play.google.com/store/apps/details?id=com.mojang.minecraftpe&hl=en&gl=us",
    "status": "ok",
    "scrapedAt": "2026-09-27T22:05:17.137Z",
    "appId": "com.mojang.minecraftpe",
    "title": "Minecraft: Dream it, Build it!",
    "developer": "Mojang",
    "developerId": "4772240228547998649",
    "developerUrl": "https://play.google.com/store/apps/dev?id=4772240228547998649",
    "developerWebsite": "http://help.mojang.com/",
    "category": "Arcade",
    "categoryId": "GAME_ARCADE",
    "price": 6.99,
    "currency": "USD",
    "priceText": "$6.99",
    "free": false,
    "rating": 4.3071604,
    "ratingCount": 5844620,
    "reviewCount": 635016,
    "ratingHistogram": { "1": 619774, "2": 178556, "3": 269189, "4": 496216, "5": 4280868 },
    "installs": "50,000,000+",
    "minInstalls": 50000000,
    "realInstalls": 97817244,
    "contentRating": "Everyone 10+",
    "contentRatingDescription": "Fantasy Violence, Users Interact, In-Game Purchases",
    "released": "2011-08-16T06:17:21Z",
    "lastUpdated": "2026-09-25T17:26:28Z",
    "version": "1.26.52.3",
    "androidVersion": "8.0",
    "containsAds": false,
    "offersIAP": true,
    "iapPriceRange": "$0.99 - $49.99 per item",
    "summary": "Millions of crafters have smashed billions of blocks! Now you can join the fun!",
    "description": "Dive into an open world of building, crafting, and survival in the ultimate sandbox adventure. Gather resources, survive the night, and build a world one block at a time....",
    "recentChanges": "What's new in 26.52: Various bug fixes!",
    "iconUrl": "https://play-lh.googleusercontent.com/tI4StRSPVhpGJH5R013naszLUawOjao1ya8FvyaNO7XY_cJFHFqo1EFaEJv_7zz3rRJ5lEpLiw14ZqQLCOYc",
    "headerImage": "https://play-lh.googleusercontent.com/S_Z7YSNVWWd3BNh3AwV0iVv0hNqJ8zvn-HwLTlYqVLU4uxSohpwKpIa-EmwwwoxOlSw8voqu5CsxQGbojanT",
    "screenshotUrls": ["https://play-lh.googleusercontent.com/ywPBuExmYGLE6oL7QENmI7wOxMPOU-XatzosE6M4bgXudBsMQWcKp1QHhHrJM1QeTadoVo7lnpO5O12WyzlYQA", "..."],
    "videoUrl": "https://play.google.com/video/lava/web/player/yt:movie:BLtLrFNRE-E?autoplay=1&embed=play",
    "privacyPolicyUrl": "http://go.microsoft.com/fwlink/?LinkId=521839",
    "playStoreUrl": "https://play.google.com/store/apps/details?id=com.mojang.minecraftpe&hl=en&gl=us",
    "source": "app",
    "country": "us",
    "language": "en"
}
```

A search row carries the same fields plus `"source": "search"`, `"searchTerm": "vpn"` and `"searchRank": 1`; a chart row adds `"chart": "topFree"`, `"chartCategory": "GAME"` and `"chartPosition": 1`. A package that does not exist (or is not sold in that country) gives a free row like this, and the run still succeeds:

```json
{
    "url": "https://play.google.com/store/apps/details?id=com.nonexistent.bogus.app12345&hl=en&gl=us",
    "status": "not_found",
    "error": "HTTP 404: page does not exist",
    "scrapedAt": "2026-09-27T22:22:09.173Z"
}
```

A review row (reviews mode), from the same kind of run:

```json
{
    "url": "https://play.google.com/store/apps/details?id=com.calm.android&hl=en&gl=us&reviewId=3eccde29-f187-46c7-9375-8d6a8db42948",
    "status": "ok",
    "appId": "com.calm.android",
    "title": "Calm - Sleep, Meditate, Relax",
    "developer": "Calm.com, Inc.",
    "source": "review",
    "reviewId": "3eccde29-f187-46c7-9375-8d6a8db42948",
    "reviewRating": 1,
    "reviewText": "I do not want your services. stop advertising to me.",
    "reviewDate": "2026-10-17T22:25:35Z",
    "thumbsUp": 0,
    "appVersion": "5.20",
    "hasReply": true,
    "replyText": "We’re sorry the ads have been frustrating. We understand you’d prefer not to receive them, and we appreciate you sharing your feedback with us.",
    "replyDate": "2026-10-19T07:19:24Z",
    "country": "us",
    "language": "en",
    "scrapedAt": "2026-10-19T11:08:35.831Z"
}
```

### Tips

- Put all your apps, keywords and countries in **one run**: you pay the start fee once.
- For keyword rank tracking, schedule a daily run with your keywords and read `searchRank` for your `appId`.
- Raise **Maximum results** when you ask for full charts, several keywords or many reviews: it caps the whole run (default 20).
- For review monitoring, schedule a daily run with **Sort reviews by** = Newest and **Reviews since** = `2 days`: the Actor stops reading each app at the first older review, so you pay only for new reviews (dedupe on `reviewId`).
- Google Play shows reviews in the run's **Language** first; set `language` to `de` for German reviews from `de`.
- Country names work (`Germany`, `Japan`), and so do the codes (`de`, `jp`). The language changes the texts; prices and charts follow the country.

### Limitations

- **No reviewer identity, no developer contact details.** Review rows never include the reviewer's name, profile picture or account id, and app rows never include the support e-mail, phone or postal address Google Play lists, because individual developers publish their own personal details there.
- Reviews appear on Google Play with a delay of up to a day, so the newest review can be several hours old.
- Google Play's search page shows 30 apps per keyword, so `searchRank` goes up to 30. Charts go up to 200 apps.
- App size is not available: Google Play no longer shows it on its website.
- A developer name must match what Google Play shows (or be its beginning, such as `Rovio`); for an exact list use the numeric developer ID from the developer's Google Play link.
- Values come from Google Play at the time of the run. Google changes its page data now and then; when it does, rows come back as `error` (never as silently wrong data) and the Actor is updated quickly; report it in the **Issues** tab.

### FAQ

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

No. The Actor reads Google Play's public store pages, which need no key and no login.

#### Can it scrape Google Play reviews?

Yes. Put the apps in **Reviews: apps to read reviews for**: each review becomes one row with the star rating, text, date, thumbs-up count, app version and the developer's reply, sorted newest, most relevant or by rating, filtered by stars and date, up to 10,000 per app and country, at $0.30 per 1,000 reviews. Reviewer names, profile pictures and account ids are never collected. App rows also carry `rating`, `ratingCount`, `reviewCount` and the 1-5 star `ratingHistogram`.

#### How do I track my app's keyword ranking (ASO)?

Add your keywords under **Search keywords**, set your countries, and schedule the run daily. Filter the rows by your `appId` and chart `searchRank` over time. `searchRank` is the position in Google Play's search results for that keyword (1 = first).

#### How do I get the top grossing games in Japan?

Set **Top charts** to Top grossing, **Chart category** to All games, **Countries** to `jp`, **Results per search, developer or chart** to 100 and **Maximum results** to 100. Add **Language** `ja` for Japanese titles and descriptions.

#### Why is an app `not_found`?

The package does not exist, or the app is not offered in that country's Google Play store (many apps are region-locked). The row names the country's page that was checked. `not_found` rows are free.

#### What is the difference between `installs`, `minInstalls` and `realInstalls`?

`installs` is the bracket Google Play displays (`50,000,000+`), `minInstalls` is its lower bound as a number, and `realInstalls` is Google Play's own approximate install count behind the bracket.

#### Can I use this Actor from an AI agent or MCP client?

Yes. Called with no arguments it returns five well-known apps; every input is a plain string or list, and every row explains itself with `status` and `error`.

### Related Actors

- [App Store Scraper](https://apify.com/glasswing/app-store-scraper) - use it to compare the same app's iOS listing, ranking and reviews.
- [Steam Store Scraper](https://apify.com/glasswing/steam-store-scraper) - use it when the app in question is also, or instead, a PC game on Steam.
- [Shopify Scraper](https://apify.com/glasswing/shopify-products-scraper) - use it if the app has a companion online store you also need to track.

### Legal and data-protection notice

This Actor reads only data that Google publishes publicly on its Google Play store pages: app listings, the names of the companies and people who publish them, and the public text of app reviews with the developer's replies. It does not extract reviewer names, profile pictures or account ids, e-mail addresses, phone numbers, postal addresses or other contact data, and it does not log in or get around any access control. Some developers publish apps under their own name, so a `developer` value can be a person's name; it is the public publisher name shown on Google Play. Review text is written by the public and can itself mention people; treat it accordingly. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. You are responsible for complying with Google's terms and applicable law when using the extracted data.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google LLC. Google Play is a trademark of Google LLC. All trademarks belong to their respective owners.

# Changelog

This Actor's version history is a separate document: https://apify.com/glasswing/google-play-scraper/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

One per line. Accepted: package names (com.whatsapp), Play Store app links (https://play.google.com/store/apps/details?id=com.whatsapp), market:// links, developer links (https://play.google.com/store/apps/developer?id=Google+LLC or /store/apps/dev?id=5700313618786177705, which list that developer's apps) and search links (https://play.google.com/store/search?q=pdf+scanner\&c=apps). A link with `gl=` is fetched in that country, unless you list countries under Countries: then every app is fetched in each listed country. A package that does not exist, or is not sold in that country, gives one free `not_found` row. Leave the built-in example here when you use search, developers or charts: it is skipped automatically.

## `searchTerms` (type: `array`):

Keywords to search Google Play for, one per line: `budget planner`, `photo editor`, `meditation`. Each keyword returns up to 30 apps (Google Play's first result page) in Google's own order; `searchRank` is the position (1 = first result), which makes this a Play Store keyword-ranking (ASO) check. A keyword with no match gives one free `not_found` row.

## `developerIds` (type: `array`):

Developers whose apps you want, one per line: the developer name exactly as Google Play shows it (Google LLC, Rovio Entertainment Corporation), a numeric developer ID (5700313618786177705) or a developer link. Returns all of the developer's apps in that country, up to `Results per search, developer or chart`. An unknown developer gives one free `not_found` row.

## `charts` (type: `array`):

Google Play's top charts to read per country: top free, top paid and top grossing. Each chart returns up to 200 apps with `chartPosition` 1, 2, 3... and the full app data.

## `chartCategory` (type: `string`):

Which category the charts cover: all apps (default), all games, or one category such as Games - Puzzle or Health & Fitness.

## `reviewApps` (type: `array`):

Apps whose reviews you want, one per line: package names (com.whatsapp) or Google Play app links. Reviews are read in every country listed under Countries and in the chosen Language (Google Play shows the reviews written in that language first). An app with no reviews for your filter gives one free `not_found` row. Leave the built-in example under Apps when you only want reviews: it is skipped automatically.

## `reviewsPerApp` (type: `integer`):

How many reviews to read per app and country, up to 10,000. The run total is still limited by Maximum results, so raise that too (for example 3 apps x 500 reviews = Maximum results 1500).

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

Newest first (default; best for monitoring), most relevant (Google Play's default order) or rating.

## `reviewRating` (type: `string`):

Keep only 1-star, 2-star ... 5-star reviews. Leave empty for every rating.

## `reviewsSince` (type: `string`):

Skip reviews older than this date: `2026-01-31`, or relative such as `30 days`, `2 weeks`, `6 months`. With Newest sort the run stops reading an app as soon as it reaches older reviews, which makes scheduled monitoring runs cheap.

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

Google Play countries as two-letter codes, one per line: `us`, `gb`, `de`, `jp`, `br` (country names such as Germany also work). Prices, currency, ratings, availability, search results and charts differ by country. Every app, keyword, developer and chart is fetched once per country.

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

Language of the texts (title, summary, description, category names, install counts), as a code: `en`, `de`, `es`, `fr`, `ja`, `pt-BR`, `zh-TW`. Dates, prices and counts stay machine-readable in every language.

## `resultsPerSource` (type: `integer`):

How many apps to keep from each keyword, developer and chart, best-ranked first. Google Play's caps: 30 per keyword (its first result page), 200 per chart, all of a developer's apps. The total is still limited by Maximum results.

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

Stop after this many rows have been saved in total. Each row with status `ok` is one billable result; `not_found` and `error` rows are never charged. Raise it for full charts or several keywords.

## `maxResults` (type: `integer`):

Same as Maximum results; accepted for API callers that use this name.

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

Optional. Google Play's public store pages answer Apify's datacenter IPs directly, so no proxy is needed. If a very large run meets rate-limit errors, enable Apify Proxy (datacenter). Residential proxies are not needed.

## Actor input object example

```json
{
  "startUrls": [
    "com.whatsapp",
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.duolingo",
    "com.mojang.minecraftpe",
    "org.telegram.messenger"
  ],
  "reviewsPerApp": 100,
  "reviewSort": "newest",
  "countries": [
    "us"
  ],
  "language": "en",
  "resultsPerSource": 50,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `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 = {
    "startUrls": [
        "com.whatsapp",
        "com.spotify.music",
        "https://play.google.com/store/apps/details?id=com.duolingo",
        "com.mojang.minecraftpe",
        "org.telegram.messenger"
    ],
    "countries": [
        "us"
    ],
    "language": "en",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/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 = {
    "startUrls": [
        "com.whatsapp",
        "com.spotify.music",
        "https://play.google.com/store/apps/details?id=com.duolingo",
        "com.mojang.minecraftpe",
        "org.telegram.messenger",
    ],
    "countries": ["us"],
    "language": "en",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/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 '{
  "startUrls": [
    "com.whatsapp",
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.duolingo",
    "com.mojang.minecraftpe",
    "org.telegram.messenger"
  ],
  "countries": [
    "us"
  ],
  "language": "en",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/google-play-scraper --silent --output-dataset

```

## MCP server setup

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