# AppBrain Google Play Rankings Scraper (`automation-lab/appbrain-google-play-rankings-scraper`) Actor

📈 Track public AppBrain Google Play charts by country and category. Export rank movement, package IDs, developers, ratings, and normalized install estimates for recurring ASO intelligence.

- **URL**: https://apify.com/automation-lab/appbrain-google-play-rankings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## AppBrain Google Play Rankings Scraper

Track public Google Play chart positions from AppBrain without maintaining a browser, login, or custom ranking-table parser.

The actor turns AppBrain ranking pages into structured app intelligence for ASO research, competitor tracking, portfolio scouting, and recurring market reports.

Choose top-free, top-paid, or top-grossing charts.

Combine them with countries and AppBrain category slugs.

Export clean JSON, CSV, Excel, XML, RSS, or Parquet from the Apify dataset.

### What does AppBrain Google Play Rankings Scraper do?

The actor reads public, server-rendered AppBrain Google Play ranking tables.

It extracts one record for every app placement in the selected chart context.

Each record includes:

- 📈 Current rank and signed daily rank movement
- 🌍 Country, chart type, and category filter
- 📱 App name, AppBrain URL, icon, and Google Play package ID
- 🏢 Developer name and AppBrain developer URL
- ⭐ Displayed category and rating
- 📥 Total and recent install estimates, both normalized and source-formatted
- 🔗 Exact source URL and scrape timestamp

The actor follows ranking pagination while respecting your item and page limits.

It deliberately does not visit AppBrain app-detail pages.

That keeps the product fast, inexpensive, and focused on the proven public chart surface.

### Who is it for?

#### ASO teams

Monitor chart movement for your apps and direct competitors across markets.

Feed snapshots into a warehouse and compare rank changes over time.

#### Mobile growth agencies

Create recurring client reports for countries, categories, and chart types.

Use package IDs as stable keys across datasets.

#### App investors and publishers

Find fast-moving apps, category leaders, and high-install competitors.

Compare recent install estimates with current chart placement.

#### Competitive-intelligence teams

Schedule daily snapshots and trigger alerts when an app enters, leaves, rises, or falls in a watched chart.

#### Data analysts

Export normalized numeric fields without writing compact-count conversion logic for values such as `73 M` or `1.4 B`.

### Why use this Google Play rankings scraper?

- ✅ **No login** — the scoped ranking pages are publicly accessible.
- ✅ **HTTP-first** — no browser startup or rendering overhead.
- ✅ **Market context** — every row keeps its chart, country, and category filter.
- ✅ **Movement-ready** — signed movement makes sorting and alerting straightforward.
- ✅ **Stable identifiers** — package IDs support joins with other Google Play datasets.
- ✅ **Scheduled workflows** — run daily or weekly through Apify schedules.
- ✅ **Controlled scale** — cap total items and pages per chart.
- ✅ **Integration-ready** — connect datasets to webhooks, APIs, MCP clients, and automation tools.

### What Google Play ranking data can I extract?

| Field | Type | Description |
|---|---|---|
| `chart` | string | `top_free`, `top_paid`, or `top_grossing` |
| `country` | string | Two-letter AppBrain market code |
| `categoryFilter` | string | Category slug used in the ranking URL |
| `rank` | number | Current chart position |
| `rankMovement` | number | Signed movement: positive up, negative down |
| `rankDirection` | string | `up`, `down`, or `unchanged` |
| `appName` | string | App name shown by AppBrain |
| `appUrl` | URL | Public AppBrain app URL |
| `packageId` | string | Google Play package identifier |
| `iconUrl` | URL | App icon URL |
| `developerName` | string | Developer shown in the table |
| `developerUrl` | URL | AppBrain developer URL |
| `category` | string | Google Play category shown in the row |
| `rating` | number | Rating displayed by AppBrain |
| `installsEstimate` | number | Normalized total install estimate |
| `installsEstimateText` | string | Source-formatted total estimate |
| `recentInstallsEstimate` | number | Normalized recent install estimate |
| `recentInstallsEstimateText` | string | Source-formatted recent estimate |
| `sourceUrl` | URL | Ranking page used for the row |
| `scrapedAt` | date | UTC extraction timestamp |

AppBrain's current chart table exposes install estimates rather than review counts.

The actor reports only fields present on that public table and does not invent missing metrics.

### How to scrape AppBrain Google Play rankings

1. Open the actor input page.
2. Choose one or more chart types.
3. Add two-letter country codes such as `us`, `gb`, `de`, or `fr`.
4. Enter `all` or AppBrain category slugs such as `social` or `productivity`.
5. Set a maximum number of ranking records.
6. Click **Start**.
7. Open the dataset to preview, filter, and export the results.
8. Add an Apify schedule when you want recurring rank snapshots.

