# Apple Podcasts Scraper — Episodes, Audio URLs & RSS Data (`logiover/apple-podcasts-episode-scraper`) Actor

Extract podcast shows and full episode lists from Apple Podcasts. Titles, descriptions, audio MP3 URLs, durations, publish dates, artwork, genres, transcripts. Via iTunes Search/Lookup API + RSS. No login. For podcast intelligence, RAG/AI training data and sponsorship research.

- **URL**: https://apify.com/logiover/apple-podcasts-episode-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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

## Apple Podcasts Scraper — Episodes, Audio URLs, Show Metadata & RSS Feed Data

Extract **podcast shows and full episode lists from Apple Podcasts (iTunes)** — episode titles, descriptions, **direct audio (MP3) URLs**, durations, release dates, artwork, genres, **episode numbers, season numbers, transcript URLs, chapter markers** and **HTML show notes**. Search by keyword, drop in podcast IDs, or paste **RSS feed URLs** directly. Combines the official iTunes Search & Lookup API with optional RSS enrichment for **full episode archives** — no proxy, no login, no API key.

Built for **podcast intelligence platforms**, **RAG / AI training data pipelines**, **ad targeting & sponsorship research**, **content discovery engines**, **podcast SEO tools** and **competitive intelligence** workflows.

---

### 🚀 What does this Apple Podcasts scraper do?

Three input modes — combine them or use one in isolation:

| Mode | When to use | What it returns |
|------|-------------|-----------------|
| **Search Terms** | Discover podcasts about a topic | All matching shows from iTunes, then every episode of each |
| **Podcast IDs** | You already know which shows you want | Fast, deterministic episode pulls for those exact shows |
| **RSS Feed URLs** | You want the full archive (>200 eps), private/custom feeds, or richer fields | Every episode in the feed, plus chapter markers, transcript URLs, HTML notes |

Behind the scenes it calls Apple's official **iTunes Search API** (`/search`) and **iTunes Lookup API** (`/lookup?entity=podcastEpisode`), then optionally parses the show's **RSS 2.0 / Podcast 2.0** feed using a streaming XML parser. Anti-bot is irrelevant — Apple's catalog endpoints are designed for third-party clients.

---

### 💡 Use cases

- **Podcast intelligence / analytics SaaS** — feed every episode of every show in a niche into your dashboard (Listen Notes / Podscan / Chartable alternative data layer).
- **RAG & LLM training data** — episode title + description + show notes HTML is high-quality, semi-structured natural language. Audio URLs feed Whisper / Distil-Whisper for transcript generation.
- **Ad & sponsorship targeting** — find every fitness / B2B SaaS / parenting show in a country, then enrich with show metadata before outreach.
- **Podcast SEO & discovery** — build category landing pages, sitemap files, episode aggregators.
- **Trend & topic monitoring** — pull weekly snapshots of "AI" podcasts to track how the conversation evolves.
- **Whisper / transcription pipelines** — feed `audioUrl` into a transcription queue at scale.
- **Competitive intel for media companies** — track release cadence, episode length distribution and topical drift of competitor shows.
- **Apple Podcasts → Spotify migration tools** — Apple is the canonical podcast index (Spotify, Pocket Casts, Overcast all sync from RSS too).

---

