# Apple Podcast Charts Scraper (`deriverge/podcast-charts-scraper`) Actor

Top podcast charts from Apple Podcasts for any country, up to 100 shows each, with rank, publisher, RSS feed, episode count and the date of the newest episode. Narrow a chart to genres such as True Crime or Business, add ratings or episodes, or schedule it to catch new entrants.

- **URL**: https://apify.com/deriverge/podcast-charts-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** News, Social media, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 podcasts

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

## Apple Podcast Charts Scraper

Apple Podcast Charts Scraper reads the Apple Podcasts top chart of each country you list and returns one row per place: rank, show name, publisher, Apple ID, RSS feed, genres, episode count and the date of the newest episode. Enter country codes such as `us` or `gb` and click **Start**; the US top 100 came back in 3 seconds on 28 October 2026. Apple's chart feed stops at 100 places, so a genre chart is made from those 100 shows. It costs $2.40 per 1,000 podcasts on the Free plan ($1.20 on Business), and the $5 of monthly credit in Apify's Free plan covers about 2,000 podcasts.

### What data does it return?

Each chart place is a row with `type: "podcast"`:

| Field | Description |
|---|---|
| `chartRank`, `chartCountry`, `chartKind` | The place, the storefront code such as `us`, and `top` or `top-subscriber`. |
| `chartGenre` | The genre you asked for, such as `True Crime`, or `null` for the overall chart. In a genre, `chartRank` counts only that genre's shows. |
| `name`, `author` | Show title and publisher, for example `The Daily` by `The New York Times`. |
| `appleId`, `appleUrl`, `feedUrl` | Apple Podcasts ID such as `1200361736`, the show's Apple page, and the RSS feed of its episodes. |
| `genres`, `primaryGenre` | All Apple genres of the show and the main one, such as `["Daily News", "News"]` and `Daily News`. |
| `episodeCount`, `latestEpisodeAt` | How many episodes Apple lists and when the newest came out, ISO 8601 in UTC. |
| `ratingAverage`, `ratingCount` | Star average and number of ratings from the show's Apple page, such as `4.7` from `365612`. Filled with **Include ratings** on. |
| `website`, `language`, `podcastType`, `description` | From the show's own feed: web page, language code, `episodic` or `serial`, and the show description. Filled only with **Include episodes** on, because that is when the feed is read. |
| `artwork`, `explicit` | Cover image URL (600 by 600 pixels) and the explicit flag. |
| `key` | Row ID such as `chart:us:top:1488:1322200189`, which the new-only mode compares between runs. |

With **Include episodes** on, every show is followed by its newest episodes as rows with `type: "episode"`: `title`, `publishedAt`, `durationSeconds`, `audioUrl`, `episodeNumber`, `seasonNumber`, `summary` and the show they belong to in `podcastName` and `podcastKey`.

### How to scrape Apple Podcasts charts

1. In **Chart countries**, add two-letter storefront codes, one per line: `us`, `gb`, `au`, `ca`, `jp`. Every country is a separate chart.
2. Choose the **Chart**: top shows, or top subscriber shows, which Apple ranks by paid subscriptions.
3. For one or more genres, fill **Chart genres** with names such as `Business` or `Entrepreneurship`, or Apple genre IDs such as `1489`. Leave it empty for the overall chart.
4. Turn on **Include ratings** for the star average and count. Turn on **Include episodes** and set **Maximum episodes per podcast** if you also want each show's newest episodes.
5. Click **Start**. The rows are in the **Output** tab, ready to export as CSV, Excel or JSON, and the `SUMMARY` record in the key-value store has the counts and any notes, such as a storefront without a subscriber chart.

The run below, True Crime and Business in the US and UK charts with ratings, returned 65 shows in 39 seconds on 28 October 2026:

```json
{
  "chartCountries": ["us", "gb"],
  "chartGenres": ["True Crime", "Business"],
  "includeRatings": true
}
```

### Example output

The first True Crime show in the US chart, from that run on 28 October 2026. Episodes were off, so the four fields read from the feed are `null`.

```json
{
  "type": "podcast",
  "key": "chart:us:top:1488:1322200189",
  "source": "chart",
  "appleId": "1322200189",
  "name": "Crime Junkie",
  "author": "Audiochuck",
  "appleUrl": "https://podcasts.apple.com/us/podcast/crime-junkie/id1322200189",
  "feedUrl": "https://feeds.simplecast.com/qm_9xx0g",
  "website": null,
  "artwork": "https://is1-ssl.mzstatic.com/image/thumb/Podcasts126/v4/8c/35/04/8c350430-2fbf-98d0-0a25-00b76550ffeb/mza_13445204151221888086.jpg/600x600bb.jpg",
  "genres": [
    "True Crime"
  ],
  "primaryGenre": "True Crime",
  "language": null,
  "episodeCount": 533,
  "latestEpisodeAt": "2026-10-26T07:00:00.000Z",
  "explicit": false,
  "podcastType": null,
  "description": null,
  "ratingAverage": 4.7,
  "ratingCount": 365612,
  "chartRank": 1,
  "chartCountry": "us",
  "chartKind": "top",
  "chartGenre": "True Crime",
  "matchedQuery": null,
  "country": "us"
}
```

### How much does it cost to scrape Apple Podcasts charts?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 podcasts | $2.40 | $1.92 | $1.56 | $1.20 |
| Episode, per 1,000 | $0.50 | $0.40 | $0.325 | $0.25 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

The US top 100 is 100 podcast rows, $0.24 on the Free plan and $0.12 on Business. Adding the 5 newest episodes of every show makes 500 episode rows more, $0.25 on Free. Ratings are included in the podcast price, and episodes removed by the date or keyword filter are not charged.

### Limits

