Youtube Most Replayed Scraper & Video Chapters

YouTube Heatmap Scraper — Extract Chapters, Peaks and Video Metadata

Youtube Most Replayed Scraper & Video Chapters pulls the most-replayed heatmap and the chapter list off a single YouTube watch page, then cross-joins them so every labelled replay peak resolves to the named chapter it falls inside. Each run returns three data types per video — chapters, replay peaks with heatmap intensity, and core video metadata — as typed, normalized JSON: no HTML, no selectors, nothing to parse. After reading this you'll know exactly which fields you get, how coverage varies by video, and how to wire the output into a script, a spreadsheet or an agent pipeline.

⚡ What is Youtube Most Replayed Scraper & Video Chapters?

Youtube Most Replayed Scraper & Video Chapters is an Apify Actor that fetches a YouTube watch page for each URL you give it and extracts two independent surfaces that YouTube embeds in the same page load: the "most replayed" engagement heatmap and, when the creator or YouTube provided one, the chapter list. It then resolves every heatmap peak to the chapter it falls inside, so a raw millisecond offset becomes a named, clickable section. No YouTube account or login is required — everything comes from the public watch page.

• 📖 Extract every chapter's title, timestamps, duration and thumbnail
• 🔥 Extract the full 100-point replay heatmap and every labelled "Most replayed" peak
• 🔗 Resolve each peak to the named chapter it sits inside, with a ready timestamped deep link
• 🎥 Pull core video metadata (views, likes, comments, upload date) from the same request
• 📦 Export as JSON, CSV or Excel — no proxy setup required to get started

📊 What data does Youtube Most Replayed Scraper & Video Chapters collect?

Every run returns three data types for each video URL you submit — chapters, heatmap replay peaks, and video metadata — all in one dataset row.

Data Type	Key Fields	JSON Field Names
Chapters	Title, start timestamp, duration, source, thumbnail	chapters[].title, chapters[].startTimestamp, chapters[].durationSeconds, chapterSource, chapters[].thumbnailUrl
Replay heatmap & peaks	Peak moment, chapter the peak falls in, hottest single moment	heatSeek[].intensityScoreNormalized, peakChapters[].chapterTitle, topHeatMomentTimestamp
Video metadata	Video ID, title, channel, views, likes, comments, length	videoId, title, channelOwner, viewCount, likes, videoLengthSeconds

Need more YouTube data?

If you also need channel-level data or per-video engagement across a channel, API-Empire publishes YouTube Channel Scraper - Transcripts for channel, Shorts, live-stream and community-post data plus spoken transcripts, and YouTube Video Scraper by Hashtag With Exact Engagement Stats for discovering videos by hashtag with exact (non-abbreviated) engagement numbers. Both are separate Actors — this one only takes explicit watch URLs, it does not search or browse a channel.

🆚 How does this differ from the official YouTube API?

The YouTube Data API v3 gives you video metadata and statistics through documented parts; it does not expose the most-replayed heatmap or a chapters resource at all. As of 2026-08-04, the documented part values for the videos.list endpoint are id, snippet, contentDetails, statistics, status, player, topicDetails, recordingDetails, liveStreamingDetails, localizations, paidProductPlacementDetails, fileDetails, processingDetails, brandPartner and suggestions — none of them return heatmap data or structured chapters. Chapters written by a creator exist only as plain text inside snippet.description; the API returns that description as one string, and turning "0:00 Intro / 1:35 Setup" into structured timestamps is left entirely to you.

Feature	YouTube Data API v3	Youtube Most Replayed Scraper & Video Chapters
Most-replayed heatmap	Not available in any documented part	✅ Full 100-bucket heatmap per video
Structured chapters	Not available; only raw description text	✅ Parsed chapters with timestamps and thumbnails
Peak-to-chapter resolution	Not applicable — no chapter or heatmap parts exist	✅ Every peak resolved to its chapter
API key / quota	Requires a Google Cloud project and API key	Not required — public watch page only
Setup time	Console project, OAuth/API key, quota request	Paste URLs and run

Use the official API when you only need catalogued metadata (titles, statistics, upload dates) inside your Google Cloud quota. Use this Actor when you need the replay heatmap, the chapter list, or the join between them — none of which the official API exposes.

🎯 Why do developers and teams scrape YouTube most-replayed and chapter data?

For AI engineers and agent builders

Chapter titles and peak timestamps make excellent grounding data for an agent that needs to answer "where in this video does X happen" without processing the video itself. Feed chapters[] and peakChapters[] straight into a RAG index keyed by videoId, and an agent can cite the exact chapter title and deepLink for a claim instead of guessing a timestamp.

For marketers and content teams

