Audio & Video Transcription + Speaker Diarization + SRT — $0.008/min, No API Key Needed

Turn any audio or video URL into accurate transcripts, speaker-labeled segments, and ready-to-use SRT / VTT / TXT files — with zero setup.

Paste YouTube, TikTok, or Instagram links, podcast episodes, or direct media files. Press Start. Get transcripts. That's it.

No OpenAI key. No Deepgram account. No GPU. No monthly subscription. You pay a flat $0.008 per audio minute through Apify — everything else is included.

---

Why this Actor?

Most transcription Actors on the store are thin wrappers: they ask you to bring your own OpenAI / AssemblyAI / Deepgram API key, so you end up managing a second account, a second bill, and a second rate limit. This Actor runs on a managed transcription backend — the key is built in.

	This Actor	Typical alternatives
Requires your own API key	No — works out of the box	Yes (OpenAI, Deepgram, ...)
Price per audio minute	$0.008 flat	$0.015+ plus your API bill
Speaker diarization	Included, on by default	Often missing or paid extra
Output formats	JSON + SRT + VTT + TXT	Usually JSON only
YouTube / TikTok / Instagram	Built-in media resolver	Direct file URLs only
Subtitle quality	Short, speaker-aware cues	Raw dumps, overlong lines
Billing	Pay per event — only minutes actually transcribed	Per run / per compute unit

A 60-minute podcast costs $0.48. A 10-minute YouTube video costs $0.08. Failed sources are never charged.

What it does

1. Resolves media from almost any URL using a built-in downloader — YouTube, TikTok, Instagram, X/Twitter, Vimeo, SoundCloud, podcast feeds, and 1000+ other sites, plus direct links to .mp3, .mp4, .wav, .ogg, .opus, .m4a, .webm, .flac files (including files stored in Apify key-value stores). Only the audio track is downloaded, so even long videos process fast.
2. Transcribes the audio with a state-of-the-art Whisper-class speech model — the spoken language is detected automatically and returned with every transcript, or you can force a specific language for extra accuracy on noisy audio.
3. Identifies speakers (diarization): speaker attribution is computed at the word level, then grouped into clean segments labeled SPEAKER_00, SPEAKER_01, ... so interviews, podcasts, and meetings stay readable.
4. Exports everything: full text, timed speaker segments (JSON), and subtitle files (SRT + VTT) — pushed to the dataset and saved as downloadable files in the key-value store. Cues are kept short and readable: a new cue starts on speaker change, on pauses, or before a line gets too long. No wall-of-text captions.

Input

{
    "sources": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://www.tiktok.com/@user/video/7300000000000000000",
        "https://example.com/podcast/episode-42.mp3"
    ],
    "language": "auto",
    "diarization": true,
    "output_formats": ["json", "srt", "vtt", "txt"],
    "maxDurationMinutes": 240
}

Field	Type	Default	Description
sources	array	(required)	URLs: YouTube/TikTok/Instagram/podcast pages or direct media file links
language	string	"auto"	Spoken language (auto, en, pt, es, fr, de, ja, ...)
diarization	boolean	true	Label each segment with the detected speaker
output_formats	array	["json", "srt", "vtt", "txt"]	Which outputs to generate
maxDurationMinutes	integer	240	Per-file duration cap; longer sources are skipped (and never charged)

Output

One dataset item per source:

{
    "url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "title": "Me at the zoo",
    "language": "en",
    "duration_s": 19,
    "text": "All right, so here we are in front of the elephants. The cool thing about these guys is that they have really long trunks.",
    "segments": [
        { "start": 0.0, "end": 2.1, "speaker": "SPEAKER_00", "text": "All right, so here we are" },
        { "start": 2.1, "end": 4.2, "speaker": "SPEAKER_00", "text": "in front of the elephants." },
        { "start": 4.6, "end": 7.3, "speaker": "SPEAKER_00", "text": "The cool thing about these guys" }
    ],
    "srt": "1\n00:00:00,000 --> 00:00:02,100\n[SPEAKER_00] All right, so here we are\n...",
    "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:02.100\n[SPEAKER_00] All right, so here we are\n...",
    "charged_minutes": 1,
    "files": {
        "srt": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-www.youtube.com-watch-v-jNQXAC9IVRw.srt",
        "vtt": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-www.youtube.com-watch-v-jNQXAC9IVRw.vtt",
        "txt": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-www.youtube.com-watch-v-jNQXAC9IVRw.txt"
    }
}

