# Podcast Host Contact Scraper — Email, Website & Socials (`haketa/podcast-contact-scraper`) Actor

Find podcast host contact details for PR, guest & sponsorship outreach: host email, website, socials, category and author. Search by keyword (iTunes) or paste RSS feed URLs — host email is present for ~90% of shows.

- **URL**: https://apify.com/haketa/podcast-contact-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Host Contact Scraper — Email, Website & Socials

> **Find podcast host contact details at scale for PR, guesting and sponsorship outreach: host email, website, socials, category, author and RSS feed.** Search by topic (via iTunes) or paste RSS feed URLs — because podcast feeds carry a public owner email, **host email is present for ~90% of shows.**

[![Podcasts](https://img.shields.io/badge/Podcast-Host%20Contacts-8940FA)]()
[![Email](https://img.shields.io/badge/Host%20Email-~90%25%20fill-2da44e)]()
[![PR & Guesting](https://img.shields.io/badge/PR%20%2F%20Guesting%20%2F%20Sponsorship-blue)]()
[![Export](https://img.shields.io/badge/Export-JSON%20%2F%20CSV%20%2F%20Excel-fb8500)]()

***

### What This Actor Does

This Actor turns podcast topics or feeds into a **contact & outreach dataset**. For each show it returns:

- **Contact** — host/owner **email**, show website
- **Socials** — Instagram, Twitter/X, Facebook, YouTube (from the feed)
- **Show** — podcast name, author/publisher, owner name, category, language, episodic/serial, episode count, cover art
- **Source** — RSS feed URL, Apple Podcasts URL, iTunes ID

Search by keyword/topic to **discover** podcasts (via the iTunes catalog), or paste specific **RSS feed URLs** — the Actor reads each show's feed and returns one clean row per podcast.

> ### ✅ Why the email fill-rate is high
>
> Podcast RSS feeds include an `<itunes:owner><email>` field that Apple **requires** for a show to be listed. That email is **public and present for the large majority of podcasts (~90%)** — so unlike social platforms, you get a real host contact on almost every result.

***

### Why Use This

- **Real host emails.** ~90% of shows expose an owner email in their feed — a direct line for guest pitches, PR, ads and sponsorship, no guessing.
- **Discover + enrich in one.** Search a topic to find relevant shows, then get each one's contact and metadata automatically.
- **Outreach-ready fields.** Email, website, socials, category and episode count let you target and personalize at scale.
- **Fast and cheap.** Reads the public iTunes API and only the RSS feed header (not every episode) — no login, no browser.

***

### Quick Start

#### Run it in the console (no code)

1. Add **Search terms** (topics/keywords, e.g. `technology`, `true crime`, `marketing`) — the Actor finds matching podcasts.
2. Optionally paste specific **RSS feed URLs** to target exact shows.
3. Set **Max per term** / **Max total**, click **Start**, then export as **JSON, CSV, Excel or HTML**, or push to Google Sheets, a webhook or a database.

#### Run it via API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchTerms": ["marketing", "startup"],
    "maxPerTerm": 100,
}

run = client.actor("YOUR_USERNAME/podcast-contact-scraper").call(run_input=run_input)

for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["podcastName"], "·", p["email"] or "-", "·", p["category"])
```

#### Build a podcast-guesting outreach list (Python)

```python
run = client.actor("YOUR_USERNAME/podcast-contact-scraper").call(run_input={
    "searchTerms": ["real estate investing"],
    "maxPerTerm": 200,
})
leads = [p for p in client.dataset(run["defaultDatasetId"]).iterate_items()
         if p.get("email")]
print(len(leads), "shows with a host email")
for p in leads[:10]:
    print(f'{p["podcastName"]} | {p["email"]} | {p["website"]}')
```

***

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Topics/keywords to discover podcasts via iTunes. |
| `feedUrls` | array | Direct podcast RSS feed URLs to scrape specific shows. |
| `country` | string | Two-letter iTunes store country for search (default `US`). |
| `maxPerTerm` | integer | Max podcasts per search term (iTunes caps at 200). Default `50`. |
| `maxItems` | integer | Optional hard cap on total podcasts. `0` = no limit. |
| `proxyConfiguration` | object | Apify Proxy. Datacenter is enough (iTunes & RSS are public). |

Provide **search terms, feed URLs, or both.**

***

### Output

Each podcast is one record:

```json
{
  "podcastName": "WSJ Tech News Briefing",
  "author": "The Wall Street Journal",
  "ownerName": "The Wall Street Journal",
  "email": "podcasts@dowjones.com",
  "website": "https://www.wsj.com/podcasts/tech-news-briefing",
  "category": "Tech News",
  "language": "en",
  "type": "episodic",
  "episodes": 1200,
  "instagram": "", "twitter": "wsj", "facebook": "", "youtube": "",
  "artwork": "https://...600x600.jpg",
  "feedUrl": "https://video-api.wsj.com/podcast/rss/...",
  "appleUrl": "https://podcasts.apple.com/us/podcast/...",
  "podcastId": "1234567890"
}
```

***

### Use Cases

#### 1. Podcast guesting & PR outreach

Find shows in your niche and pitch yourself or clients as a guest — with the host's real email and website in hand.

#### 2. Sponsorship & ad sales

Build target lists of podcasts by topic and reach the people who sell ad slots — email, site and category included.

#### 3. Media & influencer databases

Enrich a media/creator CRM with podcast host contacts, categories and reach signals (episode count, language).

#### 4. Market & competitive research

Map the podcast landscape for a topic — who's publishing, in what category and language, how active (episode count).

#### 5. Agency lead generation

Podcasters are buyers of editing, hosting, marketing and booking services — a targeted lead source with direct contacts.

***

### Tips

- **Discovery vs targeting:** use `searchTerms` to find shows by topic; use `feedUrls` when you already know the shows.
- **Broaden reach:** add several related terms (e.g. `startup`, `founder`, `venture capital`) — results are deduped across terms.
- **`country`** switches the iTunes catalog (e.g. `GB`, `DE`) for local podcasts.
- **Email is ~90%** but not 100% — a few shows omit the owner email; you still get website and socials there.
- **Schedule it** with Apify Schedules to keep a fresh podcast-contact list.

***

### Frequently Asked Questions

**Why do podcasts have host emails when social platforms don't?**
Apple requires an owner email (`<itunes:owner>`) in a podcast's RSS feed for it to be listed, and that field is public. So a real host email is available for the large majority of shows.

**Do I need any account or key?**
No. The iTunes Search API and RSS feeds are public — no login, cookies or key.

**How are podcasts discovered?**
By keyword/topic through the public iTunes podcast catalog, or directly from RSS feed URLs you provide.

**What export formats are supported?**
JSON, CSV, Excel, HTML, or via API — plus Google Sheets, webhooks, Make and Zapier.

***

### Legal & Responsible Use

This Actor collects only publicly available podcast metadata (including the owner contact email that Apple requires in public feeds) for research, PR and business use. You are responsible for how you use the data. Please:

- Comply with applicable data-protection and anti-spam laws (GDPR/CCPA, CAN-SPAM) when contacting hosts.
- Honor opt-out requests and send only relevant, non-abusive outreach.
- Do not use the data for spam, harassment, or any unlawful purpose.
- Use reasonable request volumes and scheduling.

This project is an independent tool and is not affiliated with, endorsed by, or sponsored by Apple, iTunes, or any podcast or hosting platform. All trademarks are the property of their respective owners.

# Actor input Schema

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

Keywords or topics to discover podcasts via iTunes (e.g. "technology", "true crime", "marketing"). Each term returns up to "Max per term" podcasts.

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

Direct podcast RSS feed URLs to scrape (e.g. https://feeds.simplecast.com/xxxx). Use this to target specific shows.

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

Two-letter iTunes store country for search (e.g. US, GB, DE).

## `maxPerTerm` (type: `integer`):

Maximum podcasts to collect per search term (iTunes returns up to 200).

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

Optional hard cap on total podcasts across all terms & feeds. 0 = no limit.

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

Apify Proxy. Datacenter is enough (iTunes API & RSS feeds are public) and is enabled by default.

## Actor input object example

```json
{
  "searchTerms": [
    "technology",
    "true crime"
  ],
  "country": "US",
  "maxPerTerm": 25,
  "maxItems": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `podcastName` (type: `string`):

Podcast title

## `author` (type: `string`):

Show author / publisher

## `ownerName` (type: `string`):

RSS owner name

## `email` (type: `string`):

Host/owner email

## `website` (type: `string`):

Show website

## `category` (type: `string`):

Podcast category/genre

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

Language

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

episodic / serial

## `episodes` (type: `string`):

Episode count

## `instagram` (type: `string`):

Instagram handle

## `twitter` (type: `string`):

Twitter/X handle

## `facebook` (type: `string`):

Facebook handle

## `youtube` (type: `string`):

YouTube handle

## `description` (type: `string`):

Show description (excerpt)

## `artwork` (type: `string`):

Cover art URL

## `feedUrl` (type: `string`):

RSS feed URL

## `appleUrl` (type: `string`):

Apple Podcasts URL

## `podcastId` (type: `string`):

iTunes collection ID

## `scrapedAt` (type: `string`):

ISO timestamp

# 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": [
        "technology",
        "true crime"
    ],
    "country": "US",
    "maxPerTerm": 25,
    "maxItems": 40,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/podcast-contact-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 = {
    "searchTerms": [
        "technology",
        "true crime",
    ],
    "country": "US",
    "maxPerTerm": 25,
    "maxItems": 40,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/podcast-contact-scraper").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": [
    "technology",
    "true crime"
  ],
  "country": "US",
  "maxPerTerm": 25,
  "maxItems": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/podcast-contact-scraper --silent --output-dataset

```

## MCP server setup

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

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/Enl5QplTOpRQMVQj3/builds/bOR7Lxvrw1vg1T58R/openapi.json