# Podcast Email Finder: Host Contacts for Guest Outreach (`datagleaner/podcast-email-finder`) Actor

Podcast email finder for guest outreach and host contacts: $0.01 per podcast with a public email, free when none is found. Give Apple Podcasts links, RSS feeds or a niche keyword; get the show's owner email, website, socials and activity.

- **URL**: https://apify.com/datagleaner/podcast-email-finder.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 podcast with emails

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 Email Finder: Host Contacts for Guest Outreach

**Find the podcast email and host contacts for guest outreach, sponsorship sales and PR.** Answers "podcast contact email", "podcast host email", "podcast email finder" and "podcast contacts" for any show: give it Apple Podcasts links, RSS feeds or a niche keyword, and get each show's **public owner email**, other emails, website, Instagram, X, LinkedIn and other socials, plus how active the show is. **You pay $0.01 only for a podcast where an email was found; a podcast with no email is returned free.** No login, no API key, no CAPTCHA.

Built to be called by AI agents and lead-generation pipelines as well as people: one row per podcast, the same fields every time, and the price tied to the answer you wanted.

### Use cases

- **Guest booking:** pitch yourself or a client as a guest to every active show in a niche ("b2b saas", "gardening", "personal finance"), with the address the show registered for itself.
- **Sponsorship and ad sales:** build a list of shows in your market, filter to the ones still publishing, and reach the owner or network.
- **PR and book launches:** find the shows your audience listens to and the right inbox for each.
- **Podcast networks, agencies and tools:** enrich a list of Apple IDs or RSS feeds with owner, website, socials, episode count and last-episode date.
- **AI agents:** "find the contact email for these 30 podcasts" as one tool call that charges only for hits.

### What it finds

Every contact a show publishes **openly**:

- **Owner email** from the RSS feed's `itunes:owner` tag: the address the show gave Apple Podcasts and Spotify. Found for about 90% of shows in our test runs.
- **Other feed emails:** `managingEditor` / `webMaster`, the show description, and a footer address repeated across recent episodes (a one-off address in a single episode, usually a guest's, is left out).
- **Website emails, phones and socials:** with `followLinks` on (default), up to 2 pages of the show's own website (its page, then its contact page if no email turned up). Only addresses that belong to the site are kept; theme, platform and sponsor addresses are dropped.
- **Socials:** Instagram, X, Facebook, YouTube, TikTok, LinkedIn and more, from the show description, `podcast:person` tags and the website's header and footer.
- **Show details:** Apple ID and URL, feed URL, author, hosts (`podcast:person`), genres, language, explicit flag, episode count, first and last episode dates, active flag, artwork and funding links.

### How it works

1. A keyword is searched in the Apple Podcasts directory (up to 200 shows per keyword, in the country you choose). An Apple URL or ID is looked up the same way. An RSS URL is read directly.
2. Each show's RSS feed is streamed and parsed: channel header first, then every episode for the counts and dates. Very large feeds (over 20 MB) are cut off after the header and the first episodes; `firstEpisodeAt` is then empty.
3. The show's own website is found (its RSS link, or a link in its notes that carries the show's name) and up to 2 pages of it are read.

Plain HTTP, no browser. Apple's directory API is paced to about 20 calls a minute with backoff, and each keyword costs one call, so a 200-show keyword run takes a few minutes.

### Input

| Field | Meaning |
|---|---|
| `podcasts` | Apple Podcasts URLs, Apple IDs (`1191490065`) or RSS feed URLs. |
| `searchKeywords` | Find shows by niche through Apple Podcasts search, e.g. `true crime`. |
| `maxPodcastsPerKeyword` | Shows taken per keyword (default 50, max 200). |
| `country` | Apple Podcasts storefront to search, e.g. `US`, `GB`, `DE` (default `US`). |
| `activeWithinDays` | Skip shows with no episode in this many days, e.g. `90`. Skipped shows are not returned or charged. |
| `onlyWithEmail` | Output only shows with a public email (default false). Shows without one are free either way. |
| `followLinks` | Visit up to 2 pages of the show's website for more emails and socials (default true). |
| `maxConcurrency`, `delaySecs`, `requestTimeoutSecs`, `respectRobotsTxt`, `proxyConfiguration` | Pacing and network options. No proxy by default. |

Leave everything empty to run a built-in example: 5 `gardening` podcasts (5 x $0.01 = $0.05 at most), stated in the run's status message.

```json
{
  "searchKeywords": ["b2b marketing", "saas founders"],
  "maxPodcastsPerKeyword": 100,
  "country": "US",
  "activeWithinDays": 90,
  "onlyWithEmail": true
}
```

### Output

One row per podcast. Fields that were not found are empty, never invented.

