# Podcast Guest Leads — Host Emails, Activity & Apple Charts (`technicaldost/podcast-guest-leads`) Actor

Find active podcasts by keyword or Apple category with the host email published in the show's RSS feed, last episode date, episodes per month, interview share, guest examples and Apple chart rank. Built for PR and guest booking.

- **URL**: https://apify.com/technicaldost/podcast-guest-leads.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 active podcast lead 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 Guest Booking Leads — Podcast Host Emails & Podcast Contacts

Find **active podcasts in your niche with the host's contact email**, how often they publish, whether they interview guests, and their **Apple Podcasts chart rank** — in one clean row per show. Search by keyword (e.g. *"SaaS marketing"*) or pull the top charts of any Apple Podcasts category, then filter to **shows with an email that published in the last N days**.

Built for **PR agencies, podcast guest-booking agencies, B2B founders doing their own podcast tour, and sponsorship sellers**. No login, no API key, no proxy. Schedule it weekly with *Only new* on to get only shows you have not seen before.

> **Why this one:** most podcast scrapers return raw Apple listings. This Actor reads each show's public RSS feed and tells you what a booker needs: **is the show still running, how often, does it take guests, who were recent guests, how do I reach the host, and does it chart** — and it only charges the premium price for **active shows that have an email**.

### What you get (per podcast)

| Field | Example |
|---|---|
| `podcastName`, `hostName`, `ownerName` | *SaaS Half Full* — host and feed owner |
| `email`, `emailSource`, `emailType` | `info@…` from `itunes:owner` (or `managingEditor`) in the show's public RSS feed; `business`, `personal` or `hosting-relay` |
| `website`, `appleUrl`, `feedUrl` | Show site, Apple Podcasts page, RSS feed |
| `lastEpisodeAt`, `daysSinceLastEpisode`, `isActive` | `2026-11-04T09:00:00.000Z`, `5`, `true` |
| `episodesPerMonth`, `episodesLast90Days`, `totalEpisodes` | `4.3`, `13`, `332` — real publishing cadence |
| `interviewShare`, `recentGuestExamples` | `0.8` of recent titles are interviews; `["Jane Portman", "Kelsey Sowder"]` |
| `chartRank`, `chartCategory`, `overallChartRank` | `#37` in *Marketing* (Apple top 200), overall Top 100 rank |
| `guestReadyScore` | `0–100` combining email, recency, frequency, interview share and chart presence |
| `primaryCategory`, `categories`, `language`, `country` | `Marketing`, `["Business","Marketing"]`, `en-us`, `USA` |
| `podcastId`, `foundVia`, `leadTier`, `scrapedAt` | Stable Apple collectionId, which keyword/chart found it, `premium`/`standard` |

Two table views: **PR & guest booking** (show, host, email, last episode, activity, category, rank, link first) and **All fields — qualification**. Export to CSV, Excel, JSON, Google Sheets or your CRM.

### How to use

1. Enter one or more **Keywords** (topics your client can talk about) and/or pick **Apple Podcasts categories** to scan their top charts.
2. Set **Only shows active within (days)** — 30 for very active shows, 90 for still-running shows — and tick **Only shows with a host email** if you only want reachable shows.
3. Optional: **Interview / guest shows only**, **Languages** (e.g. `en`), **Minimum total episodes**.
4. Click **Start**. Most runs finish in 1–3 minutes.
5. For ongoing prospecting, turn on **Only new since last run**, give each client a **Stream name**, and add a weekly **Schedule**.

#### Example inputs

**"SaaS marketing" shows active in the last 30 days, with email:**

```json
{
  "keywords": ["saas marketing"],
  "activeWithinDays": 30,
  "requireEmail": true,
  "maxItems": 100
}
```

**PR agency — 150-show list of active B2B interview podcasts for a client launch:**

```json
{
  "keywords": ["b2b marketing", "b2b sales", "demand generation", "revops"],
  "activeWithinDays": 60,
  "requireEmail": true,
  "interviewFormatOnly": true,
  "minEpisodes": 20,
  "languages": ["en"],
  "maxItems": 150
}
```

**Sponsorship seller — weekly scan of the UK Business and Entrepreneurship charts, new shows only:**

```json
{
  "categories": ["Business", "Entrepreneurship"],
  "country": "gb",
  "activeWithinDays": 30,
  "onlyNew": true,
  "stateKey": "uk-business-weekly"
}
```

