# Google Play Store Scraper \[FAST] | Apps & Charts (`apizy/google-play-store-scraper`) Actor

Find Google Play apps by keyword, browse Top Free, Paid, or Grossing charts, or fetch details by package ID. Get installs, ratings, screenshots, prices, and publisher contacts via JSON API or Dataset. Pay per delivered app: $0.003/listing or $0.006/detail. Failed results have no result event.

- **URL**: https://apify.com/apizy/google-play-store-scraper.md
- **Developed by:** [Apizy](https://apify.com/apizy) (community)
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Store Scraper

Find Android apps by keyword, browse Google Play Top Charts, or get complete app details from package IDs and Play Store URLs. Collect titles, icons, screenshots, descriptions, ratings, public install badges, prices, and publisher information as clean Dataset rows. Search multiple keywords or look up up to 100 apps in one run. No browser or Google account is required; HTTP API calls use an Apify token.

Use the results to research competitors, explore a category, compare pricing, discover publishers, and plan what to build next. **Pay per app delivered:** $0.003 for a quick listing or $0.006 for full details. Failed apps have no result charge; Actor Start and Apify platform usage are separate.

### What does Google Play Store Scraper do?

The Actor has three modes:

| Mode | What you provide | What you get |
| --- | --- | --- |
| **Search** | One keyword or up to 20 keywords | Ranked search results, with every matching keyword and rank retained |
| **Charts** | Top Free, Top Paid, or Top Grossing plus a category | Ranked apps for a selected country and category, including RPG, Productivity, or Finance |
| **Details** | One app or up to 100 package IDs/Play Store URLs | Full public details for each available app |

Search and Charts return quick listings by default. Turn on **Fetch full app details** to add descriptions, screenshots, install badges, ratings breakdowns, and publisher fields. Details mode always returns full details. Each unique app appears **once per run** in the Dataset, even if it matches several keywords. Its `contexts` field preserves every keyword and rank.

#### What can you use it for?

- **Research competitors:** Find apps in your niche and compare their positioning, ratings, prices, and publishers.
- **Explore market leaders:** Capture Top Free, Top Paid, or Top Grossing apps in a country and category.
- **Improve ASO:** See which apps appear for a keyword and study their titles, summaries, descriptions, and visuals.
- **Find an app idea:** Map crowded categories and look for underserved angles before building an MVP.
- **Compare monetization:** Identify paid apps and public in-app purchase indicators. Use the selected country when comparing prices.
- **Plan features:** Review competing apps' descriptions and screenshots, then pair this Actor with [Google Play Reviews Scraper](https://apify.com/apizy/google-play-reviews-scraper) to learn what users actually request.
- **Support AI-assisted development:** Give a coding assistant structured competitor data to draft a feature brief or product comparison grounded in real listings.
- **Monitor a portfolio:** Send app data to a spreadsheet, dashboard, Make, n8n, Zapier, or your own pipeline.

### How to use

1. Select **Search**, **Charts**, or **App details** in the input form.
2. Enter keywords, choose a chart and category, or provide app package IDs/URLs for the selected mode.
3. Choose the store country and language if needed. For Search or Charts, enable **Fetch full app details** when you need the complete app page.
4. Click **Run**. Open the **Dataset** for app rows and **Output** for counts, errors, and the stop reason.

Only fields for the selected mode are used. For example, an `app` value is ignored in Search mode. The form offers dropdowns for Chart and Category; you do not need to memorize category codes.

#### Which inputs should you use?

Choose one goal below. Leave fields for the other modes empty. `language: "en"` and `country: "us"` are already the defaults, so you can leave them unchanged for the US storefront.

| Goal | Mode | Fields to fill | Result event |
| --- | --- | --- | --- |
| Find apps for one phrase, with ranking | Search | `keyword: "budget tracker"`, `maxResults: 20`; leave `fullDetail` off | Listing: $0.003 per saved app |
| Compare several keywords with installs, screenshots, and publisher data | Search | `keywords: ["budget tracker", "expense tracker"]`, `maxResults: 20`, `fullDetail: true` | Detail: $0.006 per saved app |
| Get a quick Top Free chart | Charts | `chart: "top-free"`, `category: "APPLICATION"`, `maxResults: 20`; leave `fullDetail` off | Listing: $0.003 per saved app |
| Study Top Paid Productivity apps in depth | Charts | `chart: "top-paid"`, `category: "PRODUCTIVITY"`, `maxResults: 20`, `fullDetail: true` | Detail: $0.006 per saved app |
| Inspect one known app | Details | `app: "com.spotify.music"` | Detail: $0.006 per saved app |
| Compare several known apps | Details | `apps: ["com.spotify.music", "com.mojang.minecraftpe"]` | Detail: $0.006 per saved app |

In **Details** mode, full details are automatic; `fullDetail` and `maxResults` do not apply. In **Search** mode, use either `keyword` or `keywords`; in **Details** mode, use either `app` or `apps`. Search and Charts with `fullDetail: false` give quick rankings, but fields such as install badges and screenshots need `fullDetail: true`. The prices above are result events; Actor Start and platform usage are separate for batch runs.

### HTTP API (Standby)

Call the Actor as an HTTP service when you need a JSON response directly. The existing **Run** form remains available for batch jobs and saves rows to the Dataset. Standby requests return `items` in the response body and do not create Dataset rows.

| Endpoint | Example | Result |
| --- | --- | --- |
| Search | `GET /search?keyword=budget%20tracker&limit=10` | Up to 10 ranked listings |
| Charts | `GET /charts?chart=top-free&category=PRODUCTIVITY&limit=50` | Ranked category chart |
| Details | `GET /details?appId=com.spotify.music` | One full-detail app |

Add `fullDetail=true` to Search or Charts for full details. `limit` accepts 1–250 listings or 1–100 full details. `language` and `country` default to `en` and `us`. A limit is a ceiling: Google Play may return fewer apps. A successful response reports `count`, `durationMs`, `stopReason`, and `items`. Invalid query parameters return HTTP 400.

Use your Apify token in an `Authorization: Bearer` header. Standby charges one Listing event ($0.003) or Detail event ($0.006) for each app delivered in the response. Empty results have no result event; platform usage still applies. The HTTP service accepts one keyword or one package ID per request; use a batch run for multiple keywords or package IDs.

### Input examples

#### Find competitors with two keywords

```json
{
  "mode": "search",
  "keywords": ["budget tracker", "expense tracker"],
  "maxResults": 20,
  "fullDetail": false,
  "language": "en",
  "country": "us"
}
```

This requests up to **20 results per keyword**, not 20 for the whole run. If an app appears for both keywords, it is saved once with both matches in `contexts`. Set `fullDetail` to `true` to enrich each unique app.

#### Explore Top Free RPG games

```json
{
  "mode": "charts",
  "chart": "top-free",
  "category": "GAME_ROLE_PLAYING",
  "maxResults": 20,
  "fullDetail": true,
  "language": "en",
  "country": "us"
}
```

Combine a chart with a category: `top-paid` + `PRODUCTIVITY` means Top Paid Productivity apps. Choose `APPLICATION` for all apps or `GAME` for all games. A chart may contain fewer results than requested, and some chart/category combinations may be empty.

#### Get details for several apps

```json
{
  "mode": "details",
  "apps": [
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.mojang.minecraftpe"
  ],
  "language": "en",
  "country": "us"
}
```

Use `app` for one entry or `apps` for 1–100 entries; do not supply both. Duplicate IDs and URLs for the same app are processed once. If one app is unavailable, the Actor keeps successful results and reports the error in `OUTPUT.summary.errors`.

#### Input fields

| Field | Mode | Default | Description |
| --- | --- | --- | --- |
| `mode` | All | `search` | `search`, `charts`, or `details` |
| `keyword` / `keywords` | Search | None | One phrase or 1–20 phrases; use either field |
| `chart` | Charts | `top-free` | `top-free`, `top-paid`, or `top-grossing` |
| `category` | Charts | `APPLICATION` | Choose from 49 current app/game categories, or All apps/All games |
| `app` / `apps` | Details | None | One or 1–100 package IDs/Play Store URLs; use either field |
| `maxResults` | Search, Charts | `100` | Upper limit of 1–250 results **per keyword or chart** |
| `fullDetail` | Search, Charts | `false` | Fetch complete details for each found app; Details mode is always complete |
| `language` | All | `en` | Google Play language, such as `en`, `es`, or `pt-BR`; no translation |
| `country` | All | `us` | Two-letter storefront country, such as `us` or `gb` |

### Output

In a batch run, each unique app is saved as **one item in the default Dataset**. Standby requests return app rows directly in the HTTP response. The default Key-Value Store contains `OUTPUT` with the run summary; it does not contain the app rows.

**Example Dataset item** (shortened, illustrative listing):

```json
{
  "source": "search",
  "detailLevel": "listing",
  "appId": "com.example.budget",
  "appUrl": "https://play.google.com/store/apps/details?id=com.example.budget",
  "title": "Budget Planner",
  "developer": "Example Studio",
  "score": 4.5,
  "price": 0,
  "currency": "USD",
  "keyword": "budget tracker",
  "rank": 1,
  "contexts": [
    { "source": "search", "keyword": "budget tracker", "rank": 1 },
    { "source": "search", "keyword": "expense tracker", "rank": 2 }
  ],
  "language": "en",
  "country": "us",
  "scrapedAt": "2026-10-16T06:00:00.000Z"
}
```

A full-detail row uses `"detailLevel": "detail"` and can also contain `description`, `headerImage`, `screenshots`, `histogram`, `installs`, `version`, and publisher contact fields. Fields that Google Play does not provide are `null`.

| Field group | Dataset fields | Notes |
| --- | --- | --- |
| Identity and ranking | `source`, `detailLevel`, `appId`, `appUrl`, `keyword`, `chart`, `category`, `rank`, `contexts` | `contexts` keeps all keyword or chart matches for that app |
| Listing | `title`, `summary`, `developer`, `icon`, `score`, `free`, `price`, `currency` | Available when Google Play provides them |
| Description and media | `description`, `headerImage`, `screenshots`, `video` | Full details only; some media may be absent |
| Ratings and installs | `ratings`, `reviews`, `histogram`, `installs`, `minInstalls`, `maxInstalls` | Installs are based on a public threshold badge, not an exact download count |
| Pricing and category | `priceText`, `offersIAP`, `IAPRange`, `genre`, `categories` | Prices vary by storefront country; IAP fields may be absent |
| Publisher and updates | `developerId`, `developerEmail`, `developerWebsite`, `developerAddress`, `privacyPolicy`, `version`, `updated`, `released` | Contact and update fields are optional |
| Capture context | `language`, `country`, `scrapedAt` | Requested locale and capture time |

**Example `OUTPUT` summary** (shortened):

```json
{
  "summary": {
    "input": { "mode": "search", "keywords": ["budget tracker"], "maxResults": 2, "fullDetail": false, "language": "en", "country": "us" },
    "requestedCount": 2,
    "foundCount": 2,
    "discoveredCount": 2,
    "successCount": 2,
    "failedCount": 0,
    "skippedCount": 0,
    "chargedCount": 2,
    "resultEvent": "app-listing-scraped",
    "stopReason": "completed",
    "errors": [],
    "totalDurationSeconds": 1
  }
}
```

`requestedCount` is the input ceiling, not a guaranteed result count. `successCount` counts saved app rows; `chargedCount` counts result events for those rows. `stopReason` can be `completed`, `no_results`, `partial_failure`, `all_failed`, or `spending_limit`. If every app fails, the run is marked failed but still writes `OUTPUT`.

### Pricing

Pay **$0.003 per delivered listing** or **$0.006 per delivered full detail**. Each app gets only one result event: Listing or Detail. Failed, unavailable, empty, and skipped apps have **no result charge**. If you request 100 apps but only 10 are saved, result charges apply to those 10 rows.

| Delivered results | Listing charges | Full-detail charges |
| ---: | ---: | ---: |
| 10 apps | $0.03 | $0.06 |
| 100 apps | $0.30 | $0.60 |
| 1,000 apps | $3.00 | $6.00 |

Apify also charges an **Actor Start event at $0.00005** and platform usage. The Start event applies even if no app is delivered; at more than 1 GB of allocated memory, Apify may charge it more than once. The table shows result charges only. Check the [Pricing tab](https://apify.com/apizy/google-play-store-scraper/pricing) for the complete current price before running the Actor.

### Notes

- Data comes from public Google Play pages. Google may change rankings, fields, availability, and the number of results returned.
- Search can return loosely related apps for narrow phrases. Charts are snapshots for the selected country and time, not permanent rankings.
- `installs` is a public threshold such as `1,000,000+`. `minInstalls` and `maxInstalls` are derived from that label; **none is an exact download count**. The Actor does not estimate app revenue.
- Language and country affect titles, descriptions, availability, and prices. `language` requests localized store content; it does not translate it.
- Full details require an additional request per app and can take longer than quick listings. One unavailable app does not prevent the others from being saved.
- The Actor respects the run's maximum charge. When that limit is reached, it stops and records `spending_limit` and `skippedCount` in `OUTPUT`.

### More Actors You Might Like

Built by the same Apizy team and backed by our transparent pricing philosophy: you know which results are delivered, repeated apps are charged once per run, and failed or empty apps have no result charge.

| Actor | What it helps you collect |
| --- | --- |
| [Google Play Reviews Scraper](https://apify.com/apizy/google-play-reviews-scraper) | Ratings, written reviews, dates, and developer replies |
| [YouTube Channel Scraper V2](https://apify.com/apizy/youtube-channel-scraper-v2) | Subscribers, engagement, email, and social links from channels |
| [YouTube Video Scraper](https://apify.com/apizy/youtube-video-scraper) | Video titles, views, durations, thumbnails, and publish dates |
| [YouTube Comment Scraper](https://apify.com/apizy/youtube-comment-scraper) | Comments, authors, likes, and replies |

### Get in Touch

Have a question or need a custom scraping workflow? Email **apizy.studio@gmail.com**.

# Actor input Schema

## `mode` (type: `string`):

Choose Search, Top Charts, or Details by app ID/URL.

## `keyword` (type: `string`):

One keyword or phrase. Use this or Keywords in Search mode.

## `keywords` (type: `array`):

Up to 20 keywords or phrases. Duplicate apps are saved once, with all keyword/rank contexts retained.

## `chart` (type: `string`):

Choose Top Free, Top Paid, or Top Grossing. Combine with Category to browse a niche, such as Top Free RPG games. Some combinations may return no apps.

## `category` (type: `string`):

Choose one of 49 current Google Play app/game categories, or All apps/All games. For RPG charts, choose Games: Role Playing (RPG). Some chart/category combinations may return no apps.

## `app` (type: `string`):

One Android package ID or Google Play app URL. Use this or Apps in Details mode.

## `apps` (type: `array`):

Up to 100 package IDs or Google Play URLs. Invalid apps are reported individually.

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

Upper limit for each Search keyword or Chart. Google Play may provide fewer apps.

## `fullDetail` (type: `boolean`):

Enrich every found app with description, images, ratings, install badge, price, and publisher fields. Details mode always fetches full details.

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

Google Play language code, such as en, id, or pt-BR. Content is not translated by the Actor.

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

Two-letter Google Play country code, such as us or id. Charts and prices depend on country.

## Actor input object example

```json
{
  "mode": "search",
  "keyword": "weather",
  "chart": "top-free",
  "category": "APPLICATION",
  "maxResults": 5,
  "fullDetail": false,
  "language": "en",
  "country": "us"
}
```

# Actor output Schema

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

One Dataset item per unique app, including source and ranking contexts.

## `output` (type: `string`):

Effective input, counts, errors, stop reason, and duration.

# 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 = {
    "keyword": "weather",
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("apizy/google-play-store-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 = {
    "keyword": "weather",
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("apizy/google-play-store-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 '{
  "keyword": "weather",
  "maxResults": 5
}' |
apify call apizy/google-play-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apizy/google-play-store-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/EPuuePLyuLWKVPMjI/builds/44RlaGThvFlfphOnB/openapi.json