Short-form clippers use topHeatMomentTimestamp and topHeatChapterTitle to find the single most-rewatched moment of a long video and jump straight to it with topHeatDeepLink — the starting point for a Short or a Reel, without scrubbing the full runtime by hand.

For researchers and analysts

peakChapters[] shows which named section of a video an audience actually rewatches, across a whole set of videos. That is a concrete signal for studying what holds attention in tutorials, lectures or long-form talks, built entirely from publicly published data.

For developers building data products

Because output is one flat, typed row per video, chaptersFound, heatmapMarkerCount and namedPeakCount drop straight into a dashboard or scheduled monitoring pipeline without any HTML parsing step in between.

🚀 How to scrape YouTube chapters and replay data (step by step)

1. Open Youtube Most Replayed Scraper & Video Chapters on its Apify Store page and click Try for free (or add it to your account).
2. Paste one or more YouTube watch URLs into the Video URLs field, one per line. youtu.be and /shorts/ links are accepted too.
3. Optionally set chapterTitleKeywords to keep only videos whose chapters mention specific words, or switch on skipVideosWithoutChapters / skipVideosWithoutHeatmap to drop videos that don't have what you need.
4. Click Start and let the run finish — leave proxy off unless you already know you want Residential.
5. Open the Dataset tab and export the results as JSON, CSV or Excel, or pull them with the Apify API.

What to do when YouTube changes its structure

Youtube Most Replayed Scraper & Video Chapters is maintained, and the output schema is designed to stay stable — the same field names and types keep working on your end even when the extraction logic behind them has to change. No specific turnaround time is promised for any given fix.

⬇️ Input

All parameters are optional; the Actor runs with defaults if you supply nothing.

