YouTube Video Details Scraper With Subtitles & Translations

YouTube Video Scraper — Details, Subtitles and Translations

Extract full YouTube video metadata plus a properly segmented transcript — one video URL or ID in, one typed JSON row out. This YouTube video scraper returns title, description, view/like/comment counts, channel data and thumbnails alongside timestamped subtitle cues, native SRT/WebVTT caption files, and a second transcript translated by YouTube's own tlang parameter. Unlike scraping frameworks that hand back raw HTML or a naive word-list transcript, it returns ready-to-use JSON — no parsing, no de-duplication, no timestamp cleanup required before it hits your database, your model, or your pipeline. This guide covers every input parameter, every output field, and how teams run it for enrichment, monitoring, and bulk dataset builds.

---

🧭 What Does This YouTube Video Scraper Do?

It takes one or more YouTube video URLs or bare video IDs and, for each, returns a single dataset row combining video metadata, a subtitle transcript, and (optionally) a translated transcript. No YouTube account or login is required — everything is read from YouTube's public video page and its public caption endpoint. It does not accept playlist or channel URLs; those are rejected with a machine-readable reason so a malformed run doesn't produce garbage rows.

• Video metadata — title, description, publish date, duration, views, likes, comments, tags, hashtags, category, resolution, thumbnails
• Channel data — channel ID, name, handle, subscriber count, verification badge, and (optionally) avatar
• Event-aligned subtitle transcripts — one cue per YouTube caption event, not one row per word fragment
• Selectable caption source — human-uploaded subtitles vs. YouTube's auto-generated (ASR) captions, in either preference order
• Native SRT and WebVTT export — fetched directly from YouTube's caption endpoint in that format, never transcoded locally
• A second, YouTube-translated transcript in any language YouTube supports for that video
• Machine-readable failure reasons (noTranscriptReason, noTranslationReason) instead of silent blanks

---

Features & Capabilities

The core of this Actor is the caption pipeline; everything else is standard video metadata extraction hardened against YouTube's anti-bot layer.

Core features

• Event-aligned transcript segmentation — YouTube's json3 caption payload nests word-level segs (each with a tOffsetMs) inside timed events. This Actor emits one cue per event: start = the event's tStartMs plus the first non-blank segment's tOffsetMs, all segments in the event joined into one line of text, whitespace-only segments dropped, and overlapping auto-generated cues clamped so two cues never collide.
• Caption source control — captionSource picks the pool: human subtitles first (default), auto-generated first, or restrict to one pool with no fallback at all.
• Language matching — exact key match, then case-insensitive, then base-language prefix (en also matches en-US).
• Native raw formats — choosing srt or vtt in subtitlesFormat fetches that exact format from YouTube's timedtext endpoint into transcriptSrt / transcriptVtt. Nothing is transcoded locally.
• YouTube-native translation — translateTranscriptTo passes YouTube's own tlang query parameter on the caption request; the response is a second, already-translated caption track from YouTube itself.
• Uncharged accounting rows — invalid input URLs and failed extractions are still written to the dataset for visibility, but only successfully scraped videos incur a video_result charge.
• Proxy escalation — a bot-walled request escalates the route (direct → datacenter → residential) and rotates the session, rather than just sleeping and retrying the same IP.

The proxy ladder has three rungs, and the Actor moves up it automatically rather than retrying the same blocked route:

Rung	When it's used	Behavior on a bot-wall
none (container IP)	proxyConfiguration.useApifyProxy is false	Escalates to datacenter on the next failed attempt
datacenter	Escalated from none, or explicitly requested without RESIDENTIAL	Escalates to residential on the next failed attempt
residential	Default (apifyProxyGroups: ["RESIDENTIAL"])	Rotates to a new residential session on the same rung

A rotation requests a fresh proxy session at the same rung; an escalation moves to the next rung entirely. Both video-page extraction and caption-payload fetches share the same ladder instance for a given video, so a bot-wall hit on one step raises the route for the rest of that video's requests too.

⚠️ Videos in startUrls are processed sequentially, not in parallel — one video at a time, with a randomized 0.5–1.5 second pause between videos. There is no maxConcurrency input. For very large URL lists this trades run duration for a steadier, less bot-wall-prone request pattern; split a very large batch across multiple runs if you need shorter individual run times.

