Youtube Most Replayed Scraper

YouTube Most Replayed Scraper — Heatmap, Views and Engagement Data

Youtube Most Replayed Scraper reads the watch page of any YouTube video and returns the Most Replayed graph as structured JSON: the 100-point heatSeek intensity curve, the labelled mostReplayed peaks, plus channelOwner, title, viewCount, likes, comments, dateText and relativeDate. No YouTube API key, no login, and no browser session to manage — paste a URL and get typed fields back, ready to chart, index, or feed to an LLM. Try a run on the Apify Store to see your first heatmap in seconds.

What is Youtube Most Replayed Scraper?

Youtube Most Replayed Scraper is an Apify Actor that fetches the public desktop watch page for each URL you give it and parses the Most Replayed heatmap and core video metadata straight out of YouTube's own server-rendered page data. It does not call the YouTube Data API and does not require a Google account, YouTube login, or cookies — every field returned is what any visitor sees on the watch page. It's built for video editors, YouTube analytics tools, growth teams, and researchers who need the retention/replay curve as data instead of reading it off the player scrubber.

What YouTube heatmap data is publicly available to scrape?

Everything Youtube Most Replayed Scraper returns is visible on the public watch page without signing in — the graph itself is a feature YouTube renders directly under the player for any visitor.

Data category	Publicly available (no login)	Gated behind
Video title, video ID, channel name	Yes	—
View count	Yes	—
Like count	Yes, when YouTube shows it	Creator/YouTube can hide the count — returned as null, never guessed
Comment count (header total)	Yes	Individual comment text and reply threads — not returned by this Actor
Upload date (absolute + relative)	Yes	—
Most Replayed heatmap (heatSeek, mostReplayed)	Yes, once YouTube has published one	New videos without enough watch history — no graph yet; not a login gate
Private, unlisted, age-restricted or region-locked videos	No	Login, age verification, or region — returns an uncharged error row instead of data

Youtube Most Replayed Scraper only returns publicly visible data — what any visitor sees on the watch page. Nothing behind a login wall.

What data can I extract with Youtube Most Replayed Scraper?

Every run returns one row per video with identity fields, engagement metrics, the heatmap itself, and — only on failure — an error field pair.

Field	Description
videoId	11-character YouTube video ID
title	Video title
channelOwner	Channel display name
dateText	Absolute upload date as shown on the watch page (e.g. "Oct 25, 2009")
relativeDate	Relative upload date as shown on the watch page (e.g. "16 years ago")
viewCount	View count, as displayed (text, not a parsed integer)
likes	Like count as a number-shaped string, or null when YouTube hides the count
comments	Comment count from the comments panel header
mostReplayed	Array of labelled replay peaks: each item has visibleTimeRangeStartMillis, visibleTimeRangeEndMillis, decorationTimeMillis
heatSeek	Array of up to 100 intensity buckets: each item has startMillis, durationMillis, intensityScoreNormalized
error	Human-readable failure reason — present only on a failed row
errorReason	Failure code — present only on a failed row

Identity and descriptive fields

videoId, title, channelOwner, dateText, relativeDate — what the video is, who made it, and when it went up.

Engagement and heatmap fields

viewCount, likes, comments, mostReplayed, heatSeek — the counters plus the two arrays that make up the Most Replayed graph.

Error and accounting fields

error, errorReason — only ever present on the uncharged rows described in Input and Output below. Successful rows never carry these keys.

🤖 Add-on: Need additional YouTube data?

Youtube Most Replayed Scraper is deliberately scoped to the heatmap and its surrounding metadata — it does not fetch chapters, channel details, or the full tag/description block. For a channel's whole catalogue (videos, Shorts, live streams and community posts), pair it with YouTube Channel Scraper. To discover videos in the first place from a seed hashtag or keyword, use YouTube Video Scraper by Hashtag (Related Tag Expansion) and pipe its videoId output straight into this Actor's urls.

How does Youtube Most Replayed Scraper differ from the official YouTube API?

The YouTube Data API v3 is Google's official, documented API for YouTube — but it has no endpoint that returns the Most Replayed heatmap at all; that data exists only inside the watch page's client-rendered payload, which is exactly what this Actor parses.