### ⚙️ Input configuration

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchTerms` | `string[]` | `[]` | Keyword queries (e.g. `["artificial intelligence", "longform interview"]`). Each term returns up to `maxPodcastsPerSearch` shows; every show is expanded into episodes. |
| `podcastIds` | `string[]` | `[]` | iTunes collection IDs. From `https://podcasts.apple.com/us/podcast/.../id1434243584` → `1434243584`. |
| `rssFeeds` | `string[]` | `[]` | Direct podcast RSS feed URLs. Bypasses Apple entirely. Best for full archives beyond Apple's ~200-episode lookup cap. |
| `country` | `string` | `"us"` | iTunes storefront. Affects ranking and country-restricted shows. 30 storefronts supported. |
| `maxPodcastsPerSearch` | `integer` | `50` | Max podcasts per search term (iTunes hard cap = 200). |
| `maxEpisodesPerPodcast` | `integer` | `100` | Max episodes per iTunes lookup (iTunes hard cap = ~200). |
| `useRssForFullArchive` | `boolean` | `false` | After iTunes lookup, also fetch the show's RSS to unlock the full archive (chapter markers + transcript URLs + episode numbers + season numbers + HTML show notes). |
| `minReleaseDate` | `string` | `null` | Drop episodes released before this date (ISO `YYYY-MM-DD`). |
| `maxReleaseDate` | `string` | `null` | Drop episodes released after this date (ISO `YYYY-MM-DD`). |
| `explicit` | `string` | `"all"` | `all` / `clean` / `explicit` content filter. |
| `minDurationSeconds` | `integer` | `0` | Drop episodes shorter than this — useful for filtering trailers and ads. |
| `fetchShowMetadata` | `boolean` | `true` | Enrich each episode with parent-show fields (genres, primary genre, country, total track count, show description). |

---

### 📦 Output fields

| Field | Description | Example |
|-------|-------------|---------|
| `podcastId` | iTunes collection ID | `"1434243584"` |
| `podcastName` | Show name | `"Lex Fridman Podcast"` |
| `author` | Podcast creator / host | `"Lex Fridman"` |
| `episodeId` | iTunes track ID or RSS guid | `"1000766518218"` |
| `episodeGuid` | RSS-native guid (when available) | `"abc-123-uuid"` |
| `episodeTitle` | Episode title | `"#496 – FFmpeg..."` |
| `episodeNumber` | RSS `itunes:episode` | `496` |
| `season` | RSS `itunes:season` | `1` |
| `episodeType` | `full`, `trailer`, `bonus` (RSS only) | `"full"` |
| `description` | Plain-text description | `"Jean-Baptiste Kempf is..."` |
| `shortDescription` | Truncated summary | `"Jean-Baptiste Kempf is..."` |
| `showNotesHtml` | Full HTML show notes (RSS only) | `"<p>...</p>"` |
| `releaseDate` | ISO-8601 publish time | `"2026-05-06T22:06:47Z"` |
| `durationMs` | Length in ms | `15821000` |
| `durationSec` | Length in seconds | `15821` |
| `audioUrl` | **Direct audio file URL** | `"https://media.../episode.mp3"` |
| `audioContentType` | MIME type | `"audio"` |
| `audioExtension` | `mp3`, `m4a`, `mp4` | `"mp3"` |
| `audioFileSize` | Byte length (RSS only) | `253984210` |
| `artworkUrl600` | 600px artwork | `"https://...600x600bb.jpg"` |
| `episodeAppleUrl` | Apple Podcasts episode URL | `"https://podcasts.apple.com/..."` |
| `showAppleUrl` | Apple Podcasts show URL | `"https://podcasts.apple.com/..."` |
| `feedUrl` | Show RSS feed URL | `"https://.../feed.xml"` |
| `closedCaptioning` | Apple closed-caption flag | `"none"` |
| `transcriptUrl` | Podcast 2.0 transcript URL | `"https://.../transcript.srt"` |
| `chapters` | Chapter markers (Podcast 2.0) | `[...]` |
| `keywords` | RSS `itunes:keywords` | `"ai, technology, vlc"` |
| `explicitness` | Apple explicit flag | `"cleaned"` |
| `genres` | iTunes genre list | `["Technology","Science"]` |
| `primaryGenre` | Top genre | `"Technology"` |
| `country` | Storefront / language country | `"USA"` |
| `trackCountTotal` | Total episodes per Apple | `497` |
| `showDescription` | Show-level summary | `"..."` |
| `source` | `"itunes"` or `"rss"` | `"itunes"` |
| `scrapedAt` | UTC scrape timestamp | `"2026-05-18T07:19:37Z"` |