```json
{
  "podcastName": "The Tim Ferriss Show",
  "appleId": 863897795,
  "applePodcastsUrl": "https://podcasts.apple.com/us/podcast/the-tim-ferriss-show/id863897795",
  "feedUrl": "https://rss.art19.com/tim-ferriss-show",
  "website": "https://tim.blog/podcast",
  "ownerName": "Tim Ferriss",
  "ownerEmail": "tim@fourhourbody.com",
  "email": "tim@fourhourbody.com",
  "author": "Tim Ferriss: Bestselling Author, Human Guinea Pig",
  "emails": [{"email": "tim@fourhourbody.com", "source": "rss-owner"}],
  "phones": [],
  "socials": {
    "twitter": "https://x.com/tferriss",
    "instagram": "https://www.instagram.com/timferriss",
    "linkedin": "https://www.linkedin.com/in/timferriss",
    "youtube": "https://www.youtube.com/@timferriss"
  },
  "hosts": [],
  "genres": ["Entrepreneurship", "Business"],
  "language": "en",
  "country": "US",
  "explicit": false,
  "episodeCount": 890,
  "lastEpisodeAt": "2026-10-08T17:30:00+00:00",
  "firstEpisodeAt": null,
  "isActive": true,
  "artworkUrl": "https://is1-ssl.mzstatic.com/image/thumb/.../600x600bb.jpg",
  "hasEmail": true,
  "websitePagesVisited": 2,
  "status": "ok",
  "input": "https://podcasts.apple.com/us/podcast/the-tim-ferriss-show/id863897795",
  "scrapedAt": "2026-10-09T14:40:37+00:00"
}
```

`emails[].source` says where each address came from: `rss-owner` (the feed's owner tag), `rss-editor` (managingEditor or webMaster), `rss-description` (the show description), `rss-episode` (a footer repeated in recent show notes) or `website` (the show's own site). `email` is the best single address: the owner's, unless that is a hosting platform's relay address and a direct one exists. `isActive` is true when the newest episode is from the last 90 days. `firstEpisodeAt` is null here because this feed is 30 MB, past the 20 MB read limit; for most shows it is filled. A show that cannot be read (feed gone, bad ID) gets a row with `status: "error"` and an `error` message, and is not charged.

The dataset has two views: **Podcast contacts** (one row per show) and **All emails** (one row per email, with its source), ready to export as CSV or Excel.

### Pricing

Pay per answer, one event:

- **`podcast-with-email`: $0.01** for each podcast where at least one public email was found.
- A podcast with **no email is free**. It is still returned, with its website, socials and stats.
- A podcast that cannot be read (`status: "error"`) is free. There is no start fee.

**Worked example.** You search a niche and take 200 shows; about 80% of them carry a public email: 160 x $0.01 = **$1.60**. The 40 shows without an email cost nothing. Turn on `onlyWithEmail` to leave them out of the dataset; the price is the same.

**Compared with the alternatives.** The most-used podcast directory scraper charges $0.05 for every podcast, email or not, so the same 200 shows cost $10. Contact-only tools charge up to $0.50 per contact. Here a found email costs $0.01 and a miss costs nothing.

Set a maximum total charge on the run and the Actor stops cleanly when it is reached.

### What to expect

Measured on test runs (October 2026, US store): 47 of 52 shows in a "personal finance" run had a public email (90%), 43 of 46 across "b2b marketing" and "true crime". Independent shows usually list a personal or show address; big network shows (NBC, CBC, iHeart) usually list the network's podcast desk. Socials were found for about 70% of shows. A 50-show run takes about 30 to 40 seconds.

### Limits

- Keyword search returns what Apple's directory ranks for the keyword, at most 200 shows per keyword and country. Use several keywords or countries for more.
- Only public RSS feeds are read. Private, paid (subscriber-only) and Spotify-exclusive shows without a public feed cannot be read.
- Some hosts (Spotify for Creators, some networks) hide the owner email from the feed; those shows rely on their website for an email.
- Only the show's own website is visited, at most 2 pages. Social platforms are listed, never scraped.
- Very large feeds (over 20 MB, a few long-running daily shows) are read in part: the header and contacts are complete, `firstEpisodeAt` is empty and `episodeCount` is the larger of the part read and Apple's count.

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/podcast-email-finder`

Minimal input:

```
{"searchKeywords": ["personal finance"], "maxPodcastsPerKeyword": 20}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/podcast-email-finder` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com/?tools=datagleaner/podcast-email-finder`. Without a token, an agent can still find Actors with the `search-actors` tool, but running this one needs your Apify account. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com/?tools=datagleaner/podcast-email-finder"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Find 50 active podcasts about B2B SaaS and give me each host's contact email, or get the owner emails for these Apple Podcasts links."
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/podcast-email-finder")
result = tool.invoke({"run_input": json.loads('{"searchKeywords": ["personal finance"], "maxPodcastsPerKeyword": 20}')})
```

### FAQ

**Where does the email come from?** Mostly from the show's own RSS feed, where the owner publishes it so that directories can verify the show. Each address carries its `source`.

**Do I need an Apple, Spotify or Podchaser account?** No. Only public data is read, with no login or API key.

**Which inputs work?** `https://podcasts.apple.com/us/podcast/name/id123456789`, a bare Apple ID, or any RSS feed URL (`https://feeds.simplecast.com/...`, `https://anchor.fm/s/.../podcast/rss`, Libsyn, Buzzsprout, Megaphone, Art19 and so on).

