YouTube Transcript Scraper — Extract Metadata & Subtitles

YouTube Transcript Scraper — Extract Transcripts, Metadata & Subtitles

YouTube Transcript Scraper Plus turns any YouTube video, channel, or playlist URL into a clean, typed JSON row per video — full transcript text, timestamped segments, ready-to-use SRT and WebVTT subtitle strings, and real video metadata (title, channel, views, likes, duration, publish date, description, thumbnail). Unlike scraping frameworks that hand back raw HTML or leave you to call the youtube-transcript-api library yourself, this Actor combines transcript extraction, metadata resolution, and optional multi-provider AI enrichment into one Apify run with built-in residential-proxy handling. This guide covers every input and output field, exactly how caption-track selection and channel/playlist expansion work, and three concrete ways teams put it into production.

🧭 What Does YouTube Transcript Scraper Plus Do?

YouTube Transcript Scraper Plus extracts caption/transcript data and video metadata from YouTube — the video-hosting platform — and returns one flat row per video. It requires no YouTube account, login, or API key: every request is an unauthenticated HTTP call to YouTube's public watch, channel, and playlist pages (plus the public oEmbed endpoint as a metadata fallback). Point it at individual video URLs, Shorts/embed/live links, bare 11-character video IDs, or a channel/playlist URL and it expands the container to its videos automatically.

• 📝 Transcript text — full plainText, plus a segments[] array with per-segment start/duration/end/timestamp/text/deep-link
• 🎞️ Subtitle files — ready-to-use srt and vtt strings generated from the same segments
• 🎬 Video metadata — title, channel, view/like counts, duration, publish date, description, category, thumbnail
• 🌍 Authoritative language fields — languageCode, isGenerated, isTranslatable, and every available caption track, all read from the youtube-transcript-api library's own flags rather than guessed from display names
• 🔀 Caption-track control — filter to manual-only or auto-generated-only tracks, or translate the selected track into another language
• 📺 Channel and playlist expansion — a channel or playlist URL is resolved to its individual videos, up to a configurable cap
• 🤖 Optional AI enrichment — summary, key points, topic tags, and chapters, generated on request via a choice of 7 LLM providers

⚡ Features & Capabilities

YouTube Transcript Scraper Plus is built around three things: authoritative caption-track selection, honest handling of unavailable data, and optional AI enrichment layered on top of a genuine transcript row rather than replacing it.

Core features

• Authoritative track selection, not string-matching. transcriptType (any / manualOnly / autoOnly) filters candidate tracks using the library's own is_generated boolean — not a guess based on a track's display name. preferredLanguages matches on languageCode (exact, then base-language prefix) in the order you list them; if none match, the Actor falls back to the best available track using a simple scoring rule that favors a manual track, then an English track.
• Full field set per video. Every row carries plainText, segments, srt, vtt, wordCount, characterCount, readingTimeMinutes, the full language/track metadata (languageCode, language, isGenerated, isTranslatable, translationLanguages, availableLanguages, languageCount), and video metadata (title, channel, channelId, channelUrl, viewCount, likeCount, publishDate, uploadDate, durationSeconds, description, category, keywords, thumbnail, isLiveContent) — copied exactly from the row-building code in src/main.py.
• Honest, never-fabricated status. Every row carries a status field — ok, no_captions, unplayable, or error — and unavailable fields are emitted as null, never guessed or interpolated.
• Container expansion. A channel URL (@handle, /channel/UC…, /c/…, /user/…) or playlist URL (list= / /playlist) is resolved to individual video IDs, capped by maxVideosPerChannel.
• Multi-provider AI enrichment, off by default. When aiEnhancement is on, aiSummary, aiKeyPoints, aiTopics, and aiChapters are generated from plainText (first 12,000 characters) using the model set in aiModel — 22 model options across Anthropic, OpenAI, Google, xAI, DeepSeek, Perplexity, and Mistral, auto-routed to the right provider by the model-name prefix.

How YouTube Transcript Scraper Plus compares to other YouTube transcript scrapers