How this scraper compares to other YouTube scrapers

Feature	This Actor	genial_candlestand/youtube-subtitles-scraper	deanter/youtube-video-details-scraper
Transcript segmentation	Event-aligned, one cue per caption event	Per-segment rows (per their own output sample)	Not documented
Caption source control	Human/auto, either preference, no-fallback modes	Toggle auto-generated on/off only (per their README)	Fixed to Russian, falling back to English only (per their README)
Native SRT / WebVTT	Yes, fetched natively	Not documented	Not documented
YouTube-native translation	Yes, via tlang, no third-party service	Not documented	Not documented
Language selection	Any ISO code, with fallback control	Not documented	Not selectable — hardcoded Russian/English
Output format	Typed JSON, 44 fields per video	Typed JSON, per-caption-line rows	Typed JSON

Observed on each competitor's own Apify Store listing and README as of 2026-07-08. If your use case is feeding structured data to an LLM, the output-format and field-depth rows are the decision-maker — an untyped or per-word transcript is a reliability failure mode inside an agent loop, not a feature gap you can shrug off.

When another tool might suit you better

If you need a transcript for a video that has no caption track at all — no human subtitles, no auto-generated captions — this Actor correctly reports hasTranscript: false rather than fabricating one, because it only reads YouTube's own caption tracks. memo23/youtube-video-details-scraper advertises a Whisper-AI speech-to-text fallback for exactly that case (per their own listing, checked 2026-07-08); if guaranteed transcript coverage on caption-free videos matters more than knowing the transcript is YouTube's own, that fallback is a genuine reason to look there instead. The same listing also advertises downloading the video file itself to a key-value store — a feature this Actor does not offer.

This scraper within the Scrapio YouTube data stack

This Actor covers video-level detail: metadata, subtitles, and translations. For discovering and extracting publicly listed contact signals (emails, cross-platform social links) from YouTube channels rather than individual videos, use youtube-channel-contact-extractor. Both read only publicly available YouTube pages and require no YouTube account.

---

Why do developers and data teams scrape YouTube?

Content and creator research

Marketing and content teams pull video metadata and full transcripts to analyze what a channel or competitor is actually saying — not just posting frequency. Feeding title, description, tags, and transcriptText into a spreadsheet or BI tool turns a video catalogue into a searchable script archive.

AI training data and RAG indexing

transcriptText and translatedTranscriptText are the fields that matter for AI: they are clean, de-duplicated spoken-word text with no caption-file artifacts. For RAG enrichment, indexing transcriptText alongside title and description lets an agent answer "what does this video say about X" instead of just "what is this video called." For training data, the timestamped transcript array (with start, end, startSeconds, endSeconds, text per cue) gives consistent, structured alignment between spoken text and time — useful for building speech- or caption-aligned datasets without re-parsing raw caption files.

Competitive and market intelligence

Tracking views, likes, comment_count, and the derived engagement_rate across a channel's video list over repeated runs shows which topics and formats are actually landing, without relying on YouTube's own analytics dashboard.

Research and academic use

Public-data research on spoken content — discourse analysis, misinformation studies, language-learning corpora — draws on transcriptText and translatedTranscriptText across many public videos. This Actor extracts only what YouTube already serves publicly; it does not access private or unlisted videos, comments, or analytics.

Product and SaaS development

Transcript search tools, subtitle-translation products, and video-content monitoring dashboards can be built directly on this Actor's output — transcript, transcriptSrt, and transcriptVtt are already in the formats a video player or editor expects.

Localization and subtitle QA workflows

Subtitle vendors and localization teams use translatedTranscript as a machine-translated starting draft for a human-reviewed localized track, and compare transcriptLanguage against availableSubtitleLanguages / availableAutoCaptionLanguages to see which languages a video already has native creator-uploaded subtitles for versus which would need a fresh translation pass.

---

🍚 Input Parameters

All parameters below are read directly from the Actor's input schema, in schema order. Only startUrls is required.

