# Podcast & Interview Transcript Intelligence (`thescrapelab/podcast-interview-transcript-intelligence`) Actor

Extract podcast and interview transcripts from RSS feeds, transcript URLs, public media, webpages, YouTube captions, or pasted text. Export structured transcripts, SRT/VTT captions, summaries, topics, chapters, and quotes while reusing existing transcripts before paid transcription.

- **URL**: https://apify.com/thescrapelab/podcast-interview-transcript-intelligence.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** AI, Automation, Videos
- **Stats:** 1 total users, 1 monthly users, 88.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 transcript results

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

## Podcast & Interview Transcript Intelligence

Turn podcast episodes and interviews into clean, searchable data with a transcript-first podcast transcription API. Provide a podcast RSS feed, transcript URL, public audio or video file, YouTube page, or pasted text. The Actor looks for an existing transcript or caption track first and only uses paid speech-to-text when no usable transcript is available and you explicitly enable transcription.

Use it for podcast transcript extraction, interview transcription, RSS feed processing, YouTube caption retrieval, SRT/VTT subtitle generation, accessibility workflows, and transcript analysis. Results are structured for direct use in research tools, content pipelines, spreadsheets, databases, and AI applications.

Each result can include:

- the normalized transcript;
- timestamps and speaker labels when the source provides them;
- SRT and WebVTT captions;
- a concise summary and main topics;
- chapter suggestions and evidence-linked quotes;
- source, model, warning, and cost details.

### Use cases

- Turn podcast RSS feeds into searchable research data.
- Reuse Podcasting 2.0 transcripts instead of paying to transcribe audio again.
- Create captions from public interview audio or video files.
- Extract public YouTube caption tracks.
- Prepare podcast content for articles, newsletters, accessibility, or AI workflows.

### Why use this Actor?

- **Transcript first:** avoids paying to transcribe audio when the publisher already provides a usable transcript or caption track.
- **Multiple source types:** accepts RSS and Atom feeds, transcript files, public media, YouTube pages, and pasted text.
- **Structured output:** returns normalized text, timed segments, captions, summaries, topics, chapters, quotes, and processing metadata.
- **Cost-safe defaults:** paid transcription and AI analysis remain disabled unless you select them.
- **Bounded runs:** item, duration, download, runtime, and OpenRouter budget limits prevent uncontrolled processing.
- **API ready:** every result is available as a structured dataset row for automation and downstream integrations.

### Run it in Apify Console

1. Open the Actor's **Input** tab.
2. Paste up to 10 podcast feeds, transcript files, public media files, webpages, or YouTube links into **Sources**. You can also paste transcript text directly.
3. Leave **Do not transcribe audio** selected for a transcript-only, cost-safe run, or explicitly choose a transcription option.
4. Click **Start** and open the **Dataset** tab when the run finishes.

The small built-in Apify example analyzes a short two-speaker transcript and returns one meaningful row. It makes one bounded OpenRouter analysis call so the daily platform test can detect a missing key, retired model, provider failure, or invalid model response. It never downloads media or performs transcription, and the Actor retains a 240-second runtime guard.

For automation, use the **API** tab or the Python example below.

### Input

The form has six simple inputs:

- **Sources** — one list for RSS or Atom feeds, public TXT/JSON/SRT/VTT transcripts, audio/video files, webpages, and YouTube links.
- **Or paste a transcript** — private transcript text to process directly.
- **Maximum results** — the total number of rows to create.
- **When no transcript exists** — disabled, low-cost transcription, or speaker-aware transcription.
- **Transcript intelligence** — transcript only, or summary, topics, chapters, and quotes.
- **Create timestamps when missing** — regenerate timing from available public media when needed.

When audio transcription is needed, choose:

- `low_cost` — Whisper transcription, normally the cheapest option;
- `speaker_aware` — MAI transcription with best-effort speaker diarization;
- `disabled` — never send audio for transcription.

Plain-text transcripts are reused without retranscription. Enable **Require accurate timestamps** only when missing captions must be regenerated from available audio.

Transcription, AI analysis, and speaker-label requests are opt-in. New runs default to existing-transcript discovery with `transcriptionFallback: "disabled"` and `analysisMode: "none"`, so an omitted setting cannot unexpectedly spend OpenRouter credits or add avoidable warnings to the default result.