For one exact ranking page, paste it into **AppBrain ranking URLs** instead of generating combinations.

### Input parameters

#### AppBrain ranking URLs

`startUrls` accepts exact public URLs under:

`https://www.appbrain.com/stats/google-play-rankings/`

Explicit URLs replace generated chart combinations.

URLs outside this ranking scope fail closed.

#### Chart types

`charts` accepts:

- `top_free`
- `top_paid`
- `top_grossing`

#### Country codes

`countries` accepts two-letter AppBrain market codes.

Use lowercase or uppercase input; the actor normalizes values to lowercase.

#### Category slugs

`categories` accepts AppBrain URL slugs.

Use `all` for the overall chart.

Use source slugs such as `productivity`, `social`, or `games` for narrower tracking.

#### Limits

`maxItems` controls the global number of records.

`maxPagesPerChart` controls pagination for each chart-country-category combination.

#### Proxy configuration

Direct HTTP is the default and normally requires no proxy.

Configure Apify Proxy only when a longer run is throttled in your environment.

### Input examples

#### US top-free chart

```json
{
  "charts": ["top_free"],
  "countries": ["us"],
  "categories": ["all"],
  "maxItems": 100,
  "maxPagesPerChart": 1
}
````

#### Multi-country ASO monitor

```json
{
  "charts": ["top_free", "top_grossing"],
  "countries": ["us", "gb", "de"],
  "categories": ["productivity"],
  "maxItems": 600,
  "maxPagesPerChart": 1
}
```

#### Exact AppBrain ranking URL

```json
{
  "startUrls": [
    { "url": "https://www.appbrain.com/stats/google-play-rankings/top_paid/all/us" }
  ],
  "maxItems": 25,
  "maxPagesPerChart": 1
}
```

### Output example

```json
{
  "chart": "top_free",
  "country": "us",
  "categoryFilter": "all",
  "rank": 1,
  "rankMovement": 0,
  "rankDirection": "unchanged",
  "appName": "ChatGPT",
  "appUrl": "https://www.appbrain.com/app/chatgpt/com.openai.chatgpt",
  "packageId": "com.openai.chatgpt",
  "developerName": "OpenAI",
  "category": "Productivity",
  "rating": 4.8,
  "installsEstimate": 1400000000,
  "installsEstimateText": "1.4 B",
  "recentInstallsEstimate": 73000000,
  "recentInstallsEstimateText": "73 M",
  "sourceUrl": "https://www.appbrain.com/stats/google-play-rankings/top_free/all/us",
  "scrapedAt": "2026-07-19T00:00:00.000Z"
}
```

Values change as AppBrain refreshes its tables.

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

This actor uses pay-per-event pricing.

A small start charge covers run initialization, then each saved ranking record is charged according to your Apify plan tier.

The current source configuration starts at **$0.005 per run** and uses discounted per-record tiers visible on the actor pricing tab.

You pay for records successfully produced, not for a monthly actor subscription.

A 10-record first run is intentionally small and inexpensive.

For the exact live price and free-plan allowance, check the pricing panel before starting.

### Rank movement semantics

`rankMovement` is signed for easy calculations.

- `3` means the app moved up three positions.
- `-2` means the app moved down two positions.
- `0` means AppBrain marks the position unchanged.

`rankDirection` provides the same signal as a readable string.

Store snapshots over time if you need longer historical series than the daily movement shown by the source.

### Pagination and deduplication

AppBrain ranking pages generally expose batches of table rows and a next-page link.

The actor follows that source link up to `maxPagesPerChart`.

It stops early when `maxItems` is reached.

Records are deduplicated by:

- package ID
- chart
- country
- category filter

The same package can therefore appear in different useful chart contexts without being incorrectly removed.

### Tips for reliable rank monitoring

- 🕐 Schedule runs at a consistent time of day.
- 🗂️ Store each run in a warehouse with `scrapedAt` as the snapshot timestamp.
- 🔑 Join datasets on `packageId`, not app name.
- 📉 Sort by `rankMovement` to find risers and fallers.
- 🌍 Keep country codes separate instead of merging market positions.
- 📦 Start with one page per chart before expanding pagination.
- 🔔 Use a webhook to notify downstream systems when a run succeeds.
- 🧪 Test unfamiliar category slugs with a small limit first.

### Integrations

#### Google Sheets reporting

Send each completed dataset to Make or Zapier and append rows to a dated sheet.

Build pivot tables by country, category, and chart.

#### BigQuery or Snowflake history

Load daily datasets into a partitioned table.

Calculate seven-day rank velocity and chart-entry events with SQL.

#### Slack rank alerts

Use a webhook worker to compare the latest rank with the previous snapshot.

Post only movements above your chosen threshold.

#### CRM and publisher scouting

Join rising package IDs with developer records from another app dataset.

Route high-growth publishers into a research or outreach workflow.

#### Apify webhooks

Trigger your integration only after a successful actor run.

Use the default dataset ID from the webhook payload to fetch records.

### Use the actor with the Apify API

The actor ID is `automation-lab/appbrain-google-play-rankings-scraper`.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/appbrain-google-play-rankings-scraper').call({
  charts: ['top_free'],
  countries: ['us'],
  categories: ['all'],
  maxItems: 100,
  maxPagesPerChart: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/appbrain-google-play-rankings-scraper').call(run_input={
    'charts': ['top_free'],
    'countries': ['us'],
    'categories': ['all'],
    'maxItems': 100,
    'maxPagesPerChart': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~appbrain-google-play-rankings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"charts":["top_free"],"countries":["us"],"categories":["all"],"maxItems":100,"maxPagesPerChart":1}'
```

