YouTube Video Subtitles Scraper: Caption Coverage Insights Data

YouTube Subtitles Scraper — Caption Coverage, Audits and Transcripts

This YouTube subtitles scraper audits a batch of YouTube video URLs and reports, per video, exactly which caption languages exist — split into manual (creator-uploaded) and auto-generated tracks — cross-checked against the specific language codes your project needs, before you commit to a bigger fetch. It then pulls the full timestamped transcript for one primary language, labelled with honest provenance (never a silently substituted language). Unlike scraping frameworks that return raw HTML or an unlabelled transcript blob, this Actor returns typed JSON with a requiredLanguageCoverage array per video — ready for a localization backlog, a training corpus, or a compliance check without any parsing. This guide covers every input and output field and how localization, research, and AI-data teams actually deploy it.

🧭 What Does This YouTube Subtitles Scraper Do?

It takes a list of individual YouTube video or Shorts URLs and, for each one, builds a single audit row: standard video metadata, a full inventory of manual vs. auto-generated caption languages, a coverage check against the languages you specify, and the full transcript text for exactly one primary language. No YouTube account or login is required — the Actor reads the same public caption listing YouTube itself publishes for the video.

• 🗣️ Manual vs. auto-generated caption language inventory, with counts
• 📋 Per-language coverage verdict (manual / auto / unavailable) against your required language list
• 📝 Full timestamped transcript (start, dur, text segments) for one primary language, with its source labelled
• 🎬 Video metadata: title, channel name/ID/URL, duration, views, publish date, description, tags, likes, comments
• 🚦 A structured status and human-readable message on every row, success or failure
• ⚙️ Configurable concurrency (1–10 videos in parallel) and optional Apify Proxy for larger batches

⚡ Features & Capabilities

The core of this Actor is the audit-before-you-fetch workflow, backed by a retry-and-reroute strategy for reliability.

Core features

• Per-video caption inventory split into availableManualLanguages and availableAutoLanguages, each with a count field
• requiredLanguageCoverage: one { "language": ..., "availableAs": "manual" | "auto" | "unavailable" } entry per code you supply in requiredLanguages
• Single-primary-language transcript fetch via transcript (array of { start, dur, text } segments), with transcriptSource and transcriptLanguageUsed always naming exactly what was fetched
• isTranscriptTranslated is always false — this Actor never machine-translates a transcript into your primary language; if the language has no track, it reports no_transcript instead of substituting one
• Automatic retry (up to 3 attempts per video) that reroutes through a residential proxy group after the first failed attempt, rather than repeating the same failing request

When another tool might suit you better

This Actor fetches full transcript text for one primary language per video, by design — requiredLanguages only drives the coverage audit, not bulk transcript fetching. If your workflow needs full transcript text in many languages for the same batch of videos in a single run, or needs to resolve channel usernames/handles into a video list first, this tool isn't built for that; it's built specifically for the audit-first, single-language workflow described above.

YouTube Subtitles Scraper within the Scrapio data stack

This Actor covers per-video caption inventory, coverage auditing, and single-language transcript extraction. For AI-generated video summaries and most-replayed-segment highlights instead of raw captions, see Youtube Video Summarizer & Most-Replayed Highlights. For the equivalent transcript-and-caption workflow on Facebook rather than YouTube, see Facebook Video Transcript With Caption Extractor.

Why do developers and data teams scrape YouTube captions and transcripts?

🏢 Localization and captioning teams

Before committing budget to a captioning or dubbing project, localization teams need to know what already exists. Feed a batch of video URLs with your target requiredLanguages (e.g. en, es, fr, de-DE) and read requiredLanguageCoverage on each row: it tells you, per video and per language, whether a manual track already exists, an auto-generated one exists, or nothing does — before you commission new subtitle work on a video that already has it, or skip one that doesn't.

📊 AI training data and RAG indexing