### Pricing (pay per podcast — no subscription)

| Event | When it is charged | Price |
|---|---|---|
| **Active podcast lead with email** (`podcast-lead-with-email`) | Show published an episode in the last 90 days **and** its RSS feed publishes a contact email | **$0.012** |
| Podcast lead (`podcast-lead`) | Any other show delivered (no email, or no episode in 90 days) | $0.003 |

- **Dead feeds, broken feeds and shows you filter out are never charged.**
- With **Only shows with a host email** + an activity window you pay only for reachable, running shows.
- With **Only new** you never pay twice for the same show in a stream.
- Cap spend with **Max leads per run** or a maximum charge per run.

For comparison, podcast databases with contact data cost $99–$299+ per month.

### Integrations

#### n8n

Import [`integrations/n8n-workflow.json`](https://apify.com/technicaldost/podcast-guest-leads) (Workflows → Import from file). It runs the Actor every Monday via the Apify API (`run-sync-get-dataset-items`), keeps only shows **with an email**, and appends them to a Google Sheet. Create an **HTTP Header Auth** credential with `Authorization: Bearer <your Apify API token>`. Alternatively use n8n's **Apify** node: *Run an Actor* → `technicaldost/podcast-guest-leads` → *Get dataset items*.

#### Make (Integromat)

1. Add **Apify → Run an Actor**, Actor `technicaldost/podcast-guest-leads`, *Run synchronously* = Yes, paste one of the JSON inputs above.
2. Add **Apify → Get Dataset Items** using the run's `defaultDatasetId`.
3. Add a **Filter** `hasEmail = true` (or `guestReadyScore ≥ 60`), then **Google Sheets → Add a Row**, **HubSpot → Create a Contact**, **Airtable → Create a Record** or **Slack → Create a Message**.
4. Schedule the scenario weekly.

No Apify module? Use **HTTP → Make a request**: `POST https://api.apify.com/v2/acts/technicaldost~podcast-guest-leads/run-sync-get-dataset-items` with header `Authorization: Bearer <token>`, `Content-Type: application/json` and your JSON input as the body. The response is the array of podcast leads.

#### Zapier, API, Python, MCP

- **Zapier:** Apify app → *Run Actor* (`technicaldost/podcast-guest-leads`) → *Find dataset items* → Google Sheets / CRM.
- **REST API:** the `run-sync-get-dataset-items` endpoint above, or start a run and read the dataset.
- **Clients:** `apify-client` for JavaScript and Python.
- **AI agents:** call this Actor through the **Apify MCP server** — e.g. *"find 50 active marketing podcasts that interview founders and give me the host emails"*.

### FAQ

**Where does the data come from?** Show discovery from Apple's public iTunes Search API and Apple Podcasts top charts (iTunes RSS charts and `rss.applemarketingtools.com`). Contact, activity and episode data from each show's **public RSS feed** — the same feed every podcast app reads.

**Which emails are returned?** Only the contact email the podcaster chose to publish in their own RSS feed (`<itunes:owner><itunes:email>`, else `<managingEditor>`). No guessing, no enrichment databases, no scraping of websites or social profiles. Obvious hosting-platform placeholders (e.g. `noreply@`, `@anchor.fm`) are dropped.

**What email coverage should I expect?** It depends on the niche and hosting platform. Business and marketing shows usually publish an email far more often than celebrity or network shows; Spotify-hosted shows often hide it. Use **Only shows with a host email** to receive (and pay for) only reachable shows.

**What counts as "active"?** An episode (not a trailer) published in the last 90 days. `episodesPerMonth` is the average over the last 90 days. Future-dated episodes are ignored.

**How is the interview share calculated?** From the 20 latest episode titles: titles with "with Jane Doe", "ft.", "feat.", "interview", "Jane Doe | Topic" and similar patterns count as interviews. It is a heuristic — use it to rank, not as a guarantee.

**Why is `chartRank` empty for many shows?** Apple only publishes the top 200 shows per category. Most niche shows are not in it — that is normal and often makes them easier to book.

**How many shows per keyword?** Apple's search returns up to ~100–200 shows per keyword. Add more specific keywords for bigger lists.

**Does "Only new" ever re-deliver a show?** No — once a show (Apple collectionId) is delivered to a stream it is skipped in later runs of that stream. Shows that were filtered out (e.g. no email yet) are not remembered, so they can appear later once they qualify.

### Compliance

Not affiliated with Apple. This Actor reads only public, unauthenticated sources — no logins, no scraping behind logins, no paywalled data. Emails are those the podcaster published in their public RSS feed as a contact for the show.

Podcast host emails can still be **personal data**. You are responsible for lawful use:

- **CAN-SPAM (US):** identify yourself, use honest subject lines, include your postal address and a working opt-out, and honour opt-outs promptly.
- **GDPR / UK GDPR and PECR (EU/UK hosts):** rely on legitimate interest only for relevant, individual B2B pitches; keep a record of your legitimate-interest assessment; tell recipients where you got their contact; offer and honour opt-outs and deletion requests; do not keep data longer than needed.
- Send personalised, relevant pitches — not bulk spam. Do not resell or publish the lists.

### Support

Missing a field (e.g. YouTube channel, social links, average episode length)? Open an issue on the Actor's **Issues** tab — feature requests are usually shipped within days.

# Actor input Schema

## `keywords` (type: `array`):

Topics to search on Apple Podcasts (iTunes Search API), e.g. "saas marketing", "b2b sales", "founder stories". Each keyword returns up to ~100–200 shows. Use keywords, categories or both.

## `categories` (type: `array`):

Optional. Adds the top-charting shows (up to 200) of each Apple Podcasts category in the chosen country, with their chart rank. Example: Marketing, Entrepreneurship, Technology.

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

2-letter Apple Podcasts storefront code used for search and charts: us, gb, ca, au, in, ie, nz, de, fr, es…

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

How many search results (or chart positions) to check per keyword or category. Apple returns at most ~200.

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

Keep only shows that published an episode in the last N days. 0 = no activity filter. Tip: 30 for very active shows, 90 for still-running shows.

## `requireEmail` (type: `boolean`):

Drop shows whose public RSS feed does not publish a contact email (itunes:owner email or managingEditor). Shows that are dropped are not charged.

## `minEpisodes` (type: `integer`):

Skip brand-new or one-off shows with fewer episodes than this. 0 = no minimum.

## `interviewFormatOnly` (type: `boolean`):

Keep only shows where at least 30% of the 20 latest episode titles look like guest interviews ("with Jane Doe", "ft.", "Jane Doe | Topic"…). Heuristic.

## `languages` (type: `array`):

Optional. Keep only shows whose RSS <language> matches, e.g. en, es, de (en also matches en-us, en-gb). Leave empty for all.

## `includeChartRank` (type: `boolean`):

Look up each show’s rank in Apple’s top 200 for its category and the overall Top 100 (free Apple chart feeds).

## `onlyNew` (type: `boolean`):

Remembers which shows (Apple collectionId) this stream already delivered and returns only shows you have not received before. Ideal for a weekly "new shows in my niche" schedule — you never pay twice for the same show.

## `stateKey` (type: `string`):

Separate "only new" memory per client, niche or campaign (e.g. "client-acme-saas"). Each stream de-duplicates independently.

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

Hard cap on podcast leads returned (and charged) per run.

## `feedConcurrency` (type: `integer`):

How many RSS feeds to download in parallel (1–20).

## Actor input object example

```json
{
  "keywords": [
    "saas marketing",
    "b2b marketing"
  ],
  "country": "us",
  "maxShowsPerKeyword": 100,
  "activeWithinDays": 90,
  "requireEmail": false,
  "minEpisodes": 5,
  "interviewFormatOnly": false,
  "includeChartRank": true,
  "onlyNew": false,
  "stateKey": "default",
  "maxItems": 100,
  "feedConcurrency": 8
}
```

# Actor output Schema

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

All rows produced by Podcast Guest Leads — Host Emails, Activity & Apple Charts (default dataset items, JSON).

# 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 = {
    "keywords": [
        "saas marketing",
        "b2b marketing"
    ],
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/podcast-guest-leads").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 = {
    "keywords": [
        "saas marketing",
        "b2b marketing",
    ],
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/podcast-guest-leads").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 '{
  "keywords": [
    "saas marketing",
    "b2b marketing"
  ],
  "country": "us"
}' |
apify call technicaldost/podcast-guest-leads --silent --output-dataset

```

## MCP server setup

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

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/2zJhhxl3uEggAiPZV/builds/SSZoxdrW89aYY2SAd/openapi.json