# Podcast Finder & Outreach Leads - Emails, Niches & Signals (`lofomachines/podcast-outreach-finder`) Actor

Discover podcasts by topic and get contact emails, niche classification, activity signals and AI outreach angles. Built for podcast guesting, PR, sponsorship and research.

- **URL**: https://apify.com/lofomachines/podcast-outreach-finder.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** AI, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Finder & Outreach Leads — Contacts, Niches & Guest Signals 🎙️

**Find the right podcasts in seconds and turn them into a ready-to-use outreach list.** Search any topic or niche and instantly get a clean, structured dataset of matching shows — complete with **contact emails, publisher, website, categories, activity status, publishing frequency, guest-friendliness signals, and AI-generated outreach angles**.

Whether you want to **book yourself as a podcast guest**, **pitch a client for PR**, **find shows to sponsor or advertise on**, or **research a niche**, this Actor does the heavy lifting and hands you a spreadsheet-ready list of qualified podcast leads.

> No login. No accounts. No API keys to manage. Just enter your topics and run.

---

### 🚀 What you get

For every podcast, you receive a rich, consistent record:

| Field | Description |
|---|---|
| **Podcast title & publisher** | The show name and who produces it |
| **Contact email** | Public booking / contact address when available — perfect for outreach |
| **Website & social links** | Direct links to the show's site and social profiles |
| **Category & niche** | Primary category plus an AI-refined precise niche |
| **Activity status** | Active, Slowing or Dormant — focus only on live shows |
| **Publishing frequency** | Daily, Weekly, Monthly and average cadence |
| **Episode count** | How deep the back catalog is |
| **Guest-friendly score** | 0–100 signal of how likely the show books outside guests |
| **Outreach-ready score** | 0–100 signal combining reachability + activity |
| **AI outreach angle** | A concrete, ready-to-use pitch line tailored to the show |
| **AI audience & tone** | Who listens and the show's style |
| **Best use case** | Guest pitching, Sponsorship, Advertising, Research or Partnership |
| **Recent episodes** | The latest episode titles and dates |

The results are automatically **sorted by outreach-readiness**, so your best opportunities are at the top.

---

### 🎯 Who it's for

- **Founders, coaches, authors & experts** who want to get booked on podcasts as guests
- **PR agencies & publicists** building targeted media lists for clients
- **Podcast booking agencies** scaling guest placement
- **Marketers & brands** looking for shows to sponsor or advertise on
- **Sales & partnership teams** finding niche communities to reach
- **Researchers & analysts** mapping the podcast landscape of any topic

---

### 💡 Popular use cases

1. **Podcast guesting at scale** — Search your expertise (e.g. `B2B SaaS`, `real estate investing`) and get a list of interview shows that accept guests, each with a contact email and a tailored pitch angle.
2. **PR & media lists** — Build a targeted list of active shows in your client's niche in minutes instead of days.
3. **Sponsorship & advertising prospecting** — Filter for active shows with real audiences and reach out to publishers directly.
4. **Competitor & niche research** — Map every notable show in a category, including cadence, catalog depth and positioning.
5. **Cold outreach campaigns** — Export outreach-ready leads (email + angle) straight into your CRM or email tool.
6. **Content & partnership discovery** — Identify shows for cross-promotion, collaborations and co-marketing.

---

### 📥 Example input

