# App Store Top Charts & Rank Tracker (`datawright-labs/app-store-top-charts`) Actor

Apple App Store top charts for any country and category with rank history, movers and app details.

- **URL**: https://apify.com/datawright-labs/app-store-top-charts.md
- **Developed by:** [Datawright Labs](https://apify.com/datawright-labs) (community)
- **Categories:** Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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

**Get the Apple App Store top charts for any country and category, and track how apps move between runs.** This Actor collects the **Top Free, Top Paid and Top Grossing** charts for **iPhone and iPad**, up to **100 ranks per chart**, in **as many countries as you want in one run**, for the overall store or any of **40+ categories and game sub-genres**. Each entry can be enriched with **rating, number of ratings, price, current version, last update date, age rating, size and languages**.

Run it on a schedule and it becomes an **App Store rank tracker**: every run is compared with the previous one, so each row tells you its **previous rank, rank change, whether it's a new entry or a re-entry, its best rank and its recent rank history**. Switch to **"Only changes"** to get just the movers.

Data comes from **Apple's own public chart feeds** (the iTunes RSS charts, with Apple's marketing RSS as a fallback) and the **iTunes Lookup API**. No login, no browser, no scraping of app pages, so runs are fast, cheap and reliable.

### What you get

- 📊 **6 charts**: top free, top paid and top grossing, each for iPhone and iPad.
- 🌍 **Multi-country**: any App Store storefront (`us`, `gb`, `de`, `jp`, `br`, `in`, `kr`...), all in one run and one dataset.
- 🗂️ **Categories**: overall plus Games, Finance, Health & Fitness, Productivity, Shopping, Education, Photo & Video, Social Networking... and game sub-genres (Puzzle, Casual, Strategy, RPG, Casino...).
- ⭐ **App details**: average rating, rating count, current-version rating, version, last update, price and currency, bundle id, developer id and website, age rating, minimum iOS, size, languages, iPad support.
- 📈 **Rank history & movers**: `previousRank`, `rankChange` (+ = moved up), `movement` (`up`, `down`, `same`, `new`, `re-entry`, `dropped`), `isNewEntry`, `bestRank`, `appearances`, `firstSeenAt` and the last 10 ranks (`rankHistory`).
- 🧾 A **SUMMARY** record per run: charts fetched, failures, rows per chart, and which snapshot each chart was compared with.

### Use cases

- **App Store Optimization (ASO)**: track your app's and competitors' ranks per category and country every day.
- **Market research & competitive intelligence**: spot breakout apps and games early, see who climbs the grossing charts after a launch, a feature or a price change.
- **Mobile marketing & UA**: measure the chart impact of campaigns, featuring and seasonal events.
- **Investors & analysts**: build a daily dataset of top grossing apps per market as a revenue proxy.
- **Lead generation**: find fast-growing app developers (with their website) in any category and country.
- **Newsletters & dashboards**: "biggest movers of the day" or "new in the top 100" feeds straight into Google Sheets, Slack or a BI tool.

### How to use it

1. Enter one or more **countries** and pick the **charts**.
2. Optionally pick **categories** (each becomes its own chart, next to the overall one).
3. Choose **ranks per chart** (up to 100) and keep **app details** on.
4. Click **Start**. Export to CSV, Excel, JSON or Google Sheets, or call it via the API, Zapier, Make or n8n.
5. To track ranks, **schedule** the Actor (e.g. daily). Every run is compared with the previous run that used the same **History name**.

#### Input example

```json
{
  "countries": ["us", "gb", "de"],
  "charts": ["top-free", "top-grossing"],
  "genres": ["6014", "6015"],
  "limit": 50,
  "enrich": true,
  "trackRankChanges": true
}
```

Category ids: 6014 Games, 6015 Finance, 6013 Health & Fitness, 6007 Productivity, 6024 Shopping, 6017 Education, 6008 Photo & Video, 6005 Social Networking, 6016 Entertainment, 6000 Business, 6026 Developer Tools; game sub-genres 7001-7019 (e.g. 7012 Puzzle, 7003 Casual, 7017 Strategy). The input form lists them all.

### Output example