---

### 🧪 Example inputs

#### 1. Discover & pull all AI podcasts in the US

```json
{
  "searchTerms": ["artificial intelligence", "machine learning", "LLM"],
  "country": "us",
  "maxPodcastsPerSearch": 50,
  "maxEpisodesPerPodcast": 100
}
````

#### 2. Full archive of a single show (beyond Apple's 200-episode cap)

```json
{
  "podcastIds": ["1434243584"],
  "useRssForFullArchive": true,
  "fetchShowMetadata": true
}
```

#### 3. Direct RSS feeds (no iTunes lookup, fastest)

```json
{
  "rssFeeds": [
    "https://feeds.simplecast.com/54nAGcIl",
    "https://lexfridman.com/feed/podcast/",
    "https://feeds.megaphone.fm/hubermanlab"
  ]
}
```

#### 4. Recent long-form episodes only (skip trailers, drop old episodes)

```json
{
  "searchTerms": ["startup interview"],
  "country": "us",
  "minReleaseDate": "2025-01-01",
  "minDurationSeconds": 1200,
  "maxEpisodesPerPodcast": 50
}
```

#### 5. Build a clean German-language news podcast dataset

```json
{
  "searchTerms": ["nachrichten", "tagesthemen", "politik"],
  "country": "de",
  "explicit": "clean",
  "maxPodcastsPerSearch": 100,
  "maxEpisodesPerPodcast": 100
}
```

#### 6. Mix every mode in one run

```json
{
  "searchTerms": ["true crime"],
  "podcastIds": ["1200361736", "1535823522"],
  "rssFeeds": ["https://www.npr.org/rss/podcast.php?id=510289"],
  "useRssForFullArchive": true,
  "country": "us",
  "maxPodcastsPerSearch": 20,
  "maxEpisodesPerPodcast": 200
}
```

***

### 🌍 Supported countries (iTunes storefronts)

`us` · `gb` · `ca` · `au` · `de` · `fr` · `es` · `it` · `nl` · `br` · `mx` · `jp` · `kr` · `in` · `tr` · `ru` · `se` · `no` · `dk` · `fi` · `pl` · `cz` · `at` · `ch` · `be` · `ie` · `nz` · `za` · `ae` · `sa`

Most podcasts are global but rankings and country-restricted shows vary by storefront. Pull the same query against multiple storefronts to discover region-exclusive shows.

***

### 🧠 How it works

1. **Search mode** → `GET https://itunes.apple.com/search?term=...&entity=podcast&country=...&limit=...` returns up to 200 podcasts per query, each with `collectionId`, `feedUrl`, genres and artwork.
2. **Lookup mode** → `GET https://itunes.apple.com/lookup?id=COLLECTION_ID&entity=podcastEpisode&country=...&limit=...` returns the show object + the most recent ~200 episodes, each with `episodeUrl` (direct MP3), `description`, `releaseDate`, `trackTimeMillis`.
3. **RSS mode** → `GET <feedUrl>` then parses with [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser) to extract every `<item>` plus Apple namespace fields (`itunes:episode`, `itunes:season`, `itunes:duration`, `itunes:keywords`, `itunes:summary`, `itunes:explicit`, `itunes:image`) and Podcast 2.0 fields (`podcast:transcript`, `podcast:chapters`).
4. **Dedup** → episodes are keyed by `podcastId::(guid|trackId|audioUrl|title)` so combining iTunes + RSS for the same show never double-saves.

***

### 🛑 Limits & known constraints

