# YouTube Transcript Extractor & Caption Downloader (`vnx0/youtube-transcription-analyzer`) Actor Extract YouTube video transcripts with timestamps, multi-language fallback, and token-efficient JSON output. Built for AI pipelines, content analysis, and accessibility. - **URL**: https://apify.com/vnx0/youtube-transcription-analyzer.md - **Developed by:** [Vnx0](https://apify.com/vnx0) (community) - **Categories:** AI, Videos, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing $3.00 / 1,000 videos 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/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## YouTube Transcript Extractor — Download SRT Subtitles & Timestamped Captions Extract **YouTube video transcripts** with precise timestamps, multi-language support, automatic proxy fallback, and downloadable **SRT subtitle files**. Built for AI pipelines, content analysis, accessibility workflows, and video editing — no API key required, zero browser automation, and error-resilient execution that never crashes on missing captions. Try it live on [Apify Console](https://console.apify.com) or call it via API for seamless integration into your data stack. ### Features - **SRT subtitle download** — Generate ready-to-use `.srt` files compatible with VLC, Premiere Pro, DaVinci Resolve, and YouTube Studio - **Timestamped JSON output** — Every caption segment with start time (seconds) and duration for precise alignment - **Multi-language support** — Any ISO 639-1 code (`en`, `fr`, `de`, `ja`, `es`, `pt`, `ar`, `hi`) with automatic regional variant fallback - **Auto proxy fallback** — Bypasses YouTube IP blocks automatically using Apify Proxy with Chrome TLS impersonation - **100% error resilience** — Never crashes. Missing captions, disabled transcripts, and unavailable videos all produce clean error rows - **LLM-optimized** — Minimal, token-efficient JSON with no bloat. Ready for GPT, Claude, Llama, LangChain, and LlamaIndex - **Zero browser** — Pure HTTP extraction. No Playwright, no Puppeteer, no headless Chrome. Fast and cheap ### Why Extract YouTube Transcripts? Video content is exploding, but text is what machines can process. A **YouTube transcript extractor** turns hours of spoken video into structured, searchable text data in seconds. Common use cases include: - **AI & LLM training data** — Feed clean, timestamped transcripts into GPT, Claude, or Llama for fine-tuning or RAG pipelines - **Content repurposing** — Convert YouTube videos into blog posts, newsletter content, or social media threads without manual transcription - **SEO content optimization** — Index video transcripts on your site to rank for spoken keywords and capture voice-search traffic - **Accessibility compliance** — Generate captions and SRT subtitles for hearing-impaired audiences or multilingual localization - **Academic research** — Analyze lecture series, conference talks, or documentary content at scale with structured text output - **Media monitoring** — Track competitor YouTube channels by extracting and analyzing transcript text for brand mentions and topic trends ### How to Extract YouTube Transcripts #### Step 1: Get a YouTube Video URL Copy the URL of any public YouTube video. This actor supports all standard URL formats: - `https://www.youtube.com/watch?v=dQw4w9WgXcQ` - `https://youtu.be/dQw4w9WgXcQ` - `https://www.youtube.com/embed/dQw4w9WgXcQ` - `https://www.youtube.com/shorts/abc123def45` #### Step 2: Configure the Input Only one field is required — the video URL. Optional settings let you control the language: | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `youtubeUrl` | string | — | URL or ID of the YouTube video (watch, short, embed, or youtu.be formats) | | `language` | string | `"en"` | ISO 639-1 language code (e.g. `"en"`, `"fr"`, `"de"`, `"ja"`, `"es"`, `"pt"`) | #### Step 3: Run the Actor Start the run in Apify Console or via API. The actor fetches the transcript, segments it by caption timing, generates an SRT file, and pushes structured JSON to the dataset. Each run produces: 1. **Transcript segments** — One row per caption snippet with segment index, start time, duration, and text 2. **Downloadable SRT file** — SubRip subtitle format stored in the key-value store 3. **Summary row** — Total duration and download link 4. **Run statistics** — Segment count, detected language, video ID, and duration stored as JSON ### Output Format The actor pushes transcript segments and a summary row to the dataset, plus stores an SRT subtitle file in the key-value store. #### Transcript Segment Row ```json { "segmentIndex": 1, "startTime": 5.51, "duration": 3.24, "text": "Hey..", "srtFile": "https://api.apify.com/v2/key-value-stores/{storeId}/records/subtitles.srt" } ```` #### Summary Row ```json { "text": "YouTube transcript for video dQw4w9WgXcQ: 61 segments over 177.96s", "duration": 177.96, "srtFile": "https://api.apify.com/v2/key-value-stores/{storeId}/records/subtitles.srt" } ``` #### SRT Subtitle File (key-value store) SRT format with sequential numbering and HH:MM:SS,mmm timestamps: ``` 1 00:00:05,509 --> 00:00:08,749 Hey.. 2 00:00:08,830 --> 00:00:10,589 What happened? ``` #### Run Statistics (key-value store) ```json { "videoId": "dQw4w9WgXcQ", "segmentCount": 61, "totalDuration": 177.96, "language": "en", "srtFile": "https://api.apify.com/v2/key-value-stores/{storeId}/records/subtitles.srt" } ``` #### Field Reference | Field | Type | Appears In | Description | |-------|------|------------|-------------| | `segmentIndex` | integer | Segment row | Sequential segment number starting at 1 | | `startTime` | number | Segment row | Start timestamp in seconds from video start | | `duration` | number | Segment row | Segment duration in seconds | | `text` | string | Segment row | Caption text for this segment | | `srtFile` | string | Both rows | Download URL for the SRT subtitle file | | `videoId` | string | Stats JSON | 11-character YouTube video identifier | | `segmentCount` | integer | Stats JSON | Total number of transcript segments | | `totalDuration` | number | Summary + Stats | Total transcript duration in seconds | ### Use Cases for AI & LLM Pipelines This actor is designed with AI consumption as a first-class use case: - **Token-efficient fields** — No raw HTML, debug hashes, or redundant metadata. Every field serves a purpose, keeping your token budget low. - **Structured timestamps** — `startTime` and `duration` in seconds let you align transcript text with video frames for multimodal AI applications. - **Deterministic output** — Same video, same language, same JSON structure every time. No stochastic HTML parsing — the YouTube Transcript API provides consistent, typed data. - **Language fallback chain** — Request `"en"`, get `"en-GB"` if that's what the video has. Request any language, and the actor automatically finds regional variants, then falls back to the first available transcript. Never silently fail. - **Error-resilient execution** — Missing captions, disabled transcripts, and unavailable videos all produce clean error rows instead of crashing the run. Your pipeline never hangs. ### Why Choose This Actor? | Feature | This Actor | Typical YouTube Transcript Actors | |---------|-----------|----------------------------------| | Error handling | Never crashes — pushes error row | Throws exception, run fails | | Language fallback | Auto-finds regional variants | Strict language match or crash | | Output structure | Minimal, token-efficient fields | Bloated with metadata | | LLM-ready | Structured timestamps in seconds | Inconsistent formatting | | Browser automation | None — HTTP-only, fast & cheap | Often uses Playwright/Puppeteer | | API key required | No | Sometimes requires YouTube Data API key | ### Pricing This actor uses **pay-per-event** pricing at **$3 per 1,000 videos processed** (approximately $0.003 per video). There are no monthly commitments, no API key costs, and no hidden infrastructure fees. You only pay for successful transcript extractions. #### Price Comparison | Actor | Price per 1,000 videos | |-------|----------------------| | **This actor** | **$3.00** | | starvibe/youtube-video-transcript | $5.00 | | pintostudio/youtube-transcript-scraper | $10.00 | ### Frequently Asked Questions #### How do I download SRT subtitles from YouTube? Run this actor with any YouTube video URL. It automatically generates a downloadable `.srt` subtitle file with precise HH:MM:SS,mmm timestamps. The SRT file is stored in the key-value store and a direct download link is included in every dataset row. Compatible with VLC, Premiere Pro, DaVinci Resolve, and YouTube Studio. #### Does this actor work for any YouTube video? It works for any public YouTube video that has captions or subtitles enabled. Videos without any caption track (including auto-generated captions) return a clean error row. Private, unlisted, and age-restricted videos are not supported. #### What languages are supported? All languages that YouTube provides captions for. The actor accepts any ISO 639-1 language code (`"en"`, `"fr"`, `"de"`, `"ja"`, `"es"`, `"pt"`, etc.). If the exact code isn't available, it automatically falls back to regional variants (e.g. `"en"` → `"en-GB"`) and then to any available transcript as a last resort. #### How do I extract YouTube transcripts for AI and LLM pipelines? The actor outputs clean, typed JSON with `segmentIndex`, `startTime`, `duration`, and `text` fields — no raw HTML, no debug hashes, no redundant metadata. Call the actor via the Apify API from Python or JavaScript and pipe the dataset directly into LangChain, LlamaIndex, CrewAI, or your custom RAG pipeline. Each field is designed to minimize token consumption. #### How is this different from pintostudio/youtube-transcript-scraper or starvibe/youtube-video-transcript? Those are excellent actors with large user bases. This actor differentiates on four dimensions: (1) **SRT file generation** — automatically generates downloadable SubRip subtitle files, not just JSON; (2) **error resilience** — never crashes on missing transcripts, pushing an error row instead; (3) **language intelligence** — automatically finds regional and available transcript variants instead of hard-failing on a strict language code; (4) **proxy auto-fallback** — automatically retries with Apify Proxy and Chrome TLS impersonation when YouTube blocks direct requests. #### Is there a free tier or trial? You can try the actor directly in Apify Console with the default input URL. Usage is billed per 1,000 videos at the published pay-per-event rate. Apify free plan includes $5 prepaid usage credit. ### Technical Specifications | Spec | Value | |------|-------| | Runtime | Python 3.14 | | Memory | 1,024 MB | | Average run time | 1-15 seconds | | Max timeout | 3,600 seconds | | Browser | None (pure HTTP) | | TLS fingerprint | Chrome 131 impersonation | | Proxy fallback | Apify Proxy AUTO pool | | Output formats | JSON dataset + SRT subtitles | ### Support and Feedback Found a bug or have a feature request? Reach out via the Apify Store Issues tab. # Actor input Schema ## `youtubeUrl` (type: `string`): URL or ID of the YouTube video to extract the transcript, captions, and SRT subtitles from. Supports watch (youtube.com/watch?v=), short (youtube.com/shorts/), embed (youtube.com/embed/), and youtu.be/ formats. Works with any public video that has captions enabled. ## `language` (type: `string`): ISO 639-1 language code for the transcript and subtitles (e.g., 'en' for English, 'fr' for French, 'de' for German, 'ja' for Japanese, 'es' for Spanish, 'pt' for Portuguese). Automatically falls back to regional variants (en → en-GB) and any available transcript if the exact code is not found. ## `proxyUrl` (type: `string`): HTTP/HTTPS proxy URL for requests (e.g., http://user:pass@1.2.3.4:8080). Leave empty to use the built-in Apify Proxy fallback. Useful if your Apify proxy IPs are blocked by YouTube for specific videos. ## `proxyConfiguration` (type: `object`): Apify Proxy automatically bypasses YouTube IP blocks. Enabled by default — no configuration needed. ## Actor input object example ```json { "youtubeUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "language": "en", "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `stats` (type: `string`): Segment count, total duration, detected language, and video ID for this transcript extraction ## `srtFile` (type: `string`): Downloadable SubRip (.srt) subtitle file with HH:MM:SS,mmm timestamps for use in video players (VLC, Premiere, DaVinci Resolve) and caption editors ## `dataset` (type: `string`): JSON dataset with all timestamped transcript segments plus summary row. Switch between Transcript and Summary views using the dropdown above ## `datasetTable` (type: `string`): First 50 transcript segments in table format — segment index, start time, duration, and caption text # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "youtubeUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "proxyUrl": "" }; // Run the Actor and wait for it to finish const run = await client.actor("vnx0/youtube-transcription-analyzer").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "youtubeUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "proxyUrl": "", } # Run the Actor and wait for it to finish run = client.actor("vnx0/youtube-transcription-analyzer").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "youtubeUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "proxyUrl": "" }' | apify call vnx0/youtube-transcription-analyzer --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=vnx0/youtube-transcription-analyzer", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "YouTube Transcript Extractor & Caption Downloader", "description": "Extract YouTube video transcripts with timestamps, multi-language fallback, and token-efficient JSON output. Built for AI pipelines, content analysis, and accessibility.", "version": "0.0", "x-build-id": "haji3I1QfGFRfeHb0" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/vnx0~youtube-transcription-analyzer/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-vnx0-youtube-transcription-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/vnx0~youtube-transcription-analyzer/runs": { "post": { "operationId": "runs-sync-vnx0-youtube-transcription-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/vnx0~youtube-transcription-analyzer/run-sync": { "post": { "operationId": "run-sync-vnx0-youtube-transcription-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "youtubeUrl" ], "properties": { "youtubeUrl": { "title": "YouTube Video URL", "type": "string", "description": "URL or ID of the YouTube video to extract the transcript, captions, and SRT subtitles from. Supports watch (youtube.com/watch?v=), short (youtube.com/shorts/), embed (youtube.com/embed/), and youtu.be/ formats. Works with any public video that has captions enabled." }, "language": { "title": "Transcript Language", "type": "string", "description": "ISO 639-1 language code for the transcript and subtitles (e.g., 'en' for English, 'fr' for French, 'de' for German, 'ja' for Japanese, 'es' for Spanish, 'pt' for Portuguese). Automatically falls back to regional variants (en → en-GB) and any available transcript if the exact code is not found.", "default": "en" }, "proxyUrl": { "title": "Custom Proxy URL (optional)", "type": "string", "description": "HTTP/HTTPS proxy URL for requests (e.g., http://user:pass@1.2.3.4:8080). Leave empty to use the built-in Apify Proxy fallback. Useful if your Apify proxy IPs are blocked by YouTube for specific videos." }, "proxyConfiguration": { "title": "Proxy Configuration", "type": "object", "description": "Apify Proxy automatically bypasses YouTube IP blocks. Enabled by default — no configuration needed.", "default": { "useApifyProxy": true } } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```