# Podcast Scraper: Shows, Episodes & Top Charts (`glitchbound/podcast-scraper`) Actor

Scrape Apple Podcasts: search shows by keyword or genre, pull episode lists with audio URLs and durations, and read Top Podcast charts by country. Built on official public endpoints.

- **URL**: https://apify.com/glitchbound/podcast-scraper.md
- **Developed by:** [Daniel Meshulam](https://apify.com/glitchbound) (community)
- **Categories:** Automation, News, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 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/platform/actors/running/actors-in-store#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

## Podcast Scraper: Shows, Episodes & Top Charts

Three podcast tools in one Actor, built on Apple Podcasts' public directory, the same catalogue that backs most podcast apps. No key, no login.

### What it does

| Mode | What you get |
|---|---|
| **Search shows** | Find podcasts by keyword and genre, publisher, episode count, artwork, RSS feed URL |
| **Episodes** | Any show's episodes with title, description, duration, release date and **the direct audio URL** |
| **Top charts** | Apple's Top Podcasts ranking per country and genre, with `chartedAt` for daily tracking |

Competing Actors typically do one of these. Running all three in a single job keeps the output in one consistent shape.

### Input example

```json
{
  "searchTerms": ["true crime"],
  "chartCountries": ["us", "gb"],
  "genre": "true-crime",
  "maxResults": 50,
  "includeEpisodes": true,
  "maxEpisodesPerShow": 25
}
```

### Use cases

- **Feed an LLM**: episode descriptions and audio URLs are ready for transcription and summarising
- **Chart tracking**: schedule it daily to see which shows climb, and in which countries
- **Competitive research**: how often does a rival publish, and how long are their episodes?
- **Ad / sponsorship prospecting**: find shows in a genre with real publishing cadence
- **Podcast app / directory**: bootstrap a catalogue with real metadata

### What this replaces

There is no Apple Podcasts API in the sense people mean when they search for
one. What exists is the **iTunes Search API** plus Apple's public **top
podcasts RSS** feeds, and this Actor is a typed wrapper over both:

| You want | Endpoint behind it | Input to use |
|---|---|---|
| Find shows by keyword | `itunes.apple.com/search` | `searchTerms` |
| One show by its Apple ID | `itunes.apple.com/lookup` | `showIds` |
| A country's chart | `itunes.apple.com/<cc>/rss/toppodcasts` | `chartCountries` |
| Episodes with audio | the show's own **podcast RSS feed** | `includeEpisodes` |

The `feedUrl` on every show row is the show's real RSS feed, so you can hand it
straight to any podcast RSS parser and keep going without this Actor.

**Countries.** The country goes into Apple's URL, so any storefront chart works:
`us`, `gb`, `de`, `fr`, `es`, `it`, `nl`, `se`, `br`, `mx`, `jp`, `kr`, `in`,
`au`, `ca`, `il` and the rest. Pass several and each country's chart comes back
in the same run, tagged with the country it came from.

**Genres**: `all`, `arts`, `business`, `comedy`, `education`, `fiction`,
`government`, `health-fitness`, `history`, `kids-family`, `leisure`, `music`,
`news`, `religion-spirituality`, `science`, `society-culture`, `sports`,
`technology`, `true-crime`, `tv-film`.

### Notes

- **Audio URLs** come from the show's own feed entry, so episodes can be downloaded or transcribed directly.
- Apple serves up to ~195 recent episodes per show.
- Rows carry a `recordType` (`show`, `episode`, `chartEntry`, `error`) so mixed output stays easy to filter.
- Rows with an `error` field name exactly what failed. **They are never charged.**
- Public directory data only, no accounts, no personal data.

### FAQ

#### Do I need an Apple Podcasts or Spotify API key?

No. This reads Apple's public podcast directory, the same catalogue that backs
most podcast apps, with no key and no login.

#### Can I get the actual audio file for an episode?

Yes. Each episode row carries the direct audio URL from the show's own feed
entry, so episodes can be downloaded, transcribed or summarised without a
separate lookup.

#### How many episodes can I get per show?

Apple serves up to roughly 195 recent episodes per show. For a complete back
catalogue you would need the show's own RSS feed, which is also returned on every
show row.

#### How do I track podcast chart rankings over time?

Set `chartCountries` and run it on a schedule. Every chart row carries
`chartedAt`, so consecutive runs give you a ranking history. Apple only ever
publishes the current chart.

#### Can I search podcasts by genre rather than keyword?

Yes. `genre` takes Apple's genre slugs, such as `true-crime`, and can be combined
with `searchTerms` to narrow a keyword search to one genre.

#### How do I tell the different row types apart?

Every row carries a `recordType` of `show`, `episode`, `chartEntry` or `error`, so
a run that combines all three modes stays easy to filter into separate tables.

#### Is this legal, and does it include personal data?

It is public directory metadata: show titles, publishers, descriptions, artwork
and feed URLs. No accounts, no listener data, no personal data.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search Apple Podcasts for, one per line (e.g. "true crime", "startup").

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

Also pull Apple's Top Podcasts chart for these countries (us, gb, de...). Schedule it daily to track which shows are rising.

## `showIds` (type: `array`):

Apple Podcasts collection IDs to look up directly. You can paste the URL instead of the identifier, e.g. https://podcasts.apple.com/us/podcast/the-daily/id1200361736 works.

## `genre` (type: `string`):

Restrict searches and charts to one genre.

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

Also pull each show's recent episodes: title, description, duration, release date and the direct audio URL. Ideal for transcription or LLM pipelines.

## `maxEpisodesPerShow` (type: `integer`):

Upper limit of episodes per show when episodes are enabled.

## `maxResults` (type: `integer`):

Shows per search term, and chart depth per country.

## `country` (type: `string`):

Two-letter country code for searches and lookups.

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

Proxy settings.

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

A hard ceiling on rows for the entire run, across every target. The per-target limits above cap each one separately, so fifty targets at twenty each is still a thousand rows; this caps the total. The run stops cleanly when it is reached and nothing beyond that point is fetched or charged. Leave empty for no ceiling.

## Actor input object example

```json
{
  "searchTerms": [
    "true crime"
  ],
  "genre": "all",
  "includeEpisodes": false,
  "maxEpisodesPerShow": 25,
  "maxResults": 25,
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Shows, episodes with audio URLs, and Apple Podcasts chart entries.

# 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 = {
    "searchTerms": [
        "true crime"
    ]
};

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

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

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "true crime"
  ]
}' |
apify call glitchbound/podcast-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=glitchbound/podcast-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/pSt5yQGq37CGJaqTW/builds/7RihC8a1eUJHD23FI/openapi.json