# Podcast Transcript Scraper: Any Podcast to Text & SRT (`fguiraud/podcast-transcript-scraper`) Actor

Transcribe any podcast by name, Apple Podcasts link or RSS feed: newest episodes to text, timestamps and SRT subtitles in 99 languages, with episode title and date. Schedule it to get every new episode. Whisper, no API key. Optional AI summary. Pay per minute.

- **URL**: https://apify.com/fguiraud/podcast-transcript-scraper.md
- **Developed by:** [Fernando Guiraud](https://apify.com/fguiraud) (community)
- **Categories:** AI, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 audio minute (tiny/base)s

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

### What does Podcast Transcript Scraper do?

**Podcast Transcript Scraper** turns **any podcast into text**. Type the **podcast's name**, or paste its **Apple Podcasts link** or **RSS feed**, and get the newest episodes transcribed: **full transcript, timestamped segments, Markdown with timestamps and SRT/VTT subtitles**, together with the **podcast name, episode title and publish date**.

It finds the podcast's public RSS feed automatically and transcribes the audio with **open-source Whisper** in **99 languages**, so there is no OpenAI key and no subscription. **Schedule it daily** and it transcribes **only new episodes**. You **pay per minute of audio**, and failed episodes are never billed.

It runs on the Apify platform, so you also get an API, scheduling, integrations (Google Sheets, Make, Zapier, n8n, Notion via webhooks) and access for **AI agents through the [Apify MCP server](https://mcp.apify.com)**.

### Why use it?

- 📰 **Monitor podcasts in your industry**: get every new episode of 10 or 50 shows as searchable text each morning.
- ✍️ **Content repurposing**: turn your own episodes into blog posts, show notes, newsletters and social clips.
- 🔎 **Research and media monitoring**: search what guests said about your company, competitors or a topic.
- 🤖 **RAG and AI assistants**: `chunks` output with timestamps, ready for a vector database.
- 🧠 **Optional AI insights**: summary, key points, chapters with start times and action items for each episode (Claude, with your own Anthropic key).

### How to get a podcast transcript

1. Click **Try for free**.
2. In **Podcasts**, type a podcast name (e.g. `Lex Fridman Podcast`) or paste its Apple Podcasts link or RSS feed.
3. Choose how many of the newest episodes to transcribe in **Episodes per feed**.
4. Click **Start**, then download the transcripts as JSON, CSV or Excel, or as `.txt` / `.srt` files with **Also save downloadable files**.
5. To get new episodes automatically, create a **schedule** (for example daily). With **Only new episodes** on, each run transcribes and bills only episodes it has not seen before.

### Input

| Field | Description | Default |
|---|---|---|
| `podcastFeeds` | Podcast names, Apple Podcasts links or RSS feed URLs | required |
| `maxEpisodesPerFeed` | How many of the newest episodes per podcast | 3 |
| `onlyNewEpisodes` | Skip episodes transcribed by previous runs | `true` |
| `model` | `base` (recommended), `small` (most accurate) or `tiny` | `base` |
| `language` | Spoken language code or `auto` | `auto` |
| `outputs` | `text`, `markdown`, `segments`, `srt`, `vtt`, `chunks` | text, segments |
| `vocabulary` | Names and jargon to recognise better (hosts, guests, products) | - |
| `aiInsights` + `anthropicApiKey` | AI summary, chapters and action items | off |
| `maxDurationMinutes` | Transcribe (and bill) at most N minutes per episode | 240 |

```json
{
  "podcastFeeds": ["Lex Fridman Podcast", "https://feeds.npr.org/500005/podcast.xml"],
  "maxEpisodesPerFeed": 2,
  "outputs": ["text", "srt"]
}
```

### Output

One row per episode. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "podcast": "NPR News Now",
  "episodeTitle": "NPR News: 09-24-2026 8AM EDT",
  "published": "2026-09-24T12:00:00+00:00",
  "audioUrl": "https://play.podtrac.com/npr-500005/...mp3",
  "feed": "https://feeds.npr.org/500005/podcast.xml",
  "status": "ok",
  "language": "en",
  "durationSeconds": 297.1,
  "billedMinutes": 5,
  "text": "Live from NPR News in Washington, I'm ...",
  "markdown": "**[00:00:00]** Live from NPR News in Washington ..."
}
```

### Data fields

| Field | Description |
|---|---|
| `podcast`, `episodeTitle`, `published` | Episode metadata from the RSS feed |
| `audioUrl`, `feed` | Episode audio file and its feed |
| `text` / `markdown` | Full transcript, plain or with timestamps |
| `segments` | Timestamped segments (optionally word-level) |
| `srt` / `vtt` | Subtitle files |
| `chunks` | RAG-ready passages with start/end times |
| `insights` | AI title, summary, key points, chapters, action items (optional) |
| `durationSeconds`, `billedMinutes` | Episode length and minutes charged |

### How much does a podcast transcript cost?

| Event | Price |
|---|---|
| Run start (per GB of memory, default 4 GB) | $0.0005 |
| Audio minute, base or tiny model | **$0.006** ($0.36 per hour) |
| Audio minute, small model | **$0.012** ($0.72 per hour) |
| AI insights per episode (optional; Claude usage billed to your own key) | $0.01 |

A 1-hour episode with the base model costs about **$0.36**. Failed episodes and episodes with no speech are free. Use `maxDurationMinutes` to cap long episodes, and **Max cost per run** to cap a whole run.

### Use it with AI agents (MCP)

Add `https://mcp.apify.com?tools=fguiraud/podcast-transcript-scraper` to Claude, Cursor or any MCP client and ask: *"Transcribe the latest episode of the Lex Fridman Podcast and summarise the main arguments."*

### Need to transcribe other audio or video?

For meetings, interviews, voice notes, MP4 videos and files sent as base64, use [Audio & Video to Text Transcription](https://apify.com/fguiraud/audio-video-transcriber), built on the same engine.

### FAQ and limitations

- **Which podcasts work?** Any podcast with a public RSS feed, which covers almost every podcast on Apple Podcasts. Spotify-exclusive shows have no public feed and are not supported.
- **The name matched the wrong podcast.** Paste the Apple Podcasts link or the RSS feed instead of the name.
- **Who is speaking?** Speaker labels (diarization) are not included yet.
- **Copyright:** transcripts are for your own research, accessibility and analysis. Check the podcast's terms before republishing its content.
- Found a problem or need a feature? Open an issue on the **Issues** tab. Replies within 48 hours.

# Actor input Schema

## `podcastFeeds` (type: `array`):

Podcast names (e.g. 'Lex Fridman Podcast'), Apple Podcasts links or RSS feed URLs. Names and Apple links are matched to the podcast's public RSS feed automatically. The newest episodes of each podcast are transcribed (see 'Episodes per feed'); results include the podcast name, episode title and publish date.

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

How many of the newest episodes to transcribe from each podcast feed.

## `onlyNewEpisodes` (type: `boolean`):

Skip episodes already transcribed by previous runs of this Actor in your account (remembered in a key-value store named 'audio-transcriber-podcast-state'). Ideal for a daily schedule: you only pay for new episodes.

## `model` (type: `string`):

'base': good accuracy, fast (recommended). 'small': best accuracy, especially for accents, noisy audio and non-English speech; slower and billed at a higher per-minute price. 'tiny': fastest draft quality.

## `language` (type: `string`):

ISO code of the spoken language (en, es, de, fr, pt, it, ja, zh, ...) or 'auto' to detect it. Setting it avoids misdetection on short clips.

## `task` (type: `string`):

'transcribe': text in the spoken language. 'translate': translate the speech to English text.

## `vocabulary` (type: `array`):

Words the speech recognition should favour: people and company names, product names, technical terms (e.g. 'Kubernetes', 'Dr. Nguyen', 'Apify'). Improves spelling of rare words.

## `outputs` (type: `array`):

'text': full transcript split into paragraphs at pauses. 'segments': timestamped segments. 'srt' / 'vtt': ready-to-use subtitle files. 'chunks': ~chunkSize-character passages with start/end times and a token estimate, ready for vector databases. 'markdown': paragraphs prefixed with their start time, e.g. '**\[00:01:23]** ...'.

## `aiInsights` (type: `boolean`):

Analyse each transcript with Claude: title, summary, key points, chapters with start times, action items and topics (in 'insights'). Requires your Anthropic API key; Claude usage is billed to your Anthropic account, plus one small 'AI insights' event per file.

## `anthropicApiKey` (type: `string`):

Your key from console.anthropic.com. Stored as a secret input; used only to call Claude for this run.

## `insightsModel` (type: `string`):

'claude-opus-5': best quality (default). 'claude-sonnet-5': cheaper, great for meetings and podcasts. 'claude-haiku-4-5': cheapest (transcripts up to ~2 hours).

## `insightsInstructions` (type: `string`):

Optional, e.g. 'Summarise in Spanish', 'Focus on decisions and owners', 'Chapters every ~10 minutes'.

## `saveFiles` (type: `boolean`):

Save the transcript (.txt) and subtitles (.srt / .vtt, if selected in outputs) as files in the run's key-value store; the result includes their download links.

## `maxDurationMinutes` (type: `integer`):

Only the first N minutes of each file are transcribed (and billed).

## `skipSilence` (type: `boolean`):

Detect speech first and skip silent parts. Faster and reduces hallucinated text in long pauses.

## `wordTimestamps` (type: `boolean`):

Add start/end times for every word inside each segment (for karaoke-style captions or precise search). Slightly slower.

## `chunkSize` (type: `integer`):

Target size of 'RAG chunks'.

## `failOnError` (type: `boolean`):

Mark the run as FAILED when a file cannot be transcribed. Useful for pipelines and monitoring.

## Actor input object example

```json
{
  "podcastFeeds": [
    "NPR News Now"
  ],
  "maxEpisodesPerFeed": 1,
  "onlyNewEpisodes": true,
  "model": "base",
  "language": "auto",
  "task": "transcribe",
  "outputs": [
    "text",
    "markdown"
  ],
  "aiInsights": false,
  "insightsModel": "claude-opus-5",
  "saveFiles": false,
  "maxDurationMinutes": 240,
  "skipSilence": true,
  "wordTimestamps": false,
  "chunkSize": 1000,
  "failOnError": false
}
```

# Actor output Schema

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

No description

## `files` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "podcastFeeds": [
        "NPR News Now"
    ],
    "maxEpisodesPerFeed": 1,
    "outputs": [
        "text",
        "markdown"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fguiraud/podcast-transcript-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 = {
    "podcastFeeds": ["NPR News Now"],
    "maxEpisodesPerFeed": 1,
    "outputs": [
        "text",
        "markdown",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("fguiraud/podcast-transcript-scraper").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 '{
  "podcastFeeds": [
    "NPR News Now"
  ],
  "maxEpisodesPerFeed": 1,
  "outputs": [
    "text",
    "markdown"
  ]
}' |
apify call fguiraud/podcast-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

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/Hsu1drwiClaYvm1ea/builds/ZnCPMX4gQdQPl0Jif/openapi.json