Feature	YouTube Data API v3	Youtube Most Replayed Scraper
Most Replayed heatmap access	No endpoint exposes it	Returns heatSeek + mostReplayed for every video that has one
Authentication	Google Cloud project + API key or OAuth	None — no login, no API key
Default quota	10,000 units/day per project; videos.list costs 1 unit per call (per Google's developer documentation, checked 2026-08-04)	No platform-imposed quota; governed only by this Actor's own requestTimeoutSecs and maxRetries
Setup time	Create a Cloud project, enable the API, manage a key	Paste URLs and run
Data returned	Structured metadata (views, likes if public, etc.)	Same public metadata, plus the heatmap the API cannot return
Write access (comments, uploads, moderation)	Yes	No — read-only by design

Use the official API when you need authenticated write access, channel management, or other endpoints it does cover. Use Youtube Most Replayed Scraper when the data you need is the retention heatmap itself, since no official endpoint returns it.

How to use Youtube Most Replayed Scraper

Youtube Most Replayed Scraper runs on the Apify platform — no separate signup or SDK install is required to get your first result.

1. Open Youtube Most Replayed Scraper on the Apify Store and click Run, or start it via the Apify API/apify-client.
2. Paste one or more YouTube video URLs into urls — the only required input. watch?v=, youtu.be/, /shorts/, /embed/, /live/ links and bare video IDs are all accepted.
3. Optionally turn on the Apify Residential proxy, or adjust requestTimeoutSecs / maxRetries for slower networks.
4. Start the run.
5. Read results from the dataset as JSON or CSV, via the API, or stream them to a webhook once the run finishes.

How to scale to bulk video extraction

urls is an array, so a single run accepts as many watch links as you paste in — one per line — and processes them in order, applying the proxy-fallback and retry logic per URL. There is no separate batch endpoint or job-splitting input; for very large lists, splitting across multiple runs is the practical pattern for keeping any one run's timeout budget manageable.

What can you do with YouTube heatmap and engagement data?

• 🎬 Video editors use heatSeek and mostReplayed to see exactly where viewers rewatch, then cut trailers or Shorts around those timestamps instead of guessing.
• 📊 Channel analysts combine viewCount, likes and comments with heatSeek across a catalogue to compare which uploads actually hold attention, not just which get clicks.
• 🔎 Content researchers use mostReplayed peaks alongside dateText to study how retention behaviour differs between recent and older uploads.
• 📈 Marketers check whether likes comes back null (hidden by the creator) before using it to benchmark a campaign video against competitors.
• 🤖 AI/LLM engineers feed heatSeek and the metadata fields into a RAG pipeline or agent tool to auto-generate retention-based highlight timestamps or summarise "the moment everyone rewinds to" without touching the player UI.

How does Youtube Most Replayed Scraper handle rate limits and blocking?

Youtube Most Replayed Scraper runs direct (no proxy) by default. If YouTube blocks a request — or if you select a proxy that fails to initialise — it automatically switches to Apify Residential proxy and stays on it for the rest of the run; it does not fall back to datacenter proxies. Failed requests are retried up to maxRetries times with a short exponential backoff between attempts (capped at 10 seconds). Videos that YouTube itself reports as unavailable (removed, private) are not retried — they return immediately as an uncharged error row, since retrying a dead video wastes time without changing the outcome. Login-style walls (age check, content check, sign-in required) trigger one escalation to Residential before giving up.

⚠️ The Actor does not solve CAPTCHAs — it only rotates the exit IP. It also only requests the desktop web watch page: mobile, TV, and embedded YouTube clients return an HTTP 200 with a normal-looking body but never include the heatmap, so this Actor deliberately never uses them.

⬇️ Input

Parameter	Required	Type	Description	Example value
urls	Yes	array	One or more YouTube video URLs, one per line. watch?v=, youtu.be/, /shorts/, /embed/ and /live/ links are all accepted and normalised to the desktop watch page. Default: ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"].	["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "https://youtu.be/9bZkp7q19f0"]
proxy	No	object	Apify Proxy configuration. Off by default. If left off and the Actor is blocked, it switches to Apify Residential itself and stays on it. Default: {}.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}
requestTimeoutSecs	No	integer	How long to wait for a single watch-page response before treating it as failed. Default: 20. Minimum: 5. Maximum: 300.	30
maxRetries	No	integer	How many times to retry a URL that fails to load. Videos YouTube reports as unavailable are not retried. Default: 3. Minimum: 0. Maximum: 10.	3