- **iTunes Lookup ≈ 200 most recent episodes per show.** For older / full archives, enable `useRssForFullArchive` or paste the feed URL directly.
- **iTunes Search returns max 200 podcasts per query.** Split broad topics into specific sub-queries to widen reach.
- **RSS feeds vary in quality.** Some publishers truncate the feed to the latest N episodes. There is no workaround beyond contacting the publisher.
- **Transcript URLs and chapter markers** depend on the publisher adopting **Podcast 2.0** namespaces. Many big-network shows still don't.
- **Apple may rate-limit** very aggressive scraping. The actor automatically retries with exponential backoff and uses realistic browser headers.

***

### 💰 Pricing

This actor is monetized via **pay-per-event** on Apify — you pay a small per-episode result fee and Apify's compute is included. iTunes API and most RSS feeds are free.

***

### ❓ FAQ

**Does it scrape Spotify?**
Not directly. But Spotify's catalog is largely sourced from the same RSS feeds. Paste the show's RSS URL and you get the same episodes a Spotify scraper would return — for free, no auth, no rate limits.

**Does it return audio transcripts?**
Only when the publisher adopts **Podcast 2.0 `<podcast:transcript>`** (currently a minority). For full transcript coverage, take the returned `audioUrl` and feed it into Whisper or Distil-Whisper in a downstream actor.

**How fresh is the data?**
iTunes Search / Lookup is near-real-time — new episodes typically appear in the API within minutes of RSS publish.

**Can I get episodes for a show with 1,000+ episodes (like The Daily)?**
Yes — set `useRssForFullArchive: true` or pass the RSS URL directly. Tested: The Daily returned 2,800+ episodes from a single feed pull.

**Is this against Apple's terms?**
The iTunes Search & Lookup APIs are explicitly published for third-party clients (search affiliate program). RSS feeds are public-by-design. You are responsible for respecting each individual publisher's terms.

**Why use this over the Apple Podcasts Connect API?**
The Connect API is for show owners only and requires authentication. This actor works on the entire public catalog with zero credentials.

***

### 🔗 Related actors

- `logiover/website-contact-scraper` — enrich the `link` field of every podcast with publisher contact emails for sponsorship outreach
- `logiover/sitemap-to-url-crawler` — crawl the show's website for episode landing pages
- `logiover/google-news-scraper` — track press mentions of the podcasts you scraped

***

### 🆘 Support

Found a publisher whose RSS feed isn't parsing correctly, or a feature you need? Open an issue on the actor's Apify page — feedback drives the roadmap.

***

### Changelog

- **2026-05-20** — Maintenance pass: reviewed the input schema and default values for a smooth one-click start, and rebuilt the Actor on the latest base image.

*Last reviewed: 2026-05-20.*

# Actor input Schema

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

Keyword queries to discover podcasts via the iTunes Search API. Each term returns up to 200 matching podcast shows; every matched show is then expanded into its episode list (subject to 'Max Episodes Per Podcast'). Examples: 'artificial intelligence', 'true crime', 'startup', 'football tactics', 'mindfulness'. Leave empty if you supply podcast IDs or RSS feeds directly.

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

Direct iTunes collection IDs of specific podcasts to scrape. The collection ID is the numeric segment in an Apple Podcasts URL, e.g. for https://podcasts.apple.com/us/podcast/lex-fridman-podcast/id1434243584 the ID is '1434243584'. Faster and more predictable than search. Mix with 'Search Terms' if needed.

## `rssFeeds` (type: `array`):

Direct podcast RSS feed URLs to parse. Use this for podcasts not indexed in Apple, for full episode archives beyond the 200-episode iTunes lookup limit, or to get richer fields like episode numbers, season numbers, HTML show notes, chapter markers and transcript URLs. Example: 'https://lexfridman.com/feed/podcast/'.

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

The Apple Podcasts storefront to query. Most catalogs are global, but some shows are region-restricted and rankings differ by storefront. Use 'us' for the largest catalog.

## `maxPodcastsPerSearch` (type: `integer`):

Maximum number of podcast shows returned per search term. iTunes hard limit is 200. Lower this when you only want top-ranked results.

## `maxEpisodesPerPodcast` (type: `integer`):

