# Podcast Host Email & Lead Scraper (`chilly_damask/podcast-host-email-lead-scraper`) Actor

Scrape podcast host business emails + social links from Apple Podcasts & RSS feeds by keyword, Apple ID, or feed URL. No login. Pay only per email found. CSV/JSON.

- **URL**: https://apify.com/chilly\_damask/podcast-host-email-lead-scraper.md
- **Developed by:** [Jaxx](https://apify.com/chilly_damask) (community)
- **Categories:** Lead generation
- **Stats:** 1 total users, 0 monthly users, 20.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 email founds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Host Email & Lead Scraper (Pay Per Email Found)

**Turn a list of podcasts — or a single niche keyword — into a clean contact list of publicly listed podcast host business emails and social profiles. You pay only when an email is actually found. No email, no charge.**

Feed the actor niche keywords, Apple Podcasts IDs, or RSS feed URLs. It resolves each show through the **public iTunes Search / Lookup API**, fetches the show's **RSS feed**, and returns the host's business email and social links it can find, one tidy record per show — signed out, no login, no API keys, no browser.

- 📧 Publicly listed host business emails, with provenance (`owner` / `website` / `linktree`)
- 🔗 Social profiles: Instagram, TikTok, X, LinkedIn, Facebook, YouTube, Discord, Telegram, website
- 📊 Show metadata: category, episode count, last-episode date, active status, language, author
- 💰 **Pay-per-result** — priced per email found, not per subscription. A show with no email costs you **nothing**.

***

### 🎯 Best for

Self-identify in two seconds — this actor is built for:

- **Podcast guesting / PR outreach** — build a list of shows to pitch yourself or a client onto, with a contact email attached.
- **Podcast sponsorship & ad sales** — go from a niche shortlist to reachable host inboxes.
- **Agency lead generation** — turn a niche keyword into a queue of podcast leads for a client.
- **Media & influencer sourcing** — surface active shows in an adjacent niche and their public business contact.
- **Sales prospecting into the creator / podcast economy** — enrich a show list with email + socials before you reach out.

***

### 🔒 What makes this scraper different (and safer)

It runs **signed out** and reads only **public** surfaces — the public iTunes Search / Lookup API and the show's own **public RSS feed**. There is no login, no CAPTCHA, no API key, and no browser.

#### Where the emails come from

Public surfaces, signed out:

1. the show's RSS feed **`<itunes:owner>` email tag** (the contact address Apple requires a podcaster to publish for their own show), with `managingEditor` / `webMaster` as fallbacks, and
2. — one hop, optional — the show's own **linked website / Linktree**, when the feed exposes no owner email.

#### What it deliberately does NOT do

- ❌ **Does not log into anything** and does not touch private or gated data. An email a host keeps off their public feed and off their linked site simply won't appear here.

***

### 🎧 Scope & limits (read this)

- **Apple Podcasts + RSS only.** Discovery is via the public iTunes catalog, and extraction is from the show's public RSS feed. **Spotify-exclusive and YouTube-exclusive shows have no public RSS feed with an owner email**, so they are out of reach by design — there is no public surface to read.
- **The owner email is whatever the podcaster published.** Many shows list a real host/booking address; some list a generic `hello@` or a network address; some omit it entirely (in which case the optional one-hop website scan may still recover one).
- **`episodeCount` is the number of episodes present in the feed.** Most feeds carry the full back catalog, but some publishers truncate their feed to the most recent N — for those, the count reflects the feed, not the show's lifetime total.

***

### ⚙️ How it works

Plain HTTP — no browser, no key, no login:

1. **Resolve the show.**
   - *Keyword* → the public **iTunes Search API** (`itunes.apple.com/search?media=podcast`) returns matching shows, each with its canonical `feedUrl`. Billed per search query.
   - *Apple Podcasts ID* → the public **iTunes Lookup API** (`itunes.apple.com/lookup?id=…`) returns that one show's `feedUrl` + metadata.
   - *RSS URL* → used directly.
2. **Fetch the RSS feed** and parse it with a dependency-free XML reader.
3. **Extract the host email** from `<itunes:owner><itunes:email>` (fallbacks: channel `itunes:email`, `managingEditor`, `webMaster`).
4. **If no owner email**, follow the show's linked **website / Linktree** one hop and regex-extract `mailto:` and plain-text emails.
5. **Also emit** website, category, episode count, last-episode date / active status, and social links.

Built-in resilience (shared with the maintainer's other scrapers):

- up to **3 retries** per request with backoff, and a body-download-safe timeout,
- a **response-size cap** so a runaway feed can't exhaust memory,
- **run-global de-duplication** by Apple collection ID / feed URL, so a show discovered twice is fetched, charged, and emitted once,
- **honest error output** — a show whose feed ultimately fails to fetch is written to the dataset as `{ "status": "error", "errorDetail": "...", "feedUrl": "..." }` rather than silently dropped.

***

### ▶️ How to use (no code required)

1. Create a free Apify account.
2. Open this actor and either type niche keywords into **Search keywords**, paste Apple Podcasts IDs into **Apple Podcasts IDs**, or paste feed URLs into **RSS feed URLs**.
3. (Optional) cap **Max shows per keyword** and set your **Country** storefront to control cost and coverage.
4. Click **Start**.
5. Watch rows appear in the **Output** tab, then export the dataset as JSON, CSV, Excel, XML, or HTML — or pull it via the API.

***

### 📥 Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchKeywords` | array of strings | `[]` | Each keyword runs an iTunes Search query and queues the discovered shows. Billed per search query. |
| `applePodcastIds` | array of strings | `[]` | Apple Podcasts numeric show IDs — the number in `podcasts.apple.com/…/id<THIS>`. Resolved to a feed via the iTunes Lookup API. |
| `rssFeedUrls` | array of strings | `[]` | Direct podcast RSS feed URLs. Skips iTunes resolution. |
| `maxShowsPerKeyword` | integer | `50` | How many shows to collect per keyword search. Min 1, max 200. |
| `country` | string | `"us"` | ISO storefront code for the iTunes Search & Lookup APIs. |
| `scanLinkedWebsites` | boolean | `true` | When the feed exposes no email, follow the show's website / Linktree one hop and extract emails. |
| `includeSocialLinks` | boolean | `true` | Return the show's linked social profiles parsed from the feed. |
| `activeWithinDays` | integer | `90` | A show is flagged `isActive: true` when its newest episode is newer than this. Informational — does not filter output. |
| `dedupeEmails` | boolean | `true` | One record per show, with emails deduped across all sources. |

#### Example input

```json
{
  "searchKeywords": ["home barista", "indie game dev"],
  "applePodcastIds": ["1200361736"],
  "rssFeedUrls": ["https://feeds.simplecast.com/54nAGcIl"],
  "maxShowsPerKeyword": 50,
  "country": "us",
  "scanLinkedWebsites": true,
  "includeSocialLinks": true,
  "activeWithinDays": 90,
  "dedupeEmails": true
}
```

***

### 📤 Output

One record per show, written to the dataset as results come in. Export it as JSON, CSV, Excel, XML, or HTML, or read it through the API.

```json
{
  "showTitle": "Indie Coffee Show",
  "feedUrl": "https://feeds.example.com/indiecoffee",
  "hostEmail": "jane@indiecoffee.show",
  "emailSource": "owner",
  "website": "https://indiecoffee.show",
  "category": "Arts",
  "author": "Jane Barista",
  "language": "en-us",
  "episodeCount": 142,
  "lastEpisodeAt": "2026-07-02T10:00:00.000Z",
  "isActive": true,
  "collectionId": "1200361736",
  "appleUrl": "https://podcasts.apple.com/us/podcast/id1200361736",
  "artworkUrl": "https://…/600x600bb.jpg",
  "ownerName": "Jane Barista",
  "emails": [
    { "email": "jane@indiecoffee.show", "source": "owner", "domain": "indiecoffee.show" }
  ],
  "bestEmail": "jane@indiecoffee.show",
  "hasEmail": true,
  "socials": {
    "website": "https://indiecoffee.show",
    "instagram": "https://instagram.com/…",
    "x": "https://x.com/…"
  },
  "sourceMode": "keyword",
  "sourceKeyword": "home barista",
  "scrapedAt": "2026-07-14T00:00:00.000Z",
  "status": "ok",
  "errorDetail": null
}
```

Field notes:

- **`emails`** — every email found for the show, each tagged with its `source` (`owner`, `website`, or `linktree`) and `domain`. Only sources the actor actually read are emitted.
- **`hostEmail` / `bestEmail`** — a single pick, preferring a **business domain** over a freemail address (Gmail, Outlook, etc.). `emailSource` records which surface it came from.
- **`hasEmail`** — `true` when at least one email was found. It's the *gate* for billing — no email, no charge — but the `email-found` event is priced **per unique email**, so a show with two emails is two events (see the worked example under Pricing).
- **`isActive`** — `true` when the newest episode is within `activeWithinDays`, `false` when older, `null` when the feed carries no dated episodes.
- **`sourceMode`** — `"keyword"`, `"apple_id"`, or `"rss"` depending on how the show entered the run. `sourceKeyword` is set when it was discovered via a keyword search.
- **`status`** — `"ok"` for a successful record, `"error"` for a feed that failed to fetch (with a human-readable `errorDetail`). Error rows are kept, not dropped.

***

### 💰 Pricing (pay-per-event)

You are charged a **fixed price per result event** — not for platform usage or compute time.

| Event | Price | Per 1,000 | When you're charged |
|---|---|---|---|
| `email-found` | **$0.02** | **$20 / 1,000** | Once per **unique email found**. A show with **no email is free**. |
| `keyword-search` | **$0.01** | **$10 / 1,000** | Once per **keyword search query** executed. |

**No-find-free is the core trust mechanic:** you never pay for a show that yields nothing. If a feed fails, it comes back as a `status: "error"` row — never as a phantom charge for data that does not exist.

**What a run costs — a worked example:** you scan **500 shows**, **180** expose a host email (and **20** of those list two) → **200 unique emails × $0.02 = $4.00**. Add **2 keyword searches** at $0.01 → **$0.02**. Total: **$4.02** — and the 320 shows with no email cost nothing.

> The prices above are exactly what you're billed — nothing for platform usage or compute on top. Comparable Store actors price differently; compare the live listings and pick what fits your volume.

***

### ❓ FAQ

**Do I pay for shows that don't have an email?**
No. You are charged only when an email is actually found (`hasEmail: true`). A show that yields nothing — or a feed that errors — costs you nothing for the email event.

**Why can't it find every podcast's email?**
Because it reads only what the podcaster **published**. Apple Podcasts + RSS is the surface; a **Spotify-exclusive or YouTube-exclusive show has no public RSS feed with an owner email**, and a host who lists no email anywhere public can't be surfaced. That's an honest scope limit, not a bug.

**Can I test with a small list first?**
Yes. Start with two or three RSS URLs or one keyword, confirm the output looks right, then scale up. `maxShowsPerKeyword` caps volume and cost on keyword runs.

**How do I maximize the hit rate?**
Point it at active, independently-produced shows — they most often publish a real host/booking email in their feed. Keep `scanLinkedWebsites` on so the actor can follow the one hop to the show's site when the feed itself omits the email.

**Can I run it on a schedule or from my own code?**
Yes. Apify lets you run this actor from the Console UI, schedule it, call it via the Apify API, drive it with the `apify-client` SDKs for JavaScript and Python, run it from the Apify CLI, or connect it through an MCP server — and wire the output into Make, Zapier, Slack, Google Sheets, or a webhook.

**Is it legal to scrape this?**
The actor reads only publicly available data, signed out. That said, some output fields are personal data (e.g. an email address). You should have a legitimate basis for collecting and using it and should comply with applicable law (GDPR/CCPA, Apple's and the feed publishers' terms, and anti-spam rules like CAN-SPAM). If you are unsure whether your use is legitimate, consult your own legal counsel.

**What happens when a feed can't be fetched?**
The request is retried up to 3 times, then written to the dataset as a `{ "status": "error", "errorDetail": "…" }` row. You get an honest record of what failed instead of a silently missing show.

***

### 🔌 API-ready

This actor is a drop-in piece of a pipeline. Apify auto-generates integration snippets for it — JavaScript (`apify-client`), Python (`apify-client`), the Apify CLI, the REST API, an OpenAPI spec, and an MCP server — so you can call it from your own stack or an agent workflow. See the **API** tab on the actor page.

***

### Maintainer

Published by **Jaxx**. Categories: **Lead generation** · **Social media**.

Found a show that should have parsed but didn't, or a field you'd like added? Open an issue on the actor's **Issues** tab — bug reports and extraction edge cases are actively reviewed.

# Actor input Schema

## `searchKeywords` (type: `array`):

Optional. Each keyword runs an Apple Podcasts (public iTunes Search API) query and queues the discovered shows for email extraction. Billed per search query.

## `applePodcastIds` (type: `array`):

Apple Podcasts numeric show IDs. Find it in the Apple Podcasts URL: podcasts.apple.com/us/podcast/<name>/id\<THIS\_NUMBER>. Each ID is resolved to its RSS feed via the public iTunes Lookup API. Leave empty to use keywords / feed URLs only.

## `rssFeedUrls` (type: `array`):

Direct podcast RSS feed URLs (e.g. https://feeds.megaphone.fm/… or a show's own feed). Skips iTunes resolution and parses the feed straight away. Leave empty to use keywords / Apple IDs only.

## `maxShowsPerKeyword` (type: `integer`):

How many shows to collect from each keyword search (the iTunes Search API returns up to 200 per query).

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

ISO storefront code used for the iTunes Search & Lookup APIs (e.g. "us", "gb", "de"). Affects which shows a keyword search surfaces.

## `scanLinkedWebsites` (type: `boolean`):

When the feed exposes no host email, follow the show's linked website / Linktree / Beacons link one hop and regex-extract mailto: and plain-text emails.

## `includeSocialLinks` (type: `boolean`):

Return the show's linked social profiles (Instagram, TikTok, X, LinkedIn, Facebook, YouTube, Discord, Telegram, website) parsed from the feed.

## `activeWithinDays` (type: `integer`):

A show is flagged isActive=true when its most recent episode is newer than this many days. Purely informational — it does not filter output.

## `dedupeEmails` (type: `boolean`):

One record per show with emails deduped across all sources.

## Actor input object example

```json
{
  "searchKeywords": [
    "home barista",
    "indie game dev"
  ],
  "applePodcastIds": [
    "1200361736"
  ],
  "rssFeedUrls": [
    "https://feeds.simplecast.com/54nAGcIl"
  ],
  "maxShowsPerKeyword": 50,
  "country": "us",
  "scanLinkedWebsites": true,
  "includeSocialLinks": true,
  "activeWithinDays": 90,
  "dedupeEmails": true
}
```

# Actor output Schema

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

The dataset of scraped shows, rendered with the overview table view.

# 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 = {
    "searchKeywords": [
        "home barista"
    ],
    "applePodcastIds": [],
    "rssFeedUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("chilly_damask/podcast-host-email-lead-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 = {
    "searchKeywords": ["home barista"],
    "applePodcastIds": [],
    "rssFeedUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("chilly_damask/podcast-host-email-lead-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 '{
  "searchKeywords": [
    "home barista"
  ],
  "applePodcastIds": [],
  "rssFeedUrls": []
}' |
apify call chilly_damask/podcast-host-email-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YP9jKb22rl6Toz0Gr/builds/5bYYKMLQNvWx1aLl3/openapi.json