# Podchaser Podcast Scraper — Contacts, Ratings & Audience Data (`haketa/podchaser-scraper`) Actor

Scrape podcasts from Podchaser.com — title, categories, ratings & reviews, episodes, audience reach, networks, hosts & guests, sponsors, social links with follower counts, RSS feed and a verified contact email for outreach, PR & ad lead-gen. No API key or proxy needed.

- **URL**: https://apify.com/haketa/podchaser-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Podchaser Scraper — Podcast Contacts, Ratings, Audience & Sponsor Data

Export **podcast data from Podchaser.com** at scale: titles, descriptions, categories,
ratings & reviews, episode metrics, audience reach, networks, hosts & guests, **sponsors**,
**social links with follower counts**, RSS feeds, and — the part that pays for itself — a
**verified contact email** for every show, pulled straight from its RSS feed.

It's the affordable, no-lock-in alternative to the **Podchaser API** and **Podchaser Pro**
for anyone who needs a **podcast contact database**, a **podcast outreach list**, or
**podcast advertising / sponsorship intelligence** as a clean CSV, Excel or JSON file.

> **No API key. No login. No proxy required.** Podchaser serves its data over plain HTTPS,
> so this actor runs fast and cheap — typically one or two lightweight requests per podcast.

---

### ⭐ Why this scraper beats every alternative

- **🎯 Real contact emails, not guesses.** We resolve each show's RSS feed and read the
  `itunes:owner` block — the address the podcast actually publishes for business. In testing,
  **100% of mainstream shows returned a working outreach email** (e.g. `podcasts@npr.org`,
  `podcasts@cbsnews.com`, `podcast.support@bbc.co.uk`).
- **💸 No Pro subscription, no per-seat fees.** Podchaser Pro and the official API are priced
  for enterprises. This actor gives you the same public-facing fields for a fraction of the cost.
- **🧠 Structured at the source.** Data comes from Podchaser's own embedded JSON state — not
  brittle HTML scraping — so fields are clean, typed and stable.
- **🚀 Fast & proxy-free.** No headless browser, no anti-bot fights, no proxy bills. Hundreds
  of podcasts per run on direct connections.
- **🔁 Lookalike discovery built in.** Seed a few shows and let **Crawl Similar** expand your
  list to every comparable podcast in the niche.
- **📊 Sales-ready exports.** Pre-built **Podcasts**, **Contacts** and **Creators** views
  download straight to CSV / Excel — drop them into your CRM or cold-email tool.

#### Who buys this data

- **PR & comms agencies** building media lists and pitching clients onto relevant shows.
- **Podcast guesting / booking services** that need targeted host contact emails at volume.
- **Podcast ad networks & sponsorship sales teams** prospecting shows by audience and category.
- **Brands & media buyers** doing podcast advertising research and **competitor sponsor analysis**.
- **Market researchers & analysts** mapping the podcast landscape by category, network and cadence.
- **Podcast hosting & SaaS tools** enriching their own catalogs with ratings, reach and credits.
- **Recruiters & talent bookers** sourcing hosts, co-hosts and frequent guests.

---

### 🔑 SEO / keyword reference

`podchaser scraper` · `podcast scraper` · `podcast database` · `podcast contact database` ·
`podcast email finder` · `podcast outreach list` · `podcast guest pitching` ·
`podcast advertising data` · `podcast sponsorship intelligence` · `podchaser api alternative` ·
`scrape podcast data` · `podcast lead generation` · `podcast ratings and reviews export` ·
`podcast hosts and guests` · `podcast network data` · `export podcasts to csv`

---

### 🎯 What you get — per podcast record

#### 🟢 Identity & links (always present)
- `id`, `slug`, `title`, `url` (canonical Podchaser page)
- `description`, `descriptionHtml`, `imageUrl`
- `website` — the show's official site
- `rssFeedUrl` — the public feed
- `applePodcastsId`, `spotifyId`, `externalIds` (PlayerFM, Pandora, …)
- `language`, `languageCode`, `explicit`, `status`, `claimed`, `hostingProvider`

#### 🟢 The outreach gold — contact data
- `contactEmail` — primary email from the RSS `itunes:owner` block
- `contactEmailsAll` — every distinct email found in the feed
- `ownerNameFromRss` — owner / business name
- `author`, `ownerName` — iTunes author & owner

