# Youtube Transcript Scraper (`scrapier/youtube-transcript-scraper`) Actor YouTube Transcript Scraper: Extract video transcripts, captions, timestamps, titles, channel details, and video URLs. Convert YouTube content into structured text for research, content analysis, keyword extraction, summarization, and competitor monitoring. - **URL**: https://apify.com/scrapier/youtube-transcript-scraper.md - **Developed by:** [Scrapier](https://apify.com/scrapier) (community) - **Categories:** Social media, Lead generation, Automation - **Stats:** 35 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: 5.00 out of 5 stars ## Pricing $24.99/month + usage To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — 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 Scraper — Captions, Metadata, Engagement Data YouTube Transcript Scraper extracts the transcript for any YouTube video — plain text or timestamped cues — from YouTube's own subtitle tracks, no Data API key or login needed. Give it a list of video URLs and get back transcripts, plus optional video metadata (title, channel, views, likes, duration) and locally-computed engagement analytics (engagement rate, speaking pace, caption coverage). Every response is structured JSON, ready for an LLM, a vector store, or a research pipeline — one row per video, added to your dataset as it finishes. ### What is YouTube Transcript Scraper? YouTube Transcript Scraper takes a list of YouTube video URLs and returns each video's transcript as structured JSON, using the same caption/subtitle tracks the "CC" button uses — including auto-generated captions. On top of the transcript, it can optionally compute **engagement analytics** (`engagementRate`, `estimatedSpeakingRateWpm`, `transcriptCoveragePercent`) directly from the harvested metadata and transcript, at no extra request or AI cost — a step most transcript scrapers stop short of. No YouTube login or account is required for any of it. - Batch transcript extraction from any number of video URLs in one run - Plain-text or timestamped-cue output format, chosen per run - English auto-generated and non-English caption filtering, controlled independently - Optional real video metadata (title, channel, publish date, views, likes, duration, category, tags, thumbnails) harvested from the public watch page - Optional best-effort channel subscriber count - Optional locally-computed engagement analytics, derived from data already fetched ### What data can you get with YouTube Transcript Scraper? Each run can return four categories of data per video: the transcript itself, video metadata, channel info, and engagement analytics. | Result Type | Extracted Fields | Primary Use Case | | --- | --- | --- | | Transcript | `language`, `languageCode`, `isGenerated`, `content`, `wordCount`, `charCount` | Captioning, subtitling, text-mining, RAG ingestion | | Video metadata | `title`, `description`, `publishDate`, `publishDateSince`, `category`, `tags`, `durationSeconds`, `viewCount`, `likeCount`, `isLiveNow`, `thumbnailUrl`, `thumbnails`, `channelId`, `channelUsername`, `channelDisplayName`, `channelUrl`, `channelIsVerified`, `metadataFetched` | Content research, SEO context, catalog enrichment | | Channel info | `channelSubscriberCountText`, `channelSubscriberCount`, `channelExternalId`, `channelInfoCoverage` | Creator research, influencer vetting | | Engagement analytics | `engagementRate`, `estimatedSpeakingRateWpm`, `transcriptCoveragePercent` | Benchmarking engagement and caption reliability across a video list | #### Engagement analytics Turn on `includeEngagementMetrics` and the actor computes three fields locally, without any extra network request or AI call: `engagementRate` (likes ÷ views), `estimatedSpeakingRateWpm` (transcript word count divided by video runtime in minutes), and `transcriptCoveragePercent` (how much of the video's runtime the caption track actually spans, capped at 100%). These are derived entirely from data the actor already harvested for the transcript and metadata steps, so enabling them doesn't cost a second round trip. They matter because raw view/like counts alone don't tell you whether a video is fast-talking or slow, or whether its captions cover the whole runtime or cut off early — useful for benchmarking a list of videos rather than reading one at a time. ```json { "engagementRate": 0.01125, "estimatedSpeakingRateWpm": 121.4, "transcriptCoveragePercent": 98.6 } ``` Requires `fetchVideoMetadata` (or `includeChannelInfo`, which auto-enables it) — without metadata, these three fields are silently omitted. #### Video metadata Turn on `fetchVideoMetadata` and each row gains the video's title, description, publish date (absolute and relative), category, tags, duration, view/like counts, live status, thumbnail set, and channel identity — all harvested from the public watch page, no login or API key. Useful for building a content-research spreadsheet or enriching a transcript dataset with the context needed to sort and filter videos without opening YouTube. ### How does YouTube Transcript Scraper differ from the official YouTube Data API? YouTube Data API v3 does not give you caption or transcript text for an arbitrary public video: `captions.list` (public, API-key only) returns caption-track metadata, but `captions.download` — the only endpoint that returns actual caption text — requires OAuth 2.0 authorization, and in practice only the video's own channel owner can authorize it for their videos. | Feature | YouTube Data API v3 | YouTube Transcript Scraper | | --- | --- | --- | | Transcript/caption text | `captions.download` requires OAuth as the video's channel owner ([docs](https://developers.google.com/youtube/v3/docs/captions/download)) | Returns transcript text for any public video with captions, no OAuth | | Authentication | API key + OAuth consent for caption download | None — no login, no API key | | Video metadata | `videos.list`, quota-metered, max 50 video IDs per request ([docs](https://developers.google.com/youtube/v3/docs/videos/list)) | Optional, harvested from the public watch page, no quota | | Engagement analytics | Not computed — raw view/like counts only | `engagementRate`, `estimatedSpeakingRateWpm`, `transcriptCoveragePercent` computed automatically | | Batch input | Chunked into groups of 50 IDs per call | Any-size `urls` list, no ID chunking needed | | Output | Raw per-resource API JSON | One normalized dataset row per video | The official API is the right choice if you already own the channel and need OAuth-scoped access to your own captions. YouTube Transcript Scraper is the better fit when you need transcript text for videos you don't own, without setting up OAuth. ### How to scrape YouTube with YouTube Transcript Scraper? 1. Open YouTube Transcript Scraper in Apify Console. 2. Paste one or more video links into the required `urls` field, e.g. `https://www.youtube.com/watch?v=4KbrxIpQgkM`. 3. Set `outputFormat` (`text` or `timestamp`) and the language toggles (`includeEnglishAG`, `includeNonEnglish`); optionally turn on `fetchVideoMetadata`, `includeChannelInfo`, or `includeEngagementMetrics` for enrichment. 4. Click **Start** to run the actor. 5. Read results as JSON or CSV from the dataset, or pull them via the Apify API as each video finishes. ```json { "urls": ["https://www.youtube.com/watch?v=4KbrxIpQgkM"], "outputFormat": "text" } ``` #### How to run multiple videos in one job Add every video URL you want processed to the `urls` array in a single run — each one is fetched and pushed to the dataset independently, so one broken or caption-less URL doesn't stop the rest. Videos are processed one after another within the run rather than in parallel, so a longer list takes proportionally longer to finish. ### ⬇️ Input | Parameter | Required | Type | Description | Example Value | | --- | --- | --- | --- | --- | | `urls` | Yes | array | One or more YouTube video URLs (`watch?v=`, `youtu.be/`, or `/shorts/`) to extract transcripts from. | `["https://www.youtube.com/watch?v=4KbrxIpQgkM"]` | | `includeEnglishAG` | No | boolean (default `true`) | Include English auto-generated (ASR) captions when available. | `true` | | `includeNonEnglish` | No | boolean (default `false`) | Include transcripts in languages other than English. | `false` | | `outputFormat` | No | string, enum `timestamp`/`text` (default `"text"`) | `text` returns a single clean string per transcript; `timestamp` returns an array of timed cues. | `"text"` | | `fetchVideoMetadata` | No | boolean (default `false`) | Fetch title, channel, publish date, view/like counts, duration, category, tags, and thumbnails from the watch page. | `true` | | `includeEngagementMetrics` | No | boolean (default `false`) | Compute `engagementRate`, `estimatedSpeakingRateWpm`, `transcriptCoveragePercent`. Requires metadata (auto-enabled only if `includeChannelInfo` is also on). | `true` | | `includeChannelInfo` | No | boolean (default `false`) | Best-effort channel subscriber count from the channel's About page; auto-enables metadata fetch. | `false` | | `proxyConfiguration` | No | object (default `{}`) | Proxy setup for transcript and metadata/channel requests. Uses Apify Residential Proxy by default when enabled. | `{"useApifyProxy": true}` | ```json { "urls": [ "https://www.youtube.com/watch?v=4KbrxIpQgkM", "https://youtu.be/jNQXAC9IVRw" ], "includeEnglishAG": true, "includeNonEnglish": false, "outputFormat": "text", "fetchVideoMetadata": true, "includeEngagementMetrics": true, "includeChannelInfo": false, "proxyConfiguration": { "useApifyProxy": true } } ``` **Common pitfall:** turning on `includeEngagementMetrics` by itself does nothing — the analytics fields are silently omitted unless `fetchVideoMetadata` (or `includeChannelInfo`) is also enabled, since the calculation needs the harvested view/like/duration data first. ### ⬆️ Output Each processed video is pushed to the dataset as one normalized JSON row, in the order videos complete. Fields beyond the base transcript are added only when their corresponding input toggle is on; they're simply absent otherwise, never filled with a placeholder. Apify's dataset export supports JSON, CSV, Excel, and other formats from the run's Storage tab. Each successfully processed video is billed once as a `row_result` event; videos that error out are skipped entirely and never pushed, so a failed URL is never charged. #### Scraped results ```json [ { "id": "4KbrxIpQgkM", "url": "https://www.youtube.com/watch?v=4KbrxIpQgkM", "input": "https://www.youtube.com/watch?v=4KbrxIpQgkM", "transcripts": [ { "language": "English", "languageCode": "en", "isGenerated": false, "content": "Welcome back to the channel, today we're diving into...", "wordCount": 812, "charCount": 4318 } ], "scrapedAt": "2026-07-24T10:02:11Z" }, { "id": "jNQXAC9IVRw", "url": "https://www.youtube.com/watch?v=jNQXAC9IVRw", "input": "https://youtu.be/jNQXAC9IVRw", "transcripts": [ { "language": "English (auto-generated)", "languageCode": "en", "isGenerated": true, "content": "all right so here we are in front of the elephants...", "wordCount": 39, "charCount": 217 } ], "title": "Me at the zoo", "description": "The first video on YouTube.", "publishDate": "2005-04-23T20:31:52-07:00", "publishDateSince": "20 years ago", "category": "Animals", "tags": [], "durationSeconds": 19, "viewCount": 372000000, "likeCount": 18900000, "isLiveNow": false, "thumbnailUrl": "https://i.ytimg.com/vi/jNQXAC9IVRw/hqdefault.jpg", "thumbnails": ["https://i.ytimg.com/vi/jNQXAC9IVRw/hqdefault.jpg"], "channelId": "UC4QobU6STFB0P71PMvOGN5A", "channelUsername": "jawed", "channelDisplayName": "jawed", "channelUrl": "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A", "channelIsVerified": false, "metadataFetched": true, "scrapedAt": "2026-07-24T10:02:19Z" }, { "id": "dQw4w9WgXcQ", "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "input": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "transcripts": [ { "language": "English", "languageCode": "en", "isGenerated": false, "content": "We're no strangers to love, you know the rules...", "wordCount": 431, "charCount": 2190 } ], "title": "Rick Astley - Never Gonna Give You Up", "channelDisplayName": "Rick Astley", "channelUrl": "https://www.youtube.com/channel/UCuAXFkgsw1L7xaCfnd5JJOw", "publishDate": "2009-10-25T06:57:33Z", "viewCount": 1600000000, "likeCount": 18000000, "durationSeconds": 213, "metadataFetched": true, "channelInfoCoverage": "ok", "channelSubscriberCountText": "3.2M", "channelSubscriberCount": 3200000, "channelExternalId": "UCuAXFkgsw1L7xaCfnd5JJOw", "engagementRate": 0.01125, "estimatedSpeakingRateWpm": 121.4, "transcriptCoveragePercent": 98.6, "scrapedAt": "2026-07-24T10:02:27Z" } ] ``` Field values above illustrate the shape each toggle produces; exact counts will differ per video. ### How can I use the data extracted with YouTube Transcript Scraper? - **Content creators and repurposing teams:** turn `transcripts[].content` into blog posts, show notes, or social captions, and use `publishDate`/`title` to keep repurposed content organized by source video. - **AI engineers and LLM/RAG developers:** feed clean `content` text plus `wordCount`/`charCount` into chunking, embedding, or summarization pipelines — structured JSON in, no scraping glue code needed. - **SEO and content researchers:** compare `title`, `tags`, `category`, and `viewCount` across a list of competitor videos to spot topic and format gaps. - **Market and media researchers:** benchmark `engagementRate` and `estimatedSpeakingRateWpm` across a video set to compare audience response and delivery pace between channels or campaigns. ### How do you monitor YouTube video engagement over time? Engagement metrics change as a video accumulates views and likes, so re-running the actor against the same `urls` list on a schedule turns a one-off extraction into a tracking workflow. This matters most for freshly-published videos, a running content marketing campaign, or a competitor's channel you check in on periodically — a single run only tells you where a video stands today, not whether it's gaining or losing traction. The discipline is simple: keep the video list fixed, run it repeatedly on the same cadence, and diff each new row against the previous run for the same `id`. The fields worth diffing are `viewCount`, `likeCount`, `engagementRate`, and — for freshly-captioned videos — `transcriptCoveragePercent`, which can rise between runs as auto-generated captions catch up to a video's runtime. `scrapedAt` gives you the timestamp to order runs by and compute a rate of change rather than a raw delta. A practical loop: schedule a run across a fixed list of video URLs with `fetchVideoMetadata` and `includeEngagementMetrics` on, store each run's dataset, and compare `engagementRate` and `viewCount` against the prior run to flag videos whose engagement is accelerating or stalling faster than the rest of the list. Since the actor doesn't push a change-only diff itself, do the comparison outside the run — for example in a downstream script or spreadsheet reading each run's dataset — and schedule the run itself using Apify's Scheduler so it repeats on your chosen interval without manual restarts. ### Integrate YouTube Transcript Scraper and automate your workflow YouTube Transcript Scraper works with any language or tool that can send an HTTP request. #### REST API with Python ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("scrapier/youtube-transcript-scraper").call(run_input={ "urls": ["https://www.youtube.com/watch?v=4KbrxIpQgkM"], "outputFormat": "text", "fetchVideoMetadata": True, }) for row in client.dataset(run["defaultDatasetId"]).iterate_items(): print(row["id"], row["transcripts"]) ``` #### Scheduled monitoring and delivery Use Apify's Scheduler to re-run the same `urls` list at a fixed interval without manual triggers, and Apify's webhooks to fire on run completion instead of polling. Read results from the run's dataset via the API or Console after each scheduled run. ### Is it legal to scrape YouTube transcripts? Yes — scraping publicly visible YouTube captions is generally legal, since YouTube Transcript Scraper only returns caption text and page data any visitor's browser already receives; courts have generally supported access to publicly available web data (*hiQ Labs v. LinkedIn*, 9th Cir., 2019/2022). Transcript text is typically not personal data on its own, but if a video is an interview, testimony, or profile of an identifiable person, captions naming or quoting them can fall under GDPR/CCPA depending on how you store and use them. Respect YouTube's Terms of Service for your use case, and consult your legal team for commercial use cases involving bulk data storage. ### Frequently asked questions **Does this scraper need a YouTube Data API key or login?** No. It reads YouTube's public caption tracks and watch-page payload directly — no API key and no login are required for any feature, including metadata and channel info. **Can I get transcripts for private or age-restricted videos?** No. The actor makes unauthenticated requests to public pages, so it works only on videos and captions that are publicly viewable without signing in. **What transcript formats does it support?** `text` (a single clean string) or `timestamp` (an array of `{startMs, endMs, startTime, text}` cues), set via `outputFormat`. **Does it return video title, views, or channel info by default?** Not by default — a run with all toggles off returns transcript fields only. Turn on `fetchVideoMetadata` to add title, channel, publish date, views, likes, duration, category, tags, and thumbnails. **Does YouTube Transcript Scraper compute engagement analytics?** Yes — turn on `includeEngagementMetrics` to get `engagementRate`, `estimatedSpeakingRateWpm`, and `transcriptCoveragePercent` on each row. These fields are omitted if `fetchVideoMetadata` (or `includeChannelInfo`) isn't also enabled, since the calculation depends on harvested metadata. **How many videos can I process per run?** There's no fixed cap in the input schema — list as many URLs as you want in `urls`. Videos are processed one after another within the run, so the practical limit is your run's timeout and memory allocation, not a built-in count. **Can I process an entire channel or playlist automatically?** Not currently — the actor only recognizes individual video URLs (`watch?v=`, `youtu.be/`, `/shorts/`). List each video URL you want in `urls`. **How do I use this to monitor a video's engagement over time?** Schedule a recurring run across a fixed `urls` list with `includeEngagementMetrics` on, then compare `engagementRate`, `viewCount`, and `likeCount` for the same `id` against the previous run to spot videos whose engagement is changing. **Does YouTube Transcript Scraper work with Claude, ChatGPT, and AI agent frameworks?** It's callable as an HTTP endpoint through the Apify API by any agent framework — an agent can call it with a list of URLs, receive transcript JSON back, and ground its answer in the returned text. **How does YouTube Transcript Scraper compare to other YouTube transcript scrapers?** Most transcript scrapers on Apify Store also bundle video metadata (title, channel, views, duration) alongside captions. As of 2026-07-25, we did not find locally-computed engagement analytics (`engagementRate`, `estimatedSpeakingRateWpm`, `transcriptCoveragePercent`) advertised on the other transcript-scraper listings we reviewed. **Can I use it without managing proxies or YouTube credentials?** Yes. The actor routes requests through Apify's Residential Proxy by default and needs no YouTube account, cookies, or credentials from you — only your Apify API token to run it. ### Your feedback Found a bug, or need a field this actor doesn't extract yet? Let us know through the actor's Issues tab on Apify Console, or reach out via Apify's support channel. Feedback directly shapes what gets fixed and added next. # Actor input Schema ## `urls` (type: `array`): Add one or more YouTube links to extract transcripts from. Each completed video appears in your dataset automatically. ⚡ ## `includeEnglishAG` (type: `boolean`): Enable to include English auto-generated transcripts when available. ## `includeNonEnglish` (type: `boolean`): Enable to include transcripts in languages other than English. ## `outputFormat` (type: `string`): Choose transcript style: 'timestamp' includes time markers, while 'text' returns clean plain text. ## `fetchVideoMetadata` (type: `boolean`): Fetch title, channel name/ID/URL, publish date, category, tags, thumbnails, duration, view count, like count, and live-status directly from the YouTube watch page. Default is false (base transcript-only behavior). When off, none of the metadata fields are added to the output. ## `includeEngagementMetrics` (type: `boolean`): Adds engagementRate (likes ÷ views), estimatedSpeakingRateWpm (transcript words per minute of runtime), and transcriptCoveragePercent (caption coverage of the video's runtime) — all computed locally from the harvested metadata + transcript, no extra AI cost. Requires video metadata to be fetched (auto-enabled if this or channel info is on). Default is false. ## `includeChannelInfo` (type: `boolean`): Best-effort extra request to the channel's 'About' page for its subscriber count. Automatically also fetches video metadata (needed to resolve the channel). Coverage is partial (not guaranteed for every channel) — reported as-is, never fabricated. Default is false. ## `proxyConfiguration` (type: `object`): Optional proxy setup for stable access. Uses Apify Residential Proxy by default when needed. ## Actor input object example ```json { "urls": [ "https://www.youtube.com/watch?v=4KbrxIpQgkM" ], "includeEnglishAG": true, "includeNonEnglish": false, "outputFormat": "text", "fetchVideoMetadata": false, "includeEngagementMetrics": false, "includeChannelInfo": false, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `results` (type: `string`): All scraped items in the Actor's default dataset. # 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 = { "urls": [ "https://www.youtube.com/watch?v=4KbrxIpQgkM" ], "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("scrapier/youtube-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "urls": ["https://www.youtube.com/watch?v=4KbrxIpQgkM"], "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("scrapier/youtube-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=4KbrxIpQgkM" ], "proxyConfiguration": { "useApifyProxy": false } }' | apify call scrapier/youtube-transcript-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapier/youtube-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 ` 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/bBC2er1lqIKcdqMZz/builds/M5YeC3YmEaeLqkq8s/openapi.json