Fetch dataset items after the run finishes through the dataset API.

### Use AppBrain rankings through MCP

Connect the actor to AI assistants through Apify's MCP server.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/appbrain-google-play-rankings-scraper"
```

#### Claude Desktop, Cursor, and VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/appbrain-google-play-rankings-scraper"
    }
  }
}
```

Example prompts:

- “Scrape the current US top-free Google Play rankings and show the five biggest risers.”
- “Compare productivity app rankings in the US, UK, and Germany.”
- “Extract top-grossing package IDs and prepare a CSV-ready table.”
- “Run a 20-record AppBrain ranking sample and summarize developer concentration.”

### Scheduling a Google Play chart monitor

Create an Apify schedule from the actor page.

Choose a daily or weekly cron interval.

Keep the same input so every dataset uses comparable contexts.

Attach a webhook or storage integration.

Preserve `scrapedAt`, `sourceUrl`, and `packageId` for auditability.

For alerting, compare each snapshot with the last successful run rather than assuming every scheduled run completed.

### Data quality and limitations

The actor extracts the values AppBrain displays on its public ranking tables.

Install values are source estimates, not exact Google Play console figures.

Compact figures are rounded by the source before normalization.

For example, `1.4 B` normalizes to `1400000000`, but the true underlying count may differ.

Ranking and movement values can change between runs.

Country and category availability is controlled by AppBrain.

The actor does not scrape protected app-detail pages.

It does not claim to provide review counts when the current table does not show them.

### Is it legal to scrape AppBrain rankings?

Public website data can often be collected for legitimate analytics, research, and interoperability purposes.

Your use case, jurisdiction, contract obligations, and downstream handling still matter.

Review AppBrain's terms and applicable law before large or sensitive workloads.

Avoid personal-data enrichment, abusive request rates, or attempts to bypass access controls.

The actor uses conservative sequential requests and only the public ranking-table surface.

You are responsible for how you use and retain the exported data.

### Troubleshooting

#### Why did my category return unexpected results?

Confirm that you used an AppBrain URL category slug rather than a display label.

Open the desired ranking page and copy its category segment, or provide the exact URL through `startUrls`.

Begin with `maxItems: 10` while validating a new slug.

#### Why did my run fail with an HTTP or empty-table error?

The source may be temporarily throttling requests or may have changed its markup.

Retry later with a small input.

If direct requests are throttled, enable Apify Proxy in `proxyConfiguration`.

The actor fails non-zero instead of silently returning an empty dataset.

#### Why are install values different from Google Play?

AppBrain displays estimates and rounds compact values.

Treat them as market-intelligence signals rather than first-party console totals.

#### Can I scrape app descriptions or reviews?

Not with this focused actor.

Use a related Google Play metadata actor for app details, then join by `packageId`.

### Frequently asked questions

#### How many countries can I scrape at once?

You can combine up to 50 valid two-letter codes, subject to `maxItems` and run timeout.

Start with a small market set and scale after checking output.

#### Does the actor need residential proxies?

No.

The public ranking pages worked with direct HTTP during implementation.

Proxy settings remain available as an operational fallback.

#### Can the same app appear more than once?

Yes, when it belongs to different chart contexts.

That is useful for comparing countries, categories, and chart types.

Exact duplicates within one context are removed.

#### Can I monitor historical rankings?

The actor creates snapshots.

Schedule it and retain datasets to build your own historical series.