Safety limits for duration, downloads, and runtime are applied automatically. Existing API clients can still send the previous source-specific and safety fields; they remain supported but are hidden from the Console form.

Minimal JSON input:

```json
{
  "sourceUrls": ["https://example.com/podcast.xml"],
  "transcriptionFallback": "low_cost",
  "analysisMode": "standard"
}
```

### Output

The default dataset contains one row per requested transcript, episode, or media item.

```json
{
  "recordType": "transcript_result",
  "status": "success",
  "title": "Example episode",
  "transcriptSource": "existing_transcript",
  "transcript": "The normalized episode transcript...",
  "segments": [
    { "start": 0, "end": 5.4, "text": "Welcome to the show." }
  ],
  "summary": "The episode discusses...",
  "topics": ["podcasting", "accessibility"],
  "srt": "1\n00:00:00,000 --> 00:00:05,400\nWelcome to the show.\n",
  "openRouterCostUsd": 0,
  "warnings": []
}
```

Failed inputs are returned as separate sanitized error rows so a bad link does not hide successful results from the same run.

### Pricing and cost control

Finding and normalizing an existing transcript does not use OpenRouter. Optional analysis and missing-audio transcription use metered AI processing.

The release pricing is designed around these pay-per-event rates. The Actor's **Pricing** tab is authoritative once the listing is live:

- successful transcript result: `$0.005` per delivered dataset row;
- AI analysis: `$0.001` per started transcript minute;
- low-cost transcription: `$0.006` per started audio minute;
- speaker-aware transcription: `$0.012` per started audio minute.

Example totals, including the `$0.00005` Actor start event, are approximately `$0.00505` for one existing transcript, `$0.06505` for a 10-minute low-cost transcription, `$0.36505` for a 60-minute low-cost transcription, and `$0.72505` for a 60-minute speaker-aware transcription. Existing transcripts are therefore inexpensive to try, while paid transcription scales predictably with media length.

At the model rates checked for this release, OpenRouter lists Whisper Large V3 at `$0.000008` per second (`$0.00048` per minute), MAI-Transcribe 2 at `$0.10` per hour (about `$0.00167` per minute), and GPT-5.4 Nano at `$0.20/M` input tokens plus `$1.25/M` output tokens. Provider routing and billing details can make the returned cost higher, so the Actor uses deliberately conservative preflight estimates, records the actual returned OpenRouter cost in each result, and enforces a separate per-run API budget.

The event prices include ordinary Apify platform usage; it is not passed through as an additional customer platform-usage charge. A run will not start an owner-funded AI operation unless the spending allowance covers the full AI operation and its result. Model prices and event rates can change; always review the Pricing tab for the active customer-facing rates.

The base result event is delivered and charged atomically by the Apify SDK. Failed rows are not charged, and processing stops when the caller's charge limit is reached. This event is intended to cover ordinary platform compute, data transfer, and storage once pay-per-event pricing is enabled.

Regular Apify usage is bounded as well:

- processing is sequential and does not launch a browser or use a proxy;
- memory is capped at 512 MB;
- network and AI work stops after at most 280 seconds, with a 240-second default;
- one run accepts at most 10 items and 120 total audio minutes;
- all source downloads share a 100 MB default allowance and a non-increasable 150 MB ceiling;
- each run writes at most 10 dataset rows and one small run-summary record.

At 512 MB, the 280-second runtime ceiling is about 0.039 compute units. At Apify's published `$0.20/CU` base rate, that is under `$0.008` of compute for a worst-duration run; normal transcript-first runs should be much lower. Data transfer and storage operations are separate, but the download and output caps prevent an individual run from growing without bound.

### Data handling

- Media is downloaded into temporary run storage only.
- Raw audio, video, and normalized chunks are deleted before the item finishes, including after errors.
- Transcript contents are not written to logs.
- Final result rows are stored only in the caller's unnamed run dataset and follow the caller's Apify retention policy.
- Normal Apify run metadata and encrypted inputs remain subject to Apify's platform retention rules.

Only public URLs are supported. The Actor blocks local and private network destinations and does not bypass logins, DRM, CAPTCHAs, private feeds, or access controls.

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("thescrapelab/podcast-interview-transcript-intelligence").call(
    run_input={
        "sourceUrls": ["https://example.com/podcast.xml"],
        "transcriptionFallback": "low_cost",
        "analysisMode": "standard",
    }
)

