# Podcast Scraper with Emails: Active Shows for Guest Outreach (`leadsbrary/podcast-guest-finder-contacts`) Actor

Podcast scraper with emails: search Apple Podcasts by topic, then read each public RSS feed for owner email, website, last episode date, 90-day episode count and activity score. Export JSON, CSV or Excel. From $1 per 1,000 results.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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 Scraper with Emails: Active Shows for Guest Outreach

### What does this Actor do?

This podcast scraper with emails searches Apple Podcasts by topic, then reads each show's public RSS feed to return the contact email the feed publishes, the website, the latest episode date and an **activity score**. Dead shows are filtered out, so you get a list of podcasts that are still publishing, ready for guest booking, sponsorship or PR outreach.

You can also paste RSS feed URLs directly to enrich shows you already know about. Results export as JSON, CSV, Excel or HTML, or via the Apify API.

### Use cases

- **Guest booking agencies and PR teams**: build a list of active shows in a niche, with a contact where the feed publishes one.
- **Founders and experts** who want to pitch themselves as guests.
- **Sponsorship and ad buyers**: spot shows that publish regularly (episodes in the last 90 days, median gap between episodes).
- **Lead-generation and outreach tools**: feed a CRM or enrichment pipeline with podcast contacts.
- **Podcast researchers**: compare publishing cadence across a topic.

### Features

#### How it works

1. Searches Apple Podcasts for each topic (or takes the RSS feed URLs you provide).
2. Reads each show's public RSS feed.
3. Computes activity metrics, applies your filters and returns one row per podcast.

#### What you get

- Search by one or many topics and an Apple Store country (US, GB, FR, CA, DE…).
- Enrich your own list of RSS feed URLs (can be combined with search).
- Activity metrics computed from the feed: days since last episode, episodes in the last 90 days, median days between episodes, activity score (0–100), `isActive` flag.
- Filters: active within N days, minimum episodes in the last 90 days, only shows with an email, exclude free email providers (gmail.com, yahoo.com, outlook.com…), exclude explicit shows, language.
- Deduplicated by feed URL.
- Email comes only from what the public feed itself publishes (`itunes:owner`, `managingEditor` or `webMaster`); the `emailSource` field tells you which. No login, no private data.
- `maxResults` caps both the number of results and your spending.

### Input

#### Configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array of strings | `["marketing"]` (prefill) | Topics to search. Required unless `feedUrls` is given. |
| `feedUrls` | array of strings | – | RSS feed URLs to enrich directly (skips the search). |
| `country` | string | `US` | Two-letter Apple Store country code. |
| `maxResults` | integer | 50 | Stop after this many podcasts (1–5000). |
| `activeWithinDays` | integer | 90 | Keep shows whose latest episode is at most this old. `0` keeps all shows. |
| `minEpisodesLast90Days` | integer | 0 | Minimum episodes in the last 90 days. |
| `onlyWithEmail` | boolean | false | Only shows whose feed publishes a contact email. |
| `excludeFreeEmailProviders` | boolean | false | Drop gmail/yahoo/outlook-type addresses, keep business domains. |
| `includeExplicit` | boolean | true | Include shows flagged explicit by Apple. |
| `language` | string | – | Keep only shows whose RSS language starts with this code (e.g. `en`, `fr`). |

#### Example input

```json
{
  "searchTerms": ["marketing"],
  "country": "US",
  "maxResults": 20,
  "activeWithinDays": 90,
  "onlyWithEmail": true
}
```

#### Input errors and empty results

If neither `searchTerms` nor `feedUrls` is provided, the run fails immediately with a clear input error (no charge for results). A search with no matching shows finishes successfully with an empty dataset.

### Output

Each row is one podcast. Example row (values anonymized, description shortened):