Parameter	Required	Type	Default	Description
startUrls	Yes	array	—	One entry per video. Accepts https://www.youtube.com/watch?v=ID, https://youtu.be/ID, /shorts/ID, /live/ID, /embed/ID, and bare 11-character video IDs. Playlist and channel URLs are rejected with a reason instead of producing a malformed row.
subtitlesLanguage	No	string	""	ISO code of the caption track to fetch, e.g. en, en-US, es, de, pt-BR, hi, ja. Matched exact first, then case-insensitive, then base-language (en also matches en-US). Empty uses the video's own language, then English, then the first available track.
captionSource	No	string (enum)	human_first	Which caption pool to read: human_first (human subtitles, auto-generated as fallback), auto_first (auto-generated first, human as fallback), human_only (no ASR fallback), auto_only (no human fallback).
subtitlesFormat	No	string (enum)	timestamped	timestamped and plaintext are always produced (transcript and transcriptText). Choosing srt or vtt additionally fetches that exact native format into transcriptSrt / transcriptVtt.
translateTranscriptTo	No	string	""	ISO code for a second transcript translated by YouTube's own tlang parameter — no third-party translation service, no API key. The original-language transcript is still returned alongside it. Empty skips translation.
allowLanguageFallback	No	boolean	true	When the requested subtitlesLanguage isn't available: true picks the best available track instead; false returns transcript: null with noTranscriptReason: language_not_available.
skipVideosWithoutTranscript	No	boolean	false	true drops videos with no usable caption track entirely — no dataset row, no charge. false still returns the full metadata row with hasTranscript: false and a reason.
includeChannelLogo	No	boolean	true	Fills channel.logo by loading the channel's About page. Results are cached per channel within a run, so multiple videos from one channel cost one extra request, not one per video.
proxyConfiguration	No	object	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}	Standard Apify proxy configuration object.