- A chart has at most 100 places, the length of Apple's official chart feed. A **Chart size** above 100 returns 100.
- The feed has no separate genre charts. A genre keeps the shows of that genre from the country's top 100 and numbers them in order: on 28 October 2026 the US chart held 27 Business and 21 True Crime shows, the UK chart 12 True Crime and 5 Business shows.
- Not every storefront has a subscriber chart. On 28 October 2026 the US and UK had one with 100 shows each and Germany had none; the run notes such a storefront and goes on with the rest.
- Apple's chart feed sometimes fails to answer. The actor asks its two addresses at once and tries up to 8 rounds, so a bad day can make a run about 90 seconds longer; a chart that never answers is named in the run summary.
- The actor keeps to Apple's pace: about 20 directory requests a minute and at most 2 show pages a second for ratings. If Apple keeps refusing, the actor stops asking and returns the rows it has, without switching IP addresses.
- Written listener reviews are not collected, only the rating average and count.
- One run takes at most 500 shows from all its charts together, the default of **Maximum podcasts**.

### Daily chart alerts

Turn on **Return only rows new since the last run**, give the run a **Watch name** such as `business-gb` or save it as a task, and schedule it once a day. Each run then returns and charges only shows that were not in the chart the previous time. The `CHANGES` record in the key-value store also lists the shows that dropped out and every rank that moved, at no charge.

### FAQ

#### Is it legal to scrape Apple Podcasts charts?

Apple publishes its chart feed openly so that websites and apps can show the charts, and its robots.txt sets no rule for it. The actor returns public show metadata with links to Apple and to each show's feed; it does not download audio and collects nothing about listeners. You are responsible for how you use the data.

#### Which countries and genres can I use?

Any Apple storefront code, such as `us`, `gb`, `de`, `au` or `jp`, and every Apple Podcasts genre and subgenre, by name or by Apple genre ID. A subgenre counts toward its main genre as well, so a Daily News show also appears under News. A genre the actor does not recognise is named in the run notes and skipped.

#### Can I get more than the top 100?

No. Apple's chart feed ends at 100, and the actor does not guess places beyond it. For shows outside the charts, search the directory with Apple Podcasts Scraper.

### Related scrapers

- [Apple Podcasts Scraper](https://apify.com/deriverge/apple-podcasts-scraper)
- [Podcast Episodes Scraper](https://apify.com/deriverge/podcast-episodes-scraper)
- [RSS Feed Scraper](https://apify.com/deriverge/rss-feed-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/podcast-charts-scraper/changelog.md

# Actor input Schema

## `chartCountries` (type: `array`):

Two-letter storefront codes whose top charts to read, for example us, gb, de, au, jp. One chart per country and genre.

## `chartGenres` (type: `array`):

Genre names or Apple genre IDs, for example Business, True Crime, Technology, Daily News or 1489. Subgenres work too, for example Entrepreneurship. Apple's official chart feed has no genre charts, so a genre returns the shows of that genre found in the overall top 100, in chart order. Leave empty for the overall chart.

## `chartKind` (type: `string`):

Both charts come from Apple's official chart feed and go to 100 entries. The subscriber chart ranks shows by paid subscriptions.

## `chartLimit` (type: `integer`):

Entries per chart, from the top. Apple's official chart feed lists up to 100, so larger values return 100.

## `includeRatings` (type: `boolean`):

Read the average rating and the number of ratings from each podcast's page. One extra request per podcast, no extra charge.

## `includeEpisodes` (type: `boolean`):

Read each podcast's feed and return its episodes with audio URL, duration, numbers and show notes. Charged per episode.

## `maxEpisodesPerPodcast` (type: `integer`):

Newest first. Podcast feeds carry the whole archive, so this is what keeps a broad run affordable.

## `episodesPublishedAfter` (type: `string`):

Drop episodes older than this date (YYYY-MM-DD). Episodes without a date are kept. Dropped episodes are never charged.

## `keywords` (type: `array`):

Keep only episodes whose title, show notes or categories contain at least one of these words or phrases as whole words, case-insensitive. Dropped episodes are never charged.

## `includeContent` (type: `boolean`):

Return the complete show notes as plain text in the content field. Otherwise summary holds the first 300 characters and content is null.

## `maxPodcasts` (type: `integer`):

Cap on distinct chart entries collected across all charts in the run.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only chart entries that were not there before. Schedule it daily and you have a chart alert that bills only for new entrants; the CHANGES record also lists rank moves and shows that dropped out.

## `watchName` (type: `string`):

Name of the snapshot used by the new-only mode, for example "true-crime-us". Runs from a saved task get a snapshot automatically even without a name.

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

Hard cap on returned rows in the run, podcasts and episodes together.

## Actor input object example

```json
{
  "chartCountries": [
    "us"
  ],
  "chartKind": "top",
  "chartLimit": 100,
  "includeRatings": false,
  "includeEpisodes": false,
  "maxEpisodesPerPodcast": 50,
  "includeContent": false,
  "maxPodcasts": 500,
  "newOnly": false,
  "maxItems": 5000
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per chart entry with rank, podcast, author, genre, feed URL, episode count, latest episode date and ratings when requested.

## `changes` (type: `string`):

New entrants, shows that dropped out and rank moves compared with the previous snapshot of the same watch name or task.

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

Counts per source, how many rows each filter dropped, feeds that could not be read and notes.

# 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 = {
    "chartCountries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/podcast-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 = { "chartCountries": ["us"] }

# Run the Actor and wait for it to finish
run = client.actor("deriverge/podcast-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 '{
  "chartCountries": [
    "us"
  ]
}' |
apify call deriverge/podcast-charts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deriverge/podcast-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/9Bv4FOeJ24YlY12iS/builds/QXin075czT97cczwP/openapi.json