# App Rankings Scraper (`publicmoney/app-rankings-scraper`) Actor

Extract Apple App Store top charts by country and category: top free, top paid, top grossing or newest apps with their rank, name, developer, category and price, for any storefront. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/app-rankings-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

App store rank is one of the few public signals that moves before a consumer company's earnings do. This Actor reads Apple's App Store top charts for any storefront and category and returns one structured record per ranked app: rank, name, developer, category and price. Pull the finance chart in eight countries and you have a comparable panel nobody has to buy.

### What it does

- Reads **four charts**: top free, top paid, top grossing and newest, which are different questions. Grossing tracks revenue, free tracks reach.
- Covers **any App Store storefront** by two-letter country code, so the same chart across markets is one run.
- Narrows to an **Apple genre**, so you can pull the finance, business or utilities chart instead of the overall list.
- Returns up to **Apple's maximum of 200 ranked apps** per country.
- Carries the **developer name** on every row, which is what lets you map a chart back to a listed company.
- Returns **one record per ranked app** with `rank` and `country`, so a cross-market panel is a single dataset.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Track a competitor's reach | Pull the top free chart in your genre and follow their `rank` over time |
| Watch revenue momentum | Use the top grossing chart, which tracks spend rather than downloads |
| Build a cross-market panel | Pass eight country codes and compare `rank` for the same app |
| Spot a launch early | Use the newest apps chart on a daily schedule |
| Map a chart to listed owners | Group by `developer` and join to your own ticker mapping |
| Feed a research agent | Call the Actor over MCP and let the model ask for a chart and market |

### Quick start

1. Click **Try for free**.
2. Add App Store country codes, one per line: `us`, `gb`, `de`, `jp`.
3. Pick a **Chart**: `topfreeapplications`, `toppaidapplications`, `topgrossingapplications` or `newapplications`.
4. Optionally set a **Genre id** to narrow it: `6015` is Finance, `6000` Business, `6002` Utilities. Leave it empty for the overall chart. Set **Limit** up to Apple's maximum of 200.
5. Click **Start**. Rows appear within seconds.
6. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `countries` | array | `us` | Two-letter App Store country codes |
| `chart` | string | `topfreeapplications` | Which chart: top free, top paid, top grossing or newest |
| `genreId` | string | empty | Apple genre id to narrow the chart. Empty gives the overall chart |
| `limit` | integer | `50` | Ranked apps per country, up to Apple's maximum of 200 |
| `maxItems` | integer | `0` | Caps how many records are written. `0` writes them all |

```json
{
    "countries": [
        "us",
        "gb",
        "de"
    ],
    "chart": "topgrossingapplications",
    "genreId": "6015",
    "limit": 50
}
```

### Output

One dataset item per ranked app per country, in rank order. A country or genre Apple does not serve comes back as a failure row rather than an empty result.