Parameter	Required	Type	Description	Example Value
videoUrls	No	array of strings	One YouTube watch URL per line. youtu.be and /shorts/ links are accepted too.	["https://www.youtube.com/watch?v=UsdedFoTA68"]
urls	No	array of strings	Compatibility field kept for existing inputs, tasks and API calls. Default: ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]. Values here take priority in the output order.	["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]
chapterTitleKeywords	No	array of strings	Case-insensitive substring match against every chapter title. A video is kept if ANY chapter title contains ANY of these words. Leave empty to keep everything.	["intro", "setup"]
skipVideosWithoutChapters	No	boolean	Skip videos that have no chapters, before they are saved and billed. Default: false.	false
skipVideosWithoutHeatmap	No	boolean	Skip videos that have no most-replayed heatmap, before they are saved and billed. Default: false.	false
includeChapterThumbnails	No	boolean	Adds thumbnailUrl to every chapter object. Default: true.	true
proxy	No	object (proxy editor)	Off by default. If YouTube blocks a request, the Actor switches itself to the Apify Residential proxy and stays on it for the rest of the run. Default: {}.	{}
requestTimeoutSecs	No	integer	Per-request timeout for each watch page fetch. Default: 20. Minimum: 5. Maximum: 120.	20
maxRetries	No	integer	Retries after a network or block failure. A video YouTube reports as unavailable is not retried. Default: 3. Minimum: 0. Maximum: 8.	3

Example JSON input:

{
  "videoUrls": [
    "https://www.youtube.com/watch?v=UsdedFoTA68",
    "https://www.youtube.com/watch?v=x7X9w_GIm1s"
  ],
  "chapterTitleKeywords": ["intro", "setup"],
  "skipVideosWithoutChapters": false,
  "skipVideosWithoutHeatmap": false,
  "includeChapterThumbnails": true,
  "proxy": {},
  "requestTimeoutSecs": 20,
  "maxRetries": 3
}

Common pitfall: if you leave both videoUrls and urls untouched in the Apify Console, the run doesn't fail — it silently scrapes the compatibility field's built-in placeholder video. Always fill videoUrls with your own URLs rather than relying on the defaults.

⬆️ Output

Results are written to the Actor's dataset as one JSON row per video URL, in the order supplied. Export as JSON, CSV, Excel, or read the dataset through the Apify API — no additional formatting step is required.

Scraped video record

A trimmed real row — the full row carries every chapter, every heatmap bucket and every peak the video has:

{
  "channelOwner": "Leila Gharani",
  "title": "Excel Pivot Table EXPLAINED in 10 Minutes (Productivity tips included!)",
  "videoId": "UsdedFoTA68",
  "viewCount": "4369826",
  "likes": "64750",
  "comments": "1.5K",
  "dateText": "Jun 18, 2020",
  "relativeDate": "6 years ago",
  "mostReplayed": [
    { "visibleTimeRangeStartMillis": 104260, "visibleTimeRangeEndMillis": 144360, "decorationTimeMillis": 112280 }
  ],
  "heatSeek": [
    { "startMillis": "0", "durationMillis": "8020", "intensityScoreNormalized": 0.2433196310645195 }
  ],
  "videoUrl": "https://www.youtube.com/watch?v=UsdedFoTA68",
  "videoLengthSeconds": 801,
  "hasChapters": true,
  "chaptersFound": 18,
  "chapterSource": "DESCRIPTION_CHAPTERS",
  "chapters": [
    {
      "chapterIndex": 1,
      "title": "Convert Data to Excel Tables",
      "startMillis": 95000,
      "startSeconds": 95.0,
      "startTimestamp": "1:35",
      "endMillis": 166000,
      "durationSeconds": 71.0,
      "deepLink": "https://www.youtube.com/watch?v=UsdedFoTA68&t=95s",
      "thumbnailUrl": "https://i.ytimg.com/vi/UsdedFoTA68/hqdefault.jpg"
    }
  ],
  "hasHeatmap": true,
  "heatmapMarkerCount": 100,
  "peakCount": 3,
  "namedPeakCount": 3,
  "peakChapters": [
    {
      "peakIndex": 0,
      "label": "Most replayed",
      "peakMomentMillis": 112280,
      "peakMomentTimestamp": "1:52",
      "visibleTimeRangeStartMillis": 104260,
      "visibleTimeRangeEndMillis": 144360,
      "chapterIndex": 1,
      "chapterTitle": "Convert Data to Excel Tables",
      "chapterStartMillis": 95000,
      "chapterStartTimestamp": "1:35",
      "deepLink": "https://www.youtube.com/watch?v=UsdedFoTA68&t=112s"
    }
  ],
  "topHeatMomentMillis": 120300,
  "topHeatMomentTimestamp": "2:00",
  "topHeatIntensity": 1.0,
  "topHeatChapterTitle": "Convert Data to Excel Tables",
  "topHeatDeepLink": "https://www.youtube.com/watch?v=UsdedFoTA68&t=120s",
  "errorReason": null
}

Full field list on every successfully billed row: channelOwner, title, videoId, viewCount, likes (string or null when YouTube only shows a UI label), comments, dateText, relativeDate, mostReplayed[], heatSeek[], videoUrl, videoLengthSeconds, hasChapters, chaptersFound, chapterSource ("DESCRIPTION_CHAPTERS", "AUTO_CHAPTERS" or null), chapters[], hasHeatmap, heatmapMarkerCount, peakCount, peakChapters[], namedPeakCount, topHeatMomentMillis, topHeatMomentTimestamp, topHeatIntensity, topHeatChapterTitle, topHeatDeepLink, errorReason (null on success).

A video YouTube reports as unavailable produces an uncharged accounting row instead, carrying the same base keys plus error and a filled errorReason, with every chapter/heatmap/peak field zeroed out. Filter these out of downstream processing by keeping only rows where errorReason is null.

🆚 How does this compare to other YouTube scrapers?

Feature	Youtube Most Replayed Scraper & Video Chapters	Generic alternative
Output format	Typed JSON, ready to consume	❌ Often raw HTML or a browser screenshot
Most-replayed heatmap	✅ Extracted as 100 intensity buckets	❌ Not extracted — the heatmap lives in an internal page blob most scrapers never touch
Peak-to-chapter join	✅ Every peak resolved to a named chapter	❌ Not offered — heatmap and chapters are treated separately, if chapters are handled at all
Auto-generated chapters	✅ Picked up and labelled AUTO_CHAPTERS	❌ Frequently limited to creator-written description timestamps only
Billing on failed/filtered rows	✅ Unavailable videos are uncharged; filters run before billing	❌ Often bills whatever was attempted, blank rows included

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 results can you scrape with Youtube Most Replayed Scraper & Video Chapters?

There is no hard cap on the number of video URLs in the input schema — videoUrls and urls accept as many lines as you paste in. The real constraint is that videos are processed sequentially, one watch page request at a time, so total run time scales with the number of URLs plus any retries: each URL gets up to maxRetries retry attempts (default 3, max 8) with a capped exponential backoff between attempts, and each request waits up to requestTimeoutSecs (default 20s) before timing out. This Actor also does not discover videos on its own — it only scrapes the exact URLs you provide; it does not crawl a channel or search results for you. No benchmark run time is published, since actual duration depends on how many of your URLs hit retries or the residential proxy fallback.

🔌 Integrate Youtube Most Replayed Scraper & Video Chapters and automate your workflow

Youtube Most Replayed Scraper & Video Chapters works with any language or tool that can send an HTTP request, through the standard Apify API and client libraries.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "videoUrls": ["https://www.youtube.com/watch?v=UsdedFoTA68"],
    "skipVideosWithoutChapters": True,
}

