# Google Play Scraper — Play Store API & App Data | $0.50/1k (`glasswing/google-play-scraper`) Actor

Google Play Store app data without an API key: look up apps by package name or URL, search keywords with rank, list a developer's apps, read top free, paid and grossing charts in any country. Rating, installs, price, version, update date, category, screenshots. JSON, CSV, Excel.

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

## Pricing

from $0.50 / 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.

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 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.

Four 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.

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.
- **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 reads app data only. It does **not** collect user reviews, reviewer names or developer e-mail addresses, phone numbers or postal addresses.

### Why use Google Play Scraper?

- **Cheap.** $0.50 per 1,000 apps, 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.

#### 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, or a keyword or chart has no apps. `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 four inputs: **Apps** (package names or links), **Search keywords**, **Developers**, **Top charts** (plus **Chart category**).
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` |

### 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` row) | $0.0005 per app |

Examples: the default run (5 apps) costs $0.0075. 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) |
| `maxItems` | integer | `20` | Stop after this many rows in total |

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

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"
}
```

### 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 or several keywords: it caps the whole run (default 20).
- 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 user reviews, no developer contact details.** The Actor returns app data only: never reviews or reviewer names, and not the support e-mail, phone or postal address Google Play lists, because individual developers publish their own personal details there.
- 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?

No, on purpose: this Actor collects app data only, never reviews or reviewer names. It does return each app's `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`.

### Legal and data-protection notice

This Actor reads only data that Google publishes publicly on its Google Play store pages: app listings and the names of the companies and people who publish them. It does not extract reviews, reviewer names, 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. 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.

## `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"
  ],
  "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/aeYDJQjNJVBoACvov/openapi.json