#### What happens when one page cannot be parsed?

The run fails rather than presenting a misleading successful empty result.

Logs identify the source URL that failed.

### Related app data scrapers

Combine ranking snapshots with these automation-lab actors:

- [Google Play Scraper](https://apify.com/automation-lab/google-play-scraper) — enrich package IDs with app metadata.
- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper) — compare mobile ecosystems.
- [Apple App Store Top Charts Scraper](https://apify.com/automation-lab/apple-app-store-top-charts-scraper) — collect Apple chart placements.
- [ASO Keyword Rank Tracker](https://apify.com/automation-lab/aso-keyword-rank-tracker) — complement category charts with keyword positions.

Use package IDs and timestamps as durable join and comparison keys.

### Responsible scaling checklist

Before increasing run size:

- Verify the exact chart and category combination with 10 records.
- Keep pagination proportional to the ranking depth you actually need.
- Avoid duplicate chart combinations.
- Schedule at a business-relevant interval rather than continuously.
- Store only snapshots required by your retention policy.
- Configure downstream retries separately from actor retries.
- Review source changes when an empty-table error appears.

### Start collecting Google Play chart intelligence

Use the prefilled input for a fast 10-record US top-free sample.

Inspect the structured dataset.

Then add the markets, categories, chart types, schedule, and integration that fit your ASO workflow.

# Actor input Schema

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

Optional public AppBrain Google Play ranking URLs. When supplied, these replace generated chart combinations.

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

Google Play ranking chart types to collect.

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

Two-letter AppBrain country codes, such as us, gb, de, or fr.

## `categories` (type: `array`):

Use all for the overall chart or slugs such as social, productivity, or games.

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

Stop after saving this many unique app ranking records across all combinations.

## `maxPagesPerChart` (type: `integer`):

Follow at most this many AppBrain pages for each ranking combination.

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

Optional Apify Proxy settings. Direct HTTP works by default; use a proxy if AppBrain throttles your run.

## Actor input object example

```json
{
  "charts": [
    "top_free"
  ],
  "countries": [
    "us"
  ],
  "categories": [
    "all"
  ],
  "maxItems": 10,
  "maxPagesPerChart": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "charts": [
        "top_free"
    ],
    "countries": [
        "us"
    ],
    "categories": [
        "all"
    ],
    "maxItems": 10,
    "maxPagesPerChart": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/appbrain-google-play-rankings-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 = {
    "charts": ["top_free"],
    "countries": ["us"],
    "categories": ["all"],
    "maxItems": 10,
    "maxPagesPerChart": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/appbrain-google-play-rankings-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 '{
  "charts": [
    "top_free"
  ],
  "countries": [
    "us"
  ],
  "categories": [
    "all"
  ],
  "maxItems": 10,
  "maxPagesPerChart": 1
}' |
apify call automation-lab/appbrain-google-play-rankings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/appbrain-google-play-rankings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AppBrain Google Play Rankings Scraper",
        "description": "📈 Track public AppBrain Google Play charts by country and category. Export rank movement, package IDs, developers, ratings, and normalized install estimates for recurring ASO intelligence.",
        "version": "0.1",
        "x-build-id": "slas0jNWl0GunFSUR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~appbrain-google-play-rankings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-appbrain-google-play-rankings-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/automation-lab~appbrain-google-play-rankings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-appbrain-google-play-rankings-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/automation-lab~appbrain-google-play-rankings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-appbrain-google-play-rankings-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",
                "properties": {
                    "startUrls": {
                        "title": "🔗 AppBrain ranking URLs",
                        "type": "array",
                        "description": "Optional public AppBrain Google Play ranking URLs. When supplied, these replace generated chart combinations.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "charts": {
                        "title": "Chart types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Google Play ranking chart types to collect.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "top_free",
                                "top_paid",
                                "top_grossing"
                            ],
                            "enumTitles": [
                                "Top free",
                                "Top paid",
                                "Top grossing"
                            ]
                        },
                        "default": [
                            "top_free"
                        ]
                    },
                    "countries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "Two-letter AppBrain country codes, such as us, gb, de, or fr.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "categories": {
                        "title": "AppBrain category slugs",
                        "type": "array",
                        "description": "Use all for the overall chart or slugs such as social, productivity, or games.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z0-9_-]+$"
                        },
                        "default": [
                            "all"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum ranking records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique app ranking records across all combinations.",
                        "default": 100
                    },
                    "maxPagesPerChart": {
                        "title": "Maximum pages per chart",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Follow at most this many AppBrain pages for each ranking combination.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct HTTP works by default; use a proxy if AppBrain throttles your run.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```