**Can I get only shows that are still publishing?** Yes: set `activeWithinDays`, e.g. `90`. Shows that fail it are skipped before their feed is even fetched when Apple already knows their last episode date.

**What happens if I start it with no input?** It runs the built-in example, 5 `gardening` podcasts, and says so in the status message.

### Responsible use

The owner email is published by the show's owner in the public feed, for directories and listeners to reach the show. This Actor reads public data only. Email addresses can still be personal data: you are responsible for lawful use, including GDPR, CAN-SPAM and other anti-spam rules, honoring opt-outs, and sending relevant, individual pitches rather than bulk mail.

# Actor input Schema

## `podcasts` (type: `array`):

Apple Podcasts URLs (`https://podcasts.apple.com/us/podcast/name/id1191490065`), Apple IDs (`1191490065`) or RSS feed URLs, one per line.

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

Find podcasts by niche through Apple Podcasts search, for example `gardening`, `b2b saas` or `true crime`. Each keyword is searched separately. Leave this and Podcasts empty to run a 5-podcast `gardening` example.

## `maxPodcastsPerKeyword` (type: `integer`):

How many shows to take from each keyword search. Apple returns at most 200.

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

Two-letter Apple Podcasts storefront to search and look up in, such as `US`, `GB`, `DE` or `AU`. Shows differ by country.

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

Skip shows with no episode in this many days, for example `90` to keep only shows still publishing. Skipped shows are not returned or charged.

## `onlyWithEmail` (type: `boolean`):

Output only podcasts where at least one public email was found. Podcasts without an email are free either way.

## `followLinks` (type: `boolean`):

Visit the show's own website (at most 2 pages: its page and its contact page) for more emails, phones and social profiles.

## `maxConcurrency` (type: `integer`):

How many podcasts are processed at the same time. Feeds sit on many different hosts, so this can be raised for large runs.

## `delaySecs` (type: `number`):

Each podcast starts after a random pause of up to this many seconds. Apple Podcasts calls are always paced to about 20 a minute.

## `respectRobotsTxt` (type: `boolean`):

Skip website pages that the site's robots.txt disallows.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each feed or page before retrying.

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

Optional. Defaults to no proxy, which works: Apple's API and podcast feeds are public.

## Actor input object example

```json
{
  "podcasts": [
    "https://podcasts.apple.com/us/podcast/the-beginners-garden-with-jill-mcsheehy/id1191490065",
    "https://podcasts.apple.com/us/podcast/garden-girls-podcast/id1763113032",
    "1555674609",
    "https://thejoegardenershow.libsyn.com/rss"
  ],
  "maxPodcastsPerKeyword": 50,
  "country": "US",
  "onlyWithEmail": false,
  "followLinks": true,
  "maxConcurrency": 8,
  "delaySecs": 0.5,
  "respectRobotsTxt": true,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `results` (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 = {
    "podcasts": [
        "https://podcasts.apple.com/us/podcast/the-beginners-garden-with-jill-mcsheehy/id1191490065",
        "https://podcasts.apple.com/us/podcast/garden-girls-podcast/id1763113032",
        "1555674609",
        "https://thejoegardenershow.libsyn.com/rss"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/podcast-email-finder").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 = { "podcasts": [
        "https://podcasts.apple.com/us/podcast/the-beginners-garden-with-jill-mcsheehy/id1191490065",
        "https://podcasts.apple.com/us/podcast/garden-girls-podcast/id1763113032",
        "1555674609",
        "https://thejoegardenershow.libsyn.com/rss",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/podcast-email-finder").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 '{
  "podcasts": [
    "https://podcasts.apple.com/us/podcast/the-beginners-garden-with-jill-mcsheehy/id1191490065",
    "https://podcasts.apple.com/us/podcast/garden-girls-podcast/id1763113032",
    "1555674609",
    "https://thejoegardenershow.libsyn.com/rss"
  ]
}' |
apify call datagleaner/podcast-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/podcast-email-finder"
        }
    }
}
```

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/Uawygga0rnDtaoSuP/builds/R6OhgcNUmwfSFuuyp/openapi.json