YouTube Video Details Scraper: Most Replayed

YouTube Video Scraper — Replay Peaks, Chapters & Metadata

YouTube Video Details Scraper: Most Replayed pulls full video metadata for any public YouTube video and adds the two signals almost no other scraper returns: the 100-bucket most-replayed heatmap and the video's chapter markers — then joins them. Give it one or more video URLs and get back typed JSON containing the replay curve, chapter data, a set of "clip windows" (the top replay peaks snapped to their chapter with the spoken transcript text attached), a per-chapter replay-share breakdown, the full caption transcript, and standard video/channel metadata — all on the same seconds axis, so the join is exact rather than estimated. After reading this page you'll know exactly which of the 50+ output keys ship on every row, which two are computed for free from data already in the page, and what happens when a video has no replay data at all.

What is YouTube Video Details Scraper: Most Replayed?

YouTube Video Details Scraper: Most Replayed is an Apify Actor that extracts a single YouTube video's full metadata plus its replay-intensity heatmap, chapter markers, and caption transcript in one run. It targets watch?v=, youtu.be/ and /shorts/ video URLs — playlist and channel URLs are not accepted, because this Actor is built for per-video depth rather than catalogue breadth.

No YouTube account, Google login, or API key is required. The Actor reads the same public player response a signed-out visitor's browser receives; nothing behind a login wall is touched.

Key capabilities:

• Scrape full video metadata — title, description, views, likes, comments, tags, thumbnails, category, live status
• Scrape the replay heatmap — 100 buckets of {startTime, endTime, replayValue, rank} plus the single peak second
• Scrape chapter markers — {index, title, startTime, endTime, durationSeconds, url} for every creator-defined chapter
• Build clip windows — the top-N replay peaks, non-overlapping, each snapped to its chapter and captioned with the transcript spoken there
• Export as JSON, CSV or Excel through the Apify dataset

🔥 What data does YouTube Video Details Scraper collect?

One row per video, carrying video metadata plus five distinct derived data blocks — heatmap, chapters, clip windows, chapter-level replay share, and transcript — all keyed to the same seconds axis.

Data Type	Key Fields	JSON Field Names
Video metadata	Title, description, views, likes, comments, duration, category	title, description, views, likes, comment_count, duration_seconds, category
Channel	Handle, name, ID, subscriber count	channelHandle, channel_name, channelId, channelSubscriberCount
Replay heatmap	100 buckets, peak second, peak value	heatmap[], mostReplayedAt, mostReplayedAtFormatted, mostReplayedValue
Chapters	Index, title, start/end time, duration	chapters[], hasChapters, chapterCount
Clip windows	Top replay peaks, chapter join, spoken text	replayPeaks[], chapterTitle, transcriptText
Chapter replay share	Per-chapter engagement weight	chapterReplayShare[], topChapterTitle
Transcript	Full caption cues, source track	transcript[], transcriptSource, hasTranscript

Two things that are genuinely free

The heatmap and chapter data cost nothing extra: both are parsed out of the same player response that yt-dlp already fetches to get the video's title and view count — no second request, no added proxy usage. The only feature that triggers an additional network call is the transcript, and only when includeFullTranscript or attachTranscriptToPeaks is on, because caption text lives on a separate signed timedtext URL.

🔗 Need more YouTube data?

If you need catalogue breadth rather than per-video depth, YouTube Playlist Scraper and YouTube Search Scraper — Keyword Rank, Slot Owners & Results cover multi-video collection. YouTube Community Posts Scraper pulls a channel's Community tab, YouTube Influencer Finder scores channels into reach tiers, and YouTube Shorts Scraper — Sponsor Segments, Sentiment & Topics runs brand-safety analysis on a creator's Shorts. This Actor stays narrow on purpose: one video, full replay and chapter depth.

How does YouTube Video Details Scraper differ from the official YouTube Data API?

The official YouTube Data API v3 covers video metadata, statistics, captions and comments through documented, quota-governed endpoints — it does not expose most-replayed heatmap data or chapter markers at all, because both are rendered client-side on the watch page rather than published as an API resource.

Feature	YouTube Data API v3	YouTube Video Details Scraper
Google Cloud project + API key required	✓	✗
Daily quota governs usage	✓	✗ — Apify usage only
Most-replayed heatmap data	✗ — not a published resource	✓
Chapter markers	✗ — not a published resource	✓
Clip windows joining peaks, chapters and transcript	✗ — would require building this yourself from three sources	✓, computed in the row
Setup time to first result	Cloud project, key, quota enablement	Paste a URL and run