The transcript array's text segments, alongside description and tags, are the high-information text fields for both use cases. For RAG enrichment, indexing transcript text against title and channelId gives you searchable, source-attributed video content without a separate transcription step. For training data, status and success give a consistent, structured signal for filtering out unavailable or caption-less videos before they pollute a corpus — every field returns as a typed primitive, not a string that needs parsing.

📱 Content operations and creator intelligence

Content and creator-ops teams tracking a set of channels or campaigns can monitor hasManualCaptions and manualLanguageCount across a batch to see which videos are accessibility-compliant and which rely only on auto-generated captions, which are lower quality and sometimes wrong.

🔬 Research and academic use

Linguistics and media-studies researchers building corpora from publicly posted video content can use the coverage audit to select only videos with manual captions in a target language before pulling transcript text, avoiding auto-generated noise in a dataset meant to reflect real usage. Public data only.

🎥 Product and SaaS development

Accessibility-auditing tools, localization-vendor dashboards, and transcript-search products can build on requiredLanguageCoverage and transcript directly, without maintaining a caption-scraping layer themselves.

🍚 Input Parameters

Parameter	Required	Type	Constraints	Description
videosToCheck	No	array of strings	editor: stringList	One YouTube video URL per line, for example https://www.youtube.com/watch?v=VIDEO_ID, https://youtu.be/VIDEO_ID or a /shorts/ link. Channel or username input is not supported.
startUrls	No	array of strings	editor: stringList	Legacy alias for videosToCheck, kept so input built for the base YouTube Video Subtitles Scraper keeps working unchanged. Used only when videosToCheck is left empty.
requiredLanguages	No	array of strings	editor: stringList	One YouTube caption language code per line, e.g. en, es, fr, de-DE, pt-BR. Each video's row reports, per code, whether captions exist as manual, auto-generated, or unavailable. Leave empty to skip the coverage check and only fetch the primary-language transcript.
preferManualOverAuto	No	boolean	default true	When the primary transcript language has both a manual and an auto-generated track, true fetches the manual track and false fetches the auto-generated one. No effect when only one type exists.
language	No	string	editor: textfield, default en	The single language the full transcript is fetched for. This Actor never fetches full transcript text in more than one language per video — use requiredLanguages to check availability across many languages without fetching them all. Leave empty to use the first entry in requiredLanguages, or en if that is also empty.
includeFullInventory	No	boolean	default true	When true, every manual and auto-generated language code found on the video is listed (a well-captioned video can carry dozens of auto-generated codes). When false, only the coverage result for requiredLanguages is returned, keeping rows compact.
maxWorkers	No	integer	min 1, max 10, default 4	How many videos are audited in parallel. Higher values finish a large batch faster; values outside 1–10 are clamped by the Actor.
proxyConfiguration	No	object	editor: proxy	Apify Proxy configuration. Leave on default settings for normal use; configure a proxy for better reliability on larger batches.

No parameter is required — the Actor accepts an empty run configuration, but fails immediately with a clear status message if no video URLs are found in either videosToCheck or startUrls.

Example input:

{
  "videosToCheck": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/jNQXAC9IVRw"
  ],
  "requiredLanguages": ["en", "es", "fr"],
  "preferManualOverAuto": true,
  "language": "en",
  "includeFullInventory": true,
  "maxWorkers": 4,
  "proxyConfiguration": { "useApifyProxy": true }
}

Supported URL types and input formats

Only individual video/short URLs are accepted; channel names, handles, and usernames are rejected as invalid input (status: "invalid_input").

• Standard watch URL: https://www.youtube.com/watch?v=dQw4w9WgXcQ
• Short link: https://youtu.be/dQw4w9WgXcQ
• Shorts URL: https://www.youtube.com/shorts/dQw4w9WgXcQ

Any other URL shape — a channel page, a search results page, a playlist URL, or a bare username — is not validated by the Actor and produces an invalid_input row rather than being silently skipped.

📦 Output Format