Example input

{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/9bZkp7q19f0",
    "https://www.youtube.com/shorts/abc12345678"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "requestTimeoutSecs": 20,
  "maxRetries": 3
}

⬆️ Output

Every run writes typed, normalized JSON rows to the default dataset — the same field names and shapes on every run, whether the video had a heatmap or not. Only successful, charged rows carry the full metadata; failed URLs carry error and errorReason instead, and are pushed uncharged (filter these out by keeping rows where errorReason is absent). Results are downloadable in any of Apify's standard dataset export formats, including JSON and CSV. A run summary (total, succeeded, failed, withHeatmap, withoutHeatmap, whether the residential fallback was used) is also written to the key-value store under OUTPUT.

Example output

A successful row, with a Most Replayed graph present:

{
  "channelOwner": "Rick Astley",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "videoId": "dQw4w9WgXcQ",
  "viewCount": "1,650,732,981",
  "likes": "18204765",
  "comments": "241,038",
  "dateText": "Oct 25, 2009",
  "relativeDate": "16 years ago",
  "mostReplayed": [
    {
      "visibleTimeRangeStartMillis": 44800,
      "visibleTimeRangeEndMillis": 52300,
      "decorationTimeMillis": 48000
    }
  ],
  "heatSeek": [
    { "startMillis": 0, "durationMillis": 2130, "intensityScoreNormalized": 0.31 },
    { "startMillis": 2130, "durationMillis": 2130, "intensityScoreNormalized": 0.58 },
    { "startMillis": 4260, "durationMillis": 2130, "intensityScoreNormalized": 0.94 }
  ]
}

An uncharged error row for a video YouTube refuses to serve:

{
  "channelOwner": "",
  "title": "",
  "videoId": "abc12345678",
  "viewCount": "",
  "likes": null,
  "comments": "",
  "dateText": "",
  "relativeDate": "",
  "mostReplayed": [],
  "heatSeek": [],
  "error": "LOGIN_REQUIRED: Sign in to confirm your age",
  "errorReason": "BLOCKED"
}

How does it work?

Youtube Most Replayed Scraper sends one plain HTTPS GET per video to the desktop https://www.youtube.com/watch?v=<id> page with a Chrome user agent — no headless browser, no login, no cookies. It parses the two JSON blobs YouTube embeds in the page (ytInitialData and ytInitialPlayerResponse) to pull out the heatmap and the metadata fields. If the target blocks the request, the Actor switches its outgoing IP to Apify Residential proxy and retries rather than giving up. Only data already visible to any visitor on the public watch page is returned — nothing is inferred or scraped from a logged-in session. Because the output schema is fixed by this Actor's own code rather than by YouTube's page markup, the field names and shapes stay stable even when YouTube changes its page layout.

Integrations

Youtube Most Replayed Scraper works with whatever you already use to call Apify Actors — there's no separate signup or proprietary SDK.

Calling Youtube Most Replayed Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")
run = client.actor("youtube-most-replayed-scraper").call(run_input={
    "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "maxRetries": 3,
})

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

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

No-code tools (n8n, Make, LangChain)

In n8n or Make, use an HTTP Request node pointed at the Actor's run endpoint (https://api.apify.com/v2/acts/youtube-most-replayed-scraper/run-sync-get-dataset-items) with your API token, and parse the JSON response directly into the rest of your flow. In LangChain or any agent framework, wrap the same HTTP call as a tool so an agent can request a video's heatmap on demand.

Is it legal to scrape YouTube video and heatmap data?

Scraping publicly visible video metadata and the Most Replayed graph is generally legal, since Youtube Most Replayed Scraper returns only what YouTube already displays to any visitor without a login. This is content and engagement data tied to a public video and channel, not private data about individual viewers, so it sits under YouTube's Terms of Service and database-rights considerations rather than personal-data law like GDPR or CCPA. Consult legal counsel if your use case involves bulk storage of personal data, particularly if you plan to combine this output with other datasets that identify private individuals.

