# Podcast Directory Scraper (`its_raghav/podcast-directory-scraper`) Actor

Scrape podcast metadata, ratings, episodes, reviews, and contact emails from Apple Podcasts and RSS feeds.

- **URL**: https://apify.com/its\_raghav/podcast-directory-scraper.md
- **Developed by:** [Raghav Dua](https://apify.com/its_raghav) (community)
- **Categories:** Social media, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Directory Scraper

**Scrape podcast metadata, Apple ratings, episodes, reviews, and host contact emails** from Apple Podcasts and RSS feeds. Search by keyword and get structured data for any podcast — no API keys needed.

Built for podcast advertisers, PR agencies, media buyers, sponsors, market researchers, and anyone who needs podcast data at scale. Run via the Apify Console, API, or integrate with Zapier, Make, Google Sheets, and more.

### What does Podcast Directory Scraper do?

This Actor searches the Apple Podcasts directory by keyword and extracts comprehensive data for each podcast found:

- **Metadata** — podcast name, artist, genres, artwork, episode count, content rating, country
- **Apple Podcasts ratings** — aggregate star rating and total review count
- **Episodes** — title, description, publish date, duration, audio URL, episode/season numbers
- **Reviews** — individual Apple Podcasts reviews with author, rating, title, and full text
- **Contact info** — host/producer email addresses extracted from RSS feeds (found in ~70-80% of podcasts)
- **Links** — Apple Podcasts URL, RSS feed URL, podcast website

All data is returned in a clean, structured JSON format ready for analysis or integration.

### Why use Podcast Directory Scraper?

- **Find podcast host emails at scale** — extract contact info for thousands of podcasts without manual research. Perfect for podcast advertising outreach and PR campaigns.
- **No API keys required** — uses the public iTunes Search API and RSS feeds. Zero setup, zero recurring API costs.
- **No browser needed** — runs on lightweight HTTP requests only (no Playwright/Puppeteer), so it's fast and cheap to run.
- **Deduplicated results** — searching multiple queries? Results are automatically deduplicated by Apple Podcast ID.
- **Multi-country support** — search the US, UK, Canada, Australia, Germany, France, Japan, India, Brazil, or Mexico podcast directories.

### How to use Podcast Directory Scraper

1. Click **Try for free** on this page to open the Actor in the Apify Console.
2. Enter one or more **search queries** (e.g., "AI podcast", "true crime", "business").
3. Adjust settings: max results per query, whether to include episodes/reviews/contact info.
4. Click **Start** and wait for the run to complete.
5. Download your data as **JSON, CSV, Excel, or HTML** from the Output tab.

You can also run this Actor via the [Apify API](https://docs.apify.com/api/v2) or schedule it to run automatically.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQueries` | string[] | *required* | Keywords to search for (e.g., "AI podcast", "true crime") |
| `maxResultsPerQuery` | integer | 25 | Max podcasts per query (1-200) |
| `includeEpisodes` | boolean | true | Fetch episode data from RSS feeds |
| `maxEpisodesPerPodcast` | integer | 50 | Max episodes per podcast (1-500) |
| `includeReviews` | boolean | false | Fetch individual Apple Podcasts reviews |
| `maxReviewsPerPodcast` | integer | 50 | Max reviews per podcast (1-500) |
| `includeContactInfo` | boolean | true | Extract email addresses from RSS feeds |
| `country` | string | "us" | iTunes country code (us, gb, ca, au, de, fr, jp, in, br, mx) |

### Output

Each podcast in the dataset includes the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `podcastName` | string | Podcast title |
| `artistName` | string | Creator/artist name |
| `appleId` | number | Apple Podcasts collection ID |
| `appleUrl` | string | Direct link to Apple Podcasts page |
| `feedUrl` | string | RSS feed URL |
| `artworkUrl` | string | 600x600 artwork image URL |
| `genre` | string | Primary genre |
| `genres` | string[] | All genres/categories |
| `releaseDate` | string | Last release date (ISO 8601) |
| `totalEpisodes` | number | Total episode count |
| `country` | string | Country code |
| `contentRating` | string | Content advisory rating (Clean/Explicit) |
| `description` | string | Full podcast description from RSS |
| `websiteUrl` | string | Podcast website URL |
| `language` | string | Language code (e.g., "en") |
| `rating` | number | Apple Podcasts aggregate rating (1-5) |
| `reviewCount` | number | Total Apple Podcasts review count |
| `contactEmails` | string[] | Host/producer email addresses from RSS |
| `episodes` | Episode[] | Episode list (if enabled) |
| `reviews` | Review[] | Individual reviews (if enabled) |
| `scrapedAt` | string | Timestamp of scrape (ISO 8601) |

#### Example output

```json
{
  "podcastName": "Crime Junkie",
  "artistName": "audiochuck",
  "appleId": 1322200189,
  "appleUrl": "https://podcasts.apple.com/us/podcast/crime-junkie/id1322200189",
  "feedUrl": "https://feeds.simplecast.com/qm_9xx0g",
  "artworkUrl": "https://is1-ssl.mzstatic.com/image/thumb/Podcasts/.../600x600bb.jpg",
  "genre": "True Crime",
  "genres": ["True Crime", "Podcasts"],
  "releaseDate": "2026-04-06T04:00:00Z",
  "totalEpisodes": 500,
  "country": "USA",
  "contentRating": "Explicit",
  "description": "If you can never get enough true crime...",
  "websiteUrl": "https://crimejunkiepodcast.com",
  "language": "en",
  "rating": 4.7,
  "reviewCount": 78432,
  "contactEmails": ["content@audiochuck.com"],
  "episodes": [
    {
      "title": "MISSING: Jennifer Kesse",
      "description": "On January 24th, 2006...",
      "pubDate": "Mon, 31 Mar 2026 04:00:00 GMT",
      "duration": "2700",
      "audioUrl": "https://cdn.simplecast.com/audio/...",
      "episodeNumber": 498,
      "seasonNumber": null
    }
  ],
  "reviews": [
    {
      "author": "PodcastFan123",
      "rating": 5,
      "title": "Best true crime podcast",
      "content": "Ashley and Brit do an amazing job...",
      "date": "2026-03-28T14:30:00-07:00"
    }
  ],
  "scrapedAt": "2026-04-06T13:00:00.000Z"
}
````

### Data views

The Output tab in the Apify Console provides two pre-built views:

- **Podcasts Overview** — artwork, name, artist, genre, rating, review count, episodes, language, contact emails
- **Contact Info** — podcast name, artist, emails, website, Apple Podcasts link, RSS feed

### How much does it cost to scrape podcast data?

This Actor uses only lightweight HTTP requests (no browser automation), making it one of the cheapest scrapers on the platform.

Approximate costs:

- **25 podcasts with episodes + contact info**: ~$0.01 in platform usage
- **100 podcasts with episodes + reviews + contact info**: ~$0.05 in platform usage
- **1,000 podcasts**: ~$0.50 in platform usage

Costs depend on how many episodes and reviews you fetch per podcast. Disabling episodes and reviews significantly reduces run time and cost.

### Tips for best results

- **Start with specific search terms** — "AI podcast" returns better results than just "AI"
- **Disable reviews for large runs** — reviews add 1-10 extra API calls per podcast. Only enable if you need them.
- **Use multiple queries to cast a wider net** — results are automatically deduplicated, so overlapping queries won't produce duplicates.
- **Contact emails are in the RSS feed** — roughly 70-80% of podcasts include a host email in their RSS `<itunes:owner>` tag. Platform-generated emails (Anchor, SoundCloud, etc.) are automatically filtered out.

### FAQ

**Is this legal?**
This Actor accesses only publicly available data: the iTunes Search API (public, no authentication), Apple Podcasts web pages (public), and RSS feeds (public by design). Always ensure your use case complies with applicable laws and the platforms' Terms of Service.

**Why are some ratings missing?**
Podcasts with very few or no Apple reviews won't have an aggregate rating. This is normal for smaller or newer podcasts.

**Why are some contact emails empty?**
Not all podcasters include their email in the RSS feed. The `<itunes:owner>` email field is optional. Additionally, platform-generated emails (e.g., from Anchor or SoundCloud) are automatically filtered out since they don't reach the actual host.

**Can I search by podcast URL instead of keyword?**
Currently this Actor searches by keyword. URL-based lookup may be added in a future version.

**Something isn't working?**
Open an issue on the [Issues tab](https://console.apify.com/actors/YOUR_ACTOR_ID/issues) or reach out for a custom solution.

# Actor input Schema

## `searchQueries` (type: `array`):

List of search terms to find podcasts (e.g., 'AI podcast', 'true crime', 'business')

## `maxResultsPerQuery` (type: `integer`):

Maximum number of podcasts to return per search query (max 200)

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

Whether to fetch episode data from the RSS feed

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

Maximum number of episodes to include per podcast

## `includeReviews` (type: `boolean`):

Whether to fetch individual Apple Podcasts reviews

## `maxReviewsPerPodcast` (type: `integer`):

Maximum number of reviews to fetch per podcast (max 500)

## `includeContactInfo` (type: `boolean`):

Whether to extract email addresses and contact info from RSS feeds

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

iTunes country code for search results and ratings

## Actor input object example

```json
{
  "searchQueries": [
    "AI podcast"
  ],
  "maxResultsPerQuery": 25,
  "includeEpisodes": true,
  "maxEpisodesPerPodcast": 50,
  "includeReviews": false,
  "maxReviewsPerPodcast": 50,
  "includeContactInfo": true,
  "country": "us"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "AI podcast"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Podcast Directory Scraper",
        "description": "Scrape podcast metadata, ratings, episodes, reviews, and contact emails from Apple Podcasts and RSS feeds.",
        "version": "1.0",
        "x-build-id": "ahNEx3TN2pzGTnZlF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/its_raghav~podcast-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-its_raghav-podcast-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/its_raghav~podcast-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-its_raghav-podcast-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/its_raghav~podcast-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-its_raghav-podcast-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of search terms to find podcasts (e.g., 'AI podcast', 'true crime', 'business')",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of podcasts to return per search query (max 200)",
                        "default": 25
                    },
                    "includeEpisodes": {
                        "title": "Include Episodes",
                        "type": "boolean",
                        "description": "Whether to fetch episode data from the RSS feed",
                        "default": true
                    },
                    "maxEpisodesPerPodcast": {
                        "title": "Max Episodes Per Podcast",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of episodes to include per podcast",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Whether to fetch individual Apple Podcasts reviews",
                        "default": false
                    },
                    "maxReviewsPerPodcast": {
                        "title": "Max Reviews Per Podcast",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch per podcast (max 500)",
                        "default": 50
                    },
                    "includeContactInfo": {
                        "title": "Include Contact Info",
                        "type": "boolean",
                        "description": "Whether to extract email addresses and contact info from RSS feeds",
                        "default": true
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "jp",
                            "in",
                            "br",
                            "mx"
                        ],
                        "type": "string",
                        "description": "iTunes country code for search results and ratings",
                        "default": "us"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
