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

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

Multi-country ASO monitor

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

Exact AppBrain ranking URL

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

Output example

{
  "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

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

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

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

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

Claude Desktop, Cursor, and VS Code

{
  "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 — enrich package IDs with app metadata.
• Apple App Store Scraper — compare mobile ecosystems.
• Apple App Store Top Charts Scraper — collect Apple chart placements.
• 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.