Every run produces one row per input video URL, always in the same 29-key shape whether the video succeeded, failed, or was rejected as invalid input. Data is delivered as an Apify Dataset, exportable to JSON, CSV, Excel, XML, RSS or HTML directly from the Apify Console or via the API.

Output for a successfully audited video

{
  "type": "video",
  "id": "dQw4w9WgXcQ",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "channel_name": "Rick Astley",
  "channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channelUrl": "https://www.youtube.com/channel/UCuAXFkgsw1L7xaCfnd5JJOw",
  "length": "3:33",
  "views": 1670802394,
  "publishedAt": "2009-10-25T00:00:00Z",
  "description": "The official video for \"Never Gonna Give You Up\" by Rick Astley.",
  "tags": ["Rick Astley", "Never Gonna Give You Up", "80s"],
  "likeCount": 18500000,
  "commentCount": 2200000,
  "hasManualCaptions": true,
  "hasAutoCaptions": true,
  "availableManualLanguages": ["en", "de-DE", "es-419", "ja", "pt-BR"],
  "manualLanguageCount": 5,
  "availableAutoLanguages": ["en", "fr", "de", "hi", "id"],
  "autoLanguageCount": 42,
  "requiredLanguageCoverage": [
    { "language": "en", "availableAs": "manual" },
    { "language": "es", "availableAs": "unavailable" },
    { "language": "fr", "availableAs": "auto" }
  ],
  "transcriptSource": "manual",
  "transcriptLanguageUsed": "en",
  "isTranscriptTranslated": false,
  "transcript": [
    { "start": "0.240", "dur": "3.520", "text": "We're no strangers to love" },
    { "start": "3.760", "dur": "3.120", "text": "You know the rules and so do I" }
  ],
  "message": "Transcript loaded for the requested language.",
  "status": "success",
  "success": true,
  "scrapedAt": "2026-08-15T09:12:41.203Z"
}

Output for an unavailable or invalid video

{
  "type": "video",
  "id": null,
  "url": "https://www.youtube.com/channel/SomeChannelName",
  "title": "Invalid Input",
  "channel_name": null,
  "channelId": null,
  "channelUrl": null,
  "length": "0:00",
  "views": null,
  "publishedAt": null,
  "description": null,
  "tags": null,
  "likeCount": null,
  "commentCount": null,
  "hasManualCaptions": null,
  "hasAutoCaptions": null,
  "availableManualLanguages": null,
  "manualLanguageCount": null,
  "availableAutoLanguages": null,
  "autoLanguageCount": null,
  "requiredLanguageCoverage": [],
  "transcriptSource": null,
  "transcriptLanguageUsed": null,
  "isTranscriptTranslated": false,
  "transcript": [],
  "message": "Invalid input - only YouTube video URLs are accepted (e.g. https://www.youtube.com/watch?v=VIDEO_ID or https://youtu.be/VIDEO_ID).",
  "status": "invalid_input",
  "success": false,
  "scrapedAt": "2026-08-15T09:13:02.877Z"
}

Schema stability and export options

The 29-key row shape is identical across success and failure paths — every field listed above is always present, so downstream code never has to branch on missing keys. status takes one of five values: success, no_transcript (video found, but no caption track exists for the primary language, or the track returned no usable text), video_unavailable (video removed, private, or non-existent), invalid_input (URL rejected before any request was made), or temporary_issue (retries exhausted). Rows are written incrementally as each video finishes, and the dataset can be exported to JSON, CSV, Excel, XML, RSS or HTML from the Apify Console, or pulled programmatically via the Apify API or apify_client.

⚠️ Every row pushed to the dataset — including invalid_input, video_unavailable, no_transcript and temporary_issue rows — is billed as one row_result event; there is no separate free or uncharged error row. Filter on success: true (or a specific status value) if you only want to count successfully audited videos.

💡 YouTube Subtitles Scraper Strategy Guide

🎯 Strategy 1: Real-time localization backlog enrichment