{
  "startUrls": [
    { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" },
    "jNQXAC9IVRw"
  ],
  "subtitlesLanguage": "en",
  "captionSource": "human_first",
  "subtitlesFormat": "srt",
  "translateTranscriptTo": "es",
  "allowLanguageFallback": true,
  "skipVideosWithoutTranscript": false,
  "includeChannelLogo": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Supported URL types and input formats

startUrls accepts, per entry, either an object with a url key or a bare string:

• Standard watch URL: https://www.youtube.com/watch?v=dQw4w9WgXcQ
• Short link: https://youtu.be/jNQXAC9IVRw
• Shorts, live, and embed paths: /shorts/ID, /live/ID, /embed/ID
• Bare 11-character video ID with no URL at all: dQw4w9WgXcQ

Playlist URLs (/playlist, list= without watch?v=) and channel URLs (/@handle, /channel/ID, /c/, /user/, without watch?v=) are detected and rejected with playlist_url_not_supported or channel_url_not_supported instead of being silently mishandled.

---

📦 Output Format

Every run produces one JSON row per input video (or per rejected input). The default dataset view (Videos, Transcripts & Translations) surfaces all 44 fields the Actor writes — there is no hidden field beyond the view here.

Output for a scraped video

{
  "type": "video",
  "video_id": "dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "description": "The official video for “Never Gonna Give You Up” by Rick Astley...",
  "channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channel_name": "Rick Astley",
  "channel": {
    "id": "UCuAXFkgsw1L7xaCfnd5JJOw",
    "name": "Rick Astley",
    "handle": "RickAstleyYT",
    "url": "https://www.youtube.com/@RickAstleyYT",
    "subscriberCount": "3.5M subscribers",
    "logo": "https://yt3.googleusercontent.com/...",
    "badges": ["Verified"]
  },
  "published_date": "2009-10-25",
  "duration_seconds": 213,
  "views": 1650000000,
  "likes": 18000000,
  "comment_count": 2300000,
  "engagement_rate": 0.0123,
  "tags": ["Rick Astley", "Never Gonna Give You Up", "80s"],
  "hashtags": [],
  "category": "Music",
  "language": "en",
  "live_status": "none",
  "upload_type": "normal",
  "resolution": "1920x1080",
  "maxResolutionHeight": 1080,
  "fps": 25,
  "thumbnails": {
    "default": "https://i.ytimg.com/vi/dQw4w9WgXcQ/default.jpg",
    "medium": "https://i.ytimg.com/vi/dQw4w9WgXcQ/mqdefault.jpg",
    "high": "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg",
    "standard": "https://i.ytimg.com/vi/dQw4w9WgXcQ/sddefault.jpg",
    "maxres": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg"
  },
  "hasTranscript": true,
  "noTranscriptReason": null,
  "transcriptSegmentCount": 52,
  "transcriptSourceEventCount": 103,
  "transcriptSourceType": "auto",
  "transcriptLanguage": "en",
  "transcriptIsAutoGenerated": true,
  "transcript": [
    {
      "start": "18.800",
      "dur": "3.000",
      "end": "21.800",
      "startSeconds": 18.8,
      "endSeconds": 21.8,
      "text": "We're no strangers to love. You know the rules and so do"
    }
  ],
  "transcriptText": "We're no strangers to love. You know the rules and so do I...",
  "transcriptSrt": "1\n00:00:18,800 --> 00:00:21,800\nWe're no strangers to love...\n",
  "transcriptVtt": null,
  "translatedToLanguage": "es",
  "translatedTranscript": [
    {
      "start": "18.800",
      "dur": "3.000",
      "end": "21.800",
      "startSeconds": 18.8,
      "endSeconds": 21.8,
      "text": "No somos extraños al amor. Conoces las reglas y yo también"
    }
  ],
  "translatedTranscriptText": "No somos extraños al amor. Conoces las reglas y yo también...",
  "noTranslationReason": null,
  "availableSubtitleLanguages": ["en"],
  "availableAutoCaptionLanguages": ["en", "es", "fr", "de", "ja"],
  "success": true,
  "inputUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "error": null,
  "scrapedAt": "2026-07-25T12:00:00+00:00"
}

transcriptSrt is only populated when subtitlesFormat is srt; transcriptVtt only when it's vtt. Both are null for the other three format choices. channel.logo is "" when includeChannelLogo is false or no avatar could be located.

Rejected inputs (playlist/channel URLs, empty entries) and failed extractions return the same 44-key shape with success: false, hasTranscript: false, empty/zeroed metadata fields, and error / noTranscriptReason populated with the failure reason (e.g. playlist_url_not_supported, channel_url_not_supported, video_extraction_failed).

channel object fields:

Key	Description
id	Channel's internal ID
name	Channel display name
handle	The @handle portion of the channel URL, empty when the video's channel URL uses the legacy /channel/UC... form instead
subscriberCount	Formatted as "<count> subscribers", or an empty string when YouTube doesn't expose a subscriber count
logo	Channel avatar URL, or "" when includeChannelLogo is false or no avatar was found
badges	["Verified"] when YouTube marks the channel verified, otherwise an empty array

Only successful rows are charged. Actor.push_data(row, charged_event_name="video_result") runs only when row["success"] is true — rejected-input rows and failed-extraction rows are still written to the dataset (with success: false) for visibility, but are pushed without a charged_event_name, so they are not billed. To isolate only the billed rows when querying the dataset, filter on success == true.

Schema stability and export options

Field names are stable across runs — the transcript pipeline reads YouTube's caption JSON structure directly rather than scraping rendered HTML, so it isn't affected by YouTube front-end redesigns the way a DOM-scraping approach would be. Results are downloadable from the Apify dataset in JSON, JSONL, CSV, Excel, XML, HTML, or RSS, or read programmatically through the Apify API and apify-client SDKs.

---

💡 YouTube Video Scraper Strategy Guide

🎯 Strategy 1: Real-time transcript enrichment

Trigger a run whenever a new video URL lands in your system — a content queue, a CRM record, a moderation pipeline. Feed the URL into startUrls, run the Actor, then write transcriptText, translatedTranscriptText (if translateTranscriptTo is set), and hasTranscript back to the source record. A video with hasTranscript: false and a noTranscriptReason tells you immediately whether to retry with allowLanguageFallback: true or accept there's no caption track at all.

🎯 Strategy 2: Scheduled monitoring and alerting

Use an Apify schedule to re-run the same channel's recent video URLs on a recurring interval, and diff each run's views, likes, comment_count, and engagement_rate against the previous run's values for the same video_id. Alert when engagement_rate moves outside your expected range, or when a previously hasTranscript: false video suddenly returns a transcript (creator added captions after publishing).

🎯 Strategy 3: Bulk transcript dataset build

For a research or training corpus, load a list of video URLs into startUrls in one run rather than issuing one run per video — the Actor processes the list sequentially with a short randomized delay between videos and pushes one row per video to the same dataset. Export the finished dataset as CSV or JSON for downstream aggregation. Set skipVideosWithoutTranscript: true if the corpus only needs videos that actually have captions, so uncaptioned videos never produce a row.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Per-video pipelines, CMS/CRM enrichment	One run per incoming URL	JSON row per video
Scheduled monitoring	Channel or video-list tracking over time	Apify schedule, repeated runs	JSON, diffed by video_id across runs
Bulk dataset build	Research corpora, training data	One run, many URLs in startUrls	Dataset export (CSV/JSON)

---

🔗 Related YouTube Scrapers & Tools

Scraper	What it extracts
youtube-channel-contact-extractor (Scrapio)	Discovers YouTube channels by keyword or URL and extracts publicly-visible emails and cross-platform social links from the channel description
instagram-reel-transcript-scraper (Scrapio)	Scrapes an Instagram reel's caption, owner, and engagement data, with an optional self-hosted Whisper speech-to-text transcript

For channel-level contact discovery rather than video-level metadata and transcripts, use youtube-channel-contact-extractor. For the same "transcript from a short-form video" workflow on Instagram instead of YouTube, instagram-reel-transcript-scraper covers Reels.

---

How to integrate this scraper with your stack

This Actor works with any language or tool that can make an HTTP request to the Apify API — the examples below use the official Apify SDKs.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "startUrls": [
        {"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"},
        {"url": "https://youtu.be/jNQXAC9IVRw"},
    ],
    "subtitlesLanguage": "en",
    "captionSource": "human_first",
    "subtitlesFormat": "timestamped",
    "translateTranscriptTo": "es",
}

run = client.actor("<YOUR_USERNAME>/youtube-video-details-scraper-subtitles-translations").call(
    run_input=run_input
)

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    rows.append({
        "video_id": item["video_id"],
        "title": item["title"],
        "hasTranscript": item["hasTranscript"],
        "transcriptText": item["transcriptText"],
        "translatedTranscriptText": item["translatedTranscriptText"],
    })

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

Node.js

import { ApifyClient } from 'apify-client';

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

const input = {
    startUrls: [{ url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ' }],
    subtitlesLanguage: 'en',
    subtitlesFormat: 'srt',
};

const run = await client.actor('<YOUR_USERNAME>/youtube-video-details-scraper-subtitles-translations').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.video_id, item.hasTranscript, item.transcriptSrt ? 'has SRT' : 'no SRT');
}

Async and scheduled pipelines

For large URL lists, start the run and poll for completion rather than waiting synchronously — client.actor(...).start(run_input=...) in Python or client.actor(...).start(input) in Node.js returns immediately, and the run status can be polled or checked against the dataset item count. For recurring jobs, use an Apify schedule to trigger the Actor on a cron-style interval against the same or an updated startUrls list, and read the resulting dataset from your own system after each run.

---

Who Needs This YouTube Scraper? (Use Cases & Industries)

📊 Content and marketing teams

Pull transcriptText across a competitor's or your own channel's back catalogue to build a searchable script archive, then cross-reference tags and category to see which topics correlate with higher engagement_rate.

🤖 AI and RAG engineers

Index transcriptText and translatedTranscriptText per video as retrieval documents, keyed by video_id and title, so an agent can answer questions about spoken video content instead of just titles and descriptions.

🔬 Researchers

Build a corpus of public-video transcripts for discourse, language, or media-studies research using transcriptText and the timestamped transcript array — public data only, no private or unlisted videos.

🎥 Subtitle and localization tooling

Products that generate or QA subtitle files can pull transcriptSrt / transcriptVtt directly, and use translatedTranscript as a starting draft for a human-reviewed localized subtitle track.

---

Is it legal to scrape YouTube?

Scraping publicly accessible web data is generally lawful; U.S. case law including hiQ Labs v. LinkedIn (9th Cir. 2019) supports that position for data visible without logging in. This Actor only reads YouTube's public video pages and public caption endpoint — no login, no private or unlisted content. Scraping may still violate YouTube's Terms of Service, which is a contractual matter between the user and YouTube, not a criminal one. Some output fields (channel name, handle, and any personal names YouTube surfaces in public metadata) may constitute personal data under GDPR or CCPA if the channel is operated by an individual rather than an organization; storing or processing such data carries its own compliance obligations. This Actor returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

---

❓ Frequently asked questions

Does this scraper work without a YouTube account?

Yes. No YouTube account, login, or API key is required — it reads YouTube's public video page and public caption endpoint directly.

Where do the translated subtitles actually come from?

From YouTube itself, not a third-party translation service. Setting translateTranscriptTo appends YouTube's own tlang query parameter to the caption request URL, and YouTube's caption endpoint returns an already-translated caption track. No external translation API, and no API key, is involved anywhere in the pipeline.

How does this scraper handle YouTube's anti-scraping measures?

Requests default to Apify's RESIDENTIAL proxy group. If a request is bot-walled (sign-in prompts, 429/403 responses), the Actor escalates the proxy route from direct to datacenter to residential and rotates the session, rather than retrying on the same blocked IP. Video-metadata extraction retries up to 3 attempts with exponential backoff; caption fetches retry up to 3 attempts with proxy-session rotation on rate-limited (429/403/503) responses.

Can I run this at scale without getting blocked?

The Actor is built to survive YouTube's bot-walling by escalating proxy routes rather than failing outright, but no uptime or success-rate figure is published — outcomes depend on your proxy configuration and YouTube's current rate-limiting behavior. Running on the container's own IP (no Apify proxy) is logged as unreliable; RESIDENTIAL is the default for that reason.

How fresh is the data this scraper returns?

Every run performs a live fetch against YouTube at run time — nothing is cached or served from a prior run, except the channel avatar, which is cached per channel for the duration of a single run only (so ten videos from one channel trigger one avatar fetch, not ten).

Which fields work best for AI training and RAG indexing?

For RAG, index transcriptText and translatedTranscriptText — these are the highest-information text fields, already de-duplicated and joined into plain readable text. For training data, the transcript array's per-cue structure (start, end, startSeconds, endSeconds, text) gives consistent time-aligned records across every video. All fields return as typed primitives (strings, numbers, booleans, arrays) requiring no additional normalization before use.

Does this scraper return personal data, and who is responsible for it?

It returns publicly available YouTube data, which can include a channel operator's name or handle if YouTube displays it publicly. This Actor does not collect private profile data, emails, or any information YouTube does not already show publicly. Lawful basis for any further storage or use of that data sits with the person running the Actor.

Does skipVideosWithoutTranscript affect billing?

Yes, directly. Billing (video_result) is gated on successful metadata extraction (success: true), not on transcript presence. When skipVideosWithoutTranscript is true, a video with no usable caption track produces no dataset row at all and is never billed. When it's false (the default), that same video still gets a full metadata row with hasTranscript: false — and that row is charged as video_result, because the video itself was successfully extracted even though it has no transcript. Only rejected inputs and genuine extraction failures (success: false) are pushed unbilled.

Are YouTube Shorts and live-stream URLs supported?

Yes. /shorts/ID and /live/ID paths are recognized and normalized to a standard watch URL before processing, so Shorts and livestreams go through the same metadata and caption pipeline as regular videos. The live_status field reflects the video's live state as reported by YouTube.

Does this scraper work with Claude, ChatGPT, and other AI agent tools?

It isn't currently exposed through an MCP server, but it's callable as a standard HTTP endpoint by any agent framework through the Apify API — every response is typed JSON, so an agent can consume transcriptText or the full row directly without HTML parsing.

How does this scraper compare to other YouTube subtitle scrapers?

deanter/youtube-video-details-scraper is free but hardcodes subtitle language to Russian with an English fallback (per their own README) and doesn't support format or source selection. genial_candlestand/youtube-subtitles-scraper offers a simple auto-generated-captions toggle and broad export formats but doesn't document translation, native SRT/VTT, or configurable language fallback (checked 2026-07-08). memo23/youtube-video-details-scraper advertises the broadest feature set — Whisper AI fallback for caption-free videos, video file download, and 100+ language translation (checked 2026-07-08) — at the cost of a more complex, all-in-one output; this Actor is narrower and focused specifically on getting an accurate, correctly-segmented transcript and translation without those extras.

---

Disclaimer

This YouTube Video Scraper 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.