```json
{
  "podcastName": "Marketing School - Digital Marketing and Online Marketing Tips",
  "appleId": "1138869817",
  "appleUrl": "https://podcasts.apple.com/us/podcast/marketing-school-digital-marketing-and-online/id1138869817",
  "feedUrl": "https://feeds.megaphone.fm/ESHO5419936864",
  "author": "Jane Doe and John Doe",
  "ownerName": "Eric Siu and Neil Patel",
  "ownerEmail": "host@example.com",
  "emailSource": "itunes:owner",
  "websiteUrl": "https://www.marketingschool.io/",
  "socialLinks": [],
  "primaryGenre": "Marketing",
  "genres": ["Marketing", "Podcasts", "Business", "Careers"],
  "country": "USA",
  "language": "en",
  "explicit": false,
  "episodeCount": 194,
  "latestEpisodeTitle": "The AI-Native Marketer Looks Like This",
  "lastEpisodeDate": "2026-10-01T13:00:00.000Z",
  "firstEpisodeDate": "2025-10-30T13:00:00.000Z",
  "daysSinceLastEpisode": 3,
  "episodesLast90Days": 51,
  "medianDaysBetweenEpisodes": 1,
  "activityScore": 99,
  "isActive": true,
  "description": "Neil Patel and Eric Siu bring you daily ACTIONABLE digital marketing lessons…",
  "matchedSearchTerm": "marketing",
  "scrapedAt": "2026-10-04T20:13:21.423Z"
}
```

#### Output fields and fill rates

Measured on a 40-row test run (search term "marketing", US). Fields are `null` or empty when the source does not publish them.

| Field | Fill rate | Notes |
|---|---|---|
| `podcastName`, `feedUrl`, `author`, `description`, `explicit`, `episodeCount`, `latestEpisodeTitle`, `lastEpisodeDate`, `firstEpisodeDate`, `daysSinceLastEpisode`, `episodesLast90Days`, `medianDaysBetweenEpisodes`, `activityScore`, `isActive`, `scrapedAt` | 100% | |
| `ownerName` | 97.5% | |
| `language` | 97.5% | |
| `appleId`, `appleUrl`, `country`, `primaryGenre`, `genres`, `matchedSearchTerm` | 95% | Empty when you pass `feedUrls` directly (no Apple match) |
| `websiteUrl` | 90% | |
| `ownerEmail`, `emailSource` | 72.5% | Only when the feed publishes an email. In a separate run with `onlyWithEmail`, 25 of 25 rows had one. |
| `socialLinks` | 2.5% | Only links found in the feed; usually empty. Do not rely on it. |

In a French-language run (20 rows) emails were present in 90% of rows. Fill rates vary by topic and country.

### How to use via API

#### Calling the Actor

Replace `YOUR_APIFY_TOKEN` with your own token. Actor ID: `podcast-guest-finder-contacts` (use `username~podcast-guest-finder-contacts` in URLs).

**curl**

```bash
curl -X POST "https://api.apify.com/v2/acts/USERNAME~podcast-guest-finder-contacts/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["marketing"], "maxResults": 20, "onlyWithEmail": true}'
```