Trigger a run whenever a new video is published or added to a localization backlog. Run the Actor with the video's URL in videosToCheck and your project's requiredLanguages. Append requiredLanguageCoverage, hasManualCaptions, and manualLanguageCount to the video's row in your CMS or ticketing system, so a producer can see at a glance which languages still need commissioning — without opening YouTube manually for each title.

🎯 Strategy 2: Scheduled caption-coverage monitoring

Use an Apify Schedule to re-run the Actor against the same list of video URLs on a recurring cadence. Diff the new run's availableManualLanguages and requiredLanguageCoverage against the previous run's dataset on id. Alert only when a required language's availableAs value changes — for example from unavailable to manual, meaning a creator or platform just added the caption track you were waiting on.

🎯 Strategy 3: Bulk transcript dataset build

Feed a large list of video URLs into videosToCheck, set maxWorkers up to its maximum of 10 to audit and fetch in parallel, and let each video's row land in the dataset independently. Filter the resulting dataset on success: true and export transcript, title, and channel_name to CSV or a database table to build a transcript corpus, discarding rows where status is no_transcript or video_unavailable.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Localization backlog triage	Triggered per new video	Dataset row appended to CMS/ticket
Scheduled monitoring	Tracking caption additions over time	Apify Schedule, recurring	Dataset diffed run-over-run
Bulk dataset build	Research or training corpora	One large parallel run	CSV / database export

🌴 Related YouTube Scrapers & Tools

Scraper Name	What it extracts
Youtube Video Summarizer & Most-Replayed Highlights	AI-generated summaries and most-replayed-segment highlights for YouTube videos
Facebook Video Transcript With Caption Extractor	Full transcript and caption text from Facebook videos — the same audit-and-fetch pattern, different platform

How to integrate YouTube Subtitles Scraper with your stack

YouTube Subtitles Scraper works with any language or tool that can make an HTTP request through the Apify API. The examples below use the official apify-client SDKs.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "videosToCheck": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://youtu.be/jNQXAC9IVRw",
    ],
    "requiredLanguages": ["en", "es", "fr"],
    "language": "en",
    "includeFullInventory": True,
    "maxWorkers": 4,
}

run = client.actor("<your-username>/youtube-video-subtitles-scraper-caption-coverage-insights-data").call(
    run_input=run_input
)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
successful = [r for r in rows if r["success"]]

print(f"{len(successful)}/{len(rows)} videos audited successfully")
for row in successful:
    print(row["id"], row["status"], row["requiredLanguageCoverage"])

Node.js

import { ApifyClient } from 'apify-client';

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

const runInput = {
    videosToCheck: [
        'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
    ],
    requiredLanguages: ['en', 'es', 'fr'],
    language: 'en',
    includeFullInventory: true,
    maxWorkers: 4,
};

const run = await client.actor('<your-username>/youtube-video-subtitles-scraper-caption-coverage-insights-data').call(runInput);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach((row) => console.log(row.id, row.status, row.requiredLanguageCoverage));

Async and scheduled pipelines

For large batches, start the run via the API and poll the run status or dataset item count instead of waiting synchronously — a fire-and-forget pattern for jobs with hundreds of videos. For recurring audits, use an Apify Schedule to trigger the same input on a cron cadence, and an Apify webhook on run completion to notify your own system rather than polling continuously.

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

🏢 Localization and captioning teams

Vendors and in-house localization teams check requiredLanguageCoverage across a video catalogue before quoting or scheduling captioning work, avoiding duplicate spend on languages that already have manual tracks.

📊 AI/ML and data teams

Teams building RAG indexes or training corpora filter on success and status, then index transcript text and description fields — typed and pre-segmented, with no HTML or ad-hoc transcript parsing required.

📱 Content operations teams

Teams managing a portfolio of channels track hasManualCaptions and manualLanguageCount per video to flag accessibility gaps across a content library.

🔬 Researchers