Subtitle files are also stored in the run's key-value store, so you can download .srt / .vtt / .txt directly or hotlink them from your app.

If a source fails (private video, dead link, over the duration cap), the run keeps going and the failed source produces an item like:

{ "url": "https://example.com/broken-link.mp3", "error": "Could not download media from this URL: HTTP 404" }

Pricing

$0.008 per transcribed minute, rounded up per source, minimum 1 minute. Billed via Apify's pay-per-event — no subscription, no compute-unit math, no surprise bills.

Content	Cost
5-minute TikTok compilation	$0.04
10-minute YouTube video	$0.08
60-minute podcast episode	$0.48
100 x 3-minute clips	$2.40
Competitor at $0.015/min + your own OpenAI bill for the same podcast	$0.90+ and two invoices

Use it via API

Run the Actor from any language using the Apify API:

curl -X POST "https://api.apify.com/v2/acts/<username>~audio-video-transcription-diarization/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "sources": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"], "language": "auto" }'

JavaScript:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<username>/audio-video-transcription-diarization').call({
    sources: ['https://www.youtube.com/watch?v=jNQXAC9IVRw'],
    diarization: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].text);

Python:

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("<username>/audio-video-transcription-diarization").call(
    run_input={"sources": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"]}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0]["text"])

Use it from AI agents (MCP)

This Actor works out of the box with the Apify MCP server, so agents built on Claude, ChatGPT, Cursor, or any MCP-compatible framework can call it as a tool:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/sse?actors=<username>/audio-video-transcription-diarization"
        }
    }
}

Your agent can transcribe any link a user shares with no API key juggling inside the agent — this Actor needs none, and pay-per-event billing means you are only ever charged for minutes actually transcribed.

FAQ

Do I need an OpenAI (or any other) API key? No. That is the point of this Actor. Transcription runs on a managed backend whose credentials are bundled with the Actor. You only need your Apify account.

Which languages are supported? 90+ languages with automatic detection — the detected language is returned in every result. Best accuracy on English, Spanish, Portuguese, French, German, Italian, Japanese, Korean, and Chinese. Set language explicitly for noisy audio to boost accuracy.

How accurate is the diarization? How many speakers can it handle? Speaker attribution is computed per word, then grouped into segments, which keeps labels tight even in fast exchanges. It reliably separates 2–10 speakers on clean audio (podcasts, interviews, meetings). Heavy crosstalk or very short interjections may occasionally merge speakers.

Can it transcribe video files? Yes. For video sources only the audio track is extracted and processed, which keeps runs fast and cheap.

Are the subtitles actually usable as-is? Yes. Cues are automatically split on speaker changes, pauses, and length limits (roughly 42 characters / 7 seconds per cue), so the SRT/VTT files drop straight into video editors, players, and YouTube uploads without manual cleanup.

What about very long files? The default per-file cap is 240 minutes (configurable up to 24 hours via maxDurationMinutes). Each file also has a 30-minute processing timeout. Sources over the cap are skipped with an error item and are never charged.

Is a whole playlist/channel transcribed if I paste a playlist URL? No — playlist expansion is disabled on purpose so you never get surprise charges. Paste individual video URLs (pair this Actor with any channel/playlist scraper to get them).

What happens when one URL in my batch is broken? The run continues. The broken URL produces a { url, error } item in the dataset; all other sources are processed and only successful minutes are charged.

Where are my subtitle files? In the run's key-value store (links are included in each dataset item under files), and inline in the dataset item (srt, vtt fields) if you prefer to grab them from JSON.

Is my audio stored? Audio is processed transiently and deleted from the worker after transcription. Transcripts live in your Apify dataset/key-value store, under your control.

Related use cases

• Generate subtitles for YouTube/TikTok/Instagram content at scale
• Turn podcasts into blog posts, show notes, and quotes
• Feed meeting or interview transcripts into LLM pipelines and RAG systems
• Monitor spoken mentions of brands across social video
• Caption video ads for accessibility compliance (WCAG / ADA)