**JavaScript**

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('USERNAME/podcast-guest-finder-contacts').call({
    searchTerms: ['marketing'],
    maxResults: 20,
    onlyWithEmail: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("USERNAME/podcast-guest-finder-contacts").call(run_input={
    "searchTerms": ["marketing"],
    "maxResults": 20,
    "onlyWithEmail": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Pricing

#### Pay per result

Pay per result: you are charged per podcast row returned.

| Apify plan | Price per 1,000 results |
|---|---|
| Free | $1.50 |
| Bronze | $1.30 |
| Silver | $1.15 |
| Gold and above | $1.00 |

Platform usage is small: the test runs of 5 to 40 rows used under $0.001 of compute. Set `maxResults` to cap spending; start with 20.

### Troubleshooting

- **Run fails with "Provide at least one entry in searchTerms or feedUrls"**: add a search term or an RSS feed URL.
- **Empty dataset**: filters are too strict (e.g. `activeWithinDays`, `onlyWithEmail`, `language`) or the term has no shows. Loosen filters or try broader terms.
- **Fewer rows than `maxResults`**: each search term returns a limited number of shows (roughly 100–200 per term and country). Add more terms or countries.
- **`ownerEmail` is null**: the show's public feed does not publish one. Use `websiteUrl` to find a contact form, or set `onlyWithEmail` to skip those shows.
- **Email looks like an agency or hosting address**: the feed owner chose it; check it before outreach.

### FAQ

**Where do the emails come from?** Only from the show's public RSS feed (`itunes:owner`, `managingEditor`, `webMaster`). The Actor does not guess, verify or scrape private data, and does not log in anywhere.

**Is the email verified?** No. It is whatever the feed publishes.

**Is it legal to contact these people?** The data is public, but emails are personal data in some jurisdictions. Follow GDPR, CAN-SPAM and local rules, and use a relevant, honest outreach message.

**How is the activity score computed?** From the feed's own episode dates: recency of the latest episode, episodes in the last 90 days and publishing regularity. Higher means more active (0–100).

**Can I search without Apple?** Yes, pass `feedUrls` directly. Apple-specific fields will be empty.

**Which formats can I export?** JSON, CSV, Excel, XML and HTML from the dataset, or via API.

### Keywords

podcast scraper with emails, podcast guest finder, podcast email scraper, podcast contacts, podcast outreach list, Apple Podcasts scraper, podcast RSS scraper, active podcasts, podcast guest booking, podcast sponsorship leads, podcast lead generation, podcast activity score

### Hashtags

\#podcast #podcasts #podcastguest #leadgeneration #outreach #applepodcasts #rss #emailfinder #prlist #sponsorship #scraper #apify

# Changelog

This Actor's version history is a separate document: https://apify.com/leadsbrary/podcast-guest-finder-contacts/changelog.md

# Actor input Schema

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

Topics or keywords to search podcasts for (each term returns up to ~100-200 shows). Required unless you provide RSS feed URLs below.

## `feedUrls` (type: `array`):

Podcast RSS feed URLs to enrich directly (skips the search). Can be combined with search terms.

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

Two-letter country code used for the search (US, GB, FR, CA, DE…).

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

Stop after this many podcasts (also caps your spending). 20 is a cheap first run.

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

Only keep shows whose latest episode is at most this many days old. 0 keeps all shows, including inactive ones.

## `minEpisodesLast90Days` (type: `integer`):

Only keep shows with at least this many episodes in the last 90 days.

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

Only return shows whose public RSS feed publishes a contact email.

## `excludeFreeEmailProviders` (type: `boolean`):

Drop emails on consumer providers (gmail.com, yahoo.com, outlook.com…) and keep only business-domain emails.

## `includeExplicit` (type: `boolean`):

Include shows flagged explicit by Apple.

## `language` (type: `string`):

Optional: keep only shows whose RSS language starts with this code (e.g. en, fr).

## Actor input object example

```json
{
  "searchTerms": [
    "marketing"
  ],
  "country": "US",
  "maxResults": 20,
  "activeWithinDays": 90,
  "minEpisodesLast90Days": 0,
  "onlyWithEmail": false,
  "excludeFreeEmailProviders": false,
  "includeExplicit": true
}
```

# 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 = {
    "searchTerms": [
        "marketing"
    ],
    "country": "US",
    "maxResults": 20,
    "activeWithinDays": 90
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadsbrary/podcast-guest-finder-contacts").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 = {
    "searchTerms": ["marketing"],
    "country": "US",
    "maxResults": 20,
    "activeWithinDays": 90,
}

# Run the Actor and wait for it to finish
run = client.actor("leadsbrary/podcast-guest-finder-contacts").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 '{
  "searchTerms": [
    "marketing"
  ],
  "country": "US",
  "maxResults": 20,
  "activeWithinDays": 90
}' |
apify call leadsbrary/podcast-guest-finder-contacts --silent --output-dataset

```

## MCP server setup

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

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/V28ykQKee7LFSxHdl/builds/9ZGIr0RZ4hwelnQra/openapi.json