#### 🟢 Ratings, reviews & audience
- `ratingAverage`, `ratingCount`, `reviewCount`
- `followerCount`, `listCount`
- `reachVerified`, `reachProvider` — whether show-level reach is independently verified (e.g. by Acast)

#### 🟢 Episode metrics
- `numberOfEpisodes`, `avgEpisodeMinutes`, `daysBetweenEpisodes`
- `startDate`, `firstEpisodeDate`, `latestEpisodeDate`
- `latestEpisode` — `{ id, title, airDate, url, audioUrl }`

#### 🟢 Categories, networks & people
- `categories` — Podchaser category slugs
- `networks` — `[{ id, title, url, verified }]`
- `creators` — hosts & guests `[{ id, name, role, pcid, socialAccounts }]`
- `creatorRoleCounts` — credit counts by role (host, guest, author…)

#### 🟢 Monetization & growth signals
- `sponsors` — detected advertised brands `[{ name, url, iconUrl }]` → **competitor ad intelligence**
- `socialLinks` — official Twitter/X, Instagram, Facebook, YouTube **with follower counts**
- `similarPodcasts` — Podchaser "similar shows" `[{ id, slug, title }]` for lookalike expansion

---

### 💰 Real-world use cases — money-making scenarios

#### 1. Build a 5,000-podcast outreach list for a guesting agency
Seed a dozen categories (`true-crime`, `business`, `health-fitness`), turn on
**Enrich Contact Email From RSS** and **Only Podcasts With a Contact Email**, and export the
**Contacts** view. You get a deduplicated CSV of show name + verified email + category +
follower count — ready to import into Instantly, Smartlead or HubSpot.

#### 2. Podcast advertising prospecting by audience
Filter by `minReviews` and `minEpisodes` to surface established shows, sort by `followerCount`
and `reachVerified`, and pitch sponsorships to shows that already monetize.

#### 3. Competitor sponsor analysis
The `sponsors` field reveals which brands already advertise on a show (Shopify, Capital One,
Babbel, BetterHelp…). Map an entire category's sponsor graph to find brands spending in your
vertical — then sell them adjacent inventory.

#### 4. Lookalike discovery from your best shows
Feed your 20 best-performing partner podcasts as `podcastIds`, enable **Crawl Similar**, and
let the actor fan out to every comparable show in the niche. One seed expanded to 5+ similar
shows per hop in testing.

#### 5. Media lists for PR campaigns
Pull every podcast in a category with hosts, networks and verified emails. Hand your client a
tailored media list segmented by topic and reach in minutes, not days.

#### 6. Talent & guest sourcing
The `creators` array (with roles and social handles) is a ready-made database of hosts and
frequent guests — perfect for booking, recruiting or influencer outreach.

#### 7. Market & landscape research
Episode cadence (`daysBetweenEpisodes`), `numberOfEpisodes`, `startDate` and `status` let you
size and segment the market: who's active, who's dormant, how often the top shows publish.

#### 8. Enrich an existing catalog
Already have a list of show IDs? Pass them as `podcastIds` and get ratings, reach, sponsors and
contacts appended — a cheap enrichment layer for any podcast product.

#### 9. Programmatic SEO — "Best X Podcasts" pages
Generate data-backed "Top 50 Business Podcasts" pages with ratings, episode counts and links,
refreshed on a schedule.

#### 10. Lead scoring for podcast SaaS
Combine `reviewCount`, `followerCount`, `reachVerified` and `sponsors` into a fit score to
prioritize the accounts your sales team works first.

---

### ⚙️ Input — what you give

| Field | Type | What it does |
|---|---|---|
| `startUrls` | array | Any Podchaser URLs — podcast pages **or** category pages. Category pages auto-yield ~25 shows each. |
| `categorySlugs` | array | Discover by category, e.g. `news`, `comedy`, `true-crime`, `business`, `technology`. Paginated. |
| `podcastIds` | array | Scrape specific shows by numeric ID (`90473`) or slug (`the-daily-90473`). |
| `scrapeFullProfile` | boolean | Visit each show page for socials, sponsors, hosts/guests, networks & reach. Default **on**. |
| `enrichContactFromRss` | boolean | Fetch the RSS feed to extract the **contact email**. Default **on**. |
| `crawlSimilar` | boolean | Expand to "similar podcasts" of every scraped show. Default off. |
| `similarDepth` | integer | How many hops to follow when crawling similar shows (1–3). |
| `minRating` / `minReviews` / `minEpisodes` | number | Quality filters; `0` = no filter. |
| `requireContactEmail` | boolean | Keep only shows with a found email — a clean outreach list. |
| `maxRecords` | integer | Total cap on records. `0` = unlimited. |
| `maxPagesPerCategory` | integer | Pagination depth per category (~25 shows/page). |
| `requestDelay` / `maxConcurrency` | integer | Politeness & speed controls. |
| `proxyConfiguration` | object | **Optional** — Podchaser needs no proxy. Enable only for very large runs. |