Use the official API when you need authenticated operations on your own channel, or when your product must contractually rely on Google's published terms for a specific documented resource. Use this Actor when you want the replay heatmap or chapter data at all — since neither is available through the official API — or when you want a single joined row instead of building the peak/chapter/transcript join yourself. Verify current scope and quota terms against Google's published YouTube Data API v3 documentation before committing to either route.

Why do developers and teams scrape YouTube's replay and chapter data?

For AI engineers and agent builders

replayPeaks[] gives an agent pre-segmented, labelled moments instead of a raw transcript to search through: each entry carries chapterTitle, transcriptText and a deep url, so a RAG pipeline can index "what does the video say at its most-rewatched moment" without re-deriving timing from scratch. A practical workflow: index replayPeaks[].transcriptText alongside chapterReplayShare[].topChapterTitle so an agent tool can answer "which section of this video do people actually rewatch, and what's said there" directly from typed fields.

For marketers and brand teams

mostReplayedAt and replayPeaks[] show exactly which seconds of a competitor's video hold attention, which is a faster read on what hooks work than watching the full upload. Pull a competitor's recent uploads on a schedule, sort by chapterReplayShare[].replayShare, and you get a ranked list of which sections of their content strategy are actually landing — useful before commissioning your own next video in the same format.

For researchers and analysts

The heatmap is YouTube's own aggregate viewer-behaviour signal, publicly rendered on every eligible video, which makes it a defensible, reproducible data source for engagement research — no viewer-level data is collected, only the video-level intensity curve. heatmap[] gives 100 buckets per video with replayValue intact, so a corpus of videos can be compared on replay concentration without touching any individual viewer's data.

For developers building data products

video_id is a stable key and every row carries success, hasHeatmap and hasChapters flags, so a monitoring pipeline can re-run the same video list on a schedule and diff for new peaks or updated stats without guessing at what changed. That is enough to build a highlight-reel recommender, a "best moment" thumbnail generator, or a scheduled content-performance dashboard on top of one normalized row schema.

How to scrape YouTube replay peaks and chapters (step by step)

YouTube Video Details Scraper: Most Replayed runs on Apify. Start it from the Apify Console or call it through the Apify API.

1. Open the Actor on its Apify Store listing and click Try for free
2. Paste one or more video URLs into Video URLs (videoUrls) — watch?v=, youtu.be/ and /shorts/ forms all work
3. Leave the replay and chapter toggles on their defaults, or turn off includeFullTranscript / attachTranscriptToPeaks to skip the caption download entirely
4. Keep Proxy set to Residential — it's the default for a reason, covered below
5. Click Start, then export the dataset as JSON, CSV or Excel, or read it through the Apify API

What to do when YouTube changes its structure

The scraper is maintained and the output schema is held stable across updates — field names and types don't change on your end when YouTube changes its front end or player response shape. Your integration keeps reading the same keys.

⬇️ Input

All 15 parameters are optional — there is no required field, though a run with no videoUrls (and no legacy startUrls) produces zero rows.