```json
{
  "country": "us",
  "chart": "top-free",
  "chartName": "Top Free iPhone Apps",
  "device": "iphone",
  "genreId": null,
  "genreName": "All apps",
  "rank": 1,
  "previousRank": 4,
  "rankChange": 3,
  "movement": "up",
  "isNewEntry": false,
  "previousSnapshotAt": "2026-10-18T18:16:24.313Z",
  "bestRank": 1,
  "appearances": 14,
  "snapshotsInHistory": 14,
  "firstSeenAt": "2026-10-06T06:00:02.120Z",
  "rankHistory": [{ "date": "2026-10-18T18:16:24.313Z", "rank": 4 }, { "date": "2026-10-19T18:16:24.313Z", "rank": 1 }],
  "appId": "6448311069",
  "bundleId": "com.openai.chat",
  "name": "ChatGPT",
  "developer": "OpenAI OpCo, LLC",
  "developerId": 1684349733,
  "price": 0,
  "currency": "USD",
  "formattedPrice": "Free",
  "category": "Productivity",
  "releaseDate": "2023-05-18",
  "appUrl": "https://apps.apple.com/us/app/chatgpt/id6448311069",
  "averageUserRating": 4.83,
  "userRatingCount": 11438836,
  "version": "1.2026.279",
  "currentVersionReleaseDate": "2026-10-16T15:51:32Z",
  "contentRating": "12+",
  "minimumOsVersion": "18.0",
  "fileSizeMb": 268.7,
  "sellerUrl": "https://openai.com/chatgpt",
  "enrichStatus": "ok",
  "source": "itunes-rss",
  "chartUpdatedAt": "2026-10-19T18:16:20.000Z",
  "scrapedAt": "2026-10-19T18:16:24.313Z"
}
```

The dataset has two views: **Chart entries** (rank, app, rating, price) and **Rank changes** (previous rank, change, movement, best rank, first seen).

### How rank tracking works

- After each chart is collected, its **full top 100** is saved as a snapshot in a named key-value store in your own Apify account, `app-store-top-charts-history` (one record per history name + country + chart + category; the last 60 snapshots are kept).
- The next run with the same **History name** compares against the latest snapshot. On the very first run there's nothing to compare with, so the movement fields are empty.
- `new` = never seen in the stored history; `re-entry` = was on the chart in an older snapshot; `dropped` (optional) = was in the previous top N, isn't now.
- **Only changes** mode saves only movers, so a daily schedule costs just a few cents. Its first run saves the baseline and returns no rows.
- Apple refreshes the charts several times a day; for a clean daily history, schedule one run per day.

### Example tasks

Copy one of these into the JSON tab of the input (or save it as a Task) to get started quickly.

**Daily movers in the US top 100 (schedule it once a day)**

```json
{
  "countries": ["us"],
  "charts": ["top-free", "top-paid", "top-grossing"],
  "outputMode": "changes",
  "minRankChange": 5,
  "includeDropped": true
}
```

**Top grossing games in the 10 biggest markets**

```json
{
  "countries": ["us", "jp", "cn", "kr", "gb", "de", "fr", "ca", "au", "br"],
  "charts": ["top-grossing"],
  "genres": ["6014"],
  "includeOverall": false,
  "limit": 100
}
```

**Category snapshot for ASO: Finance and Health & Fitness, iPhone and iPad**

```json
{
  "countries": ["us", "gb"],
  "charts": ["top-free", "top-free-ipad"],
  "genres": ["6015", "6013"],
  "includeOverall": false,
  "limit": 50,
  "historyKey": "aso-finance-health"
}
```

### How much does it cost to scrape the App Store top charts?

You pay **$0.001 per chart entry** saved ($1 per 1,000 entries). Charts that fail to load and entries whose app-details lookup failed are free, and there is no start fee.

| Job | Entries | Cost |
|---|---|---|
| US Top Free, top 100 | 100 | **$0.10** |
| US Top Free + Top Paid + Top Grossing | 300 | **$0.30** |
| 3 charts × 10 countries | 3,000 | **$3** |
| Daily "only changes" tracker, 1 chart, 1 country (~15 movers/day) | ~450/month | **~$0.45/month** |

