# Podcast Scraper (`automation-lab/podcast-scraper`) Actor

Search Apple Podcasts for shows, get full podcast metadata, and list episodes with release dates and durations. Pure API — fast and cheap. Supports 175+ countries.

- **URL**: https://apify.com/automation-lab/podcast-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other, Marketing
- **Stats:** 107 total users, 24 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.30 / 1,000 episode scrapeds

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

## Podcast Scraper

Search and extract podcast data from Apple Podcasts. Find shows by keyword, get full details, and list episodes with metadata. No API key needed.

### 🎙️ What does Podcast Scraper do?

Podcast Scraper extracts structured podcast data from the Apple Podcasts / iTunes catalog. Three modes:

🔹 **Search** — Find podcasts by keyword across the Apple Podcasts catalog
🔹 **Details** — Get full metadata for specific podcasts by ID
🔹 **Episodes** — List recent iTunes episodes or opt into complete RSS archives with direct audio URLs

### Who is it for?

Podcast Scraper is for marketers, media researchers, podcast networks, and data teams that need podcast show metadata, episode lists, and publishing signals from Apple Podcasts at scale.

### ❓ Why use Podcast Scraper?

🔹 **No API key needed** — Uses the public iTunes Search API
🔹 **Fast and cheap** — Pure HTTP API calls, no browser needed
🔹 **5M+ podcasts** — Access the entire Apple Podcasts catalog
🔹 **Episode data** — Recent iTunes lists or complete RSS archives with release dates, durations, show notes, GUIDs, and audio enclosures
🔹 **Multi-country** — Support for all 175+ iTunes Store countries

### 💡 Use cases

🔹 **Podcast advertising** — Find relevant podcasts for ad placements by genre and audience size
🔹 **Market research** — Analyze podcast landscape in specific niches
🔹 **Competitive analysis** — Monitor competitor podcasts and episode frequency
🔹 **Content planning** — Track trending topics and popular podcast formats
🔹 **Media monitoring** — Track mentions across podcast episodes

### 📊 Sample output

#### Podcast data

| Field | Example |
|-------|---------|
| podcastName | Hard Fork |
| artistName | The New York Times |
| primaryGenre | Technology |
| episodeCount | 186 |
| feedUrl | https://feeds.simplecast.com/... |
| contentRating | Clean |

#### Episode data

| Field | Example |
|-------|---------|
| episodeName | The Future of Computing |
| releaseDate | 2026-08-30 |
| durationMinutes | 48 |
| podcastName | Example Technology Podcast |
| episodeSource | rss |
| audioUrl | https://cdn.example.com/audio/episode-42.mp3 |
| feedUrl | https://feeds.example.com/podcast.xml |

### Pricing

| Event | Price |
|-------|-------|
| Start (per run) | $0.005 |
| Podcast scraped | $0.001 |
| Episode scraped | $0.0005 |

**Free plan estimate:** ~100 podcasts or ~500 episodes per month on the Apify Free plan.

### 🔢 How to scrape podcasts

1. Go to the Podcast Scraper page on Apify
2. Select mode (search, details, or episodes)
3. Enter search keywords or Apple Podcasts IDs
4. For episode extraction, keep the default iTunes source or choose RSS for complete archives and audio URLs
5. Set country and max results
6. Click "Start" and download results as JSON, CSV, or Excel

### 📥 Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| mode | string | search, details, or episodes |
| searchTerms | string\[] | Keywords to search (search mode) |
| podcastIds | string\[] | Apple Podcasts IDs (details/episodes mode) |
| episodeSource | string | `itunes` (default, up to 200 recent episodes) or `rss` (complete feed archive with audio URLs) |
| country | string | iTunes Store country (default: US) |
| maxResults | number | Max results per query (default: 50; RSS max: 5,000; Apple API modes: 200) |

### 📤 Output fields

#### Podcast output

`type`, `podcastId`, `podcastName`, `artistName`, `feedUrl`, `artworkUrl`, `genres`, `primaryGenre`, `episodeCount`, `country`, `contentRating`, `releaseDate`, `url`, `searchTerm`, `scrapedAt`

#### Episode output

