# Video & Podcast Transcript: Any Link, MP3 or RSS to Text (`panix/video-transcript-scraper`) Actor

Turn public videos and podcasts into text from a link: TikTok, X, Vimeo, YouTube, TED, Loom, SoundCloud and many more sites, MP3/MP4 files, RSS feeds and Apple Podcasts. Captions first, Whisper speech-to-text when none. SRT, VTT, Markdown and RAG chunks for AI, research and n8n.

- **URL**: https://apify.com/panix/video-transcript-scraper.md
- **Developed by:** [PANIX AI LAB](https://apify.com/panix) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 transcripts

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

## Video & Podcast Transcript: Any Link, MP3 or RSS to Text

Turn any public video, audio file or podcast into text with timestamps. Paste links from TikTok, X, Vimeo, YouTube, Loom, Apple Podcasts or an RSS feed and get clean transcripts.

- **Many sources in one Actor**: video pages, direct audio and video files, and podcast feeds.
- **Cheap when captions exist**: it uses the creator's or the platform's captions first, and runs Whisper speech-to-text only when there are none.
- **No API keys, no login, no extra AI bill.**

**Try it now:** the input is already filled in (a YouTube video and a SpaceX video post on X). Click **Start** and the results appear in a table you can export to Excel, CSV or JSON. That example run costs a few cents, which the $5 of free monthly credit on Apify's free plan covers.

**Price:** from **$1.60 per 1,000 transcripts** from captions (speech-to-text is charged per minute), and you pay only for results you get. The full price table is in the Pricing section below.

### Example result

One result, shortened. Every field is described in the Output section below.

```json
{
  "url": "https://x.com/SpaceX/status/1732824684683784516",
  "platform": "X",
  "title": "SpaceX - At dawn from the gateway to Mars, the launch of Starship’s second fli...",
  "author": "SpaceX",
  "publishedAt": "2023-12-07T18:09:33Z",
  "durationSeconds": 114.32,
  "language": "en",
  "transcriptSource": "creator_captions",
  "transcript": "Attention all operators on countdown one. This is the final go-no-go for flight two of Starship. ...",
  "views": 5080573
}
```

### What you get

Paste links, get transcripts. This Actor turns public videos, audio files and podcasts into clean text with timestamps:

- **Video pages** from TikTok, X (Twitter), Vimeo, YouTube videos and Shorts, TED, Loom, SoundCloud, Twitch clips, Dailymotion, archive.org and many other sites
- **Direct files**: `.mp3`, `.m4a`, `.wav`, `.ogg`, `.mp4`, `.webm`, `.mov` and more (meeting recordings, calls, lectures, voice notes hosted anywhere public)
- **Podcasts**: any RSS feed, or an Apple Podcasts show or episode link (the newest episodes, or exactly the one you link)

It uses **existing captions first** (the creator's captions, the platform's automatic captions, or the podcast's own transcript file), which is fast and cheap. Only when there are none does it run **Whisper speech-to-text** inside the run. No API keys, no login, no extra AI bill.

### Who uses it

- **AI and RAG builders**: transcripts with timestamps and ready-made chunks for embeddings, search and chatbots
- **Podcast tools and researchers**: whole feeds on a schedule, only new episodes each run
- **Content and social media teams**: hooks and scripts from TikTok and X videos, subtitles for reposting
- **Marketers and analysts**: what competitors and creators say in their videos
- **n8n, Make and Zapier automations**: one HTTP call from a link to text

### Why this one

- **Captions first, speech-to-text only when needed.** A video with captions costs one small transcript charge, nothing per minute.
- **Billed by speech, not file length.** A built-in voice detector skips music, silence and intros; only minutes with speech are charged, and music-only clips are free.
- **Podcasts built in.** RSS feeds and Apple Podcasts links work directly, and when a podcast publishes its own transcript file (Podcasting 2.0), that is used instead of speech-to-text.
- **Many outputs from one run.** Plain text, timed segments, SRT and VTT subtitles, a readable Markdown version with `[m:ss]` timestamps, RAG chunks of any length, and word timestamps.
- **Free English translation** of the speech in 99 languages.
- **New items only** for schedules: a daily run on a feed transcribes and charges only new episodes.
- **Works with other Actors**: give it a dataset ID from any scraper run and it transcribes every link in it.
- **Never charged for failures.** Missing, private, DRM-protected, too-long or unsupported links and items without speech get a free row that says why.

#### Coming from another transcription tool?

| Common problem | What this Actor does |
|---|---|
| Paying per minute even when the video already has captions | Captions are used first; you pay one transcript charge and no minutes |
| Paying for the whole file when half of it is music or silence | Only detected speech minutes are charged |
| Podcasts need a separate tool or manual downloads | RSS feeds and Apple Podcasts links work directly, with new-episode monitoring |
| Raw text only, then more work to make subtitles or chunks | SRT, VTT, Markdown and RAG chunks come out of the same run |
| Failed links still cost money | Failed and skipped items are always free |

### Input

Only **Links** is required. Mix any kinds of links, one per line.

```json
{
  "urls": [
    "https://www.tiktok.com/@gordonramsayofficial/video/7229884545150061851",
    "https://x.com/SpaceX/status/1732824684683784516",
    "https://www.ted.com/talks/dan_dennett_on_our_consciousness",
    "https://feeds.npr.org/510289/podcast.xml",
    "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
    "https://example.com/recordings/team-call.mp3"
  ],
  "maxEpisodesPerFeed": 3,
  "includeSubtitles": true,
  "includeMarkdown": true,
  "chunkSeconds": 60
}
```

Main options:

| Option | What it does |
|---|---|
| `transcriptSource` | `auto` (captions first, default), `captions` (never run speech-to-text) or `speech` (always transcribe the audio) |
| `language` | Auto-detect, or a language code to prefer captions in that language and help speech-to-text |
| `translateToEnglish` | Deliver English text whatever language is spoken (no extra charge) |
| `quality` | `standard` (Whisper base) or `high` (Whisper small: better on accents, noise and rare languages; extra charge per minute) |
| `maxEpisodesPerFeed` | Newest episodes per RSS feed or Apple Podcasts show (default 5) |
| `maxMinutes` | Skip items longer than this, free (default 120) |
| `includeSegments`, `includeSubtitles`, `includeMarkdown`, `chunkSeconds`, `includeWordTimestamps` | Extra output formats |
| `newItemsOnly` + `watchlistName` | For schedules: skip everything delivered before under the same name |
| `datasetId` | Transcribe the links in another Actor's dataset |

### Output

One row per video or episode. Example (shortened) from a real run:

```json
{
  "type": "transcript",
  "status": "transcribed",
  "charged": true,
  "url": "https://x.com/SpaceX/status/1732824684683784516",
  "platform": "X",
  "mediaId": "1732820284301058052",
  "title": "SpaceX - At dawn from the gateway to Mars, the launch of Starship’s second fli...",
  "author": "SpaceX",
  "publishedAt": "2023-12-07T18:09:33Z",
  "durationSeconds": 114.32,
  "language": "en",
  "transcriptSource": "creator_captions",
  "transcript": "Attention all operators on countdown one. This is the final go-no-go for flight two of Starship. Again, our T-Zero is at seven a.m. Central. Raptor one. Go. Raptor two. Go. Stage one. Go. Stage two. Go. Copy. Go for flight. Clock is rolling. Ten. Nine. Eight. Seven. Six. Five. Four. Three. Two. One. ...",
  "segments": [
    { "start": 3.66, "end": 17.66, "text": "Attention all operators on countdown one. This is the final go-no-go for flight two of Starship. ..." },
    { "start": 17.66, "end": 32.79, "text": "two. Go. Stage one. Go. Stage two. Go. Copy. Go for flight. Clock is rolling. ... We have liftoff." }
  ],
  "views": 5080573,
  "likes": 33764,
  "comments": 2416,
  "authorUrl": "https://twitter.com/SpaceX",
  "thumbnailUrl": "https://pbs.twimg.com/ext_tw_video_thumb/1732820284301058052/pu/img/A-6jgWgxmMJ43_YO.jpg?name=orig",
  "chargedSpeechMinutes": 0,
  "scrapedAt": "2026-11-08T17:12:34Z"
}
```

This video had captions, so it cost one transcript charge and no speech minutes. When speech-to-text runs, the row also has `transcriptionModel` (`whisper-base` or `whisper-small`), `languageProbability`, `speechSeconds` and `chargedSpeechMinutes`.

`transcriptSource` tells you where the text came from: `creator_captions`, `auto_captions`, `podcast_transcript` (the podcast's own file) or `speech_to_text`. Podcast rows also have `showTitle`, `feedUrl`, `episodeNumber`, `seasonNumber` and `publishedAt`. With the output options on you also get `srt`, `vtt`, `markdown`, `chunks` and `words`.

**Free rows** (not charged) have a `status` such as `no_speech` (music or silence only), `no_captions` (captions-only mode), `too_long` or `live`, or `type: "error"` with an `errorCode` (`not_found`, `login_required`, `drm_protected`, `unsupported_site`, `blocked`...) and a plain-English `error`.

Each run also saves `SUMMARY` in its key-value store: totals, transcripts per source, charged events, rows per status, errors per code and speech-to-text minutes.

### Pricing

Pay per event, only for what you get:

| Event | When | Price (Bronze) |
|---|---|---|
| Transcript | Each delivered transcript (any source) | $0.002 |
| Speech-to-text minute | Each started minute of detected speech, only when there are no captions | $0.008 |
| High accuracy minute | Added per speech-to-text minute with `quality: high` | $0.020 |
| Actor start | Once per run, per GB of memory (default 4 GB, so $0.004) | $0.001 |

Free plan prices are slightly higher ($0.0025 per transcript, $0.009 per speech minute, $0.024 high accuracy); Silver and Gold are lower (Gold: $0.0016 per transcript, $0.006 per speech minute, $0.016 high accuracy).

Examples at Bronze:

- A YouTube or TED video with captions: **$0.002**
- A 1-minute TikTok without captions: **$0.010**
- A 60-minute podcast episode with about 55 minutes of speech: **$0.44**
- 1,000 videos with captions: **$2**

Failed, skipped and duplicate items are never charged. Set a maximum charge on the run to cap any batch.

### Tips

- **Memory**: runs use 4 GB (the minimum, so hour-long audio fits). For long podcasts or many files, 8 GB transcribes about twice as fast for roughly the same platform cost.
- **YouTube**: videos with captions work reliably. YouTube blocks audio downloads from cloud servers, so a YouTube video *without* captions usually ends as a free `blocked` row. For whole YouTube channels or playlists, use our YouTube Transcript Actor.
- **Instagram** reels have their own Actor (Instagram Reel Transcript); Facebook, Reddit, Spotify and Netflix are not supported (login or DRM).
- **Translation and rare languages**: use `quality: high` for the best results.

### Limits

- Public content only: no login, cookies or private links. Links must be reachable from the internet.
- Items up to 300 minutes (`maxMinutes`).
- No speaker labels (who said what) yet.
- Speech-to-text runs on CPU with Whisper base or small; studio-grade accuracy on very noisy audio is not guaranteed.

### FAQ

**Which sites work?** Most public video and audio pages that a standard open-source media extractor supports. We tested TikTok, X, Vimeo, YouTube, TED, Loom, SoundCloud, Twitch clips, Dailymotion, archive.org, direct files, RSS feeds and Apple Podcasts. If a site is not supported you get a free `unsupported_site` row.

**Do I need an OpenAI or other API key?** No. Speech-to-text runs inside the Actor.

**Can I transcribe my own recordings?** Yes, if the file is reachable by a public or signed link (for example a cloud storage share link or a pre-signed S3 URL).

**How do I get only new podcast episodes every day?** Schedule the Actor with your feed, `newItemsOnly: true` and a `watchlistName`. Each run skips episodes already delivered.

### API and integrations

Python (apify-client 3.x):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("panix/video-transcript-scraper").call(run_input={
    "urls": ["https://x.com/SpaceX/status/1732824684683784516", "https://feeds.npr.org/510289/podcast.xml"],
    "maxEpisodesPerFeed": 1,
    "includeMarkdown": True,
})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item.get("title"), item.get("transcriptSource"), (item.get("transcript") or "")[:100])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('panix/video-transcript-scraper').call({
    urls: ['https://www.tiktok.com/@gordonramsayofficial/video/7229884545150061851'],
    includeSubtitles: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcript);
```

**n8n, Make, Zapier**: use the Apify integration (or an HTTP request to `https://api.apify.com/v2/acts/panix~video-transcript-scraper/run-sync-get-dataset-items?token=<TOKEN>` with the input as JSON body) and map `transcript`, `markdown` or `chunks` into the next step.

# Actor input Schema

## `urls` (type: `array`):

One per line, mixed freely: a video page (TikTok, X/Twitter, Vimeo, YouTube video or Short, TED, Loom, SoundCloud, Twitch clip, Dailymotion, archive.org and many other sites), a direct audio or video file (.mp3, .m4a, .wav, .mp4, .webm...), a podcast RSS feed, or an Apple Podcasts show or episode link. Feeds and Apple Podcasts shows give their newest episodes (see Episodes per feed).

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

For each podcast feed or Apple Podcasts show: how many of its newest episodes to transcribe.

## `datasetId` (type: `string`):

Optional: the ID of a dataset from another scraper run (TikTok, X, YouTube, podcast...). Each row's url, webVideoUrl, videoUrl, postUrl, link, audioUrl, mediaUrl or feedUrl is read and transcribed (up to 5,000 rows).

## `transcriptSource` (type: `string`):

Captions first (default): use the creator's captions, the platform's automatic captions or the podcast's own transcript file when there is one (cheapest), and run speech-to-text only when there is none. Captions only: never run speech-to-text; items without captions get a free row. Speech-to-text always: ignore captions and transcribe the audio (charged per audio minute).

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

Leave on Auto: the spoken language is detected per item (99 languages) and captions in the video's own language are used. Pick a language to prefer captions in it and to tell speech-to-text what is spoken.

## `translateToEnglish` (type: `boolean`):

Deliver the transcript in English: English captions are used when the video has them, otherwise speech-to-text translates the speech. No extra charge.

## `quality` (type: `string`):

Only matters when speech-to-text runs. Standard uses Whisper base: fast and good for clear speech in major languages. High uses Whisper small: better on accents, noise, music under speech, names and less common languages, about three times slower, and adds the high-accuracy charge per audio minute.

## `maxMinutes` (type: `integer`):

Items longer than this are not transcribed and not charged (free row with status too_long). Captions are used for any length; this limit is checked before speech-to-text.

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

Add the transcript split into timed segments (start and end second, text).

## `includeSubtitles` (type: `boolean`):

Add ready-made subtitle files as text in the srt and vtt fields.

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

Add a readable Markdown version: title, source, author, date and paragraphs with \[m:ss] timestamps. Good for notes, LLM prompts and knowledge bases.

## `chunkSeconds` (type: `integer`):

Split the transcript into chunks of about this many seconds for embeddings and search (each chunk has start, end and text; YouTube chunks also get a link to that moment). 0 = no chunks.

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

Speech-to-text only: add every word with its start and end second and a confidence score. Makes transcription a little slower.

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

Stop after this many transcripts. Leave empty for no limit. You can also cap the cost with the run's maximum charge.

## `newItemsOnly` (type: `boolean`):

For scheduled runs (for example a podcast feed every day): remember every item transcribed under the watchlist name and skip it next time, so each run transcribes and charges only new episodes or videos.

## `watchlistName` (type: `string`):

Keeps separate memories for separate lists (letters, digits, - and \_). Runs with the same name share one memory.

## `maxConcurrency` (type: `integer`):

How many items are fetched at the same time while others are transcribed. Speech-to-text speed depends on the run's memory: 8 GB transcribes about twice as fast as the default 4 GB at roughly the same cost.

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

Pages are read through Apify Proxy. The default (automatic datacenter proxy) costs nothing extra and suits most sites.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "https://x.com/SpaceX/status/1732824684683784516"
  ],
  "maxEpisodesPerFeed": 5,
  "transcriptSource": "auto",
  "language": "auto",
  "translateToEnglish": false,
  "quality": "standard",
  "maxMinutes": 120,
  "includeSegments": true,
  "includeSubtitles": false,
  "includeMarkdown": false,
  "chunkSeconds": 0,
  "includeWordTimestamps": false,
  "newItemsOnly": false,
  "watchlistName": "default",
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All rows. Transcribed rows are charged; videos without speech, unsupported links and other free rows say why in statusMessage or error.

## `summary` (type: `string`):

Totals, transcripts per source (captions, podcast transcript, speech-to-text), charged events, rows per status, errors per code and speech-to-text 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://x.com/SpaceX/status/1732824684683784516"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("panix/video-transcript-scraper").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 = {
    "urls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://x.com/SpaceX/status/1732824684683784516",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("panix/video-transcript-scraper").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 '{
  "urls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "https://x.com/SpaceX/status/1732824684683784516"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call panix/video-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,panix/video-transcript-scraper"
        }
    }
}
```

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/i8NYNNBzMybk06vQh/builds/SEKs2ZzOf91CRB87b/openapi.json