Linguistics, media studies, and social-science researchers use the coverage audit to select videos with genuine manual captions in a target language before pulling transcript text for a public-data corpus.

🎥 Product and SaaS builders

Accessibility-auditing tools and transcript-search products consume requiredLanguageCoverage and transcript as a ready-made data layer instead of building and maintaining their own caption-scraping code.

Is it legal to scrape YouTube captions and video metadata?

Scraping publicly accessible web data is generally lawful in the United States — courts have repeatedly held that access to data a website makes available to the public, without circumventing a login wall, is not a violation of the Computer Fraud and Abuse Act (see hiQ Labs, Inc. v. LinkedIn Corp., 9th Cir. 2019). That precedent does not, however, override a platform's own Terms of Service, which is a separate, contractual question: violating YouTube's Terms of Service is a civil matter between you and YouTube, not a criminal one, but it is still a real risk to weigh for commercial use.

This Actor returns video metadata, caption-language inventories, and transcript text — public content published by the video's uploader, not private profile data. A channel_name can occasionally be an individual's real name rather than a brand or handle; treat any such field with the same care you would any personal name under applicable data protection law (GDPR, CCPA) if you store or process it further. YouTube Subtitles Scraper returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications, especially where an individual's name appears in the results.

❓ Frequently asked questions

Does YouTube Subtitles Scraper work without a YouTube account?

Yes. No YouTube login, API key, or cookies are required — the Actor reads the same public caption listing YouTube publishes for each video's page.

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

It retries each video up to 3 times on transient failures. After the first failed attempt, it reroutes the next attempt through a residential Apify Proxy group instead of repeating the same request, with a short backoff between attempts. A proxy configuration is optional but recommended for larger batches.

Can I run YouTube Subtitles Scraper at scale without getting blocked?

Concurrency is configurable from 1 to 10 videos in parallel via maxWorkers; values outside that range are clamped automatically. There is no published uptime or success-rate figure — reliability depends on your proxy configuration and batch size, and failures are reported per-row via status rather than failing the whole run.

How fresh is the data YouTube Subtitles Scraper returns?

Every run performs a live fetch against YouTube at request time — nothing is cached or served from a previous run. Each row's scrapedAt timestamp records exactly when that video was audited.

Which fields work best for AI training data and RAG indexing?

For RAG, index the text values inside the transcript array alongside title and description — the highest-information text fields. For training data, status and success give a consistent structured filter, and requiredLanguageCoverage gives a stable per-language label. Every field is returned as a typed primitive (string, number, boolean, array, or object) requiring no further normalization before use.

Is scraping YouTube captions a Terms of Service risk?

It can be, for commercial use — YouTube's Terms of Service restrict certain automated access, and violating them is a civil contractual risk rather than a criminal one. This Actor only accesses publicly viewable video pages and caption tracks; it does not bypass any login or paywall.

Does YouTube Subtitles Scraper return personal data?

Mostly no — the output is video and caption metadata, not user profiles. The one field that can occasionally be personal data is channel_name, where an individual creator uses their real name as their channel name. The Actor returns only what YouTube already displays publicly; the lawful basis for storing or further processing that data sits with you.

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

There is no dedicated MCP server for this Actor. It is callable as a standard Apify API endpoint by any agent framework capable of making an HTTP request or using the apify_client/apify-client SDKs — every response is typed JSON, ready to drop into an LLM context window without parsing.

What happens if the primary language has no captions at all?

transcriptSource and transcriptLanguageUsed are both null, transcript is an empty array, status is no_transcript, and success is false. The Actor never substitutes a different language's captions and reports it as the one you requested.

Can I audit channel usernames or channel URLs instead of individual videos?

No — only individual video and Shorts URLs are accepted. A channel, handle, or username URL is rejected as invalid_input rather than silently expanded into a video list.

ℹ️ Disclaimer

YouTube Subtitles Scraper extracts only publicly available video metadata, caption-language listings, and transcript text 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.