```json
{
  "searchTerms": ["personal finance", "B2B marketing", "mindfulness"],
  "country": "us",
  "maxResultsPerTerm": 50,
  "onlyWithContactEmail": true,
  "onlyActiveShows": true,
  "includeAiInsights": true
}
````

- **Topics or keywords** — one or more niches to search
- **Specific podcast links** *(optional)* — paste Apple Podcasts links to enrich exact shows
- **Market / country** — the catalog to search
- **How many shows per keyword** — control the breadth of results
- **Only outreach-ready shows** — keep only podcasts with a public contact email
- **Only active shows** — hide dormant podcasts
- **Add AI insights** — enrich with niche, audience, tone and outreach angle

***

### 📤 Example output

```json
{
  "title": "The Personal Finance Podcast",
  "publisher": "Andrew Giancola",
  "primaryCategory": "Investing",
  "contactEmail": "hello@thepersonalfinancepodcast.com",
  "websiteUrl": "https://www.thepersonalfinancepodcast.com",
  "activityStatus": "Active",
  "publishingFrequency": "Multiple per week",
  "episodeCount": 548,
  "isInterviewShow": true,
  "guestFriendlyScore": 82,
  "outreachReadyScore": 100,
  "aiNiche": "Practical personal finance & investing",
  "aiAudience": "Young professionals building wealth",
  "aiTone": "Actionable, upbeat",
  "aiAcceptsGuests": true,
  "aiBestUseCase": "Guest pitching",
  "aiOutreachAngle": "Offer a practical episode on automating savings for first-time investors.",
  "applePodcastsUrl": "https://podcasts.apple.com/us/podcast/the-personal-finance-podcast/id1..."
}
```

***

### 🔗 Integrations

The output is clean JSON/CSV/Excel, so it plugs straight into your stack:

- **n8n** — trigger a run, then push leads into your CRM or start an email sequence
- **Make (Integromat)** — automate podcast prospecting on a schedule
- **Zapier** — send new leads to Google Sheets, Airtable, HubSpot or Gmail
- **Google Sheets / Airtable** — export and share your outreach list instantly
- **Apify API & Scheduler** — run recurring searches to keep your list fresh

***

### ⚡ Why teams love it

- **Fast & scalable** — from a handful of shows to thousands in a single run
- **Cost-efficient** — pay for results, not for hours of manual research
- **No authentication** — nothing to log into, no cookies, no risk
- **Outreach-ready** — emails, angles and scores in one place
- **Consistent structure** — the same clean fields every time

***

### 🧩 Works great with these Actors

Build a full outreach and research pipeline by combining this Actor with:

- [Lead Sonar — Website Contact & Company Intelligence](https://apify.com/lofomachines/lead-sonar) — enrich the show's website into a full company + contact profile
- [Social Media Lead Finder](https://apify.com/lofomachines/fresh-lead-finder) — find people actively looking for your service across social platforms
- [Extract contacts & social links from any site](https://apify.com/lofomachines/contact-extractor) — pull every email, phone and social link from a show's website
- [Sentiment and Topics Text Classifier](https://apify.com/lofomachines/sentiment-and-topics-text-classifier) — classify and tag episodes or outreach replies at scale
- [YouTube Transcript Turbo Saver](https://apify.com/lofomachines/youtube-transcript-turbo-saver) — transcribe video versions of shows for deeper content research

***

### ❓ FAQ

**Do I need any accounts or logins?**
No. Just enter your topics and run — there is nothing to authenticate.

**Will I always get a contact email?**
Many shows publish a public contact email and it will be included. Enable **Only outreach-ready shows** to keep just those that do.

**Can I target a specific country?**
Yes — choose the market that matches your target audience.

**Can I run this automatically?**
Yes. Schedule it in Apify or trigger it from n8n, Make or Zapier to keep your list fresh.

**What format is the output?**
Clean, structured data you can export to JSON, CSV, Excel or feed directly into any tool via the Apify API.

***

#### Keywords

podcast scraper, podcast finder, podcast search, podcast contact email finder, podcast outreach tool, podcast guest finder, get booked on podcasts, podcast booking, podcast PR list, podcast sponsorship prospecting, podcast advertising, podcast lead generation, podcast database, podcast research, find podcasts by topic, podcast directory export.

# Actor input Schema

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

Enter topics, niches or keywords to find matching podcasts (e.g. "personal finance", "vegan cooking", "B2B marketing"). Add as many as you like — each one returns a fresh list of shows.

## `podcastUrls` (type: `array`):

Already know which shows you want? Paste Apple Podcasts links here and we will enrich them directly. You can use this on its own or together with keywords above.

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

The country catalog to search. Choose the market your target audience listens in.

## `maxResultsPerTerm` (type: `integer`):

Maximum number of podcasts to return for each keyword. Higher numbers give wider coverage.

## `onlyWithContactEmail` (type: `boolean`):

Keep only podcasts that expose a public contact email — ideal when you plan to pitch or run outreach campaigns.

## `onlyActiveShows` (type: `boolean`):

Filter out dormant podcasts that have not published a new episode recently, so you focus on live, reachable shows.

## `includeAiInsights` (type: `boolean`):

Enrich every show with AI: precise niche, target audience, tone, whether it books guests, a ready-to-use outreach angle and a short summary.

## Actor input object example

```json
{
  "searchTerms": [
    "personal finance",
    "true crime",
    "mindfulness"
  ],
  "podcastUrls": [
    "https://podcasts.apple.com/us/podcast/the-tim-ferriss-show/id863897795"
  ],
  "country": "us",
  "maxResultsPerTerm": 25,
  "onlyWithContactEmail": false,
  "onlyActiveShows": false,
  "includeAiInsights": true
}
```

# Actor output Schema

## `overview` (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",
        "startups"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/podcast-outreach-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 = { "searchTerms": [
        "marketing",
        "startups",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/podcast-outreach-finder").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 '{
  "searchTerms": [
    "marketing",
    "startups"
  ]
}' |
apify call lofomachines/podcast-outreach-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lofomachines/podcast-outreach-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Podcast Finder & Outreach Leads - Emails, Niches & Signals",
        "description": "Discover podcasts by topic and get contact emails, niche classification, activity signals and AI outreach angles. Built for podcast guesting, PR, sponsorship and research.",
        "version": "0.1",
        "x-build-id": "Zcqq2mK7QlJ9M2VHj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~podcast-outreach-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-podcast-outreach-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lofomachines~podcast-outreach-finder/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-podcast-outreach-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lofomachines~podcast-outreach-finder/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-podcast-outreach-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Topics or keywords",
                        "type": "array",
                        "description": "Enter topics, niches or keywords to find matching podcasts (e.g. \"personal finance\", \"vegan cooking\", \"B2B marketing\"). Add as many as you like — each one returns a fresh list of shows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "podcastUrls": {
                        "title": "Specific podcast links (optional)",
                        "type": "array",
                        "description": "Already know which shows you want? Paste Apple Podcasts links here and we will enrich them directly. You can use this on its own or together with keywords above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Market / country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "ie",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "br",
                            "mx",
                            "in",
                            "za",
                            "se",
                            "no",
                            "dk",
                            "fi",
                            "pl",
                            "jp"
                        ],
                        "type": "string",
                        "description": "The country catalog to search. Choose the market your target audience listens in.",
                        "default": "us"
                    },
                    "maxResultsPerTerm": {
                        "title": "How many shows per keyword",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of podcasts to return for each keyword. Higher numbers give wider coverage.",
                        "default": 25
                    },
                    "onlyWithContactEmail": {
                        "title": "Only outreach-ready shows",
                        "type": "boolean",
                        "description": "Keep only podcasts that expose a public contact email — ideal when you plan to pitch or run outreach campaigns.",
                        "default": false
                    },
                    "onlyActiveShows": {
                        "title": "Only active shows",
                        "type": "boolean",
                        "description": "Filter out dormant podcasts that have not published a new episode recently, so you focus on live, reachable shows.",
                        "default": false
                    },
                    "includeAiInsights": {
                        "title": "Add AI insights",
                        "type": "boolean",
                        "description": "Enrich every show with AI: precise niche, target audience, tone, whether it books guests, a ready-to-use outreach angle and a short summary.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