#### Sensible defaults
Out of the box the actor scrapes the **`news`** category, visits each show for the full profile,
enriches contacts from RSS, and caps at **100 records** — so a first run returns rich, complete
data with zero configuration.

---

### 📤 Output — what you get

Every record is one podcast. Download the full dataset as **JSON, CSV or Excel**, or use a
pre-built view:

- **Podcasts** — compact lead-gen overview (art, title, email, rating, episodes, followers…).
- **Contacts** — outreach-ready (title, email, website, RSS, category, followers).
- **Creators** — one row per (podcast, host/guest) for talent sourcing.

#### Example output — full podcast record

```json
{
  "id": 2262,
  "slug": "ted-talks-daily",
  "title": "TED Talks Daily",
  "url": "https://www.podchaser.com/podcasts/ted-talks-daily-2262",
  "description": "Want TED Talks on the go? Everyday, this feed brings you our latest talks…",
  "imageUrl": "https://assets.pippa.io/shows/.../show-cover.png",
  "language": "English",
  "languageCode": "en",
  "status": "active",
  "claimed": false,
  "website": "https://www.ted.com",
  "rssFeedUrl": "https://feeds.acast.com/public/shows/67587e77c705e441797aff96",
  "hostingProvider": "Acast",
  "applePodcastsId": "160904630",
  "spotifyId": "1VXcH8QHkjRcTCEd88U3ti",
  "categories": ["society", "culture", "arts", "technology", "education", "news", "politics"],
  "ratingAverage": 3.46,
  "ratingCount": 27,
  "reviewCount": 9,
  "followerCount": 7226,
  "numberOfEpisodes": 2227,
  "avgEpisodeMinutes": 16.3,
  "daysBetweenEpisodes": 1,
  "latestEpisodeDate": "2026-05-19 15:00:00",
  "reachVerified": true,
  "reachProvider": "acast",
  "socialLinks": {
    "twitter":   { "username": "TEDTalks", "url": "https://www.x.com/TEDTalks", "followers": 10118441 },
    "instagram": { "username": "ted", "url": "https://www.instagram.com/ted", "followers": 8394186 },
    "youtube":   { "username": "TED", "url": "https://www.youtube.com/@TED", "followers": 27400000 }
  },
  "networks": [{ "id": 13, "title": "TED", "url": "https://www.ted.com/podcasts", "verified": false }],
  "creators": [
    { "id": 25791, "name": "Elise Hu", "role": "host", "socialAccounts": [{ "platform": "twitter", "url": "https://www.x.com/elisewho" }] }
  ],
  "sponsors": [
    { "name": "Capital One", "url": "capitalone.com" },
    { "name": "Wise", "url": null },
    { "name": "Rolex", "url": null }
  ],
  "similarPodcasts": [
    { "id": 90473, "slug": "the-daily", "title": "The Daily" },
    { "title": "Freakonomics Radio" }
  ],
  "contactEmail": "podcasts@ted.com",
  "contactEmailsAll": ["podcasts@ted.com", "fixable@ted.com"],
  "ownerNameFromRss": "TED",
  "discoveredFrom": "input.podcastIds",
  "scrapedAt": "2026-05-20T12:40:00.000Z"
}
````

***

### 📊 Real-world fill rate

Measured on a live sample of mainstream podcasts (category + direct runs):

| Field group | Fill rate | Notes |
|---|---|---|
| Identity, URL, description, image | ~100% | Always present |
| Categories, ratings, reviews, episodes | ~100% | Core Podchaser data |
| **Contact email (RSS)** | **~100%** on mainstream shows | Depends on the feed publishing `itunes:owner` |
| Website, RSS, Apple ID | ~100% | |
| Sponsors, creators, latest episode | ~100% (full profile) | From the show page |
| Social links (with followers) | ~80% | Only shows that linked socials on Podchaser |
| Follower count, Spotify ID | partial | Set only for some shows |
| `reachVerified` / `reachProvider` | varies | Present for shows on verified hosts (Acast, etc.) |

> Fill rate scales with how complete a show's Podchaser profile is. Big, claimed and
> network-backed shows return the richest records.

***

### 🌍 Coverage — millions of shows, every major category

Podchaser indexes the global podcast universe. Discover by category
(`news`, `comedy`, `true-crime`, `business`, `technology`, `society-culture`, `education`,
`health-fitness`, `sports`, `arts`, `science`, `history`, `music`, `religion-spirituality`,
`tv-film`, `kids-family`, and many sub-categories), by direct IDs, or by lookalike crawling
from seed shows.

***

### 💡 Tips & best practices

#### Outreach / lead-gen

- Keep **Enrich Contact Email From RSS** on and turn on **Only Podcasts With a Contact Email**
  to get a clean, send-ready list.
- Export the **Contacts** view → import directly into your cold-email or CRM tool.

#### Sponsorship & ad intelligence

- Scrape a full category, then pivot the `sponsors` column to see which brands dominate the niche.

#### Lookalike expansion

- Start with 10–20 of your best shows in `podcastIds`, enable **Crawl Similar** with
  `similarDepth: 1–2`, and set a generous `maxRecords`.

#### Speed vs depth

- For a fast headcount, set `scrapeFullProfile: false` — the category page alone gives title,
  ratings, episodes, RSS and categories.
- For full records (socials, sponsors, creators, reach), keep it on (default).

#### Cost & politeness

- No proxy is needed. For very large jobs, add Apify Datacenter proxy and keep
  `maxConcurrency` around 4–6 with a small `requestDelay`.

***

### ❓ FAQ

**Do I need a Podchaser account or API key?**
No. The actor reads public pages — no login, no key, no Pro subscription.

**Where do the contact emails come from?**
From each podcast's own public RSS feed (`itunes:owner` → `itunes:email`), the address shows
publish for business inquiries. We only read the feed header, so it's fast.

**Is a proxy required?**
No. Podchaser serves data over plain HTTPS. A proxy is optional and only useful for very large
runs that might hit per-IP rate limits.

**How fast is it?**
Very. There's no headless browser. Discovery returns ~25 shows per category request; each full
profile is a single page fetch plus an optional RSS read.

**Can I scrape one specific show?**
Yes — put its ID or slug in `podcastIds`. The numeric ID is canonical, so even a wrong slug
resolves correctly.

**Can I get the full episode list / reviews text?**
This actor focuses on show-level data (the highest-value fields for sales, PR and research),
plus the latest/featured episode. Per-episode and review-body scraping can be added on request.

**What about audience size numbers?**
Podchaser exposes whether reach is *verified* and by whom on public pages; exact audience
estimates are a Pro/API metric and are not part of the public payload.

**Which export formats are supported?**
JSON, CSV and Excel for the full dataset, plus the Podcasts, Contacts and Creators views.

**Is this legal?**
The actor collects publicly available information. You are responsible for using the data in
line with Podchaser's terms, the RSS publishers' terms, and applicable laws (GDPR/CAN-SPAM for
outreach). See the disclaimer below.

***

### 💸 Pricing

This actor uses a **pay-per-result** model: you pay a small flat fee per podcast record returned
and nothing for failed requests or empty runs. Because it needs no proxy and no browser, runs
are cheap and fast — most of the value (verified contact email, sponsors, reach) is included in
the base result.

- A 100-podcast test run costs cents.
- Scale to thousands of contacts for a few dollars.

Exact per-result pricing is shown on the actor's Apify Store page.

***

### 🚀 Related actors by the same team

- **DesignRush B2B Agency Scraper** — agencies with budgets, reviews & contacts.
- **GoodFirms Scraper** — IT & service companies with ratings and portfolios.
- **USASpending Scraper** — US federal contracts & awardees.

Need a custom field, per-episode data, or a different source? Open an issue — happy to extend.

***

### ✅ Status & support

Actively maintained. If Podchaser changes its page structure, the JSON-state extractor is the
single point to update — issues are usually fixed quickly. Report bugs or feature requests via
the **Issues** tab on the actor page.

***

### ⚖️ Disclaimer

This actor extracts **publicly accessible** data from Podchaser.com and public podcast RSS
feeds for legitimate research, journalism and B2B outreach. It does not access private,
gated or authenticated content. You are solely responsible for complying with Podchaser's
Terms of Service, RSS publishers' terms, and all applicable data-protection and
anti-spam laws (including **GDPR** and **CAN-SPAM**) when using the data — especially for
email outreach. Always honor opt-out requests and obtain consent where required.

# Actor input Schema

## `startUrls` (type: `array`):

Any Podchaser URL — a podcast page (https://www.podchaser.com/podcasts/the-daily-90473), a category page (https://www.podchaser.com/categories/news/podcasts), or an episodes page. Category pages yield ~25 podcasts each and paginate automatically. Mixed types are fine.

## `categorySlugs` (type: `array`):

Discover podcasts from these Podchaser categories. Each category page returns ~25 podcasts and is paginated. Examples: news, comedy, true-crime, business, technology, society-culture, education, health-fitness, sports, arts, science, history, music, religion-spirituality, tv-film, kids-family.

## `podcastIds` (type: `array`):

Scrape specific podcasts directly. Accepts the numeric Podchaser ID (e.g. 90473) or the full slug-id (e.g. the-daily-90473). The numeric ID is canonical — a wrong slug still resolves to the correct podcast.

## `scrapeFullProfile` (type: `boolean`):

Visit each podcast page to extract the full record: social links with follower counts, sponsors, hosts & guests with roles, networks, audience-reach verification and similar podcasts. Turn OFF for ultra-fast listing-only discovery (title, ratings, episodes, RSS, categories from the category page alone).

## `enrichContactFromRss` (type: `boolean`):

Fetch each podcast's public RSS feed and extract the owner contact email (itunes:owner) plus any emails in the feed — the real address for outreach, guest pitching, PR and sponsorship. Adds one lightweight request per podcast (only the feed header is downloaded).

## `crawlSimilar` (type: `boolean`):

Expand discovery by following the 'similar podcasts' of every scraped show. Great for building a large, tightly-themed list from a few seeds. Respects Max Records.

## `similarDepth` (type: `integer`):

How many hops to follow when 'Crawl Similar Podcasts' is on. 1 = only the similar shows of your seeds.

## `minRating` (type: `number`):

Drop podcasts below this average rating (0–5). 0 = no filter.

## `minReviews` (type: `integer`):

Drop podcasts with fewer reviews than this. 0 = no filter.

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

Drop podcasts with fewer published episodes than this. Useful to skip inactive or trailer-only shows. 0 = no filter.

## `requireContactEmail` (type: `boolean`):

Keep only podcasts where a contact email was found (requires 'Enrich Contact Email From RSS'). Turns the output into a clean, ready-to-use outreach list.

## `maxRecords` (type: `integer`):

Total cap on podcasts to push. 0 = unlimited.

## `maxPagesPerCategory` (type: `integer`):

Pagination depth per category (~25 podcasts per page).

## `requestDelay` (type: `integer`):

Delay between requests. Higher = gentler on Podchaser.

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

Parallel request count. 3–5 is a good balance of speed and politeness.

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

Default: NO proxy — Podchaser serves data over plain HTTPS and does not require a proxy. Enable Apify Proxy (Datacenter is plenty, Residential for very large runs) only if you hit per-IP rate limits on big jobs.

## Actor input object example

```json
{
  "startUrls": [],
  "categorySlugs": [
    "news"
  ],
  "podcastIds": [],
  "scrapeFullProfile": true,
  "enrichContactFromRss": true,
  "crawlSimilar": false,
  "similarDepth": 1,
  "minRating": 0,
  "minReviews": 0,
  "minEpisodes": 0,
  "requireContactEmail": false,
  "maxRecords": 100,
  "maxPagesPerCategory": 4,
  "requestDelay": 700,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Full dataset — choose JSON / CSV / Excel in the export menu.

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

Compact lead-gen table.

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

Ready-to-use outreach list.

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

One row per (podcast, host/guest).

# 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 = {
    "startUrls": [],
    "categorySlugs": [
        "news"
    ],
    "podcastIds": [],
    "scrapeFullProfile": true,
    "enrichContactFromRss": true,
    "maxRecords": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/podchaser-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 = {
    "startUrls": [],
    "categorySlugs": ["news"],
    "podcastIds": [],
    "scrapeFullProfile": True,
    "enrichContactFromRss": True,
    "maxRecords": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/podchaser-scraper").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 '{
  "startUrls": [],
  "categorySlugs": [
    "news"
  ],
  "podcastIds": [],
  "scrapeFullProfile": true,
  "enrichContactFromRss": true,
  "maxRecords": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/podchaser-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Podchaser Podcast Scraper — Contacts, Ratings & Audience Data",
        "description": "Scrape podcasts from Podchaser.com — title, categories, ratings & reviews, episodes, audience reach, networks, hosts & guests, sponsors, social links with follower counts, RSS feed and a verified contact email for outreach, PR & ad lead-gen. No API key or proxy needed.",
        "version": "0.0",
        "x-build-id": "3W2aJrSWkmtuDtTw1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~podchaser-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-podchaser-scraper",
                "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/haketa~podchaser-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-podchaser-scraper",
                "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/haketa~podchaser-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-podchaser-scraper",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Any Podchaser URL — a podcast page (https://www.podchaser.com/podcasts/the-daily-90473), a category page (https://www.podchaser.com/categories/news/podcasts), or an episodes page. Category pages yield ~25 podcasts each and paginate automatically. Mixed types are fine.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categorySlugs": {
                        "title": "Category Slugs",
                        "type": "array",
                        "description": "Discover podcasts from these Podchaser categories. Each category page returns ~25 podcasts and is paginated. Examples: news, comedy, true-crime, business, technology, society-culture, education, health-fitness, sports, arts, science, history, music, religion-spirituality, tv-film, kids-family.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "podcastIds": {
                        "title": "Podcast IDs or Slugs",
                        "type": "array",
                        "description": "Scrape specific podcasts directly. Accepts the numeric Podchaser ID (e.g. 90473) or the full slug-id (e.g. the-daily-90473). The numeric ID is canonical — a wrong slug still resolves to the correct podcast.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeFullProfile": {
                        "title": "Scrape Full Profile",
                        "type": "boolean",
                        "description": "Visit each podcast page to extract the full record: social links with follower counts, sponsors, hosts & guests with roles, networks, audience-reach verification and similar podcasts. Turn OFF for ultra-fast listing-only discovery (title, ratings, episodes, RSS, categories from the category page alone).",
                        "default": true
                    },
                    "enrichContactFromRss": {
                        "title": "Enrich Contact Email From RSS",
                        "type": "boolean",
                        "description": "Fetch each podcast's public RSS feed and extract the owner contact email (itunes:owner) plus any emails in the feed — the real address for outreach, guest pitching, PR and sponsorship. Adds one lightweight request per podcast (only the feed header is downloaded).",
                        "default": true
                    },
                    "crawlSimilar": {
                        "title": "Crawl Similar Podcasts",
                        "type": "boolean",
                        "description": "Expand discovery by following the 'similar podcasts' of every scraped show. Great for building a large, tightly-themed list from a few seeds. Respects Max Records.",
                        "default": false
                    },
                    "similarDepth": {
                        "title": "Similar Crawl Depth",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many hops to follow when 'Crawl Similar Podcasts' is on. 1 = only the similar shows of your seeds.",
                        "default": 1
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop podcasts below this average rating (0–5). 0 = no filter.",
                        "default": 0
                    },
                    "minReviews": {
                        "title": "Minimum Reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop podcasts with fewer reviews than this. 0 = no filter.",
                        "default": 0
                    },
                    "minEpisodes": {
                        "title": "Minimum Episodes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop podcasts with fewer published episodes than this. Useful to skip inactive or trailer-only shows. 0 = no filter.",
                        "default": 0
                    },
                    "requireContactEmail": {
                        "title": "Only Podcasts With a Contact Email",
                        "type": "boolean",
                        "description": "Keep only podcasts where a contact email was found (requires 'Enrich Contact Email From RSS'). Turns the output into a clean, ready-to-use outreach list.",
                        "default": false
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Total cap on podcasts to push. 0 = unlimited.",
                        "default": 100
                    },
                    "maxPagesPerCategory": {
                        "title": "Max Pages Per Category",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Pagination depth per category (~25 podcasts per page).",
                        "default": 4
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Delay between requests. Higher = gentler on Podchaser.",
                        "default": 700
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel request count. 3–5 is a good balance of speed and politeness.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Default: NO proxy — Podchaser serves data over plain HTTPS and does not require a proxy. Enable Apify Proxy (Datacenter is plenty, Residential for very large runs) only if you hit per-IP rate limits on big jobs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
