# Podcast Transcript to AI Dataset: RSS to Training Corpus (`turboextract/podcast-transcript-dataset`) Actor

Feed in a podcast RSS feed. Get back every episode's publisher-hosted transcript as clean, structured JSON for AI training, RAG, and content intelligence. No Whisper, no audio processing.

- **URL**: https://apify.com/turboextract/podcast-transcript-dataset.md
- **Developed by:** [Moses Ndambuki](https://apify.com/turboextract) (community)
- **Categories:** AI, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 episode transcript processeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Podcast Transcript to AI Dataset: RSS to Training Corpus

**Feed in a podcast RSS feed. Get back every episode's publisher-hosted transcript as clean JSON for AI training, RAG, and content intelligence.** No Whisper, no audio processing, no $0.006/minute transcription bills.

Paste one RSS URL. Get a full-show transcript dataset. Pay only per episode with a usable transcript.

***

### Who this is for

- **AI / ML engineers** building voice, dialogue, or domain-expert corpora
- **RAG developers** indexing a podcast's full archive for a chatbot
- **Media analysts and researchers** tracking topic frequency across a show's run
- **Content teams** repurposing podcast content as search-indexable text
- **Dataset curators** assembling spoken-language training material cheaply

If you were about to pay $0.006/minute to transcribe a 500-episode archive, this costs 95% less when publishers already ship transcripts.

***

### What you get per episode

```json
{
  "podcastTitle": "The Lex Fridman Podcast",
  "podcastDescription": "Conversations about science, technology, history...",
  "language": "en-us",
  "episodeTitle": "Episode 400: Elon Musk",
  "episodeUrl": "https://lexfridman.com/elon-musk/",
  "guid": "ep-400",
  "publishedAt": "2026-10-15T14:00:00Z",
  "duration": "02:15:30",
  "audioUrl": "https://media.simplecast.com/ep-400.mp3",
  "transcriptSource": "https://lexfridman.com/transcripts/ep-400.vtt",
  "wordCount": 24180,
  "text": "Elon Musk: The most important thing I can say about...",
  "scrapedAt": "2026-11-08T12:00:00Z"
}
```

The output JSON shape is compatible with **AI Training Dataset Builder** and **Sitemap to AI Corpus** — chain the three freely for a mixed text + audio corpus.

***

### How it works

```mermaid
flowchart LR
    A[Input: RSS feed URL] --> B[Fetch and parse RSS]
    B --> C[For each episode]
    C --> D{podcast:transcript tag?}
    D -- yes --> E[Fetch VTT / SRT / JSON / HTML]
    D -- no --> F[Scrape episode page for inline transcript]
    E --> G[Normalize to plain text]
    F --> G
    G --> H{wordCount above threshold?}
    H -- yes --> I[Push episode + charge per episode]
    H -- no --> J[Skip]
```

**No audio transcription.** This actor only extracts transcripts the podcast publisher already hosts (via the Podcasting 2.0 `podcast:transcript` tag, or linked from the episode page). If you need Whisper-style audio-to-text, use a separate transcription service — this one stays cheap because it never touches audio.

***

### Quick start

#### Run from the Apify Console

1. Click **Try for free**.
2. Paste one or more podcast RSS URLs.
3. (Optional) Set `publishedAfter` to limit to recent episodes.
4. Click **Start**.
5. Download as JSON, CSV, or Excel.

#### Run from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/Turboextract~podcast-transcript-dataset/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "rssUrls": ["https://podnews.net/rss"],
    "maxEpisodesPerFeed": 50,
    "publishedAfter": "2024-01-01",
    "minWordCount": 500
  }'
```

#### Run from Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("Turboextract/podcast-transcript-dataset").call(run_input={
    "rssUrls": ["https://podnews.net/rss"],
    "maxEpisodesPerFeed": 100,
})
for ep in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ep["episodeTitle"], ep["wordCount"])
```

***

### Input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `rssUrls` | array | required | Podcast RSS feed URLs |
| `maxEpisodesPerFeed` | integer | 100 | Cap per feed |
| `publishedAfter` | string | — | ISO date; skip older episodes |
| `minWordCount` | integer | 200 | Skip thin transcripts |

***

### Pricing

**Pay per episode with a usable transcript. No subscriptions.**

| Volume | Price per episode | Total |
|---|---|---|
| Per episode | $0.003 | 1,000 episodes = $3 |
| 10,000 episodes | $0.003 | $30 |

Episodes without transcripts are silently skipped — you are not charged.

#### How it compares