`type`, `episodeId`, `podcastId`, `podcastName`, `episodeName`, `description`, `fullDescription`, `releaseDate`, `durationMinutes`, `episodeUrl`, `audioUrl`, `guid`, `feedUrl`, `episodeSource`, `artworkUrl`, `contentRating`, `episodeNumber`, `scrapedAt`

### 💡 Tips

🔹 **Finding podcast IDs** — Open a podcast in Apple Podcasts, look at the URL: `podcasts.apple.com/podcast/id{NUMBER}`. The number is the podcast ID.
🔹 **Country matters** — Different countries show different podcast catalogs and charts. Use the country parameter to search specific markets.
🔹 **Episode limits** — The default iTunes source returns up to 200 recent episodes. Choose `episodeSource: "rss"` for up to 5,000 items from the show's published RSS archive.
🔹 **RSS availability** — RSS mode resolves the feed URL through Apple. Feeds can be unavailable, invalid, or contain fewer items than the publisher's historical catalog; failures are reported with the affected podcast ID.

### 🔗 Integrations

Export podcast data to Google Sheets, Slack, Zapier, Make, or any webhook. Connect via the Apify API for automated podcast monitoring.

### 💻 API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/podcast-scraper').call({
    mode: 'search',
    searchTerms: ['artificial intelligence', 'machine learning'],
    maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/podcast-scraper').call(run_input={
    'mode': 'episodes',
    'episodeSource': 'rss',
    'podcastIds': ['1528594034'],
    'maxResults': 500,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~podcast-scraper/runs" \
  -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"mode": "search", "searchTerms": ["true crime"], "maxResults": 100}'
```

### ⚖️ Legality

Podcast Scraper accesses publicly available data through Apple's official iTunes Search API. This API is designed for programmatic access and is used by thousands of podcast apps and services.

### Use with AI agents via MCP

Podcast Scraper is available as a tool for AI assistants via the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/podcast-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=automation-lab/podcast-scraper"
        }
    }
}
```

#### Example prompts

- "Search for podcasts about 'machine learning'"
- "Get episode list for this podcast"
- "Find the top technology podcasts and their episode counts"

### FAQ

**Q: Do I need an Apple developer account?**
A: No. The iTunes Search API is public and requires no authentication.

**Q: Can I get podcast ratings and reviews?**
A: The iTunes Search API doesn't include ratings or review text. For reviews, you would need to scrape the Apple Podcasts web pages directly.

**Q: How many episodes can I get per podcast?**
A: The default iTunes source returns up to 200 recent episodes. In episodes mode, set `episodeSource` to `rss` to extract up to 5,000 items from the publisher's available RSS archive.

**Q: Does this work for Spotify podcasts?**
A: This scraper targets Apple Podcasts specifically. Most podcasts are listed on both platforms, so Apple Podcasts data covers the majority of the podcast ecosystem.

**Q: The scraper returns fewer episodes than the podcast actually has.**
A: The default iTunes source returns at most 200 recent episodes. Choose RSS mode for the complete archive currently exposed by the publisher's feed. Some publishers prune older feed items, so RSS results can still be smaller than the lifetime episode count.

**Q: My search returns podcasts from a different country.**
A: Set the `country` parameter to the correct ISO country code (e.g., "US", "GB", "DE"). Different Apple Podcasts stores have different catalogs and rankings.

**Q: Can I filter podcasts by language?**
A: The iTunes API doesn't have a language parameter. Most podcast results include metadata about content language, so you can filter the output client-side based on podcast description or primary content indicators.

### How do you find podcasts by genre or topic using an API?

Use **search mode** with targeted keywords. The iTunes Search API — which powers this scraper — supports keyword searches across podcast titles, descriptions, and author names. Tips for finding niche podcasts:

- Search for the specific topic (e.g., "founder stories", "applied machine learning", "B2B SaaS")
- Set `country` to match your target audience's market (e.g., "US", "GB", "AU")
- Use `maxResults: 200` to cast a wide net, then filter the output by `primaryGenre` or `episodeCount`
- High `episodeCount` typically signals an active, established podcast

For category browsing (e.g., "all Business podcasts"), the iTunes API does not support category filtering directly — keyword search is the most reliable approach.