- Apify's **free plan includes $5 of monthly credit**, i.e. about **5,000 chart entries a month for free**.
- Paid Apify plans get automatic discounts: **Silver -10%**, **Gold and above -20%**.
- Use **Maximum cost per run** to hard-cap spend; the Actor stops cleanly at the limit.

### App Store top charts scraper vs. the alternatives

| | This Actor | Checking the App Store app by hand | Reading Apple's RSS feeds yourself | ASO / app-intelligence suites |
|---|---|---|---|---|
| Top Free, Top Paid, Top Grossing, iPhone + iPad | ✅ | ✅ one at a time | ✅ after you write the code | ✅ |
| Many countries and 40+ categories in one run | ✅ | ❌ | DIY loops + validation | ✅ |
| Rating, rating count, price, version, size per app | ✅ built-in lookup | manual | DIY second API | ✅ |
| Rank history, movers, new entries, drop-outs | ✅ built in | ❌ | DIY state | ✅ |
| CSV / Excel / JSON / Google Sheets export | ✅ | ❌ | DIY | varies |
| Cost model | $1 per 1,000 entries, no subscription | free, manual | free + your time | monthly or annual plan |

### Use it as an API (Python, JavaScript, cURL, MCP)

Every Apify Actor is also a REST API, so you can call this App Store top charts API from your own code, a no-code tool or an AI agent.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datawright-labs/app-store-top-charts").call(run_input={"countries": ["us"], "charts": ["top-free", "top-grossing"], "limit": 100})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('datawright-labs/app-store-top-charts').call({"countries": ["us"], "charts": ["top-free", "top-grossing"], "limit": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### cURL (run and get results in one request)

```bash
curl -X POST "https://api.apify.com/v2/acts/datawright-labs~app-store-top-charts/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"countries": ["us"], "charts": ["top-free", "top-grossing"], "limit": 100}'
```

#### AI agents (MCP)

Add `https://mcp.apify.com/?tools=datawright-labs/app-store-top-charts` to Claude, Cursor or any MCP client and the agent can run it as a tool.

Results can also go straight to **Google Sheets, Slack, Make, Zapier, n8n, Airbyte or a webhook** via Apify integrations, and you can run it on a **Schedule**.

### FAQ

#### Where does the data come from?

From Apple's public chart feeds (`itunes.apple.com/{country}/rss/...`, the same feeds that power app chart widgets) and Apple's public iTunes Lookup API. The Actor makes one feed request per chart and one lookup per 100 apps, at a gentle rate, and collects no personal data.

#### Why only 100 ranks?

Apple's public feeds publish the top 100 of each chart. That's also what the App Store app shows.

#### Do the charts match what I see on my phone?

They match Apple's published chart feeds for that country. The App Store app can also show personalized or editorial lists, which aren't charts.

#### Is Google Play supported?

No, this Actor covers the Apple App Store (iPhone and iPad) only.

#### An unknown country or a category with no apps?

A storefront that doesn't exist returns an error in the SUMMARY and is not charged. Some small categories (e.g. Stickers) have empty charts in some countries.

#### Is there an App Store top charts API?

Apple publishes public chart feeds (RSS/JSON) for every storefront, but they are split by country, chart, device and genre and don't include history. This Actor calls them for you, adds app details from the iTunes Lookup API, and returns one clean table over the Apify API.

#### How do I track an app's ranking every day?

Turn on rank tracking, give the run a history key, and add a daily Schedule. Each run records rank, previous rank, rank change, best rank and the last 10 ranks for every app.

#### Can I get the top grossing apps for a specific country or category?

Yes. Pick `top-grossing`, add the country codes (e.g. `us`, `gb`, `jp`) and the categories or game genres you care about.

#### Can I get alerts when a new app enters the top 100?

Yes. Use "Only changes" mode so each run returns just the movers, new entries and drop-outs, then send them to Slack, email or a webhook with an Apify integration.

### More tools from Datawright Labs