Parameter	Required	Type	Description	Example Value
videoUrls	No	array	One or more YouTube video URLs. Accepts watch?v=ID, youtu.be/ID and /shorts/ID. Playlist and channel URLs are not supported. The legacy input key startUrls is also accepted for backward compatibility. No default array value; UI prefill is ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"].	["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]
includeHeatmapCurve	No	boolean	Return the full heatmap[] array — 100 buckets of {startTime, endTime, replayValue, rank}. Turn off to get only mostReplayedAt, which is returned either way. Default true.	true
includeChapters	No	boolean	Return chapters[], hasChapters and chapterCount. Default true.	true
maxReplayPeaks	No	integer	How many replay peaks to turn into clip windows. Minimum 0, maximum 100. 0 disables clip windows entirely. Default 5.	5
peakWindowThreshold	No	number	How far a clip window grows out from its peak; a window expands while neighbouring buckets stay ≥ peak × threshold. Minimum 0.1, maximum 1.0. Default 0.75.	0.75
maxClipSeconds	No	integer	Hard cap on a single clip window's length, in seconds. Minimum 5, maximum 3600. Default 90.	90
includeChapterReplayShare	No	boolean	Return chapterReplayShare[] and topChapterTitle. Needs both a heatmap and chapters; returns an empty array if either is missing. Default true.	true
attachTranscriptToPeaks	No	boolean	Fill transcriptText on every clip window with the caption cues overlapping that window. Off skips the caption download entirely. Default true.	true
includeFullTranscript	No	boolean	Return the complete transcript[] array on the row. Off keeps rows small when only clip windows matter. Default true.	true
transcriptLanguage	No	string	ISO code of the caption track to request, e.g. en, es, de. Empty string uses the video's own language, then English, then any available track. Default "".	"en"
preferHumanCaptions	No	boolean	On: use creator-uploaded subtitles when they exist, fall back to auto-generated. Off: prefer the auto-generated track. Default true.	true
skipVideosWithoutHeatmap	No	boolean	Mark videos with no heatmap as skipped instead of a full charged row. Skipped rows still write to the dataset with skippedReason: "no_heatmap" and success: false, and are not billed. Default false.	false
skipVideosWithoutChapters	No	boolean	Same as above for chapter markers — skippedReason: "no_chapters", success: false, not billed. Default false.	false
requestDelaySeconds	No	number	Pause between videos, in seconds. Minimum 0, maximum 60. Default 2.	2
proxyConfiguration	No	object	Apify Proxy configuration. Default and prefill: {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

Out-of-range numeric inputs sent through the API rather than the Console UI (maxReplayPeaks, peakWindowThreshold, maxClipSeconds, requestDelaySeconds) are silently clamped to their minimum/maximum rather than rejected, and a warning is written to the run log when that happens.

Common pitfall: if a run supplies both startUrls (the legacy key) and videoUrls, startUrls wins and videoUrls is ignored — the Actor checks startUrls first specifically so old integrations built against the original Actor keep working unchanged. If you're migrating an integration and results look wrong, check for a stale startUrls value before debugging anything else.

Example input

{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/3CVHLAg55sQ"
  ],
  "includeHeatmapCurve": true,
  "includeChapters": true,
  "maxReplayPeaks": 5,
  "peakWindowThreshold": 0.75,
  "maxClipSeconds": 90,
  "includeChapterReplayShare": true,
  "attachTranscriptToPeaks": true,
  "includeFullTranscript": true,
  "transcriptLanguage": "",
  "preferHumanCaptions": true,
  "skipVideosWithoutHeatmap": false,
  "skipVideosWithoutChapters": false,
  "requestDelaySeconds": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

⬆️ Output

One row per video, exported as JSON, CSV or Excel, or read live through the Apify dataset API. The Actor's default dataset view surfaces 45 columns, but the row itself carries a few keys the view doesn't display: the raw mostReplayedAt (seconds, unformatted), topChapterIndex, transcriptMessage (a human-readable status string), and — on a failed extraction only — error. All of them are documented below.

Scraped video row

{
  "type": "video",
  "video_id": "dQw4w9WgXcQ",
  "title": "Never Gonna Give You Up",
  "description": "The official video for “Never Gonna Give You Up” ...",
  "channel_id": "@RickAstleyYT",
  "channel_name": "Rick Astley",
  "published_date": "2009-10-25",
  "duration_seconds": 213,
  "views": 1694624700,
  "likes": 18549049,
  "comment_count": 2412000,
  "tags": ["rick astley", "never gonna give you up", "official video"],
  "thumbnails": {
    "default": "https://i.ytimg.com/vi/dQw4w9WgXcQ/default.jpg",
    "maxres": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg"
  },
  "channel": {
    "id": "UCuAXFkgsw1L7xaCfnd5JJOw",
    "name": "Rick Astley",
    "handle": "@RickAstleyYT",
    "url": "https://www.youtube.com/@RickAstleyYT",
    "subscriberCount": "3450000 subscribers",
    "logo": "https://yt3.googleusercontent.com/abc123",
    "badges": ["Verified"]
  },
  "transcript": [
    {
      "start": "18.240",
      "dur": "3.120",
      "text": "We're no strangers to love",
      "end": "21.360",
      "startSeconds": 18.24,
      "endSeconds": 21.36
    }
  ],
  "category": "Music",
  "language": "en",
  "live_status": "not_live",
  "engagement_rate": 0.0122,
  "hashtags": [],
  "upload_type": "normal",
  "success": true,
  "inputUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channelHandle": "@RickAstleyYT",
  "channelSubscriberCount": 3450000,
  "hasHeatmap": true,
  "heatmapBucketCount": 100,
  "heatmap": [
    {
      "startTime": 0.0,
      "endTime": 2.13,
      "durationSeconds": 2.13,
      "replayValue": 0.4821,
      "rank": 42,
      "startTimeFormatted": "0:00"
    }
  ],
  "mostReplayedAt": 46.7,
  "mostReplayedAtFormatted": "0:47",
  "mostReplayedValue": 1.0,
  "mostReplayedUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=47s",
  "hasChapters": false,
  "chapterCount": 0,
  "chapters": [],
  "chapterReplayShare": [],
  "topChapterTitle": null,
  "topChapterIndex": null,
  "replayPeaks": [
    {
      "rank": 1,
      "startTime": 44.0,
      "endTime": 51.0,
      "startTimeFormatted": "0:44",
      "endTimeFormatted": "0:51",
      "durationSeconds": 7.0,
      "replayValue": 1.0,
      "peakAt": 46.7,
      "chapterIndex": null,
      "chapterTitle": null,
      "transcriptText": "Never gonna give you up, never gonna let you down",
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=44s"
    }
  ],
  "replayPeakCount": 1,
  "hasTranscript": true,
  "transcriptSource": "subtitles:en",
  "transcriptSegmentCount": 84,
  "noTranscriptReason": null,
  "transcriptMessage": "Transcript loaded from subtitles:en",
  "transcriptTruncated": false,
  "skippedReason": null
}

Every array is shown here with one representative entry — a real row carries up to 100 heatmap buckets, one entry per creator chapter, maxReplayPeaks clip windows, and one transcript entry per caption cue.

A few field-level details worth knowing before you build against this schema:

• transcript[].start, dur and end are strings, not numbers — kept in that format for backward compatibility with the original transcript output. startSeconds and endSeconds on the same object are the numeric equivalents, rounded to 3 decimal places; use those for any arithmetic.
• channel.subscriberCount is a formatted string ("3450000 subscribers" or "" if unavailable), while the top-level channelSubscriberCount is the same value as an integer or null. Use the top-level field for filtering or sorting.
• channel.logo is a single URL string when a channel avatar was found, or an empty list [] when the channel's About page couldn't be fetched or carried no avatar — the type differs depending on which branch ran, so check with a truthy test rather than assuming one shape.
• chapters[].endTime (and endTimeFormatted, durationSeconds) can be null — YouTube's chapter data doesn't always give an explicit end time for the final chapter, and the Actor never invents one to fill the gap.
• chapterReplayShare[].avgReplayValue and .replayShare can be null in the rare case a chapter has zero overlap with any heatmap bucket, or the video's total replay intensity is zero.
• upload_type is always "normal" in the current build — it is present on every row but does not vary with the video's actual type (Short, premiere, live replay). Don't filter on it expecting Shorts detection; use duration_seconds or the source URL's /shorts/ path instead.
• transcript is dropped (never silently) on extreme rows. Apify caps a dataset item at 9 MB; a 31-hour livestream VOD produced a 46,959-cue, 7.4 MB row in testing. When a row's serialized size exceeds 7,000,000 bytes, transcript is cleared, transcriptTruncated is set to true, noTranscriptReason becomes "full_transcript_omitted_row_size_limit", and a warning is written to the run log — but replayPeaks[].transcriptText is unaffected, since clip windows carry their own short text.
• A failed extraction still writes a row. If yt-dlp can't retrieve a video after retries (removed, private, region-blocked, or a persistent bot wall), the row is pushed with success: false, all replay/chapter/transcript fields at their null or empty defaults, noTranscriptReason: "video_extraction_failed", and an error string describing what failed. This row is not billed — see the billing note directly below.
• engagement_rate divides by a views count floored at 1. views is never allowed to be 0 in that one calculation (a missing or zero view count is treated as 1 purely to avoid a divide-by-zero), so a video YouTube reports as having zero views shows engagement_rate as its raw like-plus-comment count rather than a true zero-views ratio. The views field itself is unaffected and reports YouTube's real number.

noTranscriptReason — every value it can hold

This field explains exactly why transcript is empty or hasTranscript is false, so you can branch on it instead of guessing:

Value	Meaning
null	A transcript was found and loaded successfully
transcript_disabled_by_input	Both includeFullTranscript and attachTranscriptToPeaks were off, so no caption request was made
no_caption_track_in_requested_language	transcriptLanguage was set, but no track exists in that language
no_caption_track_available	The video has no caption tracks at all, in any language
caption_http_error	The caption URL responded with a non-200 status
caption_body_empty	The caption URL returned an empty body
caption_not_json	The caption response wasn't valid JSON
caption_no_text_events	The caption payload parsed, but contained no usable text cues
caption_fetch_exception	An unhandled error occurred while downloading or parsing the caption track
full_transcript_omitted_row_size_limit	Cues were fetched and parsed successfully, but transcript was cleared afterward because the row was approaching Apify's 9 MB item cap — see transcriptTruncated
video_extraction_failed	The video itself couldn't be extracted (only appears on success: false rows)

Billing — what actually gets charged

The only charged event is video_result, fired once per video that completes extraction and isn't filtered out by skipVideosWithoutHeatmap or skipVideosWithoutChapters. Two categories of row are pushed to the dataset without that event, so they're written but not billed:

• A failed extraction (success: false, populated error, noTranscriptReason: "video_extraction_failed") — yt-dlp never got usable data back after the retry ladder ran out.
• A filtered skip (success: false, skippedReason: "no_heatmap" or "no_chapters") — extraction succeeded, but the row didn't meet a filter you turned on.

To pull only the billed rows back out of a stored dataset, filter on success === true — every row that reached the charged branch has success set to true, and every uncharged row (failed or skipped) has it forced to false.

How does YouTube Video Details Scraper compare to other most-replayed scrapers?

Feature	YouTube Video Details Scraper	Generic alternative
Output format	Normalized JSON row schema	Varies; often HTML-derived
Chapter data	✅ Full chapter markers with computed durations	Often absent
Clip windows (peaks × chapters × transcript join)	✅ Computed in the row	Not offered
Credentials required	None	Often none, varies by tool
Proxy / anti-bot handling	Automatic residential escalation on bot-wall detection	Developer managed

Checked on the Apify Store on 25 July 2026, karamelo/youtube-most-replayed-scraper-heatmap-extractor's listing documents heatmap extraction with a normalized intensityScoreNormalized score and notes that "the video must have at least 50K views to contain a heatmap graph" — a platform-side threshold, not something either scraper controls. Its output does not document chapter markers, clip windows, or a transcript join. scraper-engine/youtube-most-replayed-scraper's listing documents heatmap and core video metadata (videoId, title, viewCount, likes, comments) on a flat monthly pricing plan; its documented output example does not include chapter data either. Neither competitor's listing documents a chapter-replay-share metric or a peaks-to-transcript join.

If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

How many videos — and how many replay peaks — can you scrape?

There is no Actor-imposed cap on how many URLs you put in videoUrls — it's a list, and each entry is processed in turn with a pause of requestDelaySeconds between them. maxReplayPeaks controls how many clip windows are built per video, from 0 (disabled) up to 100, with a default of 5.

Whether a given video has replay data at all is decided by YouTube, not by this Actor — some videos never generate a heatmap (see the FAQ below), and in that case heatmap comes back empty regardless of what maxReplayPeaks is set to. The practical ceiling on peaks is the number of non-overlapping buckets the heatmap actually contains, since peaks are picked greedily and a one-bucket gap is kept between each so neighbouring peaks stay distinct.

Integrate YouTube Video Details Scraper and automate your workflow

YouTube Video Details Scraper: Most Replayed works with any language or tool that can send an HTTP request, because it's an Apify Actor under the hood.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/youtube-video-details-scraper-replay-peaks-chapters").call(run_input={
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "maxReplayPeaks": 5,
    "includeFullTranscript": True,
})