### How do you track podcast episode publishing frequency?

Use **episodes mode** to pull the episode list for specific podcasts, then analyze `releaseDate` patterns:

1. Get the podcast ID from Apple Podcasts (visible in the URL: `podcasts.apple.com/podcast/id{NUMBER}`).
2. Run the scraper in `episodes` mode with those IDs.
3. Export to CSV and sort by `releaseDate`.
4. Calculate the average gap between consecutive episode release dates.

This is useful for podcast advertising research (active vs. inactive shows), competitive analysis (how often does a competitor publish?), and content planning benchmarking.

### Can you use this scraper to monitor podcast episode titles for specific keywords?

Yes. Combine `episodes` mode with scheduled runs and keyword filtering:

1. Run the scraper weekly for a list of competitor or industry podcast IDs.
2. After each run, filter the `episodeName` and `description` fields for keywords relevant to your monitoring goal (e.g., your brand name, competitor mentions, topic trends).
3. Connect a webhook to Slack or email to receive the dataset after each run.
4. Filter programmatically using the Apify dataset API or a downstream tool like Make or Zapier.

Note: The default iTunes source returns up to 200 recent episodes. Use `episodeSource: "rss"` to extract the publisher's available archive and direct audio URLs in the Actor output.

### How do I find a podcast's RSS feed URL?

Every podcast result from this scraper includes a `feedUrl` when Apple supplies one. In episodes mode, set `episodeSource` to `rss` and the Actor will resolve and parse that feed for you, returning the available archive, show notes, and enclosure URLs (audio file links).

RSS mode lets you:

- Access episodes beyond the 200-episode iTunes API limit
- Collect direct audio file URLs from `<enclosure>` tags
- Parse full episode descriptions and stable GUIDs
- Monitor new episodes while retaining the source `feedUrl` in every row

### Related actors

🔹 [Spotify Scraper](https://apify.com/automation-lab/spotify-scraper) — Scrape Spotify tracks, albums, and playlists
🔹 [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — Extract YouTube videos, channels, and comments
🔹 [YouTube Transcript](https://apify.com/automation-lab/youtube-transcript) — Extract transcripts and captions from YouTube videos
🔹 [iTunes Scraper](https://apify.com/automation-lab/itunes-scraper) — Search iTunes for music, apps, and media

# Actor input Schema

## `mode` (type: `string`):

What to extract from Apple Podcasts.

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

Keywords to search for podcasts (used in search mode).

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

Apple Podcasts IDs (numeric; used in details and episodes modes). Find the ID in podcasts.apple.com/podcast/id{THIS\_NUMBER}.

## `episodeSource` (type: `string`):

Used only in episodes mode. iTunes preserves the original behavior and returns up to 200 recent episodes. RSS resolves each podcast's feed and can return its complete published archive with audio URLs and full descriptions.

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

iTunes Store country (2-letter code). Affects which podcasts and feeds Apple returns.

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

Maximum results per search term or podcast. Search and iTunes episode results are capped at 200 by Apple; RSS episode mode supports up to 5,000 feed items.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "technology"
  ],
  "podcastIds": [
    "1001659715"
  ],
  "episodeSource": "itunes",
  "country": "US",
  "maxResults": 10
}
```

# Actor output Schema

## `podcasts` (type: `string`):

Dataset view containing podcast show metadata.

## `episodes` (type: `string`):

Dataset view containing episode metadata, including RSS audio URLs when requested.

# 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 = {
    "mode": "search",
    "searchTerms": [
        "technology"
    ],
    "podcastIds": [
        "1001659715"
    ],
    "episodeSource": "itunes",
    "country": "US",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "mode": "search",
    "searchTerms": ["technology"],
    "podcastIds": ["1001659715"],
    "episodeSource": "itunes",
    "country": "US",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/podcast-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 '{
  "mode": "search",
  "searchTerms": [
    "technology"
  ],
  "podcastIds": [
    "1001659715"
  ],
  "episodeSource": "itunes",
  "country": "US",
  "maxResults": 10
}' |
apify call automation-lab/podcast-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/podcast-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/2zDwLVsyZ4ouvqMeu/builds/3VjeS01WAdvb1AahP/openapi.json