# Google Play Top Charts Tracker — Free, Paid & Grossing (`northbell/google-play-top-charts-tracker`) Actor

Google Play top charts for any country and category: top free, top paid and top grossing, up to 200 apps per chart. Run it again or on a schedule to get rank changes, new entries and apps that dropped out since the last run. No login.

- **URL**: https://apify.com/northbell/google-play-top-charts-tracker.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** Marketing, Developer tools
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 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 Tracker — Free, Paid & Grossing

Pick a country and a chart — top free, top paid or top grossing, optionally one category — and get the chart as rows: **rank, app name, developer, rating, installs, price, category, link and icon**, up to 200 apps per chart (the US top-free 100 in 6 s on 17 Oct 2026). Run it again, or daily, and every row adds the **previous rank, places moved and whether it is a new entry**, with a free summary row of new entries, drop-outs and the biggest risers and fallers. **$0.50 per 1,000 apps**, no login, no API key.

**Try it now — the input is already filled in.** Press **Start**: the US top-free chart on Google Play, 100 apps in about 4 seconds, for about $0.06.

| `rank` | `name` | `developer` | `rating` | `installsMin` | `appCategory` |
| --- | --- | --- | --- | --- | --- |
| 2 | ChatGPT | OpenAI | 4.78 | 1000000000 | Productivity |
| 5 | WhatsApp Messenger | WhatsApp LLC | 4.62 | 10000000000 | Communication |
| 9 | Vinted: Shop & sell pre-loved | Vinted | 4.43 | 100000000 | Shopping |

Run it again and every row says how the app moved (`previousRank`, `rankChange`, `isNewInChart`), and a free summary row per chart lists the new entries, the apps that dropped out and the biggest risers — on our account, 9 hours after the previous read, Google Authenticator had entered at 99 and FOX One had dropped out. Pick top paid or top grossing, a category, or several countries in one run.