Frequently asked questions

What YouTube fields does Youtube Most Replayed Scraper return?

It returns heatSeek (the 100-bucket intensity curve), mostReplayed (the labelled peaks), viewCount, likes and comments, plus channelOwner, title, videoId, dateText and relativeDate. See What data can I extract above for the full field table.

Does Youtube Most Replayed Scraper require a YouTube account or login?

No. It fetches the public desktop watch page with a plain HTTPS request and a Chrome user agent — no Google account, YouTube login, or cookies are used or required.

How many videos can I extract in one run?

urls accepts an array of any length, so one run can process as many watch links as you paste in. There is no fixed cap in the input schema itself; very large lists are practically limited by requestTimeoutSecs and how long you're willing to let a single run take.

What happens if a video has no Most Replayed graph?

YouTube only publishes the graph once a video has accumulated enough watch history — on a 43-video sample checked by the Actor's authors, 27 (62.8%) had one and the rest did not, with absence tracking video age more than view count. When there's no graph, the row still saves successfully with mostReplayed and heatSeek as empty arrays — it is not treated as an error.

What happens if a video is removed, private, or region-locked?

The watch page can return HTTP 200 while still refusing to serve the video (removed, private, age-restricted, or region-locked). Youtube Most Replayed Scraper detects this from the page's own playability status, skips parsing a blank row, and instead pushes an uncharged row with error and errorReason set (VIDEO_UNAVAILABLE for a dead video, BLOCKED for a login/age/content wall). Filter these out downstream by checking whether errorReason is present.

Can I scrape multiple YouTube videos at once?

Yes. Pass multiple URLs in the urls array in a single run; each is fetched, retried, and saved independently, so one slow or unavailable video doesn't block the rest.

Does Youtube Most Replayed Scraper work with Claude, ChatGPT, and other AI agent tools?

It's callable as a standard HTTP endpoint by any agent framework via the Apify API — see Integrations above. It is not currently exposed through a dedicated MCP server.

How does Youtube Most Replayed Scraper compare to other YouTube heatmap scrapers?

Other Most Replayed / heatmap extractors exist on the Apify Store; this Actor's specific behaviour — separating the heatmap surface from the chapters surface so chapter decorations are never folded into mostReplayed, returning honest empty arrays instead of fabricating peaks, and pushing failed URLs as uncharged accounting rows rather than blank successes — is documented in the sections above and in its source code. Compare listings directly for the behaviour that matters to your use case.

Does Youtube Most Replayed Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across every run — no HTML parsing, no CSS selectors. Pass it directly to an LLM prompt, index it into a vector store, or call it as an agent tool.

What happens when YouTube changes its layout or anti-bot system?

The Actor is maintained, and the output schema — the field names and shapes described above — stays stable across YouTube layout changes; only the internal parsing logic needs to adapt. No specific turnaround time for fixes is published.

Can I use Youtube Most Replayed Scraper without managing proxies or browser infrastructure?

Yes. There's no browser to run at all — the Actor makes plain HTTP requests — and proxy handling (including the Residential fallback when blocked) is managed by the Actor itself. You only need to opt into a proxy if you want one active from the first request instead of after a block.

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

For RAG or semantic search, title, channelOwner and dateText give the descriptive context to pair with a video ID. For structured analysis or training data, heatSeek and mostReplayed are the most consistently shaped fields across records — fixed-key objects in an array — while viewCount, likes and comments return as typed strings (or null for hidden likes) rather than free text.

🔗 Related scrapers

Scraper	What it extracts
YouTube Channel Scraper	A channel's profile plus its long-form videos, Shorts, live/past streams and community posts, one row per item
YouTube Video Scraper by Hashtag (Related Tag Expansion)	Videos discovered from a seed hashtag, keyword or handle by crawling YouTube's own related-tag suggestions

💬 Your feedback

Found a bug, or need a field this Actor doesn't return? Open an issue on the Actor's Apify Store page or message Scraper-Engine support directly — reports of missing fields or broken URLs help keep the heatmap parser accurate as YouTube's page markup changes.