run = client.actor("api-empire/youtube-most-replayed-scraper-and-video-chapters").call(
    run_input=run_input
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["videoId"], item["chaptersFound"], item["topHeatChapterTitle"])

Works in Python, Node.js, Go, Ruby, cURL — any client that can call the Apify API with your token.

Automation platforms (n8n, Make)

In n8n, use the official Apify node's "Run Actor" operation with this Actor's ID and your videoUrls, then read the resulting dataset with the "Get Dataset Items" operation. In Make, the Apify app module works the same way — run the Actor, then map dataset items (for example topHeatChapterTitle or chapters[]) into a scenario, spreadsheet or downstream automation.

⚖️ Is it legal to scrape YouTube most-replayed and chapter data?

Yes. Youtube Most Replayed Scraper & Video Chapters only returns publicly available data: video metadata, creator- or YouTube-generated chapters, and the aggregate replay heatmap that YouTube itself displays under the player to every viewer, logged out. It does not scrape private videos, does not require a login, and does not collect commenter identities or any other personal data about private individuals.

Because the data is public video and channel content rather than personal data, the relevant framework is YouTube's Terms of Service and database/content rights, not data-protection law — GDPR and CCPA govern personal data about individuals and generally do not attach to aggregate engagement statistics or a channel's own published content. Scraping public data is broadly established as legal (see hiQ Labs v. LinkedIn), but always review YouTube's Terms of Service for your own use case, and consult legal counsel for commercial use involving any bulk personal data.

❓ Frequently asked questions

Does Youtube Most Replayed Scraper & Video Chapters work without a YouTube account?

Yes. No login is ever required — every field comes from the public watch page, fetched logged out. A proxy is optional and off by default.

How often is the scraped data updated?

Every run fetches the watch page live at the moment it runs; nothing is served from a cache. Heatmap and chapter data reflect whatever YouTube's page returns for that request.

What happens when a video has no chapters or no heatmap?

Nothing is faked. The row still comes back with hasChapters: false and/or hasHeatmap: false, chaptersFound: 0, heatmapMarkerCount: 0 and empty arrays — unless you turn on skipVideosWithoutChapters / skipVideosWithoutHeatmap, in which case that video is dropped before it is saved and billed.

Can I scrape private or age-restricted YouTube videos?

No. Only videos whose playabilityStatus is OK on the public watch page are processed. Videos that are private, deleted, or otherwise unavailable produce an uncharged accounting row with errorReason filled in, and are not retried, since the result would not change with a different exit IP.

How am I charged for results?

Only successfully scraped videos are billed, via the row_result charged event, one per video. Videos skipped by a filter, or reported by YouTube as unavailable, are pushed as uncharged accounting rows (or not pushed at all, for filtered-out videos) — you are never billed for a result you didn't get or explicitly filtered out.

Does Youtube Most Replayed Scraper & Video Chapters work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP endpoint through the Apify API by any agent framework. Every response is typed JSON with stable field names — no HTML, no selectors, no parsing step before you pass a chapter title or a deep link into an LLM context window or a tool call.

How does it handle YouTube's anti-bot defenses?

proxy is off by default; the Actor runs direct until it hits a retryable failure (an exception, or a status like 401/403/429/500–504), a likely IP-based block, or a LOGIN_REQUIRED/AGE_VERIFICATION_REQUIRED playability status. At that point it switches itself to the Apify Residential proxy and stays on it, latched, for the rest of the run — it does not switch back. Retries back off for min(10, 1.5^attempt) seconds between attempts, up to maxRetries.

How does Youtube Most Replayed Scraper & Video Chapters compare to other YouTube scrapers?

See the comparison table above. The core observable difference is scope: this Actor extracts the most-replayed heatmap and joins it to chapters in one request, which most general-purpose YouTube scrapers do not attempt because both surfaces have to be pulled out of an internal page payload rather than a documented field.

Does it return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with stable field names throughout. Pass it directly into an LLM context window, index it into a vector store keyed by videoId, or route it through an agent tool without a parsing step.

Can I use it without managing proxies?

Yes. Proxy is optional. Left off, the Actor runs direct and only switches to Apify Residential itself if YouTube starts blocking requests — you don't have to configure or rotate anything yourself.

What happens when YouTube changes its structure or blocks the scraper?

Youtube Most Replayed Scraper & Video Chapters is maintained, and its output schema is built to stay stable on your end — field names and types don't change even when the extraction logic behind them does. No specific turnaround time is promised for any given fix.

💬 Your feedback

Found a bug, or a field that's missing something you need? We want to know. Reach out through the Actor's page on the Apify Store, or open an issue via your Apify Console — reports of a real mismatch between this README and the Actor's actual output get fixed fastest.