# Podcast Host Email & Lead Scraper (`chilly_damask/podcast-host-email-lead-scraper`) Actor

Scrape podcast host business emails + social links from Apple Podcasts & RSS feeds by keyword, Apple ID, or feed URL. No login. Pay only per email found. CSV/JSON.

- **URL**: https://apify.com/chilly\_damask/podcast-host-email-lead-scraper.md
- **Developed by:** [Jaxx](https://apify.com/chilly_damask) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 email founds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Podcast Host Email & Lead Scraper (Pay Per Email Found)

**Turn a list of podcasts — or a single niche keyword — into a clean contact list of publicly listed podcast host business emails and social profiles. You pay only when an email is actually found. No email, no charge.**

Feed the actor niche keywords, Apple Podcasts IDs, or RSS feed URLs. It resolves each show through the **public iTunes Search / Lookup API**, fetches the show's **RSS feed**, and returns the host's business email and social links it can find, one tidy record per show — signed out, no login, no API keys, no browser.

- 📧 Publicly listed host business emails, with provenance (`owner` / `website` / `linktree`)
- 🔗 Social profiles: Instagram, TikTok, X, LinkedIn, Facebook, YouTube, Discord, Telegram, website
- 📊 Show metadata: category, episode count, last-episode date, active status, language, author
- 💰 **Pay-per-result** — priced per email found, not per subscription. A show with no email costs you **nothing**.

---

### 🎯 Best for

Self-identify in two seconds — this actor is built for:

- **Podcast guesting / PR outreach** — build a list of shows to pitch yourself or a client onto, with a contact email attached.
- **Podcast sponsorship & ad sales** — go from a niche shortlist to reachable host inboxes.
- **Agency lead generation** — turn a niche keyword into a queue of podcast leads for a client.
- **Media & influencer sourcing** — surface active shows in an adjacent niche and their public business contact.
- **Sales prospecting into the creator / podcast economy** — enrich a show list with email + socials before you reach out.

---

### 🔒 What makes this scraper different (and safer)

It runs **signed out** and reads only **public** surfaces — the public iTunes Search / Lookup API and the show's own **public RSS feed**. There is no login, no CAPTCHA, no API key, and no browser.

#### Where the emails come from

Public surfaces, signed out:

1. the show's RSS feed **`<itunes:owner>` email tag** (the contact address Apple requires a podcaster to publish for their own show), with `managingEditor` / `webMaster` as fallbacks, and
2. — one hop, optional — the show's own **linked website / Linktree**, when the feed exposes no owner email.

#### What it deliberately does NOT do

- ❌ **Does not log into anything** and does not touch private or gated data. An email a host keeps off their public feed and off their linked site simply won't appear here.

---

### 🎧 Scope & limits (read this)

- **Apple Podcasts + RSS only.** Discovery is via the public iTunes catalog, and extraction is from the show's public RSS feed. **Spotify-exclusive and YouTube-exclusive shows have no public RSS feed with an owner email**, so they are out of reach by design — there is no public surface to read.
- **The owner email is whatever the podcaster published.** Many shows list a real host/booking address; some list a generic `hello@` or a network address; some omit it entirely (in which case the optional one-hop website scan may still recover one).
- **`episodeCount` is the number of episodes present in the feed.** Most feeds carry the full back catalog, but some publishers truncate their feed to the most recent N — for those, the count reflects the feed, not the show's lifetime total.

---

### ⚙️ How it works

Plain HTTP — no browser, no key, no login:

1. **Resolve the show.**
   - *Keyword* → the public **iTunes Search API** (`itunes.apple.com/search?media=podcast`) returns matching shows, each with its canonical `feedUrl`. Billed per search query.
   - *Apple Podcasts ID* → the public **iTunes Lookup API** (`itunes.apple.com/lookup?id=…`) returns that one show's `feedUrl` + metadata.
   - *RSS URL* → used directly.
2. **Fetch the RSS feed** and parse it with a dependency-free XML reader.
3. **Extract the host email** from `<itunes:owner><itunes:email>` (fallbacks: channel `itunes:email`, `managingEditor`, `webMaster`).
4. **If no owner email**, follow the show's linked **website / Linktree** one hop and regex-extract `mailto:` and plain-text emails.
5. **Also emit** website, category, episode count, last-episode date / active status, and social links.

Built-in resilience (shared with the maintainer's other scrapers):

- up to **3 retries** per request with backoff, and a body-download-safe timeout,
- a **response-size cap** so a runaway feed can't exhaust memory,
- **run-global de-duplication** by Apple collection ID / feed URL, so a show discovered twice is fetched, charged, and emitted once,
- **honest error output** — a show whose feed ultimately fails to fetch is written to the dataset as `{ "status": "error", "errorDetail": "...", "feedUrl": "..." }` rather than silently dropped.

---

### ▶️ How to use (no code required)

1. Create a free Apify account.
2. Open this actor and either type niche keywords into **Search keywords**, paste Apple Podcasts IDs into **Apple Podcasts IDs**, or paste feed URLs into **RSS feed URLs**.
3. (Optional) cap **Max shows per keyword** and set your **Country** storefront to control cost and coverage.
4. Click **Start**.
5. Watch rows appear in the **Output** tab, then export the dataset as JSON, CSV, Excel, XML, or HTML — or pull it via the API.

---

### 📥 Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchKeywords` | array of strings | `[]` | Each keyword runs an iTunes Search query and queues the discovered shows. Billed per search query. |
| `applePodcastIds` | array of strings | `[]` | Apple Podcasts numeric show IDs — the number in `podcasts.apple.com/…/id<THIS>`. Resolved to a feed via the iTunes Lookup API. |
| `rssFeedUrls` | array of strings | `[]` | Direct podcast RSS feed URLs. Skips iTunes resolution. |
| `maxShowsPerKeyword` | integer | `50` | How many shows to collect per keyword search. Min 1, max 200. |
| `country` | string | `"us"` | ISO storefront code for the iTunes Search & Lookup APIs. |
| `scanLinkedWebsites` | boolean | `true` | When the feed exposes no email, follow the show's website / Linktree one hop and extract emails. |
| `includeSocialLinks` | boolean | `true` | Return the show's linked social profiles parsed from the feed. |
| `activeWithinDays` | integer | `90` | A show is flagged `isActive: true` when its newest episode is newer than this. Informational — does not filter output. |
| `dedupeEmails` | boolean | `true` | One record per show, with emails deduped across all sources. |

#### Example input

```json
{
  "searchKeywords": ["home barista", "indie game dev"],
  "applePodcastIds": ["1200361736"],
  "rssFeedUrls": ["https://feeds.simplecast.com/54nAGcIl"],
  "maxShowsPerKeyword": 50,
  "country": "us",
  "scanLinkedWebsites": true,
  "includeSocialLinks": true,
  "activeWithinDays": 90,
  "dedupeEmails": true
}
````

***

### 📤 Output

One record per show, written to the dataset as results come in. Export it as JSON, CSV, Excel, XML, or HTML, or read it through the API.

```json
{
  "showTitle": "Indie Coffee Show",
  "feedUrl": "https://feeds.example.com/indiecoffee",
  "hostEmail": "jane@indiecoffee.show",
  "emailSource": "owner",
  "website": "https://indiecoffee.show",
  "category": "Arts",
  "author": "Jane Barista",
  "language": "en-us",
  "episodeCount": 142,
  "lastEpisodeAt": "2026-07-02T10:00:00.000Z",
  "isActive": true,
  "collectionId": "1200361736",
  "appleUrl": "https://podcasts.apple.com/us/podcast/id1200361736",
  "artworkUrl": "https://…/600x600bb.jpg",
  "ownerName": "Jane Barista",
  "emails": [
    { "email": "jane@indiecoffee.show", "source": "owner", "domain": "indiecoffee.show" }
  ],
  "bestEmail": "jane@indiecoffee.show",
  "hasEmail": true,
  "socials": {
    "website": "https://indiecoffee.show",
    "instagram": "https://instagram.com/…",
    "x": "https://x.com/…"
  },
  "sourceMode": "keyword",
  "sourceKeyword": "home barista",
  "scrapedAt": "2026-07-14T00:00:00.000Z",
  "status": "ok",
  "errorDetail": null
}
```

Field notes:

- **`emails`** — every email found for the show, each tagged with its `source` (`owner`, `website`, or `linktree`) and `domain`. Only sources the actor actually read are emitted.
- **`hostEmail` / `bestEmail`** — a single pick, preferring a **business domain** over a freemail address (Gmail, Outlook, etc.). `emailSource` records which surface it came from.
- **`hasEmail`** — `true` when at least one email was found. It's the *gate* for billing — no email, no charge — but the `email-found` event is priced **per unique email**, so a show with two emails is two events (see the worked example under Pricing).
- **`isActive`** — `true` when the newest episode is within `activeWithinDays`, `false` when older, `null` when the feed carries no dated episodes.
- **`sourceMode`** — `"keyword"`, `"apple_id"`, or `"rss"` depending on how the show entered the run. `sourceKeyword` is set when it was discovered via a keyword search.
- **`status`** — `"ok"` for a successful record, `"error"` for a feed that failed to fetch (with a human-readable `errorDetail`). Error rows are kept, not dropped.

***

### 💰 Pricing (pay-per-event)

You are charged a **fixed price per result event** — not for platform usage or compute time.

| Event | Price | Per 1,000 | When you're charged |
|---|---|---|---|
| `email-found` | **$0.02** | **$20 / 1,000** | Once per **unique email found**. A show with **no email is free**. |
| `keyword-search` | **$0.01** | **$10 / 1,000** | Once per **keyword search query** executed. |

**No-find-free is the core trust mechanic:** you never pay for a show that yields nothing. If a feed fails, it comes back as a `status: "error"` row — never as a phantom charge for data that does not exist.

**What a run costs — a worked example:** you scan **500 shows**, **180** expose a host email (and **20** of those list two) → **200 unique emails × $0.02 = $4.00**. Add **2 keyword searches** at $0.01 → **$0.02**. Total: **$4.02** — and the 320 shows with no email cost nothing.

> The prices above are exactly what you're billed — nothing for platform usage or compute on top. Comparable Store actors price differently; compare the live listings and pick what fits your volume.

***

### ❓ FAQ

**Do I pay for shows that don't have an email?**
No. You are charged only when an email is actually found (`hasEmail: true`). A show that yields nothing — or a feed that errors — costs you nothing for the email event.

**Why can't it find every podcast's email?**
Because it reads only what the podcaster **published**. Apple Podcasts + RSS is the surface; a **Spotify-exclusive or YouTube-exclusive show has no public RSS feed with an owner email**, and a host who lists no email anywhere public can't be surfaced. That's an honest scope limit, not a bug.

**Can I test with a small list first?**
Yes. Start with two or three RSS URLs or one keyword, confirm the output looks right, then scale up. `maxShowsPerKeyword` caps volume and cost on keyword runs.

**How do I maximize the hit rate?**
Point it at active, independently-produced shows — they most often publish a real host/booking email in their feed. Keep `scanLinkedWebsites` on so the actor can follow the one hop to the show's site when the feed itself omits the email.

**Can I run it on a schedule or from my own code?**
Yes. Apify lets you run this actor from the Console UI, schedule it, call it via the Apify API, drive it with the `apify-client` SDKs for JavaScript and Python, run it from the Apify CLI, or connect it through an MCP server — and wire the output into Make, Zapier, Slack, Google Sheets, or a webhook.

**Is it legal to scrape this?**
The actor reads only publicly available data, signed out. That said, some output fields are personal data (e.g. an email address). You should have a legitimate basis for collecting and using it and should comply with applicable law (GDPR/CCPA, Apple's and the feed publishers' terms, and anti-spam rules like CAN-SPAM). If you are unsure whether your use is legitimate, consult your own legal counsel.

**What happens when a feed can't be fetched?**
The request is retried up to 3 times, then written to the dataset as a `{ "status": "error", "errorDetail": "…" }` row. You get an honest record of what failed instead of a silently missing show.

***

### 🔌 API-ready

This actor is a drop-in piece of a pipeline. Apify auto-generates integration snippets for it — JavaScript (`apify-client`), Python (`apify-client`), the Apify CLI, the REST API, an OpenAPI spec, and an MCP server — so you can call it from your own stack or an agent workflow. See the **API** tab on the actor page.

***

### Maintainer

Published by **Jaxx**. Categories: **Lead generation** · **Social media**.

Found a show that should have parsed but didn't, or a field you'd like added? Open an issue on the actor's **Issues** tab — bug reports and extraction edge cases are actively reviewed.

# Actor input Schema

## `searchKeywords` (type: `array`):

Optional. Each keyword runs an Apple Podcasts (public iTunes Search API) query and queues the discovered shows for email extraction. Billed per search query.

## `applePodcastIds` (type: `array`):

Apple Podcasts numeric show IDs. Find it in the Apple Podcasts URL: podcasts.apple.com/us/podcast/<name>/id\<THIS\_NUMBER>. Each ID is resolved to its RSS feed via the public iTunes Lookup API. Leave empty to use keywords / feed URLs only.

## `rssFeedUrls` (type: `array`):

Direct podcast RSS feed URLs (e.g. https://feeds.megaphone.fm/… or a show's own feed). Skips iTunes resolution and parses the feed straight away. Leave empty to use keywords / Apple IDs only.

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

How many shows to collect from each keyword search (the iTunes Search API returns up to 200 per query).

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

ISO storefront code used for the iTunes Search & Lookup APIs (e.g. "us", "gb", "de"). Affects which shows a keyword search surfaces.

## `scanLinkedWebsites` (type: `boolean`):

When the feed exposes no host email, follow the show's linked website / Linktree / Beacons link one hop and regex-extract mailto: and plain-text emails.

## `includeSocialLinks` (type: `boolean`):

Return the show's linked social profiles (Instagram, TikTok, X, LinkedIn, Facebook, YouTube, Discord, Telegram, website) parsed from the feed.

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

A show is flagged isActive=true when its most recent episode is newer than this many days. Purely informational — it does not filter output.

## `dedupeEmails` (type: `boolean`):

One record per show with emails deduped across all sources.

## Actor input object example

```json
{
  "searchKeywords": [
    "home barista",
    "indie game dev"
  ],
  "applePodcastIds": [
    "1200361736"
  ],
  "rssFeedUrls": [
    "https://feeds.simplecast.com/54nAGcIl"
  ],
  "maxShowsPerKeyword": 50,
  "country": "us",
  "scanLinkedWebsites": true,
  "includeSocialLinks": true,
  "activeWithinDays": 90,
  "dedupeEmails": true
}
```

# 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 = {
    "searchKeywords": [
        "home barista"
    ],
    "applePodcastIds": [],
    "rssFeedUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("chilly_damask/podcast-host-email-lead-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 = {
    "searchKeywords": ["home barista"],
    "applePodcastIds": [],
    "rssFeedUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("chilly_damask/podcast-host-email-lead-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 '{
  "searchKeywords": [
    "home barista"
  ],
  "applePodcastIds": [],
  "rssFeedUrls": []
}' |
apify call chilly_damask/podcast-host-email-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Podcast Host Email & Lead Scraper",
        "description": "Scrape podcast host business emails + social links from Apple Podcasts & RSS feeds by keyword, Apple ID, or feed URL. No login. Pay only per email found. CSV/JSON.",
        "version": "1.0",
        "x-build-id": "oN3cX4ws7RCMdk3qy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chilly_damask~podcast-host-email-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chilly_damask-podcast-host-email-lead-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/chilly_damask~podcast-host-email-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chilly_damask-podcast-host-email-lead-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/chilly_damask~podcast-host-email-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chilly_damask-podcast-host-email-lead-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": {
                    "searchKeywords": {
                        "title": "Search keywords (discover shows by niche)",
                        "type": "array",
                        "description": "Optional. Each keyword runs an Apple Podcasts (public iTunes Search API) query and queues the discovered shows for email extraction. Billed per search query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "applePodcastIds": {
                        "title": "Apple Podcasts IDs",
                        "type": "array",
                        "description": "Apple Podcasts numeric show IDs. Find it in the Apple Podcasts URL: podcasts.apple.com/us/podcast/<name>/id<THIS_NUMBER>. Each ID is resolved to its RSS feed via the public iTunes Lookup API. Leave empty to use keywords / feed URLs only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "rssFeedUrls": {
                        "title": "RSS feed URLs",
                        "type": "array",
                        "description": "Direct podcast RSS feed URLs (e.g. https://feeds.megaphone.fm/… or a show's own feed). Skips iTunes resolution and parses the feed straight away. Leave empty to use keywords / Apple IDs only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxShowsPerKeyword": {
                        "title": "Max shows per keyword",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many shows to collect from each keyword search (the iTunes Search API returns up to 200 per query).",
                        "default": 50
                    },
                    "country": {
                        "title": "Country / storefront",
                        "type": "string",
                        "description": "ISO storefront code used for the iTunes Search & Lookup APIs (e.g. \"us\", \"gb\", \"de\"). Affects which shows a keyword search surfaces.",
                        "default": "us"
                    },
                    "scanLinkedWebsites": {
                        "title": "Scan linked websites (one hop)",
                        "type": "boolean",
                        "description": "When the feed exposes no host email, follow the show's linked website / Linktree / Beacons link one hop and regex-extract mailto: and plain-text emails.",
                        "default": true
                    },
                    "includeSocialLinks": {
                        "title": "Include social links",
                        "type": "boolean",
                        "description": "Return the show's linked social profiles (Instagram, TikTok, X, LinkedIn, Facebook, YouTube, Discord, Telegram, website) parsed from the feed.",
                        "default": true
                    },
                    "activeWithinDays": {
                        "title": "Active-within-days threshold",
                        "minimum": 1,
                        "type": "integer",
                        "description": "A show is flagged isActive=true when its most recent episode is newer than this many days. Purely informational — it does not filter output.",
                        "default": 90
                    },
                    "dedupeEmails": {
                        "title": "Dedupe emails",
                        "type": "boolean",
                        "description": "One record per show with emails deduped across all sources.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
