# Podcast Directory Scraper — Apple Podcasts Search & Episodes (`fabrikit/podcast-directory-scraper`) Actor

Apple Podcasts directory scraper: search shows by keyword, ID, URL or the top chart of any country and genre; get name, author, RSS feed URL, artwork, genres, episode count and latest release as flat JSON, plus optional episodes from each feed. No API key. From US$2.10 per 1,000.

- **URL**: https://apify.com/fabrikit/podcast-directory-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** News, Lead generation, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 podcast scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Podcast Directory Scraper — Apple Podcasts Search & Episodes

**Podcast Directory Scraper extracts podcast listings from podcasts.apple.com**: search any keyword, paste Apple Podcasts IDs or URLs, or read the Top Podcasts chart of any country and genre, and get one flat record per show with its name, author, RSS feed URL, artwork, genres, episode count and latest release date. Switch on the episodes add-on and the Actor opens each show's RSS feed to add the description, language, website and categories, and saves the newest episodes with title, date, duration, audio URL, show notes and season / episode numbers. It uses Apple's public directory endpoints and the public feeds, so there is no API key, no login and no browser, and you pay per podcast and per episode saved.

It is the podcast sibling of our [App Store Apps Scraper](https://apify.com/fabrikit/app-store-apps-scraper), which reads app listings from the same Apple directory service.

### What data does it return?

Podcast records (`recordType: "podcast"`):

| Field | Example | Notes |
|---|---|---|
| `podcastId`, `name`, `url` | `1200361736`, `The Daily`, `https://podcasts.apple.com/us/podcast/the-daily/id1200361736` | Apple show ID and page |
| `author`, `authorId`, `authorUrl` | `The New York Times`, `121664449` | author / producer as listed in the directory |
| `feedUrl` | `https://feeds.simplecast.com/Sl5CSM3S` | the show's RSS feed |
| `artworkUrl`, `artworkUrlSmall` | 600 px and 100 px artwork | |
| `primaryGenre`, `primaryGenreId`, `genres`, `genreIds` | `Daily News`, `1526`, `["Daily News", "News"]` | Apple's genre tree |
| `episodeCount`, `latestEpisodeDate` | `2754`, `2026-10-19T09:45:00.000Z` | as reported by Apple |
| `explicit`, `contentRating` | `false`, `Clean` | |
| `description`, `language`, `website`, `copyright`, `feedType`, `feedCategories`, `feedEpisodeCount`, `feedLatestEpisodeDate`, `feedImageUrl` | from the RSS feed | filled when episodes are included |
| `ownerName`, `ownerEmail` | `The New York Times`, `thedaily@nytimes.com` | only with `includeOwnerContact`; role or brand mailboxes on company domains only |
| `feedError` | `feed not found (HTTP 404)` | why a feed could not be read |
| `country`, `source`, `sourceInput`, `position`, `chartRank`, `chartGenre` | `us`, `chart`, `Top Business podcasts`, `4`, `4`, `Business` | where the record came from and its rank there |

Episode records (`recordType: "episode"`): `podcastId`, `podcastName`, `title`, `guid`, `publishedAt` (ISO 8601), `durationSecs`, `audioUrl`, `audioType`, `audioBytes`, `description` (show notes as plain text, first 1,000 characters), `link`, `season`, `episodeNumber`, `episodeType` (full / trailer / bonus), `explicit`, `imageUrl`, `author`, `feedUrl`, `position` (1 = newest).

E-mail addresses and phone numbers are removed from descriptions and show notes.

### Use cases

- **Podcast discovery and market research** — every show Apple lists for a keyword, with genre, episode count and how recently it published; compare countries by changing `country`.
- **Charts tracking** — the Top Podcasts chart of a country, overall or per genre (Business, True Crime, Technology, ...), with `chartRank` on each record; schedule it weekly to follow movements.
- **RSS feed finder** — the `feedUrl` of thousands of shows in one run, ready for your own player, transcription pipeline or monitoring tool.
- **Episode monitoring** — the newest episodes of a watch list of shows (audio URLs, durations, publication dates) for alerts, newsletters or content analysis.
- **Sponsorship and outreach lists** — shows, producers and websites in a genre (company and product data; owner mailboxes only when they are generic role addresses).
- **AI agents and datasets** — flat JSON with ISO dates and numeric fields for LLM pipelines, dashboards and spreadsheets.

### How to use it

1. Type one or more **search terms**, and/or paste **podcast IDs / URLs / show names**, and/or tick **Top chart** (optionally with a **genre**).
2. Choose the **directory country** (`us`, `gb`, `de`, `br`, `jp`, ...).
3. Optionally switch on **Include episodes** and set how many of the newest episodes to keep per show.
4. Set **Maximum podcasts** and run. Download JSON, CSV or Excel, or read the dataset through the API.

#### Input example: find marketing podcasts in the US directory

```json
{
  "searchTerms": ["marketing"],
  "country": "us",
  "maxItems": 20
}
```

#### Input example: Top 50 Business podcasts in Germany with their 5 newest episodes

```json
{
  "topChart": true,
  "genre": "Business",
  "chartSize": 50,
  "country": "de",
  "includeEpisodes": true,
  "maxEpisodesPerPodcast": 5,
  "maxItems": 50
}
```

#### Input example: a watch list of shows

```json
{
  "podcastIds": [
    "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
    "1588397602",
    "Marketing Brew Weekly"
  ],
  "includeEpisodes": true,
  "maxEpisodesPerPodcast": 3,
  "maxItems": 10
}
```

Sources can be mixed: the Actor processes IDs first, then show names, then the chart, then search terms; a show that already appeared is skipped (one record per show and country) and the run stops exactly at `maxItems` podcasts. When `genre` is set, the chart is read for that genre and search results outside it are dropped (subgenres count: *Marketing* belongs to *Business*).

### Output example

A podcast record and one of its episodes from a local run on 20 October 2026 (texts shortened):

```json
{
  "recordType": "podcast",
  "podcastId": 1200361736,
  "name": "The Daily",
  "url": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
  "author": "The New York Times",
  "authorId": 121664449,
  "authorUrl": "https://podcasts.apple.com/us/artist/the-new-york-times/121664449",
  "feedUrl": "https://feeds.simplecast.com/Sl5CSM3S",
  "artworkUrl": "https://is1-ssl.mzstatic.com/image/thumb/Podcasts221/v4/ab/64/66/.../600x600bb.jpg",
  "primaryGenre": "Daily News",
  "primaryGenreId": 1526,
  "genres": ["Daily News", "News"],
  "genreIds": [1526, 1489],
  "episodeCount": 2754,
  "latestEpisodeDate": "2026-10-19T09:45:00.000Z",
  "explicit": false,
  "contentRating": "Clean",
  "description": "This is what the news should sound like. The biggest stories of our time, told by the best journalists in the world. ...",
  "language": "en",
  "website": "https://www.nytimes.com/the-daily",
  "feedType": "episodic",
  "feedCategories": ["News", "Daily News"],
  "feedEpisodeCount": 66,
  "feedLatestEpisodeDate": "2026-10-19T09:45:00.000Z",
  "feedError": null,
  "country": "us",
  "source": "lookup",
  "sourceInput": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
  "position": 1,
  "scrapedAt": "2026-10-20T07:25:44.919Z"
}
```

```json
{
  "recordType": "episode",
  "podcastId": 1200361736,
  "podcastName": "The Daily",
  "title": "Inside Putin’s Plan to Cripple Ukraine This Winter",
  "guid": "1897475d-9b60-447d-ba9b-79aa09f59551",
  "publishedAt": "2026-10-19T09:45:00.000Z",
  "durationSecs": 1740,
  "audioUrl": "https://dts.podtrac.com/redirect.mp3/.../default.mp3?aid=rss_feed",
  "audioType": "audio/mpeg",
  "audioBytes": 27851293,
  "description": "President Trump said he was making an energy deal with President Vladimir V. Putin of Russia ...",
  "link": "https://www.nytimes.com/the-daily",
  "season": null,
  "episodeNumber": null,
  "episodeType": "full",
  "explicit": false,
  "position": 1,
  "scrapedAt": "2026-10-20T07:25:44.926Z"
}
```

A `SUMMARY` record in the key-value store lists, per source, how many shows Apple returned and how many were saved, the IDs that were not found, feeds that could not be read, the number of requests and the proxy used.

### Pricing

Pay per event, proxy and compute included:

- **US$2.10 per 1,000 podcasts** saved (US$0.0021 each) — `podcast-result`
- **US$0.50 per 1,000 episodes** saved (US$0.0005 each) — `episode-result`, only when `includeEpisodes` is on

Examples: 1,000 podcasts without episodes = US$2.10; 100 podcasts with their 20 newest episodes (2,000 episodes) = US$0.21 + US$1.00 = US$1.21; the Top 200 chart of a genre = US$0.42. Duplicates, shows Apple does not return and feeds that cannot be read are never charged. With a maximum cost per run set in Apify, the Actor stops cleanly at that limit.

### How it compares

- **Calling Apple's endpoints yourself** is free but limited: a search gives at most 100 shows with no paging, the chart feed has only names and IDs, and the episodes are not in the directory at all — they live in each show's RSS feed, in a dozen different flavours. This Actor batches the lookups, validates genres, de-duplicates, parses the feeds into one flat schema (durations in seconds, ISO dates, HTML stripped), respects Apple's per-IP rate limit and gives you scheduling, storage and integrations.
- **Other podcast scrapers in Apify Store** charge from about US$2.50 to US$50 per 1,000 results, and several focus on host contact details. This one is priced at US$2.10 per 1,000 shows plus US$0.50 per 1,000 episodes, covers search, lookup and genre charts in any country, and keeps personal mailboxes out of the data by design.
- **Limits that come from Apple:** 100 shows per search term (use several or more specific terms), charts of up to 200 shows, and about 20 directory calls per minute per IP, so a run with many terms advances at roughly one term every 3 seconds. Episode data depends on each feed: some hosts omit the file size, season or episode numbers.

### Integrations

Run it from the Apify API, the JavaScript or Python client, or on a schedule in Apify Console, and send the dataset to Google Sheets, Airtable, n8n, Make, Zapier or a webhook. AI agents (Claude, ChatGPT, Cursor and any MCP client) can call it through the Apify MCP server, for example "find the top 20 technology podcasts in Brazil and their latest episode".

### FAQ

**Is it legal to scrape Apple Podcasts?** The Actor reads public directory metadata that Apple serves through its open search and chart endpoints, and public RSS feeds that podcasters publish for every player. Show names, feed URLs, genres and episode data describe products and companies; when the author of a show is a private person their name can be personal data under laws such as GDPR, CCPA or Chile's Ley 21.719, so handle the data accordingly. E-mail addresses and phone numbers are stripped from descriptions and show notes, and the feed owner's mailbox is saved only on request and only when it is a generic role or brand address on a company domain. This Actor is not affiliated with Apple and this is not legal advice.

**Do I need a proxy?** Normally no. Apify's datacenter proxy is used by default for Apple's endpoints; if Apple answers with its rate limit (HTTP 403 or 429) the Actor waits and retries, and after repeated blocks switches to a residential proxy in the directory country. RSS feeds are fetched over the datacenter connection.

**Why do I get fewer than 100 shows for a term?** Apple returns only what matches; many terms have fewer results, and the genre filter drops shows outside the chosen genre (`SUMMARY.filteredOutByGenre`).

**Which genres can I use?** The 19 Apple Podcasts genres and their subgenres, by name or ID: Arts, Business, Comedy, Education, Fiction, Government, Health & Fitness, History, Kids & Family, Leisure, Music, News, Religion & Spirituality, Science, Society & Culture, Sports, TV & Film, Technology, True Crime, and subgenres such as Marketing, Investing, Self-Improvement, Mental Health or Daily News. An unknown genre fails the run with a clear message instead of silently returning the overall chart.

**Can I get all episodes of a show?** Yes: set `maxEpisodesPerPodcast` up to 10,000. The Actor saves what the feed contains (`feedEpisodeCount`); some publishers keep only the latest episodes in the feed, and Apple's `episodeCount` may be higher.

**Why is a show missing?** It is not available in that country's directory, or the ID has a typo. Not-found IDs are listed in `SUMMARY.notFound` and in the log.

### Changelog

- **2026-10-20** — First version: keyword search, lookup by ID / URL / show name, Top Podcasts chart per country and genre, episodes and show details from RSS feeds, exact `maxItems`, pay per podcast and per episode.

### En español

**Podcast Directory Scraper** extrae fichas de podcasts del directorio de Apple Podcasts sin API key ni login: busca por palabra clave, por ID o URL del programa, o desde el ranking Top Podcasts de cualquier país y género. Por cada programa entrega nombre, autor, URL del feed RSS, portada, géneros, cantidad de episodios y fecha del último episodio; con el complemento de episodios abre el feed RSS para sumar descripción, idioma, sitio web y categorías, y guarda los episodios más recientes (título, fecha, duración en segundos, URL del audio, notas, temporada y número). Cuesta US$2,10 por cada 1.000 podcasts y US$0,50 por cada 1.000 episodios guardados. Si lo que necesitas son fichas de apps de la App Store, usa nuestro [App Store Apps Scraper](https://apify.com/fabrikit/app-store-apps-scraper).

# Actor input Schema

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

Keywords to search in the Apple Podcasts directory, one search per entry (for example: marketing, true crime, meditación). Apple returns at most 100 shows per term; the rank of each show for the term is saved as `position`.

## `podcastIds` (type: `array`):

Specific shows: numeric Apple Podcasts IDs (1200361736 or id1200361736), Apple Podcasts URLs (https://podcasts.apple.com/us/podcast/the-daily/id1200361736, episode URLs work too) or a show name (resolved to the top search match). The country in a URL overrides the directory country below.

## `topChart` (type: `boolean`):

Read Apple's Top Podcasts chart of the directory country (all genres, or only the genre below). The rank is saved as `chartRank` on every record.

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

Optional Apple Podcasts genre, by name or ID: Arts, Business (1321), Comedy, Education, Fiction, Government, Health & Fitness, History, Kids & Family, Leisure, Music, News, Religion & Spirituality, Science, Society & Culture, Sports, TV & Film, Technology (1318), True Crime (1488), or a subgenre such as Marketing, Investing, Self-Improvement, Mental Health. The top chart is read for that genre and search results outside it are dropped.

## `chartSize` (type: `integer`):

How many ranked shows to read from the top chart (1 to 200).

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

Two-letter Apple Podcasts country code (us, gb, de, fr, es, br, mx, jp, in, ...). Search results, charts and genre names are specific to each country's directory.

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

Open the RSS feed of every show to add its description, language, website, categories and feed stats to the podcast record, and save one `episode` record per episode (title, date, duration, audio URL, show notes, season / episode numbers). Charged per episode saved.

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

Newest episodes to save per show when episodes are included (1 to 10,000).

## `includeOwnerContact` (type: `boolean`):

Add the `itunes:owner` name of the feed and, only when it is a role or brand mailbox on a company domain (info@, podcast@, show name@...), its e-mail. Personal mailboxes and free e-mail providers are never saved. Needs "Include episodes".

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

Stop after this many podcasts in total (exact; duplicates across sources are skipped and not charged). Episode records do not count towards this limit.

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

Apify Proxy settings for Apple's endpoints. They normally work from datacenter IPs; if Apple answers with its per-IP rate limit (HTTP 403/429) the Actor retries with backoff and switches to a residential proxy in the directory country. RSS feeds are always fetched through the datacenter / direct connection.

## Actor input object example

```json
{
  "searchTerms": [
    "marketing"
  ],
  "topChart": false,
  "chartSize": 50,
  "country": "us",
  "includeEpisodes": false,
  "maxEpisodesPerPodcast": 20,
  "includeOwnerContact": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `records` (type: `string`):

All podcasts (recordType = podcast) and, when requested, their episodes (recordType = episode) collected during the 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 = {
    "searchTerms": [
        "marketing"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/podcast-directory-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": ["marketing"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/podcast-directory-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 '{
  "searchTerms": [
    "marketing"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/podcast-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/podcast-directory-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/ipMIyCkcZfYjjLVEy/builds/1z0yb0Ou3jOWz45hJ/openapi.json