**Then:** paste the `appId` of any app that moved into [Google Play Reviews Scraper — See Why the Rating Moved](https://apify.com/northbell/google-play-rating-tracker) (input `appIds`) to read the reviews behind it.

### Call it from a script or a schedule

```bash
curl -X POST "https://api.apify.com/v2/acts/northbell~google-play-top-charts-tracker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countries":["us"],"charts":["top-free"]}'
```

The response is the rows themselves (a JSON array). To run it on a timetable instead, save the input as a task in Apify Console and add a Schedule; n8n, Make and Zapier run it through their Apify app with the same input.

### What you get

Two kinds of rows, told apart by `type`. A `chart-entry` row is one app in one chart (charged); a `chart-summary` row is one per chart (free).

| Field | What it is |
|---|---|
| `country`, `chart`, `category`, `categoryId` | which chart: country code, `top-free` / `top-paid` / `top-grossing`, and the category (`All apps (no games)` and `categoryId` `null` for the overall apps chart; otherwise the name and Google Play's id, e.g. `Health & Fitness` / `HEALTH_AND_FITNESS`) |
| `rank` | position in the chart, 1 = top |
| `previousRank`, `rankChange`, `isNewInChart`, `previousRunAt` | the change since your previous run of the same chart. `rankChange` is positive when the app moved **up**. `null` on the first run |
| `appId`, `name`, `developer` | the app (its Android package name) and the publisher name Google Play shows |
| `rating` | Google's average star rating with up to six decimals (4.779803), `null` for an app that has no ratings yet |
| `installsMin` | the install count Google Play shows as a lower bound (`1,000,000+` becomes `1000000`) |
| `price`, `currency` | price in the store's own currency (`0` = free; in the top grossing chart this is the app's own price, not its revenue) |
| `appCategory` | the app's own category, in the language you asked for |
| `url`, `iconUrl` | the Google Play page of the app and its icon |
| `observedAt` | when the run started |

`chart-summary` rows add `entries` (apps read), `hasBaseline`, `previousRunAt`, `newEntryCount`, `droppedOutCount`, `newEntries` (`rank`, `appId`, `name`), `droppedOut` (`previousRank`, `appId`, `name`), `biggestRisers` and `biggestFallers` (top 5 by `rankChange`, with `rank`, `previousRank`, `rankChange`) and a `note`. On the first run of a chart `hasBaseline` is `false`, `previousRunAt`, `newEntryCount`, `droppedOutCount`, `newEntries`, `droppedOut`, `biggestRisers` and `biggestFallers` are `null`, and `note` says to run it again.

### Use it for

- **Competitor and market watching** — see which apps break into the top charts of your category or country, and which ones fall out
- **Launch and campaign tracking** — schedule it daily for a country and see whether a release or a marketing push moved a rank
- **Trend research** — compare the same category across countries, or free against grossing, to find what pays where

### Input

```json
{ "countries": ["us", "gb", "jp"], "charts": ["top-free", "top-grossing"], "categories": ["Health & Fitness", "GAME"], "limit": 100, "language": "en" }
```

Categories can be Google Play ids (`GAME`, `HEALTH_AND_FITNESS`, `FINANCE`, `TOOLS`, `GAME_PUZZLE` …) or names (`Health & Fitness`, `Games`, `Games: Puzzle` …, case does not matter). Leave `categories` empty for the overall chart of apps. **That chart has no games in it** (Google Play keeps games in their own charts), so add `GAME`, or a game subcategory such as `GAME_PUZZLE`, to read games. Several values can also be typed on one line, separated by commas. Every combination of country × chart × category is read as its own chart.

The previous ranks are remembered per country, chart and category in a named key-value store in your Apify account, so the second run of the same Actor already shows movement. Schedule it (Apify → Schedules) at the same time every day for a clean history.

### Pricing

**$0.50 per 1,000 apps** (one chart of 100 apps = $0.05), plus $0.01 per run. Summary rows and error rows (a country or chart that could not be read) are free. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing. For example, 10 countries × 3 charts × 100 apps is at most 3,000 apps = $1.50 + $0.01, and less than that because top paid charts are short (see below).

### Notes

- Public data only: the same top-chart lists Google Play shows on its own category pages for the Top free, Top grossing and Top paid tabs. No login. `developer` is the publisher name Google Play shows with each app; nothing else about people is read.
- Google Play returns **at most 200 apps per chart**, so `limit` stops at 200. Rank is the position in Google's list.
- **Top paid charts outside games are short.** Google Play lists few paid apps now: on the day this Actor was built, the US top paid chart of apps had 85 apps, Japan's had 7, and 37 of the 52 US categories had 8 or fewer (Health & Fitness: 1; Social: 0). The `GAME` top paid chart is the exception: 200 in the US. You get what Google lists. A chart with no apps comes back as a free `chart-summary` row with `entries` `0` and a note, not as an error. Top free and top grossing charts were never empty in testing, so an empty one is reported as a free error row.
- Top grossing ranks apps by revenue but Google does not publish the amounts. You get the order, not the money. `price` there is the app's own price, which is `0` for most of them (their revenue comes from in-app purchases and subscriptions).
- `language` only changes the language of app names and category names. The ranks do not depend on it. Charts depend on the country.
- Countries are two-letter codes (`us`, `gb`, `jp`, `de`, `kr`, `br`, `in` …; `uk` is accepted as `gb`), about 190 of them. For a code Google Play has no store of its own for (for example `cn`, `ir`, `cu`, `kp`, or a small territory), Google does not return an error — it quietly answers with another store's chart. To avoid selling you the wrong chart, those codes are rejected before the run starts.
- Category ids are checked the same way: an id Google does not know gives an empty chart that looks like a real one, so unknown ids are rejected. Available: the 32 app categories, `FAMILY`, `WATCH_FACE`, `GAME` and 17 game subcategories (`GAME_PUZZLE`, `GAME_ACTION` …). `category` is the chart's category; `appCategory` is the app's own category. In the `GAME` chart, `appCategory` is the game's subcategory (`Puzzle`, `Action` …).
- `previousRank`, `rankChange`, `isNewInChart` and `previousRunAt` are `null` on the first run of a chart, and `categoryId` is `null` for the overall chart. `previousRank` and `rankChange` are also `null` for an app that was not in the chart last time. If you read **more** apps per chart than last time, `isNewInChart` is `null` for the ranks below your previous depth, because there is no way to tell whether they are new. Reading fewer never reports drop-outs below the new depth. A drop-out means the app is no longer within the top `limit` apps you read; it may still be further down Google's own chart.
- Charts move through the day, so run it at about the same time of day and do not expect much movement between two runs a few minutes apart.
- A run reads a chart in about a second. If Google Play refuses several charts in a row, the run stops, adds one error row with `skippedCharts` (how many were left) and tells you to run it again later. If Google changes how its chart tabs load, you get free error rows and a failed run rather than wrong data.
- In the Apify Console the two views (Chart entries, Chart summaries) each list every row and only fill the columns that row type has. To see only summaries, filter on `type` = `chart-summary`.

To see the same charts for **the App Store**, see [App Store Top Charts Tracker](https://apify.com/northbell/app-store-top-charts-tracker). To **search apps and read app details** on Google Play, see [Google Play Scraper](https://apify.com/northbell/google-play-scraper). To follow **the rating of your own app over time**, see [Google Play Rating Tracker](https://apify.com/northbell/google-play-rating-tracker).

### For AI agents

`{"countries": ["us"], "charts": ["top-free"], "categories": ["Health & Fitness"], "limit": 10}` returns one `chart-summary` row and 10 `chart-entry` rows with the rank, app, developer, rating, installs and price. Rows have `type`: `chart-entry`, `chart-summary` or `error`. Run the same input again later to get `previousRank`, `rankChange` (positive = moved up) and `isNewInChart` on every entry.

# Actor input Schema

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

One Google Play country per line, as a two-letter code: us, gb, jp, de, fr, kr, br, in … (the United Kingdom is gb). Every country is a separate chart. Codes Google Play has no store of its own for are rejected.

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

Which charts to read: top free, top paid and/or top grossing. Each one is read for every country and category you give.

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

Optional. One category per line, by Google Play id (GAME, HEALTH_AND_FITNESS, FINANCE, TOOLS, GAME_PUZZLE …) or by name (Health & Fitness, Games, Games: Puzzle …). Leave empty for the overall chart of apps, which has no games in it (Google Play keeps games in their own charts): add GAME or a game subcategory such as GAME_PUZZLE to read games.

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

How many apps to read from the top of each chart. Google Play returns at most 200 per chart, so 200 is the maximum. Some charts, mostly top paid, are shorter than that.

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

Language of the app names and category names, as a Google Play language code: en, ja, de, fr, es, pt-BR, zh-TW … The ranks do not depend on it.

## Actor input object example

```json
{
  "countries": [
    "us"
  ],
  "charts": [
    "top-free"
  ],
  "limit": 100,
  "language": "en"
}
```

# Actor output Schema

## `entries` (type: `string`):

Every app in every chart with its rank, the rank at your last run, price, developer and rating.

## `summaries` (type: `string`):

Per chart: new entries, apps that dropped out, biggest risers and fallers since your last run.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/google-play-top-charts-tracker").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"],
}

# Run the Actor and wait for it to finish
run = client.actor("northbell/google-play-top-charts-tracker").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"
  ]
}' |
apify call northbell/google-play-top-charts-tracker --silent --output-dataset

```

## MCP server setup

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

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/UrdnpuywztjJavptm/builds/cjjVRMPIXAPd9ktWW/openapi.json