for video in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not video["success"]:
        continue
    print(video["video_id"], video["mostReplayedAtFormatted"], video["replayPeakCount"])

Works in Python, Node.js, Go, Ruby, cURL — any language that can send an HTTP request.

Automation platforms (n8n, Make, LangChain)

In n8n, the Apify node calls the Actor and returns dataset items directly into the next node — point it at <YOUR_USERNAME>/youtube-video-details-scraper-replay-peaks-chapters with the same JSON input shown above. In Make, the Apify module's run-and-wait action feeds a Google Sheets or Airtable step with each video's replay and chapter data, no code required. In a LangChain or similar agent framework, wrap the apify_client call above as a tool function — the returned row is already typed JSON, so no parsing step sits between the Actor and the agent's context window.

Is it legal to scrape YouTube's replay heatmap and chapter data?

Yes — this Actor collects only publicly visible video and channel metadata that YouTube renders to any signed-out visitor, including the replay heatmap and chapter markers shown in the player itself.

The output is content and channel metadata rather than personal data about private individuals: video titles, descriptions, statistics, replay-intensity buckets, chapter timestamps, and the publishing channel's public business identity. No viewer-level data, comments, or watch history is collected, so the personal-data regimes that govern scraping individual user profiles don't attach to this output in the same way. The obligations that do apply are contractual — YouTube's Terms of Service — and copyright-related if you republish titles, thumbnails or transcripts as your own content rather than as extracted data for internal analysis.