| Tool | Pricing model | 1,000 episodes |
|---|---|---|
| **Podcast Transcript to AI Dataset** | $0.003 per episode | **$3** |
| OpenAI Whisper API | $0.006 per audio minute | ~$360 (avg 60 min episodes) |
| AssemblyAI | $0.37 per audio hour | ~$370 |
| Deepgram | $0.26 per audio hour | ~$260 |
| Rev.com (human) | $1.50 per minute | $90,000 |

**Why so much cheaper?** This actor does not transcribe audio. It only harvests transcripts the publisher already ships via the Podcasting 2.0 standard or episode show-notes pages.

***

### Common use cases

- **AI training corpora** for conversational / interview / domain-expert models
- **RAG knowledge bases** over a podcast network's full back catalog
- **Topic modeling** across years of episodes to spot trend shifts
- **Searchable archives** for shows that only publish MP3s + bare show notes
- **Research corpora** on linguistics, interviewing technique, discourse analysis

***

### Tips for best results

- Podcasts on Podcasting 2.0 hosts (Transistor, Simplecast, Captivate, Fountain, Castopod) have the best transcript coverage
- Set `minWordCount: 500` to drop one-liners and ad-only episodes
- Use `publishedAfter` for incremental refreshes — pair with Apify's weekly scheduler
- If a podcast has no transcripts, you'll see 0 episodes processed and 0 charges — safe to try any feed

***

### Pairs well with

- **AI Training Dataset Builder** — same JSON shape; combine article corpora with podcast corpora
- **Sitemap to AI Corpus** — pair show-website pages with episode transcripts
- **Research Citation Explorer** — different buyer, same account

(Links updated as related actors ship.)

***

### FAQ

**What percentage of podcasts have transcripts?**
Growing fast. ~30% of top-100 shows now ship `podcast:transcript` tags; most major hosts (Simplecast, Transistor, Buzzsprout, Captivate, Fountain) add them automatically. Many indie shows publish full transcripts in show notes.

**Will this transcribe audio with Whisper?**
No. By design. Audio transcription is a different cost profile (~$0.006/min vs $0.003 per already-published episode). If you need that, use a dedicated transcription service and combine downstream.

**What formats are supported?**
WebVTT, SRT, JSON (Podcasting 2.0 segments), plain text, and HTML transcript pages. Format is auto-detected from MIME type.

**What about paywalled transcripts (Patreon, Substack private feeds)?**
This actor doesn't authenticate. Public RSS feeds only.

**Can I run on a schedule?**
Yes. Apify's scheduler + `publishedAfter` set to "last week" is perfect for incremental ingestion.

**What if an episode has multiple transcripts (multi-language)?**
We prefer JSON > VTT > SRT > HTML > plain text, in that order. Language-specific selection is on the roadmap.

**Does the output chain with other actors?**
Yes — `text`, `wordCount`, `publishedAt`, `language` fields match **AI Training Dataset Builder** exactly.

***

### Support

Open an issue on the actor's Apify page or message the maintainer. Bug reports with the failing RSS URL get the fastest turnaround.

- Source examples and docs: https://github.com/andersonjames38phd-cpu/podcast-transcript-dataset
- Community Discord (updates, support, feature requests): https://discord.gg/8SrXSCpvgj

Built and maintained by [Turboextract](https://apify.com/Turboextract) on the Apify platform.

# Actor input Schema

## `rssUrls` (type: `array`):

One or more podcast RSS feed URLs. Episodes are parsed from each feed and transcripts fetched when the publisher provides them.

## `maxEpisodesPerFeed` (type: `integer`):

Cap on episodes processed per RSS feed.

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

Skip episodes published before this date. Format: YYYY-MM-DD.

## `minWordCount` (type: `integer`):

Skip episodes whose transcript has fewer words than this.

## Actor input object example

```json
{
  "rssUrls": [
    "https://mp3s.nashownotes.com/pc20rss.xml"
  ],
  "maxEpisodesPerFeed": 10,
  "publishedAfter": "",
  "minWordCount": 200
}
```

# Actor output Schema

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

One record per podcast episode with transcript and metadata.

# 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 = {
    "rssUrls": [
        "https://mp3s.nashownotes.com/pc20rss.xml"
    ],
    "maxEpisodesPerFeed": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("turboextract/podcast-transcript-dataset").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 = {
    "rssUrls": ["https://mp3s.nashownotes.com/pc20rss.xml"],
    "maxEpisodesPerFeed": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("turboextract/podcast-transcript-dataset").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "rssUrls": [
    "https://mp3s.nashownotes.com/pc20rss.xml"
  ],
  "maxEpisodesPerFeed": 10
}' |
apify call turboextract/podcast-transcript-dataset --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/MIGDADs4pOmeaGT5O/builds/RzIqaauTn5f3fbL6Q/openapi.json
