# Podcast Transcriber & Analyzer (`hgservices/podcast-transcriber`) Actor

Download, Transcribe and analyze any podcast from an RSS feed, Apple Podcasts link, show name, or episode URL.

- **URL**: https://apify.com/hgservices/podcast-transcriber.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** AI, MCP servers, Agents
- **Features:** Limited permissions
- **Stats:** 25 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $12.00 / 1,000 speech to text transcriptions

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 Downloader, Transcriber & Analyzer** turns any podcast into **searchable text and structured insights**. Paste an **RSS feed**, an **Apple Podcasts link**, a **show name**, or a **direct episode link** — and get back an **accurate, speaker-labeled transcript with inline timestamps** for every episode, plus optional **AI summaries, chapters, topics, named people and brands, guest names, sentiment, ad reads, and keyword mentions** — and downloadable **SRT/VTT subtitle files**.

Transcribe a single episode in seconds, or point it at a whole show to process the **entire back catalog**. Because it runs on the [Apify platform](https://apify.com), you also get a full [API](https://docs.apify.com/api/v2), [scheduling](https://docs.apify.com/platform/schedules), and one-click [integrations](https://apify.com/integrations) with Make, Zapier, Google Sheets, Slack, and more.

### What can you do with Podcast Transcriber & Analyzer?

- **Media & brand monitoring** — track every mention of your brand, product, competitors, or executives across the podcasts that matter to you.
- **Content repurposing** — generate show notes, blog posts, newsletters, and social clips from a transcript.
- **Video & social captions** — export **SRT/VTT subtitle files** to caption a YouTube or social-video cut of an episode, with timecodes ready to drop into any editor.
- **Research & due diligence** — read instead of listen, and search across hours of audio in seconds.
- **SEO & discoverability** — publish episode transcripts to rank for what your guests actually said.
- **Accessibility** — provide transcripts for listeners who are deaf or hard of hearing.

### How to use Podcast Transcriber & Analyzer

1. Click **Try for free**.
2. On the **Input** tab, provide **one** source: an RSS feed URL, an Apple Podcasts link, a show name, or a direct episode URL.
3. Choose **which episodes** to process — the **latest** (default), **all**, or a filter (by date range, position, title, or GUID).
4. **Analysis runs by default** (summaries, chapters, topics, entities, guests, sentiment, and ad reads). Optionally turn on **Subtitle export** (SRT/VTT) or **Store audio file**, or add **Mention keywords** to track brands.
5. Click **Start**. Timestamped transcripts and insights appear on the **Output** tab; any subtitle/audio files land in the **Storage** (key-value store) tab.

### Input

You only need **one** of these to get started:

| Input | Example |
| --- | --- |
| **RSS feed URL** | `https://feeds.buzzsprout.com/1195244.rss` |
| **Apple Podcasts link** | `https://podcasts.apple.com/us/podcast/.../id1434243584` |
| **Show name** | `Lex Fridman Podcast` |
| **Direct episode URL** | `https://.../episode.mp3` or an episode web page |

Then fine-tune with options like **which episodes** (latest / all / by date / by title), **speaker labels**, **timestamps**, **subtitle export (SRT/VTT)**, **store the audio file**, and **which analyses** to run. See the **Input** tab for the full list with descriptions and defaults.

### Output

You get **one record per episode**, with show and episode metadata, the transcript, and (optionally) analysis:

```json
{
  "showTitle": "The Interview",
  "episodeTitle": "Danny McBride Thinks Men Learned All the Wrong Lessons From Movies",
  "publishedAt": "2026-06-20T09:00:00+00:00",
  "durationSeconds": 2255,
  "transcript": "[Speaker 1 00:00:25] From The New York Times, this is the interview. I'm David Marchese...",
  "transcriptLength": 44755,
  "detectedLanguage": "en",
  "speakerCount": 5,
  "analysis": {
    "summary": "Danny McBride discusses his short-story collection and how it satirizes modern masculinity...",
    "chapters": [{ "title": "The Crisis of Modern Masculinity", "summary": "How 1980s media sold a macho ideal..." }],
    "topics": ["masculinity", "satire", "parenting", "storytelling"],
    "entities": [{ "name": "Danny McBride", "type": "person" }],
    "guests": ["Danny McBride"],
    "sentiment": { "overall": "positive", "rationale": "Lighthearted yet introspective..." },
    "adReads": [{ "brand": "Apple Card", "excerpt": "No annual fee, no late fees, and no foreign transaction fees..." }],
    "mentions": [{ "keyword": "HBO", "count": 3, "quotes": ["...my great HBO shows..."] }]
  },
  "subtitleKvsKeys": { "srt": "subtitles-<guid>.srt", "vtt": "subtitles-<guid>.vtt" }
}
```

You can download the dataset in **JSON, CSV, Excel, or HTML**, or pull it from the API.

#### Data fields

| Field | Description |
| --- | --- |
| `showTitle`, `showAuthor`, `feedUrl`, `language`, `categories` | Podcast (show) details. |
| `episodeTitle`, `publishedAt`, `durationSeconds`, `episodeNumber`, `season`, `enclosureUrl` | Episode details. |
| `transcript`, `transcriptLength`, `detectedLanguage`, `speakerCount` | The transcription — speaker-labeled, with inline `[Speaker N HH:MM:SS]` timestamps when **Timestamps** is on. |
| `analysis.summary`, `.chapters`, `.topics`, `.entities`, `.guests`, `.sentiment`, `.adReads`, `.mentions` | AI insights (when **Analyze** is on). |
| `subtitleKvsKeys` | Keys of the generated **SRT/VTT** subtitle files in the key-value store (when **Subtitle export** is on). |
| `audioKvsKey` | Where the saved audio file lives (when **Store audio** is on). |

### How much does it cost to transcribe a podcast?

This Actor uses **pay-per-event** pricing, so you pay only for the work each run actually does, across four events:

| Event | Unit | Charged when |
| --- | --- | --- |
| Episode metadata | per episode | An episode is returned (a flat baseline charge for every delivered episode, including metadata-only runs). |
| Media downloaded | per MB | The episode's audio file is downloaded — needed for transcription, and for **Store audio** when enabled. |
| Transcription | per audio minute | An episode is transcribed. |
| Analysis | per episode | AI analysis runs for an episode (one flat charge per episode, regardless of episode length or how many analysis types you select). |

Cost scales mainly with the **total audio minutes** you process, so a 5-minute news episode is a few cents while a 3-hour interview costs more. Keyword **mentions** are computed locally and are not charged. To keep runs cheap, leave **episode selection** on **latest**, or set **Max episodes**. You can try the Actor for free with your Apify free-tier credits before scaling up.

### Tips

- **Transcribe a whole show:** set episode selection to **all**. Use **Max episodes** to cap a large back catalog.
- **Build a podcast monitor:** add your brand and competitor names to **Mention keywords**, then [schedule](https://docs.apify.com/platform/schedules) the Actor over your favorite shows to get a running feed of mentions.
- **Faster, cheaper runs:** turn off **Store audio** if you only need text, and lower **Max audio minutes** to skip very long episodes.
- **Free subtitles & timestamps:** **Subtitle export** (SRT/VTT) and inline **Timestamps** are generated from the transcription you're already paying for — they add **no extra charge**.

### Frequently asked questions

**Can it transcribe a Spotify link?** No — Spotify hosts its audio in a closed format. Use the show's RSS feed or its Apple Podcasts link instead (most shows are on both).

**What about video podcasts on YouTube?** Use the [Speech-to-Text Transcription](https://apify.com/hgservices/speech-to-text) Actor with the video URL.

**Which languages are supported?** The language is detected automatically, covering 30+ languages.

**Can it transcribe private or members-only feeds?** No — the Actor only accesses publicly available episodes.

**Is this legal?** Transcribing publicly available podcasts for analysis is generally fine, but you are responsible for how you use the output (respect copyright and the show's terms).

Found a podcast that doesn't resolve, or have a feature request? Open an issue on the **Issues** tab — we read every one.

# Actor input Schema

## `source` (type: `string`):

Provide exactly one podcast reference — the type is auto-detected:

- **RSS/Atom feed** — e.g. https://feeds.buzzsprout.com/1195244.rss
- **Apple Podcasts link** — any podcasts.apple.com URL; add `?i=<episodeId>` to pin a single episode
- **Show name** — resolved to its feed via the iTunes Search API
- **Direct episode/audio URL** — an .mp3/.m4a/etc. file (or an episode web page); transcribed as a single episode

## `episodeSelection` (type: `string`):

How to pick episodes from a feed/show. 'latest' = newest episode only.

## `maxEpisodes` (type: `integer`):

Optional convenience cap for 'all'/'dateRange'. Leave empty for no cap — your run is bounded by your Apify credits and the run timeout.

## `fromDate` (type: `string`):

For 'dateRange': only episodes published on/after this ISO date.

## `toDate` (type: `string`):

For 'dateRange': only episodes published on/before this ISO date.

## `episodeIndex` (type: `integer`):

For 'index': 0 = newest, 1 = next, ...

## `episodeGuid` (type: `string`):

For 'guid': the exact episode GUID to select.

## `titleContains` (type: `string`):

For 'titleMatch': select episodes whose title contains this text (case-insensitive).

## `includeTranscript` (type: `boolean`):

Produce a transcript for each episode (transcribed in-process with Deepgram).

## `includeAnalysis` (type: `boolean`):

Run AI analysis on each transcript — summaries, topics, entities, guests, and more. Keyword 'mentions' run independently and don't require this.

## `analysis` (type: `array`):

Which AI analyses to produce per episode.

## `mentions` (type: `array`):

Keywords/brands to find in each transcript (deterministic; no API key needed). Powers podcast monitoring.

## `includeAudio` (type: `boolean`):

Download each episode's audio and store it in the key-value store (key 'audio-<guid>').

## `subtitleFormats` (type: `array`):

Generate subtitle files from the transcript timings and store them in the key-value store (key 'subtitles-<guid>.<ext>'). Their keys appear on each record as 'subtitleKvsKeys'. Requires transcription.

## `diarize` (type: `boolean`):

Label different speakers in the transcript.

## `smartFormat` (type: `boolean`):

Apply punctuation/formatting to the transcript.

## `timestamps` (type: `boolean`):

Prefix each speaker turn in the transcript with its start time (HH:MM:SS), e.g. `[Speaker 1 00:01:58]`.

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

Skip (don't transcribe) episodes longer than this. Podcasts are long-form (some interview shows run 4–5 hours), so the default is generous.

## `proxyConfiguration` (type: `object`):

Proxy used when downloading episode audio for transcription.

## Actor input object example

```json
{
  "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521",
  "episodeSelection": "latest",
  "episodeIndex": 0,
  "includeTranscript": true,
  "includeAnalysis": true,
  "analysis": [
    "summary",
    "chapters",
    "topics",
    "entities",
    "guests",
    "sentiment",
    "adReads"
  ],
  "mentions": [],
  "includeAudio": false,
  "subtitleFormats": [],
  "diarize": true,
  "smartFormat": true,
  "timestamps": true,
  "maxAudioMinutes": 600,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `episodes` (type: `string`):

One record per episode: show/episode metadata, transcript, and optional analysis.

## `audio` (type: `string`):

Downloaded episode audio stored in the key-value store (only when includeAudio is enabled).

## `subtitles` (type: `string`):

Exported SRT/VTT subtitle files stored in the key-value store (only when subtitleFormats are requested).

# 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 = {
    "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521" }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/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 '{
  "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521"
}' |
apify call hgservices/podcast-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hgservices/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 <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/xfymKHJYzq1tMuek6/builds/uxQDcOEaVj6hfREAo/openapi.json