# Podcast & Audio Transcriber (`quietbyte/podcast-audio-transcriber`) Actor

Podcast RSS feeds and audio/video files to text with Whisper large-v3-turbo: clean transcript, timestamped markdown, SRT/VTT subtitles and RAG-ready chunks. Uses the show's own transcript when its feed has one ($0.002 flat). Pay per minute, nothing for failures; monitor mode does new episodes only.

- **URL**: https://apify.com/quietbyte/podcast-audio-transcriber.md
- **Developed by:** [Quietbyte](https://apify.com/quietbyte) (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 $3.00 / 1,000 audio minute transcribeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 & Audio Transcriber

Turn podcast episodes and audio or video files into text with **Whisper large-v3-turbo**: a clean transcript, markdown with `[hh:mm:ss]` timestamps, **SRT and WebVTT subtitles**, and **RAG-ready chunks**. When a show already publishes its own transcript in its RSS feed, you get that instead, for a flat $0.002.

Paste RSS feeds or direct file links, and get one record per episode. Pay per minute of audio, and nothing for files that fail.

### What people use it for

- **RAG and AI agents:** timestamped chunks ready to embed, so an answer can link to the exact minute of the episode.
- **Show notes, SEO and newsletters:** the full text of every new episode the day it comes out (monitoring mode).
- **Subtitles:** SRT or VTT files for video podcasts, clips and Shorts.
- **Research and media monitoring:** what a set of shows said about a company, product or topic, searchable.
- **Accessibility:** a text version of every episode for people who can't listen.

**What it costs:** a 30-minute episode costs $0.09 on a paid Apify plan, or $0.15 on the free plan. An episode whose feed already has a transcript costs $0.002. Failed downloads, files without speech and skipped episodes cost nothing.

### Pricing

| What you get | Paid Apify plans | Free plan |
|---|---|---|
| One started minute of audio transcribed with Whisper | **$0.003** | $0.005 |
| A show's own transcript, read from its feed | **$0.002** per episode | $0.002 per episode |

You're charged after a transcript is ready. Billing uses the real length of the audio file (dynamically inserted ads count), per started minute, with a one-second grace. A run never spends more than the limit you set in Apify, and **Max minutes to transcribe per run** adds a cap of your own.

### What you get

One record per episode or file. A real record (text shortened):

```json
{
  "id": "d74a4412e8a0ff31",
  "source": "feed",
  "feedUrl": "https://rss.buzzsprout.com/2632213.rss",
  "podcastTitle": "On The Line with Jim Pyne",
  "episodeTitle": "Bruce Smith: 200 Sacks, 19 NFL Seasons & the Legacy of a Hall of Famer | On the Line with Jim Pyne",
  "audioUrl": "https://www.buzzsprout.com/2632213/episodes/19953675-bruce-smith-200-sacks-19-nfl-seasons-the-legacy-of-a-hall-of-famer-on-the-line-with-jim-pyne.mp3",
  "publishedAt": "2026-10-13T09:00:00Z",
  "transcriptSource": "publisher",
  "language": "en-us",
  "durationSeconds": 1668,
  "billedMinutes": 0,
  "transcriptFormat": "json",
  "wordCount": 4826,
  "text": "SPEAKER_00: Welcome to On the Line with Jim Pine. I'm Jim Pine. ...",
  "markdown": "[00:00:00] **SPEAKER_00** Welcome to On the Line with Jim Pine. ...",
  "chunks": [{"index": 0, "start": 0.16, "end": 68.16, "startTimestamp": "00:00:00", "speakers": ["SPEAKER_00", "SPEAKER_02"], "wordCount": 244, "text": "..."}],
  "srt": "1\n00:00:00,160 --> 00:00:02,000\nWelcome to On the Line with Jim Pine.\n\n2\n00:00:02,240 --> 00:00:03,040\nI'm Jim Pine.\n..."
}
```

`transcriptSource` is `"publisher"` when the show's own transcript was used and `"whisper"` when the audio was transcribed. Whisper records also carry `durationSeconds`, `billedMinutes` and `model`.

### How it works

1. **Reads each feed**, newest episodes first, and applies your filters (date, title keywords, how many per feed).
2. **Uses the show's own transcript** when the episode links one (the Podcasting 2.0 `podcast:transcript` tag). It's exactly what the publisher wrote, and cheaper.
3. **Otherwise transcribes the audio:**
   - downloads the file and converts it to 16 kHz mono, which is what Whisper hears anyway;
   - cuts it into pieces of about 10 minutes, at pauses, so no word is split;
   - transcribes each piece with Whisper large-v3-turbo, passing on the end of the previous piece as context;
   - stitches the timestamps back together.
4. **Builds the outputs:** plain text, timestamped markdown, chunks, SRT/VTT and raw segments, whichever you choose.

Typical speed: a one-hour episode is ready in a few minutes.

### What you can put in

| Field | What it does |
|---|---|
| **Podcast RSS feeds** | Feed URLs of the shows. Most podcast directories and show websites list them. |
| **Episodes per feed** | How many of the newest matching episodes to take from each feed (default 3). |
| **Audio or video file links** | Public direct links to MP3, M4A, WAV, OGG, FLAC, MP4, WebM and anything else ffmpeg reads. |
| **Published within (days)** / **Title keywords** | Episode filters. |
| **Use the show's own transcript** | On by default. Turn off to always transcribe the audio. |
| **Spoken language** | `en`, `de`, `es`, `pt-BR`… Empty means auto-detect (about 100 languages). |
| **Max minutes to transcribe per run** | Your own cost cap. 0 means only the Apify spending limit applies. |
| **Output options** | Markdown, RAG chunks (and their size), SRT, VTT, raw segments. |
| **Only new episodes** + **Monitor name** | Monitoring mode (below). |

### Daily monitoring

Turn on **Only new episodes** and schedule the Actor daily. Each run returns only episodes it hasn't transcribed before, so you pay once per episode. Give each schedule its own **Monitor name** if you run several with different inputs.

### Limits and fair use

- Up to **6 hours** and **600 MB** per file.
- **On the free Apify plan, a run transcribes up to 60 minutes of audio.** Shows' own transcripts don't count toward that, and paid plans have no such cap.
- **No YouTube, TikTok, Instagram, Facebook, X, Vimeo, SoundCloud or Spotify links.** Those are web pages, not audio files, and their terms don't allow downloading the media. Use RSS feeds or direct file links.
- Only transcribe audio you have the right to use. A transcript of someone's show is still their content: credit the show if you quote or republish it.
- No speaker names yet: Whisper doesn't tell speakers apart. Shows' own transcripts often do include speaker names, and those are kept.
- Accuracy is very good on clear speech. It drops with loud music, crosstalk or a lot of jargon. Setting **Spoken language** helps with short clips.

### Privacy and data handling

- Audio is downloaded into the run's temporary storage, converted, and sent to **Groq's speech-to-text API** (Whisper large-v3-turbo) for transcription.
- The temporary files are deleted as soon as each episode is done.
- Transcripts are stored only in your own Apify dataset.

### FAQ

**Can I transcribe YouTube videos?** No. See *Limits*: their terms don't allow it.

**Which languages?** Whisper's ~100 languages, detected automatically. The detected language is in the `language` field.

**What if a feed has a transcript but I want Whisper's?** Turn off **Use the show's own transcript**.

**How do I get subtitles for a video file?** Put the file link in **Audio or video file links** and keep **SRT subtitles** on. Turn on **WebVTT** if your player wants VTT.

**Can AI agents use it?** Yes, through the Apify API, the Apify MCP server, Make, Zapier or n8n. A record is plain JSON with the text, chunks and timestamps.

### Related Actors

More tools from the same developer:

- [Podcast Transcript Scraper](https://apify.com/quietbyte/podcast-transcripts): only the transcripts publishers already put in their feeds, $0.002 each, no audio processing.
- [Visa Sponsorship Jobs API](https://apify.com/quietbyte/ats-jobs-visa): Greenhouse, Lever, Ashby, SmartRecruiters and Recruitee boards with sentence-level visa tags.
- [Workday Jobs Scraper](https://apify.com/quietbyte/workday-jobs-visa): any Workday careers site, with visa tags backed by official H-1B and UK sponsor records.
- [Remote Jobs by Country](https://apify.com/quietbyte/remote-jobs-by-country): four remote boards in one feed, filtered to jobs open to your country.
- [UK Visa Sponsor Jobs](https://apify.com/quietbyte/reed-jobs-uk-visa): UK jobs from Reed's official API, checked against the Home Office register of licensed visa sponsors.

# Actor input Schema

## `feedUrls` (type: `array`):

RSS feed URLs of the shows to transcribe. Newest episodes first. The feed URL is listed in most podcast directories and on the show's website.

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

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

## `audioUrls` (type: `array`):

Direct links to audio or video files: MP3, M4A, WAV, OGG, FLAC, MP4, WebM and anything else ffmpeg reads. Not YouTube, TikTok, Spotify or other platform pages: their terms don't allow downloading the media.

## `publishedWithinDays` (type: `integer`):

Only episodes published in the last N days. 0 means no date limit.

## `titleKeywords` (type: `array`):

Only episodes whose title contains at least one of these words or phrases (not case sensitive).

## `usePublisherTranscripts` (type: `boolean`):

Many feeds link a transcript the publisher made (Podcasting 2.0). When an episode has one, you get it for a flat $0.002 instead of paying per minute. Turn off to always transcribe the audio.

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

Language code such as en, de, es or pt-BR. Leave empty to detect it automatically. Setting it helps with short or noisy audio.

## `maxAudioMinutes` (type: `integer`):

A cost cap: episodes that would take the run past this many transcribed minutes are skipped (and cost nothing). 0 means no cap beyond the run's spending limit. On the free Apify plan a run transcribes at most 60 minutes.

## `includeMarkdown` (type: `boolean`):

Add the transcript as markdown with \[hh:mm:ss] timestamps.

## `includeChunks` (type: `boolean`):

Add the transcript split into chunks of about 'Words per chunk' words, each with its start time, ready for embeddings.

## `chunkWords` (type: `integer`):

Target chunk size for RAG chunks.

## `includeSrt` (type: `boolean`):

Add SubRip (.srt) subtitles.

## `includeVtt` (type: `boolean`):

Add WebVTT (.vtt) subtitles.

## `includeSegments` (type: `boolean`):

Add the raw segments (start, end, text) as a list.

## `maxResults` (type: `integer`):

Stop after this many transcripts. 0 means no limit.

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

Remember what was transcribed and return only episodes this monitor hasn't seen before. Schedule the run daily to get each new episode once.

## `monitorName` (type: `string`):

Optional name for the memory used by monitoring mode, so several schedules with different inputs stay separate.

## Actor input object example

```json
{
  "feedUrls": [
    "https://feeds.npr.org/500005/podcast.xml"
  ],
  "maxEpisodesPerFeed": 1,
  "publishedWithinDays": 0,
  "usePublisherTranscripts": true,
  "maxAudioMinutes": 0,
  "includeMarkdown": true,
  "includeChunks": true,
  "chunkWords": 250,
  "includeSrt": true,
  "includeVtt": false,
  "includeSegments": false,
  "maxResults": 0,
  "onlyNewEpisodes": false
}
```

# Actor output Schema

## `results` (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 = {
    "feedUrls": [
        "https://feeds.npr.org/500005/podcast.xml"
    ],
    "maxEpisodesPerFeed": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietbyte/podcast-audio-transcriber").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 = {
    "feedUrls": ["https://feeds.npr.org/500005/podcast.xml"],
    "maxEpisodesPerFeed": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("quietbyte/podcast-audio-transcriber").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 '{
  "feedUrls": [
    "https://feeds.npr.org/500005/podcast.xml"
  ],
  "maxEpisodesPerFeed": 1
}' |
apify call quietbyte/podcast-audio-transcriber --silent --output-dataset

```

## MCP server setup

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

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/92FbXhZ02muZv2JYb/builds/nEmxfUf48eS6MsAPs/openapi.json