# Google Play Top Charts Scraper: Android App Rankings by Country (`glitchbound/google-play-charts-scraper`) Actor

Google Play rank tracker for ASO: Play Store rankings by country. Top free apps, top paid apps, top grossing, trending apps, top new apps, top Android games in 130 countries. Mobile app rankings by category, rating, installs, rank history since last run. Optional: exact installs, developer emails.

- **URL**: https://apify.com/glitchbound/google-play-charts-scraper.md
- **Developed by:** [glitchbound](https://apify.com/glitchbound) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 20 total users, 17 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 chart entries

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Play Top Charts Scraper: Rankings by Country

> **Charts end on 15 November 2026.** Google's robots.txt asks automated tools not to read the Play Store address the charts come from, and this Actor follows robots.txt. Until then every chart run ends with an unbilled notice row. **App details stay**: `appIds` reads each app's public page, which robots.txt allows. Keyword ranks were removed on 8 November for the same reason (they came from Play Store search).

Track **Google Play top charts**: Top Free, Top Paid, Top Grossing, Trending and Top New Free apps and games, in **130 countries** and **54 categories**, with rank, rating, installs, price, developer and age rating.

Read from the Play Store's own chart data, the same data the Play Store draws its Top charts from. No API key, no login, no Google account.

Also a **Google Play app scraper**: give it `appIds` (package names or Play Store URLs) and it returns each app in full, with rating, installs, price, description, screenshots and developer contact.

### What you get per app

One row per charting app:

```json
{
  "rank": 1,
  "country": "US",
  "chart": "top-free",
  "category": "all-apps",
  "appId": "com.openai.chatgpt",
  "title": "ChatGPT",
  "developer": "OpenAI",
  "genre": "Productivity",
  "rating": 4.78,
  "installs": "1,000,000,000+",
  "minInstalls": 1000000000,
  "contentRating": "Teen",
  "price": 0,
  "currency": "USD",
  "isFree": true,
  "inAppPurchases": "$8.00 - $100.00 per item",
  "url": "https://play.google.com/store/apps/details?id=com.openai.chatgpt&gl=us",
  "store": "google-play",
  "chartedAt": "2026-09-15T10:00:00Z"
}
```

| Field | What it is |
|---|---|
| `rank` | position in the chart, 1 is top |
| `country` | the country the chart was read for |
| `chart` | `top-free`, `top-paid`, `top-grossing`, `trending` or `top-new-free` |
| `category` | the Play category; `all-apps` and `all-games` are the overall charts |
| `appId` | the package name, stable across runs and countries: the key to join on |
| `title`, `developer`, `genre` | as Google Play shows them |
| `rating` | average stars, 0 to 5 |
| `installs` | the install band exactly as Google prints it, e.g. `10,000,000+` |
| `minInstalls` | the same band as a number, for sorting |
| `contentRating` | age rating in that country |
| `price`, `currency`, `isFree` | 0 for free apps |
| `inAppPurchases` | the in-app purchase price range, when the app sells any |
| `summary` | the listing's description as plain text |
| `icon`, `url` | icon image and the app's Play Store page |
| `chartedAt` | when this ranking was read, so daily runs stack into a rank history |

### Full app details, optional

Turn on `includeDetails` and each charting app's own Play page is read too, adding what the chart itself does not carry:

```json
{
  "ratingCount": 60498356,
  "reviewCount": 66564,
  "ratingHistogram": {"1": 2503569, "2": 673927, "3": 1796945, "4": 5550701, "5": 49973043},
  "exactInstalls": 1567613533,
  "releasedAt": "2023-07-26",
  "updatedAt": "2026-09-11T04:21:47Z",
  "version": "1.2026.251",
  "minAndroidVersion": "7.1",
  "containsAds": true,
  "developerEmail": "support@openai.com",
  "developerWebsite": "https://help.openai.com",
  "developerUrl": "https://play.google.com/store/apps/dev?id=7577165439232992817",
  "privacyPolicyUrl": "https://openai.com/policies/privacy-policy"
}
```

- **Exact installs, not the band**: `exactInstalls` is Google's own count, so two apps both shown as `1,000,000,000+` can be told apart.
- **Developer contact on every row**: the support email and website each developer publishes, for outreach to the publishers climbing a chart.
- **Same price per row.** Pages are read four at a time and each app once per country, so a Top 100 with details takes well under a minute.
- An app with no page in that country gets a `detailsNote` saying so, and still counts as its chart row.

### Compare markets in one run

```json
{
  "countries": ["us", "gb", "de", "jp", "br", "in"],
  "charts": ["top-free", "top-grossing"],
  "categories": ["all-games"],
  "limit": 100
}
```

Twelve charts in one run: the same category across six markets, downloads and revenue side by side.

### What moved since yesterday

Every row also says where the app stood **the last time your account read
that chart**: `previousRank`, `rankChange` (positive means it climbed) and
`newInChart`. Schedule the run daily and the dataset is a rank tracker, not a
snapshot: the apps that jumped, the ones that fell and the ones that just
entered, with `previousChartedAt` saying when "last time" was. The previous
read is kept in a key-value store in your own account
(`google-play-charts-history`); turn it off with `trackRankChanges: false`.

### Built to be scheduled

A chart is a snapshot; the story is in how it moves. Schedule this daily and every row carries `chartedAt`, so consecutive runs become a rank history with no extra work: who is climbing, who is falling out, who just entered the top 10.

### App details by package name or URL

Add `appIds` and the run reads **any Google Play app in full**: give it package
names (`com.calm.android`) or paste the Play Store address, and each app comes
back as one row per country.

```json
{ "appIds": ["com.mojang.minecraftpe", "https://play.google.com/store/apps/details?id=com.calm.android"],
  "countries": ["us"], "charts": [] }
```

```json
{
  "rowType": "app",
  "country": "US",
  "appId": "com.mojang.minecraftpe",
  "title": "Minecraft: Dream it, Build it!",
  "developer": "Mojang",
  "genre": "Arcade",
  "rating": 4.3,
  "ratingCount": 5880777,
  "installs": "100,000,000+",
  "exactInstalls": 100280157,
  "price": 6.99,
  "currency": "USD",
  "inAppPurchases": "$0.99 - $49.99 per item",
  "contentRating": "Everyone 10+",
  "shortDescription": "Millions of crafters have smashed billions of blocks! Now you can join the fun!",
  "version": "1.26.62.1",
  "updatedAt": "2026-11-04T19:03:05Z",
  "developerEmail": "help@minecraft.net",
  "screenshots": ["https://play-lh.googleusercontent.com/ywPBuExm...", "..."]
}
```

- **Every field the listing shows**: also `summary` (the full description,
  as plain text), `recentChanges` (What's new), `ratingHistogram`,
  `reviewCount`, `releasedAt`, `minAndroidVersion`, `containsAds`,
  `developerWebsite`, `developerUrl`, `privacyPolicyUrl`, `icon`,
  `headerImage` and `video` where the listing has one.
- **Same fields as a chart row.** Checked on 80 charting apps on 2026-11-07:
  title, developer, genre, rating, installs, price, age rating, in-app
  purchases, icon and description matched their chart rows.
- **Price per country.** Each app is read once for every country in
  `countries`, since price, currency and availability differ by market.
- **A URL and the bare name are one app**, read and billed once. A value that
  is not a Play package name (an App Store id, say) and an app Google has no
  page for in that country each come back as an **unbilled** error row.
- **Leave `charts` empty to read only these apps.** Up to 1,000 app pages per
  run, read four at a time: about a quarter of a second per app.

### Pricing

**$1.00 per 1,000 chart entries**, pay per result, lower on higher Apify plans. No subscription and no minimum. An app row from `appIds` is billed as one chart entry.

- A chart that could not be read, and an input value that is not recognised, each come back as an **unbilled** error row that says which one and why.
- `maxItems` puts a hard ceiling on the whole run. It stops cleanly there and nothing beyond it is fetched or charged.
- A daily US Top Free chart of 100 apps costs about $3 a month.

### Options

- **Charts**: Top Free, Top Paid, Top Grossing, plus **Trending** (the apps rising fastest right now, Google's own list) and **Top New Free** (recently released free apps)
- **Categories**: 54, from `all-apps` and `all-games` to every games genre, `finance`, `shopping`, `health-and-fitness`, `education` and the rest
- **Countries**: 130, listed below
- **Apps per chart**: up to 200, Google's own ceiling
- **App details**: `includeDetails` adds rating count, exact installs, release and update dates and developer contact to every row
- **Apps**: `appIds` reads any app in full by package name or Play Store URL, see App details by package name or URL above

### Countries

United States, United Kingdom, Canada, Australia, India, Germany, France, Spain, Italy, Netherlands, Sweden, Norway, Denmark, Finland, Poland, Portugal, Ireland, Austria, Switzerland, Belgium, Czechia, Romania, Hungary, Greece, Turkey, Saudi Arabia, United Arab Emirates, Egypt, South Africa, Nigeria, Kenya, Brazil, Mexico, Argentina, Colombia, Chile, Peru, Japan, South Korea, Taiwan, Hong Kong, Singapore, Malaysia, Thailand, Vietnam, Philippines, Indonesia, New Zealand, Russia, Ukraine, Kazakhstan, Pakistan, Bangladesh, Sri Lanka, Qatar, Kuwait, Morocco, Israel, Iraq, Jordan, Lebanon, Oman, Bahrain, Yemen, Algeria, Tunisia, Libya, Ghana, Tanzania, Uganda, Cameroon, Côte d'Ivoire, Senegal, Zambia, Zimbabwe, Mozambique, Angola, Rwanda, Mauritius, Botswana, Namibia, Venezuela, Ecuador, Bolivia, Paraguay, Uruguay, Costa Rica, Panama, Guatemala, Dominican Republic, Puerto Rico, El Salvador, Honduras, Nicaragua, Jamaica, Trinidad and Tobago, Bulgaria, Croatia, Serbia, Slovenia, Slovakia, Lithuania, Latvia, Estonia, Belarus, Moldova, Azerbaijan, Georgia, Armenia, Uzbekistan, Kyrgyzstan, Tajikistan, Cambodia, Myanmar, Laos, Nepal, Mongolia, Macao, Luxembourg, Malta, Cyprus, Iceland, Bosnia and Herzegovina, North Macedonia, Albania, Fiji, Papua New Guinea, Haiti, Bahamas, Belize.

**Why a list and not any code.** Google Play answers a country it does not recognise with a different chart, not an error. A tool that passes any code through will sooner or later bill you for the wrong market and never say so. Every country here was checked against Google's own answer: its chart had to differ from the one Google serves for a code with no Play market (Antarctica gets the same chart as Bouvet Island) and from every other country's. Five codes failed that check and are left out: Ethiopia, Montenegro, Afghanistan, Brunei and Barbados. Russia has Top Free only, because Google Play takes no payments there.

### Use cases

- **ASO and competitor tracking**: see the day a rival enters or drops out of your category's chart
- **Market research**: find what is winning in Brazil or Japan before it reaches the US
- **Mobile games**: watch Top Grossing by genre across markets
- **Spot breakouts early**: Trending and Top New Free show what is rising before it reaches Top Free
- **Publisher and investor intelligence**: which developers own a category, and how installs bands move
- **Both stores**: pair it with [App Store Top Charts Scraper](https://apify.com/glitchbound/app-charts-scraper); `store` and a matching row shape make the two join cleanly

### Honest limits

- **Rating count, release date and developer contact come from each app's own page**, so on chart rows they are there only with `includeDetails` on; `appIds` rows always carry them. For reviews use [App Store & Google Play Scraper](https://apify.com/glitchbound/app-store-scraper).
- **Up to 200 apps per chart.** Asking for more returns 200, which is all Google serves.
- **A chart some countries do not have** (a small category in a small market) comes back as an unbilled error row, not as an empty result.

### The rest of this set

- **Quick start on GitHub**: [danielhagever/google-play-top-charts-api](https://github.com/danielhagever/google-play-top-charts-api), a ready `curl`, a standard-library Python script that writes a CSV, and the MCP setup
- **[App Store Top Charts Scraper](https://apify.com/glitchbound/app-charts-scraper)**: the iOS App Store top charts API by country, Top Free, Paid and Grossing, with ratings and rank changes
- **[App Store & Google Play Scraper](https://apify.com/glitchbound/app-store-scraper)**: one app's ratings, price and metadata in both stores
- **[App Store & Google Play Reviews Scraper](https://apify.com/glitchbound/app-reviews-scraper)**: every review for an app, both stores
- **[App Store Developer Portfolio Scraper](https://apify.com/glitchbound/app-developer-scraper)**: every app one publisher has shipped
- **[ASO Keyword Rank Tracker](https://apify.com/glitchbound/aso-keyword-rank-tracker)**: where an app ranks for a keyword in App Store search

### FAQ

**How do I track Google Play app rankings over time?** Schedule this Actor daily with the charts and countries you care about. Every row carries `rankChange` against your previous run (and `newInChart` for an app that just entered), so the dataset is a rank history with the deltas already worked out, not a pile of snapshots to diff yourself.

**Is there an official Google Play top charts API?** No. Google publishes none. This reads the chart data the Play Store app and website themselves show, so the ranks are Google's own.

**How do I get trending apps on Google Play?** Ask for `"charts": ["trending"]`: Google's own "movers and shakers" list of the apps rising fastest, up to 200 per country and category. It is not a reshuffle of Top Free: in the US on 18 October 2026 the two top 100s shared 7 apps. `top-new-free` ranks recently released free apps.

**Which countries does it cover?** 130, listed above. A code Google does not serve as a market is refused rather than answered with another country's chart, which is what Google itself would do.

**Do I need a Google account or an API key?** No.

**Is it the real ranking?** Yes. It is the same chart data the Play Store shows, read at the moment of the run and stamped with `chartedAt`.

**How fast is it?** About one second per chart. A run of 50 charts finishes in about a minute. With `includeDetails`, add about a quarter of a second per app.

**Can I get the developer's email?** Yes: turn on `includeDetails` and each row carries `developerEmail` and `developerWebsite`, as the developer publishes them on Google Play.

**Can I scrape one specific Google Play app?** Yes: put its package name or Play Store URL in `appIds` and leave `charts` empty. You get one row per app and country with the full listing: rating and rating count, installs (the band and Google's exact count), price, description, screenshots, version, dates and developer contact.

**Can I get the iOS App Store too?** Yes, with [App Store Top Charts Scraper](https://apify.com/glitchbound/app-charts-scraper), same row shape.

### Use it from an AI agent

This Actor is a ready-made tool for Claude, ChatGPT, Cursor or any other MCP
client, through Apify's MCP server. Add it as a connector at:

```
https://mcp.apify.com?tools=glitchbound/google-play-charts-scraper
```

In Cursor or VS Code the same address goes in `mcp.json`:

```json
{ "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=glitchbound/google-play-charts-scraper" } } }
```

The first call asks you to sign in to Apify, or takes an API token. From then
on the agent sees this Actor's input fields and calls it directly.

### Feedback

If this saved you time, a review on the Actor's Store page helps other people
find it. If something is missing or wrong, the Issues tab on the same page is
the fastest way to reach me, and it gets read.

# Actor input Schema

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

Which Google Play countries to read, 130 verified. Add several to compare the same chart across markets in one run. Only countries whose chart was checked against Google's own answer are offered: Google answers a code it has no market for with another chart, not an error.

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

Top Free and Top Paid rank by downloads; Top Grossing ranks by revenue. Trending is Google's list of the apps rising fastest right now; Top New Free ranks recently released free apps. Charts end on 15 November 2026 (Google's robots.txt asks tools not to read them; app details stay). Leave empty when you only want app details; with neither, Top Free is read.

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

Play categories, 54 of them. all-apps and all-games are the overall charts.

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

How many ranked apps to return per chart. Google serves up to 200.

## `includeDetails` (type: `boolean`):

Also read each charting app's own Play page and add the rating count, review count, star histogram, exact install count, release and last-update dates, version, whether it shows ads, and the developer's email, website and privacy policy. Same price per row; about a quarter of a second more per app. Each app is read once per country, however many charts it is in.

## `trackRankChanges` (type: `boolean`):

Compare each chart with the last time your account read it, and add previousRank, rankChange (positive = moved up) and newInChart to every row. The last read is kept in a key-value store in your own account, named google-play-charts-history. Schedule the run daily and every row says what moved.

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

A hard ceiling on rows for the entire run, across every chart, keyword and app. The run stops cleanly when it is reached and nothing beyond that point is fetched or charged. Leave empty for no ceiling.

## `appIds` (type: `array`):

One per line: a package name such as com.calm.android, or the app's Play Store address (https://play.google.com/store/apps/details?id=com.calm.android). Each app is read once for every country above, since price, currency and availability differ by country. Leave Charts empty to read only these apps.

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

Proxy settings.

## Actor input object example

```json
{
  "countries": [
    "us"
  ],
  "charts": [
    "top-free"
  ],
  "categories": [
    "all-apps"
  ],
  "limit": 100,
  "includeDetails": false,
  "trackRankChanges": true,
  "appIds": [
    "com.whatsapp"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Top Free, Paid and Grossing Google Play chart positions by country and category.

# 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 = {
    "countries": [
        "us"
    ],
    "charts": [
        "top-free"
    ],
    "categories": [
        "all-apps"
    ],
    "limit": 100,
    "appIds": [
        "com.whatsapp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("glitchbound/google-play-charts-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 = {
    "countries": ["us"],
    "charts": ["top-free"],
    "categories": ["all-apps"],
    "limit": 100,
    "appIds": ["com.whatsapp"],
}

# Run the Actor and wait for it to finish
run = client.actor("glitchbound/google-play-charts-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "countries": [
    "us"
  ],
  "charts": [
    "top-free"
  ],
  "categories": [
    "all-apps"
  ],
  "limit": 100,
  "appIds": [
    "com.whatsapp"
  ]
}' |
apify call glitchbound/google-play-charts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glitchbound/google-play-charts-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yC8ZiNowcKubjRgeb/builds/bigJa6S2gKaP885O5/openapi.json