if run is None:
    raise RuntimeError("Actor run failed")

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["title"], item["status"])
    print(item["summary"])
```

### Limitations

- Speaker labels are best effort and depend on the transcript source or selected model.
- Plain-text transcripts have no accurate SRT/VTT output unless audio is available and timestamp regeneration is requested.
- YouTube processing uses public caption tracks only; it does not download YouTube audio when captions are absent.
- Restricted, signed, private, or expired media links may fail.
- Sources larger than the per-item or total run download allowance are rejected before further processing.
- Work not completed before the configured runtime allowance is stopped and completed result rows are preserved.
- Results summarize the supplied recording and should not be treated as independently verified facts.

### Troubleshooting and support

- **No transcript was produced:** confirm the URL is public and returns media, RSS, TXT, JSON, SRT, or VTT without a login.
- **No timestamps or subtitles:** the existing transcript is plain text. Enable accurate timestamps and provide public media if timed output is required.
- **AI unavailable:** reduce the requested duration, increase the run spending limit, or retry after checking the Pricing tab.
- **Some episodes failed:** inspect each dataset row's `warnings` and `errors`; successful episodes remain available.

Use the Actor's Issues tab to report a reproducible source or output problem. Do not include private media links, tokens, or transcript contents in an issue.

# Changelog

This Actor's version history is a separate document: https://apify.com/thescrapelab/podcast-interview-transcript-intelligence/changelog.md

# Actor input Schema

## `sourceUrls` (type: `array`):

Add RSS or Atom feeds, TXT/VTT/SRT/JSON transcripts, public audio or video, webpages, or YouTube links.

## `transcriptText` (type: `string`):

Optional private transcript text to clean, structure, or analyze directly.

## `maxMediaItems` (type: `integer`):

Maximum transcript or media items processed in this run.

## `transcriptionFallback` (type: `string`):

Disabled avoids transcription costs. Low cost uses Whisper. Speaker-aware separates speakers.

## `analysisMode` (type: `string`):

Optionally create a summary, topics, chapters, and key quotes.

## `requireTimestamps` (type: `boolean`):

If an existing transcript has no timing and media is available, use transcription to create timed captions.

## `directTitle` (type: `string`):

Legacy API title for pasted text.

## `transcriptUrls` (type: `array`):

Backward-compatible transcript URL input.

## `mediaUrls` (type: `array`):

Backward-compatible media URL input.

## `rssFeedUrls` (type: `array`):

Backward-compatible podcast feed input.

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

Maximum recent episodes selected per feed.

## `includeSpeakerLabels` (type: `boolean`):

Legacy API control for speaker labels.

## `includeWordTimestamps` (type: `boolean`):

Legacy API control for word timestamps.

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

Optional language hint for API clients.

## `keywords` (type: `array`):

Optional specialist vocabulary for API clients.

## `maxMinutesPerItem` (type: `integer`):

Automatic per-item audio duration guard.

## `maxTotalMinutes` (type: `integer`):

Automatic total audio duration guard.

## `maxDownloadMbytes` (type: `integer`):

Automatic per-item download guard.

## `maxTotalDownloadMbytes` (type: `integer`):

Automatic total download guard.

## `maxRunSeconds` (type: `integer`):

Automatic runtime guard.

## Actor input object example

```json
{
  "maxMediaItems": 3,
  "transcriptionFallback": "disabled",
  "analysisMode": "none",
  "requireTimestamps": false,
  "maxEpisodesPerFeed": 1,
  "includeSpeakerLabels": false,
  "includeWordTimestamps": false,
  "maxMinutesPerItem": 60,
  "maxTotalMinutes": 60,
  "maxDownloadMbytes": 75,
  "maxTotalDownloadMbytes": 100,
  "maxRunSeconds": 240
}
```

# Actor output Schema

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

One result for each requested transcript, episode, or media item.

## `runSummary` (type: `string`):

Counts, timing, model usage, costs, and sanitized warnings.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/podcast-interview-transcript-intelligence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/podcast-interview-transcript-intelligence").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 '{}' |
apify call thescrapelab/podcast-interview-transcript-intelligence --silent --output-dataset

```

## MCP server setup

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

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/SsDzJtmsy8f9Sob7Q/builds/zZYE3VFfoZhPqzJOS/openapi.json