Maximum episodes returned per podcast via the iTunes Lookup API. iTunes hard limit is ~200 most recent episodes. To go beyond, enable 'Use RSS Feed For Full Archive' or pass the show's RSS feed URL directly via 'RSS Feed URLs'.

## `useRssForFullArchive` (type: `boolean`):

When enabled, after each iTunes lookup the actor also fetches the podcast's RSS feed (URL provided by iTunes as 'feedUrl') and merges all RSS episodes into the dataset. This unlocks full archives well beyond iTunes' ~200 episode cap, plus richer metadata (episode numbers, season numbers, chapter markers, transcript URLs, HTML show notes). Adds one HTTP request per podcast and is rate-limited automatically.

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

Filter to episodes released on or after this date. ISO format (YYYY-MM-DD). Example: '2025-01-01' to skip everything older. Leave empty for no lower bound.

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

Filter to episodes released on or before this date. ISO format (YYYY-MM-DD). Leave empty for no upper bound.

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

Filter by content rating. 'all' returns everything (default), 'clean' excludes episodes flagged as explicit by Apple, 'explicit' returns only explicit content.

## `minDurationSeconds` (type: `integer`):

Drop episodes shorter than this. Useful for excluding trailers, ads or 1-minute teasers. Set 0 to disable.

## `fetchShowMetadata` (type: `boolean`):

When enabled, every episode record is enriched with its parent show's fields (artist, genre list, total track count, show artwork, show description, etc.). Disable if you only need raw episode data and want smaller records.

## Actor input object example

```json
{
  "searchTerms": [
    "artificial intelligence"
  ],
  "podcastIds": [],
  "rssFeeds": [],
  "country": "us",
  "maxPodcastsPerSearch": 50,
  "maxEpisodesPerPodcast": 100,
  "useRssForFullArchive": false,
  "minReleaseDate": null,
  "maxReleaseDate": null,
  "explicit": "all",
  "minDurationSeconds": 0,
  "fetchShowMetadata": true
}
```

# Actor output Schema

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

iTunes collection ID

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

Show name

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

Podcast creator

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

iTunes track ID or RSS guid

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

Episode title

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

Episode number

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

Season number

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

Publish timestamp

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

Length in seconds

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

Direct audio file URL

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

mp3, m4a, etc.

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

Top iTunes genre

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

Apple Podcasts episode page

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

Show RSS feed

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

