# Podcast Transcriber: Podcast & Audio to Text, MP3, SRT, VTT (`prime619/podcast-transcriber`) Actor Podcast to text and audio to text with Whisper speech to text: podcast transcription from RSS feeds, Apple Podcasts links or MP3/audio/video URLs, full transcript with word timestamps as TXT, SRT, VTT and JSON. Only new episodes since the last run. Groq with your own key or local Whisper. - **URL**: https://apify.com/prime619/podcast-transcriber.md - **Developed by:** [Philipp Primisser](https://apify.com/prime619) (community) - **Categories:** AI, Videos, Automation - **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.10 / 1,000 audio minute (groq, your key)s 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 Transcriber: Podcast & Audio to Text, MP3, SRT, VTT > **Try it free:** Apify's free plan includes monthly platform credit, no credit card needed. One example run with the input below costs about **$0.02** (the ~3-minute Gettysburg Address recording, transcribed without your own API key at $0.006 per audio minute). ```json { "mediaUrls": [ "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3" ], "transcriptionProvider": "managed", "confirmRights": true } ``` Paste this into the **JSON** tab of the input form and click **Start**. Get a podcast transcript for any episode: turn podcast episodes and audio files into searchable text (podcast to text and audio to text with Whisper speech to text). Give the Actor one or more **podcast RSS feeds**, **Apple Podcasts links** or **direct audio/video links** (MP3, M4A, WAV, MP4 and more) and get, for every episode, the **full transcript**, **timestamped segments with word timestamps**, and ready-made **TXT, SRT, VTT and JSON files**. Run it on a schedule with **"Only new episodes"** and it transcribes each new episode exactly once - a simple podcast monitor for media monitoring, research, show notes and podcast SEO. ### What you get - 🎙️ **Podcast RSS feeds or audio URLs** - mp3, m4a, wav, ogg, mp4, webm and more - 🆕 **Only new episodes since the last run** - remembers what it already transcribed (per monitor name) - 📝 **Full text + segments with start/end times**, word-level timestamps when available - 📄 **Files per episode**: plain text (TXT), subtitles (SRT, WebVTT) and a JSON file with every word timestamp - 🌍 **Many languages** with automatic language detection (Whisper) - ⚡ **Three engines**: fast Groq Whisper large-v3-turbo with **no API key needed**, Groq with **your own Groq API key** (lowest price), or the built-in local Whisper (no third party) - 💸 **Pay only for audio you transcribe** - per started audio minute, with a cost cap per episode - 🛑 Clear error messages instead of silently empty results ### Full podcast transcripts or short clips? This Actor gives you the full plain podcast transcript of each episode, from the first word to the last. That is what you want for searching through episodes, writing notes or show notes, pulling quotes, or keeping a text archive of a podcast. It does not judge which parts are interesting. If you are after short videos, have a look at [Podcast & Video Clip Finder](https://apify.com/prime619/podcast-clip-finder). It picks the strongest 20 to 60 second moments of an episode and returns them ready to cut, with timestamps, subtitles for each clip and hook title ideas for TikTok, Reels and Shorts. ### Get a podcast transcript from any RSS feed or Apple Podcasts link 1. Paste a podcast RSS feed URL or an Apple Podcasts show link into **Podcast RSS feed URL(s)** (or a direct mp3 link into **Direct audio/video file URL(s)**). 2. Tick **"I own this audio or am allowed to transcribe it"**. 3. Optional: paste your own **Groq API key** (free at [console.groq.com/keys](https://console.groq.com/keys)) for the lowest price per minute. Without a key, the Actor uses Groq Whisper large-v3-turbo for you, no key needed. 4. Start. Each episode appears in the dataset; the files are linked in every item. **Free demo:** leave everything empty (or keep the prefilled link) to transcribe a 63-second public-domain LibriVox recording of the Gettysburg Address. The demo needs no key and is never charged. #### Podcast monitor (only new episodes) Turn on **Only new episodes since the last run**, set **Max episodes per feed** (e.g. 3) and create a [schedule](https://docs.apify.com/platform/schedules) (daily or weekly). Each run transcribes only episodes that earlier runs have not transcribed yet. Use **Monitor name** to keep separate lists, for example one per client. Failed episodes are retried on the next run. ### Input example ```json { "rssFeedUrls": ["https://www.nasa.gov/feeds/podcasts/small-steps-giant-leaps"], "confirmRights": true, "maxEpisodesPerFeed": 2, "onlyNewEpisodes": true, "transcriptionProvider": "auto", "groqApiKey": "gsk_...", "outputFormats": ["txt", "srt", "vtt", "json"] } ``` ### Output One dataset item per episode (shortened): ```json { "episodeTitle": "Human Factors: Designing Systems with People in Mind - Part 1 of 2", "podcastTitle": "Small Steps, Giant Leaps", "publishedAt": "2026-09-16T12:34:00Z", "feedUrl": "https://www.nasa.gov/feeds/podcasts/small-steps-giant-leaps", "mediaUrl": "https://traffic.megaphone.fm/....mp3", "language": "en", "transcriptionEngine": "groq:whisper-large-v3-turbo", "wordTimestamps": "word", "mediaDurationSeconds": 1139.0, "transcribedSeconds": 1139.0, "billedAudioMinutes": 19, "wordCount": 2950, "text": "The knowledge of how human cognition systems work ...", "segments": [ {"id": 0, "start": 0.72, "end": 5.6, "startTimestamp": "00:00:00.720", "text": "The knowledge of how human cognition systems work and how they're evolved has led to a lot", "words": [{"word": "The", "start": 0.74, "end": 0.86}, {"word": "knowledge", "start": 0.86, "end": 1.16}]} ], "txtUrl": "https://api.apify.com/v2/key-value-stores/.../records/transcript-41b57fe93743.txt", "srtUrl": "https://api.apify.com/v2/key-value-stores/.../records/transcript-41b57fe93743.srt", "vttUrl": "https://api.apify.com/v2/key-value-stores/.../records/transcript-41b57fe93743.vtt", "jsonUrl": "https://api.apify.com/v2/key-value-stores/.../records/transcript-41b57fe93743.json" } ``` Also included: podcast author, episode GUID, episode page and plain-text show notes. The run's key-value store has a `RUN_SUMMARY` with the status of every episode, errors and billed minutes. Export the dataset as JSON, CSV, Excel or via the API. ### Engines | | Groq, no key needed | Groq (your key) | Local Whisper | |---|---|---|---| | Model | Whisper large-v3-turbo | Whisper large-v3-turbo or large-v3 | Whisper base or tiny (faster-whisper) | | Speed | very fast | very fast (10 minutes of audio in about 5 seconds in our tests) | about 0.75x real time at 1 GB memory (10 min of audio in ~7.5 min); with 4 GB about 4x faster | | Accuracy | best | best | good with clear English speech; names and rare words are often wrong | | Who processes the audio | Groq Inc. (USA), through the Actor developer's Groq account | Groq Inc. (USA), your own account | only inside your Apify run | | Limits | one rate limit shared by all users (see below) | Groq's limits for your account | max. 120 minutes per episode and what fits into the run timeout | | Extra cost | none, included in the per-minute price | Groq bills your key directly (about $0.04 per audio hour at the time of writing) | none | **Auto** (default) uses your own Groq key when you enter one, otherwise Groq with no key needed. #### No API key needed: how it works and its limits Without a key of your own, the Actor sends the audio to Groq's Whisper large-v3-turbo using the developer's Groq account. You get the same transcript quality as with your own key and the turbo model, without signing up anywhere, at a somewhat higher price per minute. The catch: this runs on Groq's free tier, so there is one rate limit and one daily quota that all users of the Actor share. At the moment that is roughly 2 hours of audio per hour and 8 hours of audio per day for everyone together. The Actor waits up to about two minutes when Groq is busy. If the limit is still used up, the rest of the episode is transcribed with the local Whisper engine and billed as local minutes, so you still get a complete transcript, but that part is slower and less accurate. The run's status message and the `transcriptionEngine` field tell you when this happened. For large batches or daily monitors, your own free Groq key is the more reliable choice. The free demo (empty input) always uses the local engine. The audio is sent to Groq Inc. in the USA (see Data protection below). **German and other non-English audio:** the local engine works best for clear English speech. With the small `base` model, German and other languages come out noticeably less accurate, and results can vary from run to run. For German and other languages, use a Groq engine (no key needed, or your own key) and always set **Spoken language**. **Tip for the local engine:** set the run memory to 4096 MB. It is about 4x faster and the price per audio minute stays the same. If an episode does not fit into the run timeout, the Actor delivers and bills only the part it transcribed and says so in the status message. **Skipped speech:** the local engine checks its transcript for longer stretches of speech that came back without text and re-transcribes those parts with full precision (float32), at no extra charge. With the `base` model this second pass needs at least 2048 MB memory (at 1024 MB it runs with `tiny`; with `base` the run log only notes the gap). ### Pricing (pay per event) You pay per **started audio minute** that was actually transcribed - nothing for episodes that fail, are skipped or contain no speech: - **Audio minute (Groq, no key needed)** - Groq Whisper large-v3-turbo through the developer's Groq account - **Audio minute (Groq, your key)** - for transcription with your own Groq API key - **Audio minute (local Whisper)** - for the built-in engine, which uses much more compute - Apify's small default **Actor start** event See the **Pricing** tab for the current prices. **Max audio minutes per episode** caps the cost per episode, and the run stops cleanly when your **Maximum cost per run** is reached (the episode in progress is shortened to fit). ### Data protection (GDPR) and rights - **Only transcribe audio you are allowed to use.** The Actor processes public podcast feeds and files you point it to; you confirm your rights with the checkbox and are responsible for how you use the transcripts. Transcripts of third-party podcasts are typically fine for personal research or internal monitoring but usually not for republishing. - **No YouTube, Spotify, TikTok etc.** Their terms do not allow downloading media. Use the show's RSS feed or a direct file link instead. Apple Podcasts links are only used to look up the show's public RSS feed through Apple's public lookup service; the audio always comes from the publisher's own feed. - **Groq engines:** the audio is sent to [Groq](https://groq.com/privacy-policy/) (Groq Inc., USA) for transcription: with your own key under your own Groq account, or without a key under the developer's Groq account. The Actor never stores your audio or transcripts outside your own Apify storage. If the audio contains personal data (voices, names), you are the controller under the GDPR and need a legal basis; check Groq's terms and data processing terms for your use case, or use the local engine, which keeps the audio inside the Apify run. - The Actor stores results only in your own Apify storage (dataset, key-value store, and for "only new episodes" a named key-value store `podcast-transcriber-state` that holds episode IDs). The developer has no access to your data. ### FAQ **Which feeds work?** Any public RSS/Atom podcast feed with audio or video enclosures (Libsyn, Anchor/Spotify for Podcasters RSS, Megaphone, Buzzsprout, Podbean, ...). If you only have an Apple Podcasts link, paste it as it is: show links go into **Podcast RSS feed URL(s)**, episode links (with `?i=`) work in either field. The Actor finds the show's public RSS feed for you. Shows that are exclusive to Apple or subscriber-only have no public feed and are skipped with a clear error, without charge. **How accurate is it?** Groq's Whisper large-v3 (and large-v3-turbo, which the no-key engine uses) is among the most accurate open speech models. The local base model is fine for clear English speech; names and technical terms can be wrong. Set **Spoken language** if you know it. **Speaker labels?** Not yet - Whisper does not identify speakers. **Can I process long episodes?** Yes. Long files are split at pauses and the timestamps are stitched together. With Groq, episodes of several hours work; the local engine stops after 120 minutes per episode (use 4096 MB memory for long episodes). **Why did a run return nothing?** The status message and `RUN_SUMMARY` always say why: no new episodes since the last run, filters matched nothing, a feed or file could not be downloaded, or the cost limit was reached. Questions or a feed that does not work? Open an issue on the Actor page. ### Further reading - [faster-whisper int8 dropped up to 60 s of speech. float32 didn't](https://dev.to/prime619/faster-whisper-int8-dropped-up-to-60-s-of-speech-float32-didnt-4nba): the measurement behind the thread cap in this Actor's local engine. - [Podcast to text in Python](https://dev.to/prime619/podcast-to-text-in-python-transcribe-any-episode-from-its-rss-feed-3e8f): the same core job as a free script you run yourself ([GitHub](https://github.com/philippprimisser-max/podcast-to-text)). ### Related Actors by the same developer - [Podcast Transcript Scraper](https://apify.com/prime619/podcast-transcript-fetcher): pulls the transcripts podcasters already publish in their RSS feed. Cheaper and faster than transcribing when a show has them. - [Podcast & Video Clip Finder](https://apify.com/prime619/podcast-clip-finder): finds the strongest short-form moments in a podcast or video and returns timestamps, hooks and SRT subtitles for each clip. # Changelog This Actor's version history is a separate document: https://apify.com/prime619/podcast-transcriber/changelog.md # Actor input Schema ## `rssFeedUrls` (type: `array`): Public podcast RSS feeds. Episodes are taken from the audio/video enclosures, newest first. You can also paste an Apple Podcasts show link (podcasts.apple.com/.../id123...): the Actor looks up the show's public RSS feed and downloads the audio from the publisher, never from Apple. Spotify page links are not supported. ## `mediaUrls` (type: `array`): Direct, publicly accessible links to media files (mp3, m4a, wav, ogg, mp4, webm ...). An Apple Podcasts episode link (with ?i=...) also works: it is matched to the episode in the show's public RSS feed. YouTube, Spotify, TikTok, Instagram etc. are not supported. The prefilled link is a free 63 s public-domain demo (LibriVox, Gettysburg Address): it runs without a key, is never charged and is also used when you leave all sources empty. ## `confirmRights` (type: `boolean`): Required for your own sources. Only transcribe audio you own, have licensed or are otherwise allowed to transcribe. You are responsible for how you use the transcripts. Not needed for the built-in public-domain demo. ## `maxEpisodesPerFeed` (type: `integer`): How many episodes to transcribe per feed and run (newest first, after the filters below). ## `onlyNewEpisodes` (type: `boolean`): Remembers transcribed episodes (in a named key-value store in your account) and skips them next time. Ideal for a daily or weekly schedule. Failed episodes are retried. ## `monitorName` (type: `string`): Use different names to keep separate 'already transcribed' lists, e.g. one per client or task. Leave empty for the default list. ## `episodeTitleFilter` (type: `string`): Only episodes whose title contains this text (case-insensitive). ## `publishedAfter` (type: `string`): Only episodes published on or after this date (YYYY-MM-DD). Episodes without a date are skipped when set. ## `transcriptionProvider` (type: `string`): Auto (default): Groq with your own key if you enter one, otherwise Groq Whisper large-v3-turbo with no key needed. No key needed: we run Whisper large-v3-turbo on Groq for you (audio is processed by Groq in the USA). It shares one rate limit with all users of this Actor; if that is used up, the rest of the audio is transcribed with local Whisper (billed as local minutes) and the run says so. Groq (your key): the same models with your own Groq API key, the lowest price per minute (Groq bills you directly, about $0.04 per audio hour at the time of writing). Local: open-source Whisper inside the Actor, no third party, but slower (about 0.75x real time at 1 GB memory, 4 GB is ~4x faster at the same price), less accurate, max. 120 minutes per episode and a higher per-minute price. ## `groqApiKey` (type: `string`): Optional. Your own key from https://console.groq.com/keys gives the lowest price per minute and your own Groq limits. Stored encrypted by Apify and only sent to api.groq.com. Leave empty to use the no-key engine. ## `language` (type: `string`): Two-letter ISO code like "en" or "de". Leave empty for automatic detection. Setting it improves accuracy. ## `groqWhisperModel` (type: `string`): Only with your own Groq key. whisper-large-v3-turbo is cheaper and faster; whisper-large-v3 is a bit more accurate. The no-key engine always uses whisper-large-v3-turbo. ## `localModel` (type: `string`): For the local engine, and for the rest of an episode when the no-key engine's shared limit is used up. base (default) is more accurate, tiny about twice as fast. The .en models are English-only. Both run with 1 GB memory; 4 GB memory makes them about 4x faster at the same price per audio minute. ## `maxAudioMinutesPerEpisode` (type: `integer`): Only the first N minutes of each episode are transcribed (cost cap). Billed minutes never exceed this. ## `outputFormats` (type: `array`): Files saved per episode in the key-value store (links in every dataset item). ## `includeWordTimestamps` (type: `boolean`): Adds start/end times for every word to the segments in the dataset. The JSON file always contains them. ## `maxWordsPerCue` (type: `integer`): Length of SRT/VTT subtitle cues. ## `maxFileSizeMb` (type: `integer`): Larger files are rejected before processing. ## Actor input object example ```json { "mediaUrls": [ "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3" ], "confirmRights": false, "maxEpisodesPerFeed": 1, "onlyNewEpisodes": false, "transcriptionProvider": "auto", "groqWhisperModel": "whisper-large-v3-turbo", "localModel": "base", "maxAudioMinutesPerEpisode": 180, "outputFormats": [ "txt", "srt", "vtt", "json" ], "includeWordTimestamps": true, "maxWordsPerCue": 12, "maxFileSizeMb": 500 } ``` # Actor output Schema ## `transcripts` (type: `string`): One item per episode: metadata, full text, timestamped segments and file links. ## `files` (type: `string`): TXT, SRT, VTT and JSON file per episode. ## `summary` (type: `string`): Status per episode, errors, billed audio minutes. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "mediaUrls": [ "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3" ] }; // Run the Actor and wait for it to finish const run = await client.actor("prime619/podcast-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mediaUrls": ["https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3"] } # Run the Actor and wait for it to finish run = client.actor("prime619/podcast-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 '{ "mediaUrls": [ "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3" ] }' | apify call prime619/podcast-transcriber --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,prime619/podcast-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 ` 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/ToAy8Jwc9DXakpVjc/builds/a1tXcgMHMxYtJzho2/openapi.json