Consult legal counsel for commercial applications that republish or redistribute collected video content or transcripts at scale.

❓ Frequently asked questions

Does YouTube Video Details Scraper work without a YouTube account?

Yes. No YouTube account, Google login, or API key is required to run it — the only credential involved is your Apify token, used to start the run through the Apify Console or API.

How fresh is the data?

Every run fetches the video live from YouTube through yt-dlp at request time. Nothing is served from a cache — each run reflects the video's current view count, chapter list, and heatmap state at the moment it ran.

⚠️ What happens when a video has no replay heatmap or no chapters?

Both are common and handled explicitly, not treated as errors. YouTube only generates the most-replayed heatmap for videos that have accumulated enough engagement — a brand-new upload or a low-view video can come back with hasHeatmap: false, heatmap: [], and every mostReplayed* field null, while the rest of the row (title, views, transcript, chapters) is populated normally. Chapters are creator-defined and roughly one in three videos has none at all; those rows get hasChapters: false, an empty chapters[], and null chapter titles on any clip windows — never an invented chapter name. By default both cases still produce a full, billed row; set skipVideosWithoutHeatmap or skipVideosWithoutChapters to true if you'd rather those videos come back as an unbilled skippedReason row instead.

Can I scrape private, unlisted or age-restricted videos?

