# Google Play Store Scraper — App Search, Reviews & ASO Charts (`sian.agency/play-store-apps-scraper`) Actor

Scrape Google Play Store app data, reviews and ASO competitive charts in one run. App search, full app details, reviews, category list and all 6 top-charts — top free, paid and grossing apps & games, category-filterable. Clean structured JSON, pay per result.

- **URL**: https://apify.com/sian.agency/play-store-apps-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Business, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.29 / 1,000 app 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Play Store Scraper — Apps, Reviews & ASO Charts 📱

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-Instagram AI Transcript](https://img.shields.io/badge/Store-Instagram%20AI%20Transcript-E4405F)](https://apify.com/sian.agency/instagram-ai-transcript-extractor?fpr=sian) [![Store-Douyin Scraper](https://img.shields.io/badge/Store-Douyin%20Scraper-000000)](https://apify.com/sian.agency/douyin-scraper?fpr=sian) [![Store-Xiaohongshu Scraper](https://img.shields.io/badge/Store-Xiaohongshu%20Scraper-FF2442)](https://apify.com/sian.agency/xiaohongshu-rednote-scraper?fpr=sian)

#### 🎉 The whole Google Play ASO toolkit in one run — app search, full app details, reviews, the category list, and all six top-charts, no API key required
##### Built for ASO managers, app marketers, market analysts, app-intelligence platforms, and indie developers who need clean, structured Google Play data on a schedule

### 📋 Overview

**One actor, the entire Play Store.** Most Google Play tools on the Store do one thing — reviews *or* a single app lookup. This actor bundles **5 operations** behind a single dropdown: keyword **App Search**, deep **App Details**, paginated **App Reviews**, the full **Categories** list, and — the part nobody else ships — all six **Top Charts** (top free, paid and grossing apps *and* games), filterable by category. Pick one operation per run, get one tidy dataset out. No API key, no developer registration, no proxy setup.

Where the rest of the market stops at reviews, this actor turns Google Play into a full **app-store-optimization (ASO) and app-market-intelligence** surface: see who ranks where, track chart movement, map a niche by keyword, and mine reviews for sentiment — all from the same clean JSON shape.

**Why ASO and app-intelligence teams choose us:**
- ✅ **Every Play Store surface in one run**: search, details, reviews, categories **and all 6 top-charts** — no stitching several actors together
- 📊 **The charts nobody else returns**: top free / paid / grossing **apps and games**, category-filterable — a true competitive-ranking feed for ASO, not just reviews
- ⚡ **5 operations in one actor**: App Search · Top Charts · App Details · App Reviews · Categories, picked from one dropdown
- 💰 **Pay only for successful rows**: failed lookups land as `status:"error"` rows at **$0** — you're never billed for a hiccup
- 🧱 **Clean, deduped JSON**: one flat camelCase row per app, review or category — no raw nested mess, no snake_case duplicates
- ✨ **No API key, zero setup**: no Google Play developer account, no scraping infrastructure — paste an input and run

### ✨ Features

- 🔍 **App Search**: free-form keyword search across Google Play, cursor-paginated (~20 apps/page), region- and language-aware
- 📊 **Top Charts**: pull any of the six Google Play charts — `top-free-apps`, `top-paid-apps`, `top-grossing-apps`, `top-free-games`, `top-paid-games`, `top-grossing-games` — optionally scoped to a single category
- 📱 **App Details**: full single-app enrichment — downloads, ratings, pricing, content rating, developer, version history, "what's new", data-safety disclosures and Android requirements, by App ID
- ⭐ **App Reviews**: paginated reviews with `reviewText`, `reviewRating`, author, app version, likes and developer replies — sort by relevance, newest or rating, filter by star
- 🗂️ **Categories**: the full Google Play category list (`categoryId` + `categoryName`) to drive chart filters and keyword research
- 🌍 **Any region**: query any market with a simple ISO country code (`us`, `gb`, `de`, `in`, `br`, …) plus an optional language code
- 🏆 **Chart Rankings**: every chart row carries `chartRank` and `chartLabel` so you can track position over time
- 📈 **Rich App Metadata**: `numDownloads`, `numRatings`, `numReviews`, `reviewsPerRating`, `containsAds`, `currentVersion`, `appFirstReleasedAt` and more on every app row
- 🔗 **Direct Play Store URLs**: `appPageUrl`, `appIcon`, `privacyPolicyLink` and developer contact fields ready for branded feeds
- 📊 **Single Clean Dataset Shape**: one flat row per item, filterable by `_operation` and `status` — the same export pipeline works across all five operations

### 🎬 Quick Start

So simple, no training needed! Pick an operation, fill the matching input, click Run.

```bash
## Or use the API — one line
curl -X POST https://api.apify.com/v2/acts/sian.agency~play-store-apps-scraper/runs?token=YOUR_TOKEN \
-d '{"operation":"topCharts","chartType":"top-free-games","category":"GAME_PUZZLE"}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick an Operation

Choose one of five operations from the dropdown: **App Search**, **Top Charts**, **App Details**, **App Reviews**, or **Categories**. One run = one operation.

#### Step 2: Fill the Matching Input

- **App Search** → a `query` (e.g. `fitness tracker`)
- **Top Charts** → a `chartType` (e.g. `top-grossing-apps`), optionally a `category`
- **App Details** → an `appId` (e.g. `com.spotify.music`)
- **App Reviews** → an `appId`, optionally `sortBy` / `rating`
- **Categories** → no extra input — just run it

Optionally set `country`, `language`, `limit`, and `maxPages`.

#### Step 3: Click Run

One click and we fetch, flatten, normalize, and push clean rows to your dataset. An HTML run report lands in the key-value store. Export to JSON, CSV, or Excel from the Apify console — or pull via API.

**That's it! In seconds, you'll have:**

- Clean flat rows from any of five operations — same shape, ready to export
- Competitive chart rankings across apps and games, category-filterable
- Full app metadata, ratings, downloads and version history
- App reviews with text, stars, author and developer replies
- Error rows for failed inputs — never billed

### 📥 Input Configuration

One operation per run. Each operation has its own required field (validated before charging). The remaining filters apply where relevant.

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| operation | enum | Yes | One of: `search`, `topCharts`, `appDetails`, `appReviews`, `categories` |
| query | string | search | Free-form keyword search (e.g. `fitness tracker`) |
| chartType | enum | topCharts | One of the six charts (e.g. `top-free-apps`, `top-grossing-games`) |
| category | string | No | Google Play category ID to scope a chart (e.g. `GAME_PUZZLE`) |
| appId | string | appDetails / appReviews | Play package name (e.g. `com.spotify.music`) |
| sortBy | enum | No | App Reviews order: `MOST_RELEVANT`, `NEWEST`, `RATING` |
| rating | enum | No | App Reviews star filter: `1`–`5` (blank = all) |
| country | string | No | ISO country / region code (default `us`) |
| language | string | No | ISO language code (e.g. `en`, `es`, `de`) |
| limit | integer | No | Rows per request (search / charts / reviews; up to 50 for reviews & charts) |
| maxPages | integer | No | Max pages for App Search & App Reviews (1–20, default 3) |

> **Note:** App Details and App Reviews are premium operations and require a paid plan. On the free tier they return a single notice row and make **no** upstream call (you are not charged). App Search, Top Charts and Categories run on every tier.

### 📤 Output

Every run produces one flat dataset (one row per app, review or category) plus an HTML report in the key-value store. All rows share a common envelope (`_operation`, `_page`, `_fetchedAt`, `status`) so you can mix and filter freely.

#### App row (Search · Top Charts · App Details)

```json
{
  "appId": "com.spotify.music",
  "appName": "Spotify: Music and Podcasts",
  "appCategory": "Music & Audio",
  "appCategoryId": "MUSIC_AND_AUDIO",
  "appDeveloper": "Spotify AB",
  "numDownloads": "1,000,000,000+",
  "rating": 4.3,
  "numRatings": 31250194,
  "numReviews": 1042113,
  "price": 0,
  "isPaid": false,
  "containsAds": false,
  "chartRank": 1,
  "chartLabel": "top free music",
  "currentVersion": "9.1.40.1486",
  "appPageUrl": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "appIcon": "https://play-lh.googleusercontent.com/...",
  "_operation": "topCharts",
  "status": "success"
}
```

#### Review row (App Reviews)

```json
{
  "reviewId": "7e1815f2-36d1-4187-a936-12f969747892",
  "reviewText": "The paid version is excellent but very expensive.",
  "reviewRating": 5,
  "authorName": "Catherine Hempel",
  "authorAppVersion": "9.1.40.1486",
  "reviewDatetimeUtc": "2026-04-21T16:15:57.000Z",
  "reviewLikes": 17,
  "developerReply": null,
  "appId": "com.spotify.music",
  "_operation": "appReviews",
  "status": "success"
}
```

#### Category row (Categories)

```json
{ "categoryId": "GAME_PUZZLE", "categoryName": "Puzzle", "_operation": "categories", "status": "success" }
```

The dataset ships with two views: **Overview** (every field) and **Additional** (a curated key-column subset for quick scanning).

### 💼 Use Cases & Examples

#### 1. ASO Competitive Intelligence — Who Ranks Where

Pull all six top-charts, filtered by category, to map exactly which apps and games dominate each ranking. Schedule daily runs to track chart movement and spot rising competitors before they break out. `chartRank` + `chartLabel` give you a clean time-series.

#### 2. App Market Research & Discovery

Search Google Play by keyword to map every app in a niche, then enrich each with App Details — downloads, ratings, pricing, content rating, developer and version history. Build an app-market dataset without scraping the store page-by-page.

#### 3. Review Mining & Sentiment Analysis

Extract reviews at scale — text, star rating, author, app version, likes and developer replies — for sentiment analysis, feature-request mining, bug triage and competitor review monitoring. Feed structured rows straight into your NLP pipeline.

#### 4. Keyword & Category Research

Use the Categories list plus keyword search to understand how Google Play organises apps, which categories competitors target, and where ranking opportunities exist. Power your ASO keyword strategy and category-placement decisions.

#### 5. App Intelligence Product Feeds

Feed an app-analytics dashboard, market-intelligence platform or investor research tool with fresh, structured Play Store data — metadata, chart rankings, ratings and reviews — refreshed on a schedule without managing a browser scraper.

#### 6. Developer Benchmarking & Monitoring

Track your own app's rating, review trends, version cadence and chart position against direct rivals. Combine App Details + App Reviews + Top Charts for a single competitive dashboard.

### 🔌 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/play-store-apps-scraper').call({
    operation: 'search',
    query: 'photo editor',
    country: 'us',
    maxPages: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")

## Pull the top grossing games chart for the Puzzle category
run = client.actor("sian.agency/play-store-apps-scraper").call(run_input={
    "operation": "topCharts",
    "chartType": "top-grossing-games",
    "category": "GAME_PUZZLE",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["chartRank"], item["appName"], item["rating"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~play-store-apps-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"operation":"appReviews","appId":"com.spotify.music","sortBy":"NEWEST","maxPages":3}'
```

#### Automation Workflows (N8N / Zapier / Make)

Trigger the actor on a schedule, then route the dataset into Sheets, a database, or a BI tool. Filter by `_operation` and `status` so each downstream step handles exactly the rows it expects.

### 📈 Performance & Pricing

This actor uses **pay-per-event** pricing — you pay for successful result rows, not for time or compute. Error rows are free.

#### FREE Tier (Try It Now)

- Run **App Search**, **Top Charts** and **Categories** end-to-end
- App Details & App Reviews return an upgrade-notice row (no charge, no upstream call)
- Perfect for evaluating output shape and chart coverage before scaling

#### PAID Tier (Production Ready)

- Unlock **App Details** and **App Reviews** at scale
- Priced per result row, tiered down as volume grows
- The **Categories** operation is always free
- Failed lookups are always **$0**

### ❓ Frequently Asked Questions

**Do I need a Google Play API or developer account?**
No. Paste an input and run — no API key, no developer registration, no proxy setup.

**What is an App ID?**
The Google Play package name, e.g. `com.spotify.music`. It's the `appId` field on any search or chart row, and the `id=` value in a Play Store URL (`play.google.com/store/apps/details?id=...`).

**How do I find apps to run App Details or Reviews on?**
Run **App Search** or **Top Charts** first, collect the `appId` values, then loop through App Details / App Reviews.

**Which operations are free?**
App Search, Top Charts and Categories run on every tier. App Details and App Reviews require a paid plan (they return a free notice row otherwise).

**Can I filter a chart to one category?**
Yes — set `category` to a Google Play category ID (run **Categories** first to get the full list, e.g. `GAME_PUZZLE`, `PRODUCTIVITY`).

**How many results per run?**
App Search and App Reviews paginate up to `maxPages` (default 3, cap 20). Charts and Categories return their full list in one shot.

**Can I scrape other regions?**
Yes — set `country` to any ISO code (`gb`, `de`, `in`, `br`, …) and optionally `language`.

**Why does my run have `status:"error"` rows?**
A specific lookup failed (e.g. a removed app or a transient hiccup). Those rows are free and clearly flagged — filter them out by `status`.

### 🐛 Troubleshooting

**App Details / Reviews returns only a notice row**

- These are paid operations. On the free tier they return one `_rowType:"upgrade_required"` notice row and make no upstream call. Upgrade to a paid plan to unlock them.

**"App not found"**

- Confirm the `appId` is a valid package name from a recent search or chart row. Apps can be delisted — re-run the search to refresh IDs.

**Top Chart returns nothing for a category**

- Confirm the `category` is a valid ID from the **Categories** operation. Some category/chart combinations are sparse — try the chart without a category filter.

**Results are for the wrong region**

- Set `country` to the right ISO code (e.g. `gb` for the UK) and optionally `language`.

### 🧰 More by SIÁN Agency

- [Instagram AI Transcript Extractor](https://apify.com/sian.agency/instagram-ai-transcript-extractor?fpr=sian) — Reels & video transcripts
- [Douyin Scraper](https://apify.com/sian.agency/douyin-scraper?fpr=sian) — TikTok China API & video data
- [Xiaohongshu (RedNote) Scraper](https://apify.com/sian.agency/xiaohongshu-rednote-scraper?fpr=sian) — Notes, users & search
- [Browse all SIÁN actors →](https://apify.com/sian.agency?fpr=sian)

### ⚠️ Trademark Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Google LLC.** "Google Play", "Google Play Store", "Android" and related marks are trademarks of Google LLC and are used here only to describe the publicly available data this tool helps you collect. Use this actor responsibly and in compliance with applicable laws, Google Play's terms of service, and data-protection regulations (including GDPR and CCPA where applicable). You are responsible for how you use the data you extract.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data. They only collect information that developers and Google Play have chosen to make publicly available — app listings, ratings, public reviews and chart rankings. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that public reviews can contain personal data (such as reviewer names). 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're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or feature requests, open an issue in the actor's repository or use the **Issues** tab on the actor page
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>
- ⭐ If this saves you time, a 5-star review helps us ship more features.

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🔍 App Search** — search Google Play by keyword, paginated (~20 apps/page)
- **📊 Top Charts** — pull a Google Play top-chart (free / paid / grossing × apps / games), category-filterable
- **📱 App Details** — full details for one app by its App ID (paid plan)
- **⭐ App Reviews** — reviews for one app, paginated (paid plan)
- **🗂️ Categories** — the full Google Play category list (free)

💡 **TIP:** Run App Search or Top Charts first to discover App IDs, then drill into App Details / Reviews.

## `query` (type: `string`):

🔍 **Required for `App Search` operation.**

A free-form keyword query — exactly what you would type into the Play Store search bar.

- `fitness tracker`
- `photo editor`
- `language learning`

💡 **TIP:** Use specific keywords to surface a tight set of competing apps for ASO research.

⚠️ **Ignored** for all other operations.

## `chartType` (type: `string`):

📊 **Required for `Top Charts` operation.**

Which Google Play top-chart to pull:

- `top-free-apps` — Top Free apps
- `top-paid-apps` — Top Paid apps
- `top-grossing-apps` — Top Grossing apps
- `top-free-games` — Top Free games
- `top-paid-games` — Top Paid games
- `top-grossing-games` — Top Grossing games

💡 **TIP:** Combine with the `Category` filter below to chart a single Play Store category.

⚠️ **Ignored** for all other operations.

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

Optional. Filter a Top Chart to a single Google Play category by its ID (e.g. `GAME`, `GAME_PUZZLE`, `MUSIC_AND_AUDIO`, `PRODUCTIVITY`).

💡 **TIP:** Run the `Categories` operation first to get the full list of valid category IDs.

⚠️ Only used for Top Charts.

## `appId` (type: `string`):

📱 **Required for `App Details` and `App Reviews`.**

The Google Play package name / App ID (e.g. `com.spotify.music`, `com.instagram.android`). This is the `appId` field from a search or chart result row, and the `id=` value in a Play Store URL.

💡 **TIP:** Run App Search or Top Charts first to collect `appId` values, then loop through App Details / Reviews.

⚠️ **Ignored** for all other operations.

## `sortBy` (type: `string`):

Optional. Order for `App Reviews`.

- `MOST_RELEVANT` (default)
- `NEWEST`
- `RATING`

⚠️ Only used for App Reviews.

## `rating` (type: `string`):

Optional. Return only reviews with this star rating for `App Reviews`. `ANY` returns all ratings.

⚠️ Only used for App Reviews.

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

🌍 ISO 3166-1 alpha-2 country code for the Play Store region (e.g. `us`, `gb`, `de`, `in`, `br`). Default `us`.

Applies to all operations except Categories.

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

Optional. ISO 639 language code for results (e.g. `en`, `es`, `de`, `pt`). Defaults to the region's primary language.

## `limit` (type: `integer`):

Optional. Number of rows to request per page (App Search, Top Charts, App Reviews). Higher values reduce upstream calls. Leave blank for the source default.

💡 **TIP:** App Reviews and Top Charts support up to 50 per request.

## `maxPages` (type: `integer`):

📄 **Applies to `App Search` and `App Reviews` only.** Ignored for single-record operations.

💡 **TIP:** Start small (1–3 pages) to preview results before scaling up. Pagination stops automatically when the data source reports no more results.

⚠️ Hard cap: 20 pages to prevent runaway runs.

## Actor input object example

```json
{
  "operation": "search",
  "query": "fitness tracker",
  "chartType": "top-free-apps",
  "category": "GAME_PUZZLE",
  "appId": "com.spotify.music",
  "sortBy": "MOST_RELEVANT",
  "rating": "ANY",
  "country": "us",
  "language": "en",
  "limit": 50,
  "maxPages": 3
}
```

# Actor output Schema

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

Per-row results — one flat row per app, review or category with clean camelCase fields (appId, appName, appDeveloper, rating, numDownloads, chartRank, reviewText, reviewRating, categoryId, …).

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, pages fetched, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "query": "fitness tracker",
    "category": "",
    "appId": "com.spotify.music",
    "country": "us",
    "language": "en",
    "limit": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/play-store-apps-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 = {
    "query": "fitness tracker",
    "category": "",
    "appId": "com.spotify.music",
    "country": "us",
    "language": "en",
    "limit": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/play-store-apps-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "fitness tracker",
  "category": "",
  "appId": "com.spotify.music",
  "country": "us",
  "language": "en",
  "limit": 50
}' |
apify call sian.agency/play-store-apps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/play-store-apps-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Store Scraper — App Search, Reviews & ASO Charts",
        "description": "Scrape Google Play Store app data, reviews and ASO competitive charts in one run. App search, full app details, reviews, category list and all 6 top-charts — top free, paid and grossing apps & games, category-filterable. Clean structured JSON, pay per result.",
        "version": "1.0",
        "x-build-id": "faaY2NTtbTVMzToqc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~play-store-apps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-play-store-apps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sian.agency~play-store-apps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-play-store-apps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sian.agency~play-store-apps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-play-store-apps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "🎯 Operation — what do you want to scrape?",
                        "enum": [
                            "search",
                            "topCharts",
                            "appDetails",
                            "appReviews",
                            "categories"
                        ],
                        "type": "string",
                        "description": "🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.\n\n- **🔍 App Search** — search Google Play by keyword, paginated (~20 apps/page)\n- **📊 Top Charts** — pull a Google Play top-chart (free / paid / grossing × apps / games), category-filterable\n- **📱 App Details** — full details for one app by its App ID (paid plan)\n- **⭐ App Reviews** — reviews for one app, paginated (paid plan)\n- **🗂️ Categories** — the full Google Play category list (free)\n\n💡 **TIP:** Run App Search or Top Charts first to discover App IDs, then drill into App Details / Reviews.",
                        "default": "search"
                    },
                    "query": {
                        "title": "🔍 Search Query (for App Search)",
                        "type": "string",
                        "description": "🔍 **Required for `App Search` operation.**\n\nA free-form keyword query — exactly what you would type into the Play Store search bar.\n- `fitness tracker`\n- `photo editor`\n- `language learning`\n\n💡 **TIP:** Use specific keywords to surface a tight set of competing apps for ASO research.\n\n⚠️ **Ignored** for all other operations."
                    },
                    "chartType": {
                        "title": "📊 Chart Type (for Top Charts)",
                        "enum": [
                            "top-free-apps",
                            "top-paid-apps",
                            "top-grossing-apps",
                            "top-free-games",
                            "top-paid-games",
                            "top-grossing-games"
                        ],
                        "type": "string",
                        "description": "📊 **Required for `Top Charts` operation.**\n\nWhich Google Play top-chart to pull:\n- `top-free-apps` — Top Free apps\n- `top-paid-apps` — Top Paid apps\n- `top-grossing-apps` — Top Grossing apps\n- `top-free-games` — Top Free games\n- `top-paid-games` — Top Paid games\n- `top-grossing-games` — Top Grossing games\n\n💡 **TIP:** Combine with the `Category` filter below to chart a single Play Store category.\n\n⚠️ **Ignored** for all other operations.",
                        "default": "top-free-apps"
                    },
                    "category": {
                        "title": "🗂️ Category (for Top Charts)",
                        "type": "string",
                        "description": "Optional. Filter a Top Chart to a single Google Play category by its ID (e.g. `GAME`, `GAME_PUZZLE`, `MUSIC_AND_AUDIO`, `PRODUCTIVITY`).\n\n💡 **TIP:** Run the `Categories` operation first to get the full list of valid category IDs.\n\n⚠️ Only used for Top Charts."
                    },
                    "appId": {
                        "title": "📱 App ID (for App Details & Reviews)",
                        "type": "string",
                        "description": "📱 **Required for `App Details` and `App Reviews`.**\n\nThe Google Play package name / App ID (e.g. `com.spotify.music`, `com.instagram.android`). This is the `appId` field from a search or chart result row, and the `id=` value in a Play Store URL.\n\n💡 **TIP:** Run App Search or Top Charts first to collect `appId` values, then loop through App Details / Reviews.\n\n⚠️ **Ignored** for all other operations."
                    },
                    "sortBy": {
                        "title": "🔀 Review Sort (for App Reviews)",
                        "enum": [
                            "MOST_RELEVANT",
                            "NEWEST",
                            "RATING"
                        ],
                        "type": "string",
                        "description": "Optional. Order for `App Reviews`.\n\n- `MOST_RELEVANT` (default)\n- `NEWEST`\n- `RATING`\n\n⚠️ Only used for App Reviews.",
                        "default": "MOST_RELEVANT"
                    },
                    "rating": {
                        "title": "⭐ Filter by Star Rating (for App Reviews)",
                        "enum": [
                            "ANY",
                            "ONE_STAR",
                            "TWO_STARS",
                            "THREE_STARS",
                            "FOUR_STARS",
                            "FIVE_STARS"
                        ],
                        "type": "string",
                        "description": "Optional. Return only reviews with this star rating for `App Reviews`. `ANY` returns all ratings.\n\n⚠️ Only used for App Reviews.",
                        "default": "ANY"
                    },
                    "country": {
                        "title": "🌍 Region / Country",
                        "type": "string",
                        "description": "🌍 ISO 3166-1 alpha-2 country code for the Play Store region (e.g. `us`, `gb`, `de`, `in`, `br`). Default `us`.\n\nApplies to all operations except Categories."
                    },
                    "language": {
                        "title": "🗣️ Language",
                        "type": "string",
                        "description": "Optional. ISO 639 language code for results (e.g. `en`, `es`, `de`, `pt`). Defaults to the region's primary language."
                    },
                    "limit": {
                        "title": "🔢 Results per request",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Optional. Number of rows to request per page (App Search, Top Charts, App Reviews). Higher values reduce upstream calls. Leave blank for the source default.\n\n💡 **TIP:** App Reviews and Top Charts support up to 50 per request."
                    },
                    "maxPages": {
                        "title": "📄 Max pages to fetch",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "📄 **Applies to `App Search` and `App Reviews` only.** Ignored for single-record operations.\n\n💡 **TIP:** Start small (1–3 pages) to preview results before scaling up. Pagination stops automatically when the data source reports no more results.\n\n⚠️ Hard cap: 20 pages to prevent runaway runs.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