Scrape timestamp

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "artificial intelligence"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/apple-podcasts-episode-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchTerms": ["artificial intelligence"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/apple-podcasts-episode-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 '{
  "searchTerms": [
    "artificial intelligence"
  ]
}' |
apify call logiover/apple-podcasts-episode-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Podcasts Scraper — Episodes, Audio URLs & RSS Data",
        "description": "Extract podcast shows and full episode lists from Apple Podcasts. Titles, descriptions, audio MP3 URLs, durations, publish dates, artwork, genres, transcripts. Via iTunes Search/Lookup API + RSS. No login. For podcast intelligence, RAG/AI training data and sponsorship research.",
        "version": "1.0",
        "x-build-id": "062DNyOlb3BoDsStj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~apple-podcasts-episode-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-apple-podcasts-episode-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/logiover~apple-podcasts-episode-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-apple-podcasts-episode-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/logiover~apple-podcasts-episode-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-apple-podcasts-episode-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keyword queries to discover podcasts via the iTunes Search API. Each term returns up to 200 matching podcast shows; every matched show is then expanded into its episode list (subject to 'Max Episodes Per Podcast'). Examples: 'artificial intelligence', 'true crime', 'startup', 'football tactics', 'mindfulness'. Leave empty if you supply podcast IDs or RSS feeds directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "podcastIds": {
                        "title": "Podcast IDs (iTunes Collection IDs)",
                        "type": "array",
                        "description": "Direct iTunes collection IDs of specific podcasts to scrape. The collection ID is the numeric segment in an Apple Podcasts URL, e.g. for https://podcasts.apple.com/us/podcast/lex-fridman-podcast/id1434243584 the ID is '1434243584'. Faster and more predictable than search. Mix with 'Search Terms' if needed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "rssFeeds": {
                        "title": "RSS Feed URLs",
                        "type": "array",
                        "description": "Direct podcast RSS feed URLs to parse. Use this for podcasts not indexed in Apple, for full episode archives beyond the 200-episode iTunes lookup limit, or to get richer fields like episode numbers, season numbers, HTML show notes, chapter markers and transcript URLs. Example: 'https://lexfridman.com/feed/podcast/'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "iTunes Storefront Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "br",
                            "mx",
                            "jp",
                            "kr",
                            "in",
                            "tr",
                            "ru",
                            "se",
                            "no",
                            "dk",
                            "fi",
                            "pl",
                            "cz",
                            "at",
                            "ch",
                            "be",
                            "ie",
                            "nz",
                            "za",
                            "ae",
                            "sa"
                        ],
                        "type": "string",
                        "description": "The Apple Podcasts storefront to query. Most catalogs are global, but some shows are region-restricted and rankings differ by storefront. Use 'us' for the largest catalog.",
                        "default": "us"
                    },
                    "maxPodcastsPerSearch": {
                        "title": "Max Podcasts Per Search Term",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of podcast shows returned per search term. iTunes hard limit is 200. Lower this when you only want top-ranked results.",
                        "default": 50
                    },
                    "maxEpisodesPerPodcast": {
                        "title": "Max Episodes Per Podcast",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum episodes returned per podcast via the iTunes Lookup API. iTunes hard limit is ~200 most recent episodes. To go beyond, enable 'Use RSS Feed For Full Archive' or pass the show's RSS feed URL directly via 'RSS Feed URLs'.",
                        "default": 100
                    },
                    "useRssForFullArchive": {
                        "title": "Use RSS Feed For Full Archive",
                        "type": "boolean",
                        "description": "When enabled, after each iTunes lookup the actor also fetches the podcast's RSS feed (URL provided by iTunes as 'feedUrl') and merges all RSS episodes into the dataset. This unlocks full archives well beyond iTunes' ~200 episode cap, plus richer metadata (episode numbers, season numbers, chapter markers, transcript URLs, HTML show notes). Adds one HTTP request per podcast and is rate-limited automatically.",
                        "default": false
                    },
                    "minReleaseDate": {
                        "title": "Minimum Release Date (ISO)",
                        "type": "string",
                        "description": "Filter to episodes released on or after this date. ISO format (YYYY-MM-DD). Example: '2025-01-01' to skip everything older. Leave empty for no lower bound.",
                        "default": null
                    },
                    "maxReleaseDate": {
                        "title": "Maximum Release Date (ISO)",
                        "type": "string",
                        "description": "Filter to episodes released on or before this date. ISO format (YYYY-MM-DD). Leave empty for no upper bound.",
                        "default": null
                    },
                    "explicit": {
                        "title": "Explicit Content Filter",
                        "enum": [
                            "all",
                            "clean",
                            "explicit"
                        ],
                        "type": "string",
                        "description": "Filter by content rating. 'all' returns everything (default), 'clean' excludes episodes flagged as explicit by Apple, 'explicit' returns only explicit content.",
                        "default": "all"
                    },
                    "minDurationSeconds": {
                        "title": "Min Duration (seconds)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop episodes shorter than this. Useful for excluding trailers, ads or 1-minute teasers. Set 0 to disable.",
                        "default": 0
                    },
                    "fetchShowMetadata": {
                        "title": "Include Show Metadata",
                        "type": "boolean",
                        "description": "When enabled, every episode record is enriched with its parent show's fields (artist, genre list, total track count, show artwork, show description, etc.). Disable if you only need raw episode data and want smaller records.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
