# Universal Media Transcriber (`insights_data/universal-media-transcriber`) Actor

Transcribe any video, audio or podcast link: YouTube, TikTok, Instagram, X, Spotify, podcast RSS, cloud files and 1,800+ sites. Get full transcripts, timestamps, speaker labels, SRT/VTT subtitles, summaries and RAG-ready chunks. 99 languages, no API key needed.

- **URL**: https://apify.com/insights_data/universal-media-transcriber.md
- **Developed by:** [Insights Data](https://apify.com/insights_data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $21.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🎧 What is Universal Media Transcriber?

Create podcast show notes, blog posts and subtitles from video and podcast links, and run media monitoring on what people say, with **Universal Media Transcriber**. It is made for content creators, marketers, podcast teams, researchers and AI developers who need timestamped transcripts, SRT/VTT subtitles and structured rows from video, audio and podcast links or from files they upload. Paste a YouTube, TikTok, Instagram, X, Facebook or SoundCloud link, a podcast RSS feed or an audio file into this video transcriber and click **Start**, no coding needed.

It first looks for a transcript the publisher already released, then for the platform's captions, and runs speech recognition only when neither exists, so files without captions still get speech to text. When a podcast host publishes its own podcast transcript, that file is used first.

- **Content repurposing:** go from video to blog post, quotes and social posts using the clean transcript of videos, Shorts, Reels, TikToks and episodes.
- **Podcast show notes:** transcribe a podcast back catalog from its feed and write show notes from the text.
- **Brand monitoring YouTube and podcast content:** find mentions of your brand, product or competitor with their timestamp and, where the site supports it, a link to that moment.
- **Transcripts for RAG:** feed timestamped chunks into your vector database or AI pipeline.
- **Video accessibility:** make SRT and VTT subtitles for any recording.
- **YouTube competitor analysis:** compare speaker talk time, speaking pace and opening hooks across your competitors' videos.

#### What can Universal Media Transcriber do?

- 🔗 **Transcribe links in bulk:** videos, Shorts, Reels, TikToks, posts, podcast episodes, RSS feeds, Apple Podcasts and Spotify shows, YouTube channels and playlists, SoundCloud tracks and sets, Google Drive / Dropbox / OneDrive share links and direct files, in any mix.
- 🔎 **Search and transcribe:** each search query adds the top YouTube or SoundCloud results.
- 🎯 **Filter feeds and channels:** published after / before, title contains / excludes, minimum and maximum duration, YouTube Shorts on or off.
- 👥 **Speaker labels and keyword monitoring:** Speaker 1, Speaker 2 (or your own names), plus every hit of your keywords with timestamp, context and (where the site supports it) a link.
- 💾 **Export files:** SRT, VTT, TXT, Markdown, Word (.docx) and JSON per transcript, plus one combined report.
- 🔌 **Run it your way:** use the Apify API, schedule runs, get a webhook per finished row, connect Make, Zapier or Google Sheets, and download data in JSON, CSV, Excel, XML or HTML.

***

### 📝 Video transcriber data: what can Universal Media Transcriber extract?

Every transcript row has the spoken text plus the media details the source shows. This is the data you can extract from each link:

| | |
|---|---|
| 📝 Transcript `text`, clean transcript `cleanText`, `wordCount` | ⏱️ Timestamped `segments` (with a link to each moment where the site supports it) and `paragraphs` |
| 💬 Subtitles `srt` and `vtt` | 👥 `speakers` and `speakerTalkTime` |
| 🔔 Keyword hits `mentions` and `mentionCounts` | 📚 RAG `chunks` with timestamps (and links where the site supports them) |
| ✨ Extractive `summary` (key sentences taken from the transcript, not AI-written) and up to 15 `keywords` | 📑 `chapters` published with the video or episode |
| 🔗 `url`, `inputUrl`, `platform`, `sourceType` | 👤 `title`, `uploader`, `publishedAt`, `durationSeconds`, `thumbnailUrl` |
| 🌍 `language` and `transcriptSource` (publisher, captions, auto-captions or speech-recognition) | 📈 `hook3s`, `hookStartSeconds`, `speechSeconds`, `speechRatio`, `wordsPerMinute` |
| 🚦 `status`, `charged`, `error`, `warnings` | 💾 `files` (links to your export files) |

> **Note:** Some fields are filled only in certain cases. `speakers` and `speakerTalkTime` appear when **Speaker labels** is on. `mentions` and `mentionCounts` appear when you set **Keywords to monitor**. `files` appears when you pick **Export files**. `chapters`, `thumbnailUrl`, `description`, `tags`, `engagement` and podcast fields like `episodeNumber`, `season` and `guid` are filled when the source publishes them. `languageProbability` and `model` are filled on rows made by speech recognition.

Transcripts come with timestamps: every segment has `start` and `end` seconds, and for YouTube, Twitch, Dailymotion, Vimeo, SoundCloud, Rumble and direct media file links you paste, it also has a link that opens the media at that moment. Episodes taken from a podcast feed have no segment links, though their mentions and chunks can have one. Turn on **Word-level timestamps** to get word level timestamps (start, end and confidence per word).

#### Which links can it transcribe?

| Source | What you get |
|---|---|
| YouTube video or Short | One YouTube transcript per link, from the creator's or the automatic YouTube captions when they exist |
| YouTube channel | The newest videos (and the newest Shorts if **Include YouTube Shorts** is on). Paste a channel link to use it as a YouTube channel transcript scraper |
| YouTube playlist | The newest items of the playlist |
| TikTok, Instagram, X, Facebook, Reddit, LinkedIn, Twitch, Vimeo, Dailymotion, Rumble, Loom, Bilibili, Threads and more | One transcript per post: a TikTok transcript, an Instagram reel transcript or a Facebook video transcript |
| SoundCloud track, set or artist | One SoundCloud transcript per track, or the newest tracks of a set or artist |
| Podcast RSS feed, Apple Podcasts show | The newest episodes |
| Spotify show or episode | Found through the show's public podcast feed |
| Google Drive, Dropbox, OneDrive | The shared file (it must be shared with "anyone with the link") |
| Direct audio or video file | mp3, mp4, m4a, wav, flac, aac, ogg, opus, webm, mov, mkv, avi and other common formats |

Other links are tried too. When a link can't be read, you get a free row that says why.

#### What data can't Universal Media Transcriber extract?

- Translations (the `translation` field is always `null`) and AI insights beyond the built-in summary and keywords (`ai` is always `null`).
- Live or upcoming streams (they come back as `bad_input` until they end).
- Private, members-only or age-restricted media, unless you add your own cookies.
- Spotify-only shows that have no public podcast feed.
- Comments and other non-audio data. For TikTok comments, try [TikTok Comments & Replies Scraper](https://apify.com/insights_data/tiktok-comments-replies-scraper).

***

### 🧭 Video transcriber tutorial: how to transcribe video to text

Universal Media Transcriber is designed for an easy start, even if you have never used Apify before.

1. [Create a free Apify account](https://console.apify.com/sign-up) using your email.
2. Open [Universal Media Transcriber](https://apify.com/insights_data/universal-media-transcriber).
3. Paste one or more links into **Media links** (or add a search, upload files, a file with links or a dataset).
4. For a podcast feed, channel, playlist or search, set **Items per feed / channel / search**. The default is **2**, so a feed gives only its 2 newest episodes unless you raise it (up to 500).
5. Click **Start** and wait for the run to finish. Rows appear in the **Output** tab while the run is going.
6. In the **Output** tab, click **Export** to download your data in JSON, CSV, Excel, XML or HTML.

That is all a video transcriber from link input needs: nothing to install, one link in and one transcript row out, and the video to text work runs in the Apify cloud.

***

### 💲 Video transcriber pricing: how much does Universal Media Transcriber cost?

Universal Media Transcriber uses **pay-per-event** pricing. You pay **$0.03 per delivered transcript ($30.00 per 1,000 results)** on the Free plan (lower on paid plans, see below), plus Apify platform usage for the run, plus a tiny start fee ($0.00005 per run at the default 1 GB of memory).

| Part | Price | When it is charged |
|---|---|---|
| 💲 Result | **$0.03 per transcript** on the Free plan (lower on paid plans) | Each delivered transcript row (`status` = `ok`) |
| ⚙️ Platform usage | Apify platform usage (compute) | Paid by you on top of the event prices; shown on the run page |
| 🚀 Actor start | $0.00005 per GB of run memory | Once per run |

| Apify plan | Price per transcript | Price per 1,000 transcripts |
|---|---|---|
| Free | $0.03 | $30.00 |
| Starter | $0.027 | $27.00 |
| Scale | $0.024 | $24.00 |
| Business and higher | $0.021 | $21.00 |

Paid Apify plans get a lower result price. The plan discount applies to that price only. The start fee is the same on every plan, and platform usage is billed at your Apify plan's own rates.

The price is **per transcript, not per minute**: a 19-second clip and a 2-hour episode cost the same ($0.03 each on the Free plan). The price is also the same whether the text comes from a publisher transcript, captions or speech recognition. Failed rows are free, and the copies in the section tables (Transcripts, Segments, Mentions and the others) are not charged again.

| Transcripts | Result charges (Free plan) | Plus |
|---|---|---|
| 10 | about $0.30 | platform usage + start fee |
| 100 | about $3 | platform usage + start fee |
| 1,000 | about $30 | platform usage + start fee |

#### How do I estimate platform usage?

Platform usage depends on your media, so we don't publish a fixed figure. Items with captions or a publisher transcript skip the audio download, so they use less platform usage than items that need speech recognition. Longer recordings that need speech recognition use more. To estimate your bill:

1. Run 1 or 2 items of the kind you plan to transcribe (for example, one podcast episode without captions).
2. Open the run page and read the platform usage cost.
3. Divide it by the number of items, then multiply by the number of items you plan to run, and add the result price for your plan ($0.03 per transcript on the Free plan).

See the [pricing tab](https://apify.com/insights_data/universal-media-transcriber/pricing) for the live event list.

#### Can I cap what a run costs?

Yes. Before you click **Start**, set **Maximum cost per run** in the run options below the input form (or with the API). The Actor checks this limit each time it charges a transcript result. When the limit is reached, the run stops cleanly with the message "Spend limit reached — N transcript(s) delivered." and keeps every row saved so far. Leave some room in your budget for platform usage.

#### Is Universal Media Transcriber free to try?

Yes. You can try it on the [Apify Free plan](https://apify.com/pricing), which gives you $5 of credit every month:

- Free-plan runs work the same as paid runs.
- The credit is used up by transcript results ($0.03 each on the Free plan) plus platform usage. Failed rows are free.
- Set **Maximum cost per run** when you start a run, and do a small test run with 1 or 2 links first.

***

### ⬇️ Input

No single field is required, but you need **at least one source**: **Media links** (`urls`), **Search queries** (`searchQueries`), **Upload audio or video files** (`audioFiles`), **File with links** (`inputFile`) or **Dataset** (`datasetId`). With none of them, the run ends with "Nothing to transcribe". All other settings have working defaults.

Here's an example that transcribes one 19-second YouTube video and watches for the word "elephants". In the input form, fill in two fields:

- 🔗 **Media links:** `https://www.youtube.com/watch?v=jNQXAC9IVRw`
- 🔔 **Keywords to monitor:** `elephants`

Leave everything else as it is. The same input as JSON (for the API):

```json
{
  "urls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"],
  "searchTerms": ["elephants"]
}
```

> ⚠️ **Keywords to monitor** (`searchTerms`) and **Search queries** (`searchQueries`) are different fields. **Keywords to monitor** finds words inside your transcripts. **Search queries** finds new videos or tracks on YouTube or SoundCloud to transcribe, and each transcript it delivers is charged.

See the [input tab](https://apify.com/insights_data/universal-media-transcriber/input-schema) for a full description of every field.

#### Settings most people change

| Setting (field) | What it does | Default |
|---|---|---|
| 🔗 **Media links** (`urls`) | Links, one per line: videos, posts, episodes, feeds, shows, channels, playlists, share links, files | empty |
| 🔎 **Search queries** (`searchQueries`) + **Search on** (`searchPlatform`) | Each query adds the top results from `youtube` or `soundcloud` | `youtube` |
| 📤 **Upload audio or video files** (`audioFiles`) | Each uploaded file becomes one transcript | empty |
| 📊 **Items per feed / channel / search** (`maxItemsPerSource`) | Newest items taken per feed, show, channel, playlist, SoundCloud set and search (1–500) | 2 |
| 🪜 **Transcript source** (`transcriptStrategy`) | Auto (best available), Captions / published transcripts only, or Always speech recognition | `auto` |
| 🌍 **Spoken language** (`language`) | A language code like `en`, `es`, `de` or `pt-BR`; empty = auto-detect. Also picks the caption track in that language | empty |
| 👥 **Speaker labels** (`speakerLabels`) | Adds Speaker 1, Speaker 2 to segments, paragraphs and subtitles | off |
| 🔔 **Keywords to monitor** (`searchTerms`) | Words or brands to find in every transcript | empty |
| 💾 **Export files** (`exportFormats`) | `srt`, `vtt`, `txt`, `md`, `docx`, `json` files per transcript | none |

#### Advanced settings

You can skip this table: the defaults work for most runs. It is here for when you need finer control.

| Setting (field) | What it does | Default |
|---|---|---|
| 📄 **File with links** (`inputFile`) | .txt (one link per line), .csv (any column with links) or .json (rows of another scraper's output) | empty |
| 📥 **Dataset** (`datasetId`) | Chain another run: one media link per row, up to 5,000 rows | empty |
| 🪄 **Accept auto-generated captions** (`acceptAutoCaptions`) · **Use the publisher's own transcript** (`usePublisherTranscripts`) | Use automatic captions; use a transcript the podcast host published | on · on |
| 🧠 **Speech model size** (`model`) | Auto, Tiny, Base, Small, Medium and larger sizes | `auto` |
| 📖 **Vocabulary** (`vocabulary`) | Comma-separated names, brands and jargon to spell right | empty |
| 🔤 **Word-level timestamps** (`wordTimestamps`) · **Skip silence and music** (`vadFilter`) | Start, end and confidence per word; skip silent and music-only parts | off · on |
| ⏩ **Start at** (`startAt`) · **End at** (`endAt`) · **Max minutes per item** (`maxMinutesPerItem`) | Transcribe only part of a recording; cap per item (1–600 minutes) | empty · empty · 120 |
| 🔢 **Number of speakers** (`numSpeakers`) · **Speaker names** (`speakerNames`) | 0 = detect automatically (up to 6), or set up to 10; names replace Speaker 1, Speaker 2 | 0 · empty |
| 📅 **Published after** (`publishedAfter`) · **Published before** (`publishedBefore`) | Date filters for feeds, channels and searches | empty |
| 🎯 **Title contains** (`titleContains`) · **Title excludes** (`titleExcludes`) | Words to require or skip; separate alternatives with `\|` | empty |
| ⏳ **Minimum duration** (`minDurationSeconds`) · **Maximum duration** (`maxDurationSeconds`) · **Include YouTube Shorts** (`includeShorts`) | Duration filters in seconds; also take the newest Shorts of a channel | 0 · 0 · off |
| 🧹 **Clean transcript** (`cleanTranscript`) | Adds `cleanText` without fillers (um, uh), \[Music]-type tags and stutters | on |
| 📚 **RAG chunk size** (`ragChunkWords`) · **Chunk overlap** (`ragChunkOverlapWords`) | Words per chunk and overlap; 0 = no chunks | 300 · 40 |
| 🔠 `subtitleMaxCharsPerLine` · `subtitleMaxLines` · `subtitleMaxSeconds` | Subtitle layout: characters per line, lines per cue, seconds per cue | 42 · 2 · 6 |
| 📼 `includeSubtitlesInRecord` · `includeSegments` · `includeFailedItems` | What each row contains | on · on · on |
| 📑 **Combined report** (`combinedReport`) | One Markdown + Word file with all transcripts and a run summary | off |
| 👀 **Watchlist ID** (`watchlistId`) · **Only new items** (`newItemsOnly`) · **Reuse saved transcripts** (`cacheTranscripts`) | Memory between runs; skip items earlier runs already did; reuse saved transcripts with the same settings (this saves time and platform usage; the result is still charged) | empty · off · on |
| 📬 **Webhook URL** (`webhookUrl`) | Every finished row (without segments, subtitles and chunks) is sent as JSON to your URL | empty |
| ⏰ **Stop starting new items after** (`maxRunMinutes`) | Minutes; items not started by then become free `deadline` rows | 0 (off) |
| 🍪 **Cookies** (`cookies`) | A cookies.txt export for age-restricted or members-only media. Stored encrypted | empty |
| ⚡ **Parallel downloads** (`maxConcurrency`) · **Retries** (`maxRetries`) | 1–16 parallel downloads (speech recognition runs one item at a time); 0–10 retries | 3 · 2 |
| 🆙 **Refresh site support before the run** | Use it if links from one site suddenly fail. Adds a short wait at the start | off |
| 🌐 **Proxy** (`proxyConfiguration`) | No proxy by default. If a site blocks the requests, the run switches to Apify Proxy automatically. You can also pick a proxy yourself | no proxy |

#### Start at and End at

> ⚠️ The Console shows a date picker for these fields. Ignore it and type minutes or hours yourself (or send them as JSON).

These fields mark a point **inside the recording**, not a calendar date. Type a time from the start of the recording. For example, to transcribe minutes 10 to 40, set **Start at** to `10 minutes` and **End at** to `40 minutes`.

- ✅ Good: `10 minutes`, `1 hour`, `90 seconds`, `00:10:00`, `600`
- ❌ Bad: `2026-09-01`

#### Items per feed / channel / search

With the default of 2, a feed, channel, playlist or search gives only its **2 newest matching items**. Raise it to get more.

- ✅ Good: `10` to transcribe the last 10 episodes of a podcast
- ❌ Bad: keeping `2` and expecting a whole back catalog

> ⚠️ Every delivered transcript is charged, so set this number with your budget in mind.

#### Transcript source

**Auto** uses the publisher transcript, then captions, then speech recognition. **Captions / published transcripts only** never runs speech recognition: items without captions come back as free `no_captions` rows. **Always speech recognition** transcribes the audio itself and is slower.

- ✅ Good: `auto` for a mix of links
- ❌ Bad: `captions` for direct audio files (files never have captions)

#### Speaker labels and word-level timestamps

Both make the run download the audio, even when captions exist, so runs take longer. Word-level timestamps also use speech recognition for every item. Speaker detection finds **up to 6 speakers** on its own (it can also return a single speaker), or uses the number you set in **Number of speakers** (up to 10). Very short or nearly silent audio gets no speaker labels.

- ✅ Good: turn them on only when you need them
- ❌ Bad: turning them on for a large caption-only job

#### Speech model size

Bigger models need more run memory: Tiny and Base 1 GB, Small 2 GB, Medium and the next larger sizes 4 GB, the largest 8 GB. If the run has less memory, the biggest model that fits is used and the log says so. **Auto** at the default 1 GB uses Base.

- ✅ Good: `auto` at 1 GB
- ❌ Bad: Medium at 1 GB (it falls back to Base)

This only matters for items that need speech recognition. Captions and publisher transcripts are used as they were published. The model sizes trade speed for accuracy: Tiny is the fastest, Base is fast, and Small and bigger are more accurate but slower and need more memory. More memory also gives the run more CPU, but it raises platform usage and the start fee. We don't publish accuracy or speed figures, because they depend on the audio. For a podcast without captions, the simplest check is to transcribe one episode at the default 1 GB, read the text, and only raise the memory and model size if the spelling isn't good enough. Adding names and jargon to **Vocabulary** also helps.

The spoken language is detected automatically, or you can set it in **Spoken language** (for example `en`, `es`, `de` or `pt-BR`). Set it when you know the language; it also picks the caption track in that language. Test a short sample first if your audio is not in English or mixes languages.

#### Watchlist ID and Only new items

**Only new items** needs a **Watchlist ID** (letters, digits, `_` and `-`, up to 64 characters). Without one, it is ignored with a warning. The watchlist is kept in a storage in your Apify account between runs.

- ✅ Good: `"watchlistId": "my-podcasts", "newItemsOnly": true`
- ❌ Bad: `"newItemsOnly": true` alone

***

### ⬆️ Output

Results are saved to a dataset while the run is going. Open the **Output** tab to see them as a table or JSON, pick a view, and click **Export** to download them in JSON, CSV, Excel, XML or HTML. You can also choose which fields to export.

Besides **All results**, each section has its own table: **Transcripts**, **Segments**, **Insights**, **Mentions**, **RAG chunks**, **Subtitles** and **Failed items**. Export files are in the run's key-value store (**Export files**), and the combined report (`_all_transcripts.md`, `_all_transcripts.docx`, `_run_summary.json`) is under **Combined report**.

#### JSON example

Results for the input example above (long values shortened with "…"; the full row also has `paragraphs`, `cleanText`, `vtt` and more fields):

```json
{
  "url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "inputUrl": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "sourceType": "video",
  "platform": "youtube",
  "title": "Me at the zoo",
  "uploader": "jawed",
  "publishedAt": "2005-04-24T03:31:52.000Z",
  "durationSeconds": 19,
  "language": "en",
  "transcriptSource": "captions",
  "text": "All right, so here we are, in front of the elephants the cool thing about these guys is that they have really... really really long trunks and that's cool (baaaaaaaaaaahhh!!) and that's pretty much all there is to say",
  "wordCount": 39,
  "hook3s": "All right, so here we are, in front of the elephants",
  "hookStartSeconds": 1.2,
  "wordsPerMinute": 148.8,
  "summary": "All right, so here we are, in front of the elephants the cool thing about these guys…",
  "keywords": ["front", "elephants", "long", "trunks", "baaaaaaaaaaahhh"],
  "aiSource": "offline-extractive",
  "mentions": [
    {
      "term": "elephants",
      "start": 1.2,
      "startTime": "00:01",
      "context": "All right, so here we are, in front of the elephants the cool thing about these guys…",
      "link": "https://www.youtube.com/watch?v=jNQXAC9IVRw&t=1s"
    }
  ],
  "mentionCounts": { "elephants": 1 },
  "chunks": [
    {
      "index": 0,
      "start": 1.2,
      "end": 18.881,
      "startTime": "00:01",
      "text": "All right, so here we are, in front of the elephants…",
      "wordCount": 39,
      "link": "https://www.youtube.com/watch?v=jNQXAC9IVRw&t=1s"
    }
  ],
  "segments": [
    {
      "start": 1.2,
      "end": 3.36,
      "text": "All right, so here we are, in front of the elephants",
      "link": "https://www.youtube.com/watch?v=jNQXAC9IVRw&t=1s"
    }
  ],
  "srt": "1\n00:00:01,200 --> 00:00:03,360\nAll right, so here we are, in front of the\nelephants\n…",
  "cached": false,
  "status": "ok",
  "charged": true,
  "billableEvent": "caption-transcript",
  "billedSeconds": 0,
  "billedMinutes": 0,
  "error": null
}
```

There are no speaker fields here because **Speaker labels** was off. The `summary` is extractive: it picks the most informative sentences of the transcript (here, the clip is so short that the summary is the whole transcript). It is not written by AI.

`billableEvent`, `billedSeconds` and `billedMinutes` are labels for your information only: they say where the text came from and how many seconds speech recognition handled (0 here, because the text came from captions). Every delivered transcript costs the same result price for your plan ($0.03 on the Free plan), whatever these fields say.

#### Failed rows

When an item can't be transcribed, its row has `charged: false`, an `error` text and one of these `status` values. These rows are free. `billedMinutes` is only on successful rows.

| `status` | Meaning |
|---|---|
| `no_speech` | Silent or music-only media |
| `no_captions` | Captions-only mode and no publisher transcript or captions |
| `source_unavailable` | The media could not be fetched (blocked, private, removed, unsupported link, Spotify-only show, post without media) |
| `bad_input` | The input could not be found or read, or it is a live or upcoming stream |
| `transcription_failed` | Speech recognition failed |
| `deadline` | **Stop starting new items after** was reached before this item started |

#### Export transcript to Word, SRT and more

Pick formats in **Export files** to get a `transcript-…` file per item in SRT, VTT, TXT, Markdown, Word (.docx) or JSON, with links in the row's `files` field. So you can go from video to SRT, or export transcript to Word, in one run. Turn on **Combined report** for a single Markdown and Word document with every transcript.

***

### 💡 Tips and advanced usage

#### How long does a run take?

It depends on your media, so we don't publish speed figures. Items with captions or a publisher transcript finish quicker, because the audio is not downloaded. Items that need speech recognition take longer, longer recordings take longer, and speech recognition handles one item at a time. More memory gives the run more CPU. To plan a big job, time a test run with 1 or 2 typical items. Rows appear in the **Output** tab as soon as each one is ready.

#### How many transcripts can you get in one run?

There is no fixed cap beyond your input: up to 500 items per feed, channel, playlist or search, up to 5,000 rows from a chained dataset, and any number of links. How many you actually get depends on whether the media is public, the filters you set and **Items per feed / channel / search**. The best way to know for your list is a quick test run.

#### How to get faster or cheaper results

- Keep **Transcript source** on **Auto**: items with captions or a publisher transcript skip the audio download.
- Leave **Speaker labels** and **Word-level timestamps** off unless you need them.
- Use the filters (dates, title words, duration) so only the items you want are transcribed and charged.
- For a long video transcriber job, use **Start at**, **End at** or **Max minutes per item** to transcribe only the part you need. The cap also applies to captions and publisher transcripts.
- More run memory gives the run more CPU and allows bigger speech models. It also raises the start fee and platform usage, so test first.

#### Run it on a schedule: podcast monitoring

For weekly media monitoring of the podcasts and YouTube channels in your niche:

1. **Save your input as a task.** Paste the feeds and channel links into **Media links**, set **Items per feed / channel / search** to `5`, add your brand and competitor names to **Keywords to monitor**, set a **Watchlist ID** such as `brand-watch` and turn on **Only new items**. Then save the input as a new task.
2. **Add a schedule.** Open **Schedules**, create a weekly (or daily) schedule and add your task to it.
3. **Compare runs.** Thanks to the watchlist, each run transcribes only episodes and uploads that earlier runs haven't done, and items already on the watchlist are not charged again. When nothing is new, the run says so and ends. Open the **Mentions** table of each run, or compare the `mentionCounts` column across runs, to see how often each name came up that week.

Add a **Webhook URL** to get every new transcript row sent to your own tool as soon as it is ready.

#### Known issues

- YouTube sometimes asks for sign-in. When a site blocks the requests, the run switches to Apify Proxy automatically. For age-restricted or members-only media, paste a cookies.txt export into **Cookies**.
- Spotify-only shows without a public podcast feed can't be transcribed. Apple Podcasts subscriber-only episodes are not in the public listing.
- If links from one site suddenly fail, turn on **Refresh site support before the run** and tell us in the Issues tab.

***

### 🔌 Integrations and API

#### Can I use Universal Media Transcriber as a video transcription API?

Yes. Through the [Apify API](https://docs.apify.com/api/v2) you can start runs, schedule them and fetch results, so your own code can call it like an audio transcription API: send links or files, get transcript rows back. Use the `apify-client` [NPM package](https://apify.com/insights_data/universal-media-transcriber/api/javascript) for Node.js or the `apify-client` [PyPI package](https://apify.com/insights_data/universal-media-transcriber/api/python) for Python. See the [API tab](https://apify.com/insights_data/universal-media-transcriber/api) for ready-to-use code.

#### How to transcribe YouTube video to text with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("insights_data/universal-media-transcriber").call(run_input={
    "urls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"],
    "searchTerms": ["elephants"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["status"], item.get("text"))
```

#### Can I integrate Universal Media Transcriber with other apps?

Yes. Connect it with almost any cloud service through [Apify integrations](https://apify.com/integrations): **Make, Zapier, Slack, Google Sheets, Google Drive, Airbyte, GitHub, LangChain** and more. Use [Apify webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions when a run finishes, or the Actor's own **Webhook URL** to receive each finished row. Three workflows that fit the schedule above:

- **Google Sheets mention log:** add the Google Sheets integration to your scheduled task. After each run, the new rows go to a sheet with `title`, `url`, `publishedAt` and `mentionCounts`, so you can see which episodes named your brand.
- **Slack alert per new episode:** put a Make, Zapier or n8n webhook address into **Webhook URL**. Each finished row arrives as JSON, and the scenario posts the title, link and `mentionCounts` to a Slack channel. Failed rows arrive too, with `status` and `error`, so filter on `status` = `ok` in the scenario.
- **RAG pipeline:** when a run finishes, fetch its rows through the API (or the LangChain integration) and load the `chunks` with their timestamps and links into your vector database.

#### Can I use Universal Media Transcriber with AI agents (MCP)?

Yes. Connect it to Claude and other AI assistants through the Apify MCP server. Open the [MCP tab](https://apify.com/insights_data/universal-media-transcriber/api/mcp) for setup steps. The RAG chunks are AI-ready: each one has its text, timestamps, the source title and, where the site supports it, a link to that moment.

***

### 🧰 Other video and social media scrapers

These Actors from the same author work well next to Universal Media Transcriber when you also need post details, engagement or comments:

- 🎵 [TikTok Profile Scraper](https://apify.com/insights_data/tiktok-profile-scraper): videos, reposts, stories and playlists of a TikTok profile with views, likes, comments, shares, music, hashtags and author stats, plus optional transcripts
- 🏷️ [TikTok Hashtag Scraper](https://apify.com/insights_data/tiktok-hashtag-scraper): videos of any hashtag in bulk with captions, views, likes, comments, shares, saves and author stats, plus optional transcripts
- 🎞️ [Facebook Post and Reel Scraper](https://apify.com/insights_data/facebook-post-and-reel-scraper): posts, reels and videos from links, pages, profiles and groups with views, reactions, comments, shares, caption, video links and transcript
- 🗨️ [TikTok Comments & Replies Scraper](https://apify.com/insights_data/tiktok-comments-replies-scraper): comments and replies from TikTok videos, photo posts and whole profiles
- 🎬 [Bilibili Scraper — Videos, Comments, Danmaku & Creator Uploads](https://apify.com/insights_data/bilibili-scraper-videos-comments-danmaku-creator-uploads): Bilibili videos, comments with replies, danmaku (bullet comments) and creator uploads
- 🗞️ [Google News Scraper](https://apify.com/insights_data/google-news-scraper): headlines, publisher, publish date and the real article URL by search term, topic or link, for news next to your media monitoring

***

### ❓ FAQ

#### How does Universal Media Transcriber work?

It works like you opening each link and typing out what is said, only faster. It reads all your sources and removes duplicates, expands feeds, channels, playlists and searches into their newest items, and applies your filters. For each item it uses a publisher transcript or the platform's captions when one exists, and speech recognition only when there is none. Then it builds segments, subtitles, chunks, mentions, the summary and keywords, and saves the row right away.

#### Is it a transcript scraper or a transcript generator?

Both. When captions or a published transcript exist, it collects them like a transcript scraper; when they don't, it makes the text from the audio like a transcript generator. The `transcriptSource` field tells you which one happened. On YouTube links with captions it behaves like a YouTube transcript extractor; on audio files and podcasts without a published transcript, it is a media transcriber that works from the audio.

#### How to transcribe a podcast with Universal Media Transcriber?

Paste the podcast's RSS feed, Apple Podcasts link or Spotify show link into **Media links** and set **Items per feed / channel / search** to the number of episodes you want. That is all you need to transcribe podcast episodes in bulk. To transcribe podcast from RSS feed on a schedule, add a **Watchlist ID** and turn on **Only new items**.

#### Can I get a Spotify podcast transcript?

Yes, when the show is also published as a public podcast feed. The episode is found in that feed and transcribed. Spotify-only shows without a public feed come back as a free `source_unavailable` row.

#### Can I transcribe Google Drive video and audio files?

Yes. To transcribe Google Drive video files, share them with "anyone with the link" and paste the share link. Dropbox and OneDrive links work the same way. To transcribe audio file uploads instead, use **Upload audio or video files**: each file becomes one transcript. As an audio to text transcriber it handles mp3, m4a, wav, flac and other common formats.

#### Can I transcribe a whole YouTube playlist or channel?

Yes. To transcribe YouTube playlist items or a channel's uploads, paste the playlist or channel link and raise **Items per feed / channel / search** (up to 500). Turn on **Include YouTube Shorts** to get a YouTube Shorts transcript for the newest Shorts of a channel as well.

#### Does it use YouTube captions or speech to text?

It uses YouTube captions when the video has them (creator captions or, if **Accept auto-generated captions** is on, automatic ones). Without captions it switches to speech recognition. Choose **Always speech recognition** in **Transcript source** if you want the audio transcribed every time.

#### How is captions mode different from speech recognition?

The three **Transcript source** options differ in where the text comes from. The price per delivered transcript is the same in every mode ($0.03 on the Free plan, lower on paid plans).

| | Auto (best available) | Captions / published transcripts only | Always speech recognition |
|---|---|---|---|
| Uses a publisher transcript or captions | ✅ first choice | ✅ only source | Only the site's captions, as a fallback when the audio can't be fetched |
| Transcribes the audio itself | ✅ when nothing else exists | ❌ | ✅ every item |
| Items without captions | Transcribed from the audio | Free `no_captions` row | Transcribed from the audio |
| Downloads the audio | Only when needed | ❌ | ✅ (slower) |

#### Does it support speaker diarization?

Yes. Turn on **Speaker labels** for speaker diarization: segments, paragraphs and subtitles get Speaker 1, Speaker 2 (or the names you set in **Speaker names**), and each row gets talk time per speaker. It detects up to 6 speakers on its own, or uses your **Number of speakers** (up to 10). Very short or nearly silent audio gets no labels.

#### Is it legal to transcribe YouTube videos?

Transcribing publicly available videos for research, accessibility or personal analysis is generally fine, but republishing someone else's words can be limited by copyright. Respect personal data rules such as GDPR, the platforms' terms (for example the [YouTube Terms of Service](https://www.youtube.com/t/terms)) and the creators' rights. This is not legal advice; ask a lawyer for your specific case.

#### Why am I getting fewer results than expected?

- **Items per feed / channel / search** defaults to 2. Raise it.
- Filters (dates, title words, duration) remove items before they are transcribed, and those items get no row.
- Check the **Failed items** table: the `status` and `error` columns say why an item has no transcript.
- If you set **Maximum cost per run** or **Stop starting new items after**, the run may have stopped early on purpose.

***

### 📧 Support and feedback

Found a bug or have a feature request? Please create an issue on the [Issues tab](https://apify.com/insights_data/universal-media-transcriber/issues/open).

Need a **custom solution** or a different transcript format? Contact us at hello.insights.data@gmail.com.

Built and maintained by [Insights Data](https://apify.com/insights_data).

# Actor input Schema

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

Links to transcribe, one per line: videos, Shorts, Reels, TikToks, X / Facebook / Instagram posts, podcast episodes, podcast RSS feeds, Apple Podcasts and Spotify shows or episodes, YouTube channels and playlists, SoundCloud tracks and sets, Google Drive / Dropbox / OneDrive share links and direct audio or video files (mp3, mp4, wav, m4a, ...). Feeds, shows, channels and playlists give their newest items.

## `searchQueries` (type: `array`):

Search terms; each one adds the top results (as many as 'Items per feed / channel / search') from the platform chosen below.

## `searchPlatform` (type: `string`):

Where the search queries run.

## `audioFiles` (type: `array`):

Audio or video files from your computer (mp3, mp4, wav, m4a, mov, ...). Each file becomes one transcript.

## `inputFile` (type: `string`):

A .txt (one link per line), .csv (any column with links) or .json file (rows of another scraper's output) with media links.

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

Pick a dataset from another run (for example a TikTok, YouTube or podcast scraper), or give its ID through the API. One media link is taken from each row (up to 5,000 rows).

## `transcriptStrategy` (type: `string`):

Auto delivers the best available transcript for each item: a transcript the publisher already published, the platform's captions, or speech recognition when there is neither. 'Captions only' never runs speech recognition (items without captions come back as free no_captions rows). 'Always speech recognition' transcribes the audio itself.

## `acceptAutoCaptions` (type: `boolean`):

Count the platform's auto-generated captions as captions. Turn off to use only creator-uploaded captions (other items go to speech recognition in Auto mode).

## `usePublisherTranscripts` (type: `boolean`):

When a podcast episode comes with a transcript published by its host, deliver that one (usually edited and with speaker names).

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

Language code of the recording (en, es, de, pt-BR, ...). Leave empty to detect it automatically. Also picks the caption track in that language when one exists.

## `model` (type: `string`):

Size of the speech-recognition model. Auto picks a fast model that fits the run's memory. Bigger models are more accurate and slower. Memory needed: tiny and base 1 GB, small 2 GB, medium, distil-large-v3 and large-v3-turbo 4 GB, large-v3 8 GB; when the run has less, the biggest model that fits is used.

## `vocabulary` (type: `string`):

Names, brands and jargon the recording contains, comma-separated, so speech recognition spells them right (for example: OpenAI, Anthropic, Claude, LangChain).

## `wordTimestamps` (type: `boolean`):

Add start/end/confidence for every word inside each segment (karaoke captions, precise cuts). Uses speech recognition for every item.

## `vadFilter` (type: `boolean`):

Skip silent and music-only parts: faster and no invented lines over silence.

## `startAt` (type: `string`):

Transcribe only from this point of the recording, counted from its start. Use a relative value; the picker lists days and weeks, so for minutes and hours type them in JSON input: 90 seconds, 10 minutes, 1 hour, 00:10:00 or 600. A calendar date cannot mark a point in a recording. Empty = from the start.

## `endAt` (type: `string`):

Transcribe only up to this point of the recording, counted from its start. Use a relative value; the picker lists days and weeks, so for minutes and hours type them in JSON input: 20 minutes, 1 hour, 00:20:00 or 1200. A calendar date cannot mark a point in a recording. Empty = to the end (or the max minutes below).

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

Longer recordings are transcribed up to this many minutes. Long recordings are processed piece by piece; more run memory gives more CPU and faster speech recognition.

## `speakerLabels` (type: `boolean`):

Mark segments, paragraphs and subtitles with Speaker 1, Speaker 2, ... (who speaks when). The audio is downloaded for this, also when captions exist, so runs take longer.

## `numSpeakers` (type: `integer`):

How many people speak, when you know it (more accurate labels). 0 = detect automatically.

## `speakerNames` (type: `array`):

Names for Speaker 1, Speaker 2, ... in order of who speaks first (for example: Host, Guest).

## `maxItemsPerSource` (type: `integer`):

Newest items taken from each podcast feed, Apple Podcasts / Spotify show, YouTube channel or playlist, SoundCloud artist or set, and search query (after the filters below).

## `publishedAfter` (type: `string`):

Only items published after this date. Pick a date (2026-09-01) or a relative window (30 days, 2 weeks, 6 months).

## `publishedBefore` (type: `string`):

Only items published before this date. Pick a date (2026-09-30) or a relative time (7 days = published more than 7 days ago).

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

Only items whose title contains one of these words, case-insensitive; separate alternatives with | (interview|Q\&A).

## `titleExcludes` (type: `string`):

Skip items whose title contains one of these words; separate alternatives with | (trailer|teaser).

## `minDurationSeconds` (type: `integer`):

Skip items shorter than this (when the source reports a duration). 0 = no minimum.

## `maxDurationSeconds` (type: `integer`):

Skip items longer than this (when the source reports a duration). 0 = no maximum.

## `includeShorts` (type: `boolean`):

For a YouTube channel link, also take the newest Shorts (in addition to the newest videos).

## `searchTerms` (type: `array`):

Brands, names or keywords to find in every transcript. Each hit is listed with its timestamp, the words around it and a link that opens the media at that moment.

## `cleanTranscript` (type: `boolean`):

Add cleanText: the transcript without um/uh, \[Music] tags and stutters.

## `ragChunkWords` (type: `integer`):

Split each transcript into chunks of about this many words, with timestamps and links (ready for a vector database). 0 = no chunks.

## `ragChunkOverlapWords` (type: `integer`):

Words repeated between neighbouring chunks so no idea is cut in half.

## `subtitleMaxCharsPerLine` (type: `integer`):

Maximum characters per subtitle line (42 is the broadcast standard).

## `subtitleMaxLines` (type: `integer`):

Maximum lines shown at once.

## `subtitleMaxSeconds` (type: `number`):

Longest time one subtitle stays on screen.

## `includeSubtitlesInRecord` (type: `boolean`):

Put the SRT and VTT subtitle text on every row. They are always in the Subtitles table too.

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

Put the timestamped segments and readable paragraphs on every row (off = smaller rows). Segments are always in the Segments table too.

## `includeFailedItems` (type: `boolean`):

Add a free row for every item that could not be transcribed, with the reason (no_speech, source_unavailable, bad_input, ...).

## `exportFormats` (type: `array`):

Also save each transcript as files in the run's key-value store; the row's files column links to them.

## `combinedReport` (type: `boolean`):

One Markdown and one Word file with every transcript of the run, plus a run summary JSON, in the key-value store.

## `watchlistId` (type: `string`):

Name for a memory of transcribed items that is kept between runs (letters, numbers, - and \_). Use it with a schedule to follow a feed or channel.

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

With a Watchlist ID: skip items transcribed by earlier runs, so a scheduled run delivers (and bills) only new uploads.

## `cacheTranscripts` (type: `boolean`):

Keep each transcript and reuse it when the same item is run again with the same transcript settings, so re-running with new keywords, chunks or export files is fast.

## `webhookUrl` (type: `string`):

Every finished row (without segments, subtitles and chunks) is also POSTed here as JSON (Zapier, Make, n8n, your server).

## `maxRunMinutes` (type: `number`):

Items not started after this many minutes come back as free deadline rows. 0 = no limit.

## `cookies` (type: `string`):

Optional Netscape cookies.txt content for age-restricted or members-only media, or when YouTube asks to sign in. Stored encrypted.

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

How many items are fetched at the same time. Speech recognition runs one item at a time.

## `maxRetries` (type: `integer`):

Retries for a failed request.

## `autoUpdateYtDlp` (type: `boolean`):

Update the built-in site support to its newest release before transcribing (adds about 10-20 seconds). Turn on if links from a site suddenly fail.

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

By default no proxy is used. If a site blocks the requests, the run switches to a datacenter proxy and then to a residential proxy (with up to 3 retries) and keeps it for the rest of the run. Pick a proxy here to start with it.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "https://feeds.buzzsprout.com/1538779.rss",
    "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
  ],
  "searchPlatform": "youtube",
  "transcriptStrategy": "auto",
  "acceptAutoCaptions": true,
  "usePublisherTranscripts": true,
  "model": "auto",
  "wordTimestamps": false,
  "vadFilter": true,
  "maxMinutesPerItem": 120,
  "speakerLabels": false,
  "numSpeakers": 0,
  "maxItemsPerSource": 2,
  "minDurationSeconds": 0,
  "maxDurationSeconds": 0,
  "includeShorts": false,
  "cleanTranscript": true,
  "ragChunkWords": 300,
  "ragChunkOverlapWords": 40,
  "subtitleMaxCharsPerLine": 42,
  "subtitleMaxLines": 2,
  "subtitleMaxSeconds": 6,
  "includeSubtitlesInRecord": true,
  "includeSegments": true,
  "includeFailedItems": true,
  "exportFormats": [],
  "combinedReport": false,
  "newItemsOnly": false,
  "cacheTranscripts": true,
  "maxRunMinutes": 0,
  "maxConcurrency": 3,
  "maxRetries": 2,
  "autoUpdateYtDlp": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `transcripts` (type: `string`):

One row per transcript: title, platform, language, source, words, speakers, summary and the full text.

## `segments` (type: `string`):

One row per timestamped segment with speaker and a link to that moment.

## `insights` (type: `string`):

Summary, keywords, chapters and the opening hook per transcript.

## `mentions` (type: `string`):

One row per hit of a monitored keyword, with timestamp, context and link.

## `chunks` (type: `string`):

Transcript chunks of about N words with timestamps and links, ready for a vector database.

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

SRT and VTT subtitles per transcript and export file links.

## `failed` (type: `string`):

Items that could not be transcribed, with the reason. Not charged.

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

Every row of the run with every field.

## `files` (type: `string`):

SRT, VTT, TXT, Markdown, Word and JSON files per transcript (when Export files is set).

## `report` (type: `string`):

All transcripts in one Markdown and one Word file, plus the run summary (when Combined report is on).

# 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://feeds.buzzsprout.com/1538779.rss",
        "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insights_data/universal-media-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 = {
    "urls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://feeds.buzzsprout.com/1538779.rss",
        "https://github.com/openai/whisper/raw/main/tests/jfk.flac",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("insights_data/universal-media-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 '{
  "urls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "https://feeds.buzzsprout.com/1538779.rss",
    "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call insights_data/universal-media-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insights_data/universal-media-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/8m6JknTVGanz2kDOd/builds/hfFfFmer6bGPF43mo/openapi.json