| Field group | Fields |
| --- | --- |
| Position | `status`, `country`, `chart`, `genreId`, `rank` |
| App | `name`, `developer`, `category`, `appId`, `url` |
| Price | `price`, `currency` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "country": "us",
    "chart": "topgrossingapplications",
    "genreId": "6015",
    "rank": 1,
    "name": "Coinbase",
    "developer": "Coinbase, Inc.",
    "category": "Finance",
    "appId": "886427730",
    "price": 0.0,
    "currency": "USD",
    "validFrom": "2026-09-06T05:30:00.000Z",
    "url": "https://apps.apple.com/us/app/coinbase/id886427730"
}
```

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~app-rankings-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countries": ["us", "gb", "de"], "chart": "topgrossingapplications", "genreId": "6015", "limit": 50}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/app-rankings-scraper").call(run_input={"countries": ["us", "gb", "de"], "chart": "topgrossingapplications", "genreId": "6015", "limit": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["validFrom"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/app-rankings-scraper"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Record with data | $0.002 | $0.0007 |
| Actor start | $0.00005 per GB | Same |

A record that returned no data is published as a failure row and is **never charged**. Six volume tiers apply, so the per-record price falls with monthly volume.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| A country returns `failed` | The code is not an App Store storefront. Use two-letter codes such as `us`, `gb`, `de`, `jp`. |
| A genre returns nothing | The genre id is wrong. Apple's ids are numeric, so Finance is `6015`, not the word. |
| I asked for 200 and got fewer | Apple serves fewer than 200 in some small storefronts and narrow genres. That is the source. |
| `price` is 0 on the paid chart | The app is temporarily free. The chart position was earned as a paid app. |
| Google Play is missing | This Actor reads the Apple App Store only. Play Store charts are not covered. |

### FAQ

#### Does Apple have an App Store rankings API?

Apple publishes chart feeds for its storefronts but no supported product API for rankings, and the commercial alternatives are expensive. This Actor reads the public charts.

#### Does it cover Google Play?

No, Apple App Store only. If Play coverage matters, treat this as one of two signals rather than the whole picture.

#### Which chart should I use?

They answer different questions. Top grossing tracks money spent, so it is the closest thing to a revenue signal. Top free tracks reach and installs. Newest catches launches.

#### Where do I find the genre ids?

They are Apple's numeric genre codes. Finance is `6015`, Business `6000`, Utilities `6002`. Leave the field empty for the overall chart.

#### Can I get download or revenue numbers?

No. Apple publishes rank, not volume. Rank is a relative signal, which is why the grossing chart over time is more useful than any single day.

#### Do I need a the App Store API key?

No. You need an Apify token to call the Actor over the API. No the App Store credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

#### Is it legal to scrape the App Store?

This Actor reads Apple's public App Store charts, which need no login, and it collects no personal data beyond the developer name Apple publishes on each listing. How you use chart data commercially is governed by your own agreements, so take your own legal advice for your use case.

### Changelog

- **0.0.2** Added genre filtering, the newest-apps chart and multi-country runs.
- **0.0.1** First release. Top charts per country.

### Feedback

Found a field the App Store publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

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

Two-letter App Store country codes, one per line. Each country is a separate storefront with its own chart, so the same app can rank differently in each. Every country you add multiplies the records returned by the limit. Examples: 'us', 'gb', 'de', 'jp'. Default is 'us'.

## `chart` (type: `string`):

Which of Apple's four top charts to read. Top grossing ranks by money spent and is the closest thing to a revenue signal; top free ranks by installs and measures reach; top paid ranks paid downloads; newest surfaces recent launches. Examples: 'topgrossingapplications', 'topfreeapplications', 'newapplications'. Default is 'topfreeapplications'.

## `genreId` (type: `string`):

Apple's numeric genre id, used to read one category's chart instead of the overall list. Leave it empty for the overall chart across all categories. Examples: '6015' Finance, '6000' Business, '6002' Utilities.

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

How many ranked apps to return per country, counted from rank 1. Apple serves at most 200, and small storefronts or narrow genres return fewer than you ask for. Examples: 10, 50, 200. Default is 50.

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

Maximum number of countries to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every country given.

## Actor input object example

```json
{
  "countries": [
    "us",
    "gb"
  ],
  "chart": "topfreeapplications",
  "limit": 50,
  "maxItems": 0
}
```

# Actor output Schema

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

One item per requested input, in the default dataset.

# 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",
        "gb"
    ],
    "chart": "topfreeapplications",
    "limit": 50,
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/app-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 = {
    "countries": [
        "us",
        "gb",
    ],
    "chart": "topfreeapplications",
    "limit": 50,
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/app-rankings-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",
    "gb"
  ],
  "chart": "topfreeapplications",
  "limit": 50,
  "maxItems": 0
}' |
apify call publicmoney/app-rankings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicmoney/app-rankings-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/Qs8eCNKVHBA1Ex4rd/builds/mtxG8Rartw1PedUbN/openapi.json