- [Bulk PageSpeed & Core Web Vitals Checker](https://apify.com/datawright-labs/pagespeed-auditor): audit PageSpeed / Lighthouse scores for many URLs.
- [Sitemap URL Extractor](https://apify.com/datawright-labs/sitemap-url-extractor): get every URL of a site from its sitemaps.
- [Website Screenshot API](https://apify.com/datawright-labs/website-screenshot): bulk full-page screenshots and PDFs.
- [Google Autocomplete Keyword Scraper](https://apify.com/datawright-labs/autocomplete-keyword-scraper): long-tail keyword ideas from Google, YouTube and Bing.
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/datawright-labs/ats-jobs-scraper): normalized job feeds from 5 ATS platforms.
- [Broken Link Checker](https://apify.com/datawright-labs/broken-link-checker): find broken links, images and redirects across a whole site.

Tip: pair it with the **Google Autocomplete Keyword Scraper** (YouTube engine) for App Store keyword ideas around the apps that are climbing.

Made by **Datawright Labs**: reliable, fairly priced web data tools. Questions or a missing feature? Open an issue on the Issues tab; we usually reply within a day.

# Actor input Schema

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

Two-letter App Store country codes (ISO 3166), e.g. us, gb, de, fr, jp, br, in, ca, au. Each country has its own charts.

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

Which App Store charts to collect. Top grossing ranks apps by revenue (in-app purchases and subscriptions included).

## `genres` (type: `array`):

Optional App Store categories (genres). Each selected category is collected as its own chart in addition to the overall 'All apps' chart. Leave empty for the overall charts only.

## `includeOverall` (type: `boolean`):

Also collect the overall chart when categories are selected. Turn off to get only the category charts.

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

How many top positions to save per chart (1-100; Apple publishes the top 100).

## `enrich` (type: `boolean`):

Look up every charted app in Apple's iTunes Lookup API: average rating, rating count, current version and its release date, formatted price, content rating, size, languages, seller. Batched (100 apps per request), adds only seconds.

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

Save each chart snapshot in a named key-value store in your account ('app-store-top-charts-history') and compare with the previous run: previous rank, rank change, up/down/new/re-entry, best rank, rank history. Schedule the Actor (e.g. daily) to build a rank history.

## `outputMode` (type: `string`):

'All entries' saves every chart position. 'Only changes' saves just movers: new entries, re-entries, dropped apps and rank changes of at least the minimum below (you pay only for those rows). The first run in 'Only changes' mode saves a baseline and returns no rows.

## `minRankChange` (type: `integer`):

In 'Only changes' mode, report an app that stayed on the chart only if it moved at least this many positions.

## `includeDropped` (type: `boolean`):

Add a row (movement = 'dropped') for each app that was in the previous snapshot's top N but isn't any more. Its current rank is filled in if it's still in the top 100.

## `historyKey` (type: `string`):

Separate rank histories, e.g. one per client or schedule. Runs with the same name compare with each other.

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

Not needed normally: Apple's public feeds work without a proxy. Use it only if you see repeated HTTP 403/429 errors.

## Actor input object example

```json
{
  "countries": [
    "us",
    "gb"
  ],
  "charts": [
    "top-free",
    "top-paid",
    "top-grossing"
  ],
  "genres": [],
  "includeOverall": true,
  "limit": 100,
  "enrich": true,
  "trackRankChanges": true,
  "outputMode": "all",
  "minRankChange": 1,
  "includeDropped": false,
  "historyKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every chart position with app details and rank changes.

## `summary` (type: `string`):

SUMMARY record: charts fetched, failures, rows per chart, history snapshot compared with.

# 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"
    ],
    "charts": [
        "top-free",
        "top-paid",
        "top-grossing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datawright-labs/app-store-top-charts").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",
    ],
    "charts": [
        "top-free",
        "top-paid",
        "top-grossing",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("datawright-labs/app-store-top-charts").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"
  ],
  "charts": [
    "top-free",
    "top-paid",
    "top-grossing"
  ]
}' |
apify call datawright-labs/app-store-top-charts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datawright-labs/app-store-top-charts"
        }
    }
}
```

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/G6zhPmDOTOi5DL82E/builds/VtNpgCzVYO5UsH9fj/openapi.json