Feature	YouTube Transcript Scraper Plus	karamelo/youtube-transcripts	pintostudio/youtube-transcript-scraper
Channel/playlist input, auto-expanded to videos	✅ built in, capped by maxVideosPerChannel	Not documented on their listing — input is per-video URL (observed on the Apify Store, 2026-07-26)	Not documented — single videoUrl input only (observed on the Apify Store, 2026-07-26)
Video metadata fields	✅ title, channel, views, likes, duration, publish date, description, category, thumbnail	✅ documents 14 metadata data points added per their listing's 03-06-2025 update — channel handle/name/ID, subscriber count, view/like/comment counts, dates, keywords, thumbnail, description (observed on the Apify Store, 2026-07-26)	Not documented — output shown is a transcript-only searchResult array (observed on the Apify Store, 2026-07-26)
SRT / WebVTT subtitle output	✅ ready-to-use srt and vtt strings via includeSrt/includeVtt	Multiple caption formats documented (plain text, timestamped, XML, XML+timestamps, one-line string); SRT/WebVTT specifically not named among them (observed on the Apify Store, 2026-07-26)	Not documented (observed on the Apify Store, 2026-07-26)
Manual vs. auto-generated caption filtering	✅ transcriptType, using the library's is_generated flag	Not documented (observed on the Apify Store, 2026-07-26)	Not documented (observed on the Apify Store, 2026-07-26)
Transcript translation	✅ translateTo, gated on the track's own isTranslatable flag	Not documented (observed on the Apify Store, 2026-07-26)	Not documented (observed on the Apify Store, 2026-07-26)
AI-generated summary / topics / chapters	✅ optional, 22-model choice across 7 providers	Not documented (observed on the Apify Store, 2026-07-26)	Not documented (observed on the Apify Store, 2026-07-26)

If your use case is feeding transcripts to an LLM or a database, the metadata and language-field rows above are the decision-makers — a transcript-only output means every consumer downstream has to make a second call just to know what video and language it belongs to.

When another tool might suit you better

karamelo/youtube-transcripts documents an in-UI "Export" flow covering CSV, XML, XLSX, and HTML downloads, plus a raw XML caption format and a one-line-string output mode (observed on the Apify Store, 2026-07-26). If your workflow specifically needs XML-formatted captions or a point-and-click multi-format download rather than JSON dataset rows and SRT/VTT strings, that's a genuine reason to prefer their tool. If you need typed JSON with metadata and subtitle files ready to consume programmatically, this Actor's output needs no reformatting step.

YouTube Transcript Scraper Plus within the Scrapio data stack

YouTube Transcript Scraper Plus covers video transcripts, subtitles, and video-level metadata. It does not scrape channel-level creator analytics or video comment threads — those live outside the Scrapio catalog, in Scraper-Engine's YouTube Channel Finder With Creator Analytics and YouTube Comments & Replies Scraper. For other public-video platforms in the Scrapio catalog, TikTok Trending Scraper and Facebook Reels Scraper cover short-form video discovery and engagement metrics rather than transcripts.

Why do developers and data teams scrape YouTube?

🏢 Content, marketing, and localization teams

Feed startUrls with a channel or playlist and repurpose plainText into blog posts, show notes, or SEO landing pages without manually transcribing anything. Turn on includeSrt/includeVtt to get subtitle files ready for upload alongside the source video, and set translateTo to localize captions into another language when the source track's isTranslatable flag allows it — all from the same run that pulled the transcript.

📊 AI training data and RAG indexing

plainText is the highest-information field for both use cases — it's the full natural-language transcript, already cleaned of segment boundaries. For RAG enrichment, index plainText alongside title, channel, publishDate, and url so a retrieval hit can be traced back to its source video and timestamp via segments[].url. For training data, wordCount, readingTimeMinutes, category, and durationSeconds form a consistently typed feature set across every row — every field returns as a typed primitive, never a display string that needs parsing. When aiEnhancement is on, aiTopics gives a pre-extracted topic-tag layer on top of the raw text.