No. Only videos playable to a signed-out visitor are returned. A private, unlisted-without-link, deleted, or otherwise restricted video fails extraction after the retry ladder runs out, and the Actor writes an unbilled row with success: false and an error message rather than fabricating data.

Can I still use the old startUrls input key?

Yes. startUrls is checked first, ahead of videoUrls, specifically so runs, schedules and integrations built against the original Actor keep working without any input changes. If a run sends both keys, startUrls takes priority and videoUrls is ignored — worth knowing if you're migrating and see unexpected videos in the output.

Does YouTube Video Details Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n, or a hand-written tool definition can invoke it and get typed JSON back. No parsing step is needed before passing replayPeaks[] or transcript[] into an LLM context window or a vector store.

How does YouTube Video Details Scraper handle YouTube's anti-bot system?

Every extraction attempt runs through up to three tries. On a bot-wall response (YouTube's "Sign in to confirm you're not a bot" page), the Actor escalates to a fresh residential proxy session on a new exit node rather than retrying on the same burnt one, with a short backoff between attempts. Residential proxy is the schema default because it measurably outperforms datacenter IPs against this specific wall — see the input note above for the measured comparison.

How does YouTube Video Details Scraper compare to other most-replayed scrapers?

See the comparison table above — checked on the Apify Store on 25 July 2026, the closest competitors document heatmap extraction but neither documents chapter markers, a chapter-level replay-share metric, or a clip-window join between peaks, chapters and the transcript.

Does YouTube Video Details Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with stable field names. No HTML, no selectors, no parsing. Pass a row directly into an LLM context window, index it into a vector store, or route it through an agent tool.

Can I use YouTube Video Details Scraper without managing proxies?

Yes. Proxy selection and retry escalation are handled by the Actor through the proxyConfiguration input — you choose a group (Residential is the default and the one YouTube tolerates best) and the Actor handles session rotation on failure. You never touch an individual IP.

What happens when YouTube changes its structure?

The scraper is maintained and the output schema is held stable across updates — field names and types don't change on your end when YouTube changes its player response or front-end structure, so your integration keeps working without edits.

💬 Your feedback

Found a bug, or a field YouTube exposes that isn't in the output yet? We want to know. Open an issue on the Actor's Issues tab with the exact input JSON and the video URL that reproduced it — that's the fastest path to a fix.