# 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
- **Stats:** 15 total users, 9 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# 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("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hgservices/podcast-transcriber",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/xfymKHJYzq1tMuek6/builds/s57L0Kx4JxdwNI4Fv/openapi.json