📱 Competitive and market intelligence

Track a competitor's or industry's YouTube output by running the same channel URLs on a schedule and diffing on videoId to catch new uploads, or on viewCount/likeCount to catch which existing videos are gaining traction. category and keywords make it possible to segment a channel's output by content type without watching every video.

🔬 Research and academic use

Academic and social-research use cases — discourse analysis, content-trend studies, media research — can build a structured transcript corpus from public channels and playlists at scale. Every field documented in this README comes from content YouTube serves to an unauthenticated visitor; no private or unlisted video is accessible unless you supply its URL directly, and even then only if it is not access-restricted.

🎥 Product and SaaS development

Because output is typed JSON with a stable field set, it's a direct fit for building a video-search product, a transcript-based accessibility tool, or a content-monitoring dashboard on top of scheduled runs. srt/vtt give a downstream product playable-ready subtitle files without re-deriving timing from raw segment data.

🍚 Input Parameters

All parameters below are read directly from .actor/actor.json's input schema — names, types, defaults, and constraints are reproduced exactly, in schema order.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array (stringList)	Video URLs, 11-character video IDs, Shorts/embed/live links, or channel/playlist URLs. Containers are expanded to their videos.	"https://www.youtube.com/watch?v=4KbrxIpQgkM"
preferredLanguages	No	array (stringList, default [])	ISO language codes in priority order (e.g. en, es, fr, de). First available match wins, matched on languageCode. Empty = auto-pick the best track.	["en", "es"]
transcriptType	No	string (select; enum any / manualOnly / autoOnly; default "any")	Which caption tracks to consider, using the library's is_generated flag.	"any"
translateTo	No	string (textfield, default "")	ISO code to translate the selected transcript into via the library's translate() — only works when the chosen track's isTranslatable is true.	"es"
includeSegments	No	boolean (default true)	Include the per-segment array (start, duration, end, timestamp, text, deep-link url). Plain text is always included regardless.	true
includeSrt	No	boolean (default true)	Include a ready-to-use SRT subtitle string in each row.	true
includeVtt	No	boolean (default true)	Include a ready-to-use WebVTT subtitle string in each row.	true
maxVideosPerChannel	No	integer (minimum 1, default 10)	When a channel or playlist URL is provided, scrape up to this many of its videos.	10
concurrency	No	integer (minimum 1, maximum 20, default 5)	How many videos to process in parallel.	5
aiEnhancement	No	boolean (default false)	Add an AI-generated summary, key points, topic tags, and chapters using the provider selected below. Requires an API key. Off by default.	false
aiModel	No	string (select; default "claude-haiku-4-5")	AI model/provider for enrichment. Provider is auto-detected from the model-name prefix. See the full enum below.	"claude-haiku-4-5"
aiApiKey	No	string (textfield, secret)	API key for the selected provider. Falls back to a provider-specific environment variable if left blank.	"sk-ant-..."
proxyConfiguration	No	object (proxy editor; default {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]})	Apify Proxy configuration. YouTube blocks datacenter IPs for transcript requests, so Residential is the default.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

aiModel's full enum, exactly as defined in the schema (provider in parentheses): claude-haiku-4-5 (Anthropic — cheapest), claude-sonnet-5 (Anthropic), claude-opus-4-8 (Anthropic — best), claude-fable-5 (Anthropic — most capable), gpt-4o-mini (OpenAI — cheap), gpt-4o (OpenAI), gpt-4.1-mini (OpenAI), gpt-4.1 (OpenAI), o3-mini (OpenAI — reasoning), o1 (OpenAI — reasoning), gemini-2.0-flash-lite (Google — cheapest), gemini-2.0-flash (Google — cheap), gemini-2.5-flash (Google), gemini-2.5-pro (Google — best), grok-3-mini (xAI — cheap), grok-3 (xAI), deepseek-chat (cheap), deepseek-reasoner, sonar (Perplexity — cheap), sonar-pro (Perplexity), mistral-small-latest (cheap), mistral-large-latest.

aiApiKey falls back, per provider, to: ANTHROPIC_API_KEY (Claude), OPENAI_API_KEY (GPT/o-series), GEMINI_API_KEY or GOOGLE_API_KEY (Gemini), XAI_API_KEY or GROK_API_KEY (Grok), DEEPSEEK_API_KEY (DeepSeek), PERPLEXITY_API_KEY or PPLX_API_KEY (Sonar), MISTRAL_API_KEY (Mistral).

Example input

{
  "startUrls": ["https://www.youtube.com/watch?v=4KbrxIpQgkM"],
  "preferredLanguages": ["en"],
  "transcriptType": "any",
  "translateTo": "",
  "includeSegments": true,
  "includeSrt": true,
  "includeVtt": true,
  "maxVideosPerChannel": 10,
  "concurrency": 5,
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Supported URL types and input formats

startUrls accepts, one entry per line:

• A single video URL — https://www.youtube.com/watch?v=4KbrxIpQgkM, https://youtu.be/4KbrxIpQgkM, a Shorts URL (/shorts/…), an embed URL (/embed/…), or a live URL (/live/…). Each pattern is matched by a dedicated regex against the 11-character video ID.
• A bare 11-character video ID — 4KbrxIpQgkM on its own line, matched directly with no URL required.
• A channel URL — https://www.youtube.com/@channelname, /channel/UC…, /c/…, /user/…, or a bare @handle. It is normalized to the channel's /videos tab (unless the URL already targets /shorts or /streams) and expanded to up to maxVideosPerChannel videos found on that single page load — see the limitation noted in the FAQ below.
• A playlist URL — any URL containing list=… (or /playlist), expanded the same way, capped by maxVideosPerChannel.

📦 Output Format

Every video is pushed as one flat JSON row to the Apify dataset. The default dataset view surfaces 26 of the row's fields as table columns; the row itself carries 40 keys total — open the row-building code in src/main.py's process_video_sync() to see every key initialized up front, defaulting to null and only overwritten when genuinely found.

Output for the transcript row

This is the complete row shape, illustrated with representative values:

{
  "videoId": "4KbrxIpQgkM",
  "url": "https://www.youtube.com/watch?v=4KbrxIpQgkM",
  "status": "ok",
  "title": "How Neural Networks Actually Work",
  "channel": "Example Tech Channel",
  "channelId": "UCabcdefghijklmnopqrstuv",
  "channelUrl": "https://www.youtube.com/channel/UCabcdefghijklmnopqrstuv",
  "viewCount": 842193,
  "likeCount": 24710,
  "publishDate": "2024-03-11",
  "uploadDate": "2024-03-11",
  "durationSeconds": 912,
  "description": "In this video we break down how neural networks learn, step by step...",
  "category": "Education",
  "keywords": ["neural networks", "machine learning", "deep learning"],
  "thumbnail": "https://i.ytimg.com/vi/4KbrxIpQgkM/maxresdefault.jpg",
  "isLiveContent": false,
  "language": "English",
  "languageCode": "en",
  "isGenerated": false,
  "isTranslatable": true,
  "translationLanguages": [
    { "language": "Spanish", "languageCode": "es" },
    { "language": "French", "languageCode": "fr" }
  ],
  "translationLanguageCount": 2,
  "availableLanguages": [
    { "language": "English", "languageCode": "en", "isGenerated": false, "isTranslatable": true }
  ],
  "languageCount": 1,
  "translatedTo": null,
  "segmentCount": 318,
  "plainText": "Neural networks are, at their core, a way of approximating a function...",
  "segments": [
    {
      "start": 0.0,
      "duration": 3.44,
      "end": 3.44,
      "timestamp": "00:00:00",
      "text": "Neural networks are, at their core...",
      "url": "https://www.youtube.com/watch?v=4KbrxIpQgkM&t=0s"
    }
  ],
  "srt": "1\n00:00:00,000 --> 00:00:03,440\nNeural networks are, at their core...\n\n2\n...",
  "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:03.440\nNeural networks are, at their core...\n\n...",
  "wordCount": 2145,
  "characterCount": 12876,
  "readingTimeMinutes": 10.73,
  "aiSummary": null,
  "aiKeyPoints": null,
  "aiTopics": null,
  "aiChapters": null,
  "scrapedAt": "2026-07-26T00:00:00Z",
  "error": null
}

aiSummary, aiKeyPoints, aiTopics, and aiChapters are null unless aiEnhancement is true and a valid provider API key was resolved — the keys are always present on the row for schema stability, they're just unpopulated by default. translatedTo stays null unless translateTo was set and the chosen track's isTranslatable was true.

Output for video metadata

Metadata fields — title, channel, channelId, channelUrl, viewCount, likeCount, publishDate, uploadDate, durationSeconds, description, category, keywords, thumbnail, isLiveContent — are embedded in the same row above, not a separate dataset; this Actor returns one entity (a video's transcript-plus-metadata row). They come primarily from the watch page's ytInitialPlayerResponse JSON (videoDetails and microformat), with likeCount parsed separately from the page's accessibility text. If the primary fetch doesn't yield a title or channel, the Actor falls back once to the public oEmbed endpoint for title, channel, and thumbnail only. Unlike the transcript fetch, this metadata fetch is not retried on failure — a failed request simply leaves the affected fields null rather than blocking the row. viewCount and likeCount are reported honestly as null when YouTube doesn't expose them for a given video, never estimated.

Output for subtitles and language data

Also embedded in the same row: segments[] (when includeSegments is true), srt (when includeSrt is true), and vtt (when includeVtt is true) are all derived locally from the same fetched caption snippets — no extra request per format. availableLanguages[] lists every caption track YouTube offers for the video (language, languageCode, isGenerated, isTranslatable), regardless of which one was ultimately selected, so you can see what alternatives existed even for a video where the requested language/type wasn't available (status: "no_captions").

Schema stability and export options

The full field set stays the same across every run regardless of which optional toggles are on — unpopulated fields are null rather than the key being dropped, so downstream consumers can rely on a fixed schema. Results are stored in the Actor's default Apify dataset and can be exported from the Apify Console or API in JSON, CSV, Excel, XML, or HTML, or fetched programmatically via apify_client.

💡 YouTube Transcript Scraper Plus Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new video enters your workflow — a CMS webhook, a new row in a content calendar — passing that video's URL as the single startUrls entry. Read the finished dataset via the Apify API and write plainText, srt, and (with aiEnhancement on) aiSummary/aiTopics back onto the source record, ready for a blog draft or a subtitle upload, without a human re-transcribing anything.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify schedule to run the same channel or playlist URL daily or weekly. Diff each run's output against the previous one on videoId to detect new uploads, or on viewCount/likeCount for existing videos to catch which ones are gaining traction. maxVideosPerChannel controls how deep each scheduled run looks, since expansion reads only the channel or playlist's initial page load rather than paginating further.

🎯 Strategy 3: Bulk dataset build

For a research or training corpus, feed a large startUrls list — individual videos, or channel/playlist URLs with maxVideosPerChannel set to the volume you need per source — in one run, or split it across parallel runs. concurrency accepts up to the schema's documented maximum of 20; export the combined dataset to CSV or push it into a database via the Apify API's dataset endpoints.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Turning a new video into a blog draft or subtitle file on ingestion	On-demand, single-video, low maxVideosPerChannel	JSON via API, written back to source system
Scheduled monitoring	Tracking a channel's upload cadence and view/like trends	Recurring Apify schedule, same channel/playlist URL each run	JSON/CSV, diffed run-over-run
Bulk dataset build	Research corpora, RAG indexing, training data	One large run or several parallel runs, concurrency up to 20	CSV/JSON export or direct database load

🌴 Related YouTube Scrapers & Tools

Scraper	What it extracts
YouTube Channel Finder With Creator Analytics (Scraper-Engine)	Channel-level creator profile and analytics data
YouTube Comments & Replies Scraper (Scraper-Engine)	Comment threads on YouTube videos
Facebook Reels Scraper With Engagement Analytics	Short-form Facebook video data with engagement metrics
TikTok Trending Scraper With Trend Insights	Trending short-form video data on TikTok

How to integrate YouTube Transcript Scraper Plus with your stack

YouTube Transcript Scraper Plus works with any language or tool that can make an HTTP request to the Apify API. The examples below use the Actor name from .actor/actor.json: youtube-transcript-scraper-plus.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("youtube-transcript-scraper-plus").call(run_input={
    "startUrls": [
        "https://www.youtube.com/watch?v=4KbrxIpQgkM",
        "https://www.youtube.com/@channelname",
    ],
    "preferredLanguages": ["en"],
    "transcriptType": "any",
    "includeSrt": True,
    "includeVtt": True,
    "maxVideosPerChannel": 10,
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("transcripts.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print(f"Saved {len(rows)} transcript rows to transcripts.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });

const run = await client.actor('youtube-transcript-scraper-plus').call({
    startUrls: ['https://www.youtube.com/watch?v=4KbrxIpQgkM'],
    transcriptType: 'any',
    includeSrt: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Fetched ${items.length} transcript(s)`);
items.forEach(row => console.log(row.videoId, row.status, row.wordCount));

Async and scheduled pipelines

For large startUrls lists, call the Actor via apify_client's .start() method instead of .call() to fire the run and return immediately, then poll run status or subscribe to the run's webhook to know when the dataset is ready. For recurring collection off a channel or playlist, use an Apify schedule rather than a self-managed cron job.

🎯 Who Needs YouTube Transcript Scraper Plus? (Use Cases & Industries)

🏢 Content, marketing, and localization teams

Repurpose plainText from a channel's back catalog into blog posts or SEO content, and use srt/vtt plus translateTo to produce subtitle files in additional languages without a separate transcription vendor.

📊 AI and data engineering teams

Index plainText for RAG retrieval over a channel's video history, using segments[].url to link retrieval hits back to an exact moment in the source video; use the full row set as a typed feature table for classification or summarization models.

📱 Competitive intelligence analysts

Track a set of competitor or industry channels on a schedule and flag new videoId values or rising viewCount/likeCount on existing videos, with category and keywords segmenting output by content type.

🔬 Researchers

Build a public-data transcript corpus for discourse-analysis or content-trend research across as many public channels and playlists as your startUrls list covers; every field traces back to content YouTube serves to an unauthenticated visitor.

🎥 Accessibility and SaaS product builders

Use srt/vtt directly as subtitle files for an accessibility tool or video platform, or build a transcript-search product on the full row set — schema stability across runs means the same integration works whether or not AI enrichment is turned on.

Is it legal to scrape YouTube?

Scraping publicly accessible web pages is generally lawful in the United States — the Ninth Circuit's hiQ Labs v. LinkedIn (2019, reaffirmed 2022) held that scraping data a website makes available without a login does not violate the Computer Fraud and Abuse Act. That precedent concerns unauthorized-access law, not YouTube's own Terms of Service — scraping in a way that violates a platform's ToS is a separate matter of civil contract risk, not a criminal one.

This Actor's output includes creator-identity fields (channel, channelId, channelUrl) where a channel is operated by an individual rather than a brand or organization; if you store or process this data about identifiable people, data protection laws such as the GDPR (EU/UK) or the CCPA (California) may apply depending on your jurisdiction and use case. The transcript and video-metadata fields themselves are content YouTube publishes for public viewing, not personal data about a data subject.

YouTube Transcript Scraper Plus returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data or republished content.

❓ Frequently asked questions

Does YouTube Transcript Scraper Plus work without a YouTube account?

Yes. Every request is an unauthenticated HTTP call to YouTube's public watch, channel, and playlist pages, plus the public oEmbed endpoint — no login, cookies beyond a consent cookie, or API key are required for scraping itself. An API key is only needed if you turn on aiEnhancement.

How does YouTube Transcript Scraper Plus handle YouTube's anti-scraping measures?

Apify Residential Proxy is the schema default (apifyProxyGroups: ["RESIDENTIAL"]), since YouTube blocks datacenter IPs for transcript requests. Transcript fetches retry up to 4 times (MAX_TRANSCRIPT_TRIES) on transient errors — matched against a fixed list of exception-name fragments (blocked, ssl, connection, timeout, proxy, maxretry, chunked, requestfailed, toomanyrequests) — with each retry rotating to a fresh sticky-session residential IP and a short backoff between attempts. Concurrent workers are also assigned different starting IPs from the same pool, so parallel videos don't share a session.

Can I run YouTube Transcript Scraper Plus at scale without getting blocked?

concurrency is schema-capped at 20. Internally, the proxy pool is sized to min(60, max(8, concurrency + 8)) residential URLs, so pool size scales with concurrency up to a 60-URL ceiling. No uptime or block-rate figure is published for this Actor; reliability in practice depends on your Apify proxy plan and YouTube's own rate limiting, both outside this Actor's control.

How fresh is the data YouTube Transcript Scraper Plus returns?

Every run fetches live from YouTube's own watch/channel/playlist pages at the time it runs — nothing is cached or served from a prior run. scrapedAt on every row records exactly when that row was collected.

Which fields work best for AI training and RAG indexing?

For RAG, index plainText alongside title, channel, publishDate, and url, using segments[].url to deep-link a retrieval hit to its exact moment in the video. For training data, wordCount, readingTimeMinutes, category, durationSeconds, and isGenerated form a consistently typed feature set — every field returns as a typed primitive, never a string requiring parsing. With aiEnhancement on, aiTopics adds a pre-extracted category layer.

What happens to personal data returned by this Actor?

YouTube Transcript Scraper Plus returns publicly available video content and metadata, including creator-identity fields (channel, channelId, channelUrl) where the channel is operated by an individual. The lawful basis for storing and using that data — and compliance with GDPR, CCPA, or other applicable data protection law — sits with you as the operator of the run, not with the Actor.

Does YouTube provide an official API I could use instead?

Partially. YouTube's Data API v3 can return video statistics such as view and like counts, but its caption-retrieval endpoints are scoped to videos the authenticated account owns — they are not built to fetch transcript text for arbitrary third-party videos the way this Actor does. Building that path yourself means integrating a separate caption-extraction library (this Actor uses youtube-transcript-api), handling YouTube's anti-bot IP blocking with your own proxy rotation, and re-solving both every time YouTube changes its front end.

Does YouTube Transcript Scraper Plus work with Claude, ChatGPT, and other AI agent tools?

There is no dedicated MCP server documented for this Actor. It is callable as an HTTP endpoint by any agent framework through the Apify API — every response is typed JSON, so no parsing step is required before passing a transcript row into an LLM's context window. Note that the Actor itself also calls out to an LLM when aiEnhancement is on, using whichever provider you select in aiModel.

How does YouTube Transcript Scraper Plus compare to other YouTube transcript scrapers?

karamelo/youtube-transcripts documents the richest competing metadata set — 14 added data points including subscriber count and comment count — plus multiple export formats including XML (observed on the Apify Store, 2026-07-26); it doesn't document SRT/WebVTT output, manual-vs-auto filtering, translation, or AI enrichment. pintostudio/youtube-transcript-scraper and topaz_sharingan/Youtube-Transcript-Scraper-1 both document simple single-or-list video-URL inputs with plain transcript output and no channel/playlist expansion, metadata, subtitle files, or AI layer (observed on the Apify Store, 2026-07-26). Where this Actor differs from all three: authoritative is_generated/isTranslatable flags rather than guessed values, native SRT/WebVTT generation, channel/playlist expansion, and optional multi-provider AI enrichment in the same run.

ℹ️ Disclaimer

YouTube Transcript Scraper Plus extracts only publicly available data from YouTube. This tool is intended for lawful use cases only. Users are responsible for complying with YouTube's terms of service and applicable data protection laws in their jurisdiction.