Youtube Most Replayed Scraper With Channel Details

YouTube Most Replayed Scraper — Heatmap, Peaks and Channel Data

YouTube Most Replayed Scraper With Channel Details reads a YouTube watch page once and returns the most-replayed peaks (mostReplayed[]), the full replay heatmap curve (heatSeek[]), core video metadata (viewCount, likes, comments, dateText), and the channel behind the video — channelId, @handle, canonical URL, avatar, subscriber text and verified badge — from that same fetch. Per-channel rollups group every kept video by creator. Built for creator researchers, clip and shorts sourcers, and audience-retention analysts who need heatmap data and channel identity in one pass instead of two separate scrapes.

---

🎬 What is Youtube Most Replayed Scraper With Channel Details?

It is an Apify Actor that takes a list of YouTube watch URLs and, for each one, extracts the most-replayed graph, the underlying heatmap intensity curve, standard video metadata, and a full channel identity block — without a second request and without a YouTube account or API key. Results are written to an Apify dataset row by row as each URL finishes, so partial results are visible while a long list is still running.

• Discovery is by URL, not by search or category — you supply exact urls (required) and can append a second videoUrls list that gets merged and de-duplicated
• Core identifying fields: videoId, title, channelId, channelHandle, channelUrl
• Secondary data type: the most-replayed peaks and heatmap curve, plus viewCount, likes and comments
• Channel enrichment on every row: channelName, channelAvatarUrl, subscriberCountText, isVerified, channelBadges
• Real filters: keep verified channels only (onlyVerifiedChannels), or match channel name/handle/URL against keywords (channelNameKeywords) — both run before billing
• Export formats: whatever the Apify dataset natively supports — JSON, CSV, Excel and XML, plus the Apify API and apify-client SDKs

---

📊 What data can you extract with this YouTube scraper?

Every processed URL returns video metadata, the replay heatmap, and a full channel identity block in a single dataset row. Field names below are copied exactly from src/main.py and src/yt_extractors.py.

Field	Example value	Use case
videoId	"dQw4w9WgXcQ"	Stable 11-character key for joins
title	"Rick Astley - Never Gonna Give You Up (Official Video)"	Content identification
channelOwner	"Rick Astley"	Display name as rendered on the page
viewCount	"1799067526"	View count string from the player payload
likes	"19296166" or null	Engagement signal; null when the creator hides the count
comments	"2.4M"	Abbreviated comment count, "" when comments are off
dateText	"Oct 24, 2009"	Publish date as displayed
relativeDate	"16 years ago"	Relative publish age as displayed
mostReplayed	array (see below)	The labelled most-replayed peaks
heatSeek	array (see below)	The full intensity curve under the progress bar
channelId	"UCuAXFkgsw1L7xaCfnd5JJOw" or null	Permanent channel key, survives renames
channelName	"Rick Astley" or null	Channel display name
channelHandle	"@RickAstleyYT" or null	Current handle
channelUrl	"https://www.youtube.com/@RickAstleyYT" or null	Canonical channel URL, scheme-normalised to https://
channelAvatarUrl	image URL or null	Largest avatar thumbnail found on the page
subscriberCountText	"4.52M subscribers" or null	Rounded text exactly as YouTube renders it
isVerified	true / false / null	null only when the channel owner block is missing entirely
channelBadges	["Official Artist Channel"]	Raw badge labels found on the channel
channelDetailsFetched	true / false	Whether a channel ID or name could be resolved for this row
channelVideoIndex	1 or null	1-based position of this video among that channel's rows in this run
rowStatus	"ok" / "skipped" / "error"	Billing and quality status of the row
sourceUrl	the input URL	Traceability back to the input list
error / errorReason	present on skipped/error rows only	Why the row was not billed

🔥 The heatmap and most-replayed peaks

mostReplayed[] holds the labelled peaks YouTube surfaces above the seek bar, each item carrying visibleTimeRangeStartMillis, visibleTimeRangeEndMillis and decorationTimeMillis. heatSeek[] holds the full underlying intensity curve, each item carrying startMillis, durationMillis and intensityScoreNormalized. YouTube only publishes this graph for a subset of videos — coverage measured on a 43-video probe set on 2026-08-01 was 27 of 43 (62.8%), and it is all-or-nothing: a video carries either exactly 100 heatmap buckets or none at all, never a partial curve. Videos without a graph still return every metadata and channel field; the two arrays are simply empty.

🎯 Targeting data: channel filters

onlyVerifiedChannels (boolean, default false) keeps and charges a video only when its channel carries a verified or official-artist badge — measured selective on the same probe set, where 33 of 43 channels were badged. channelNameKeywords (array, default []) does a case-insensitive substring match against the channel name, handle and URL, keeping a row if any keyword matches. Both filters run before the charged push, so filtered-out rows are never billed.

---

🆚 How does this differ from the official YouTube Data API?

YouTube Data API v3 is Google's public, official API for video and channel metadata, but its videos.statistics resource exposes only viewCount, likeCount, commentCount and the deprecated favoriteCount — no heatmap, no most-replayed segments, and no engagement-curve data of any kind (confirmed against Google's current API reference, checked 2026-08-04). This Actor reads the same rendered watch page a browser loads and parses the ytInitialData/ytInitialPlayerResponse blobs directly, which is the only surface that carries the most-replayed graph at all.

Feature	YouTube Data API v3	This Actor
Most-replayed peaks / heatmap	❌ Not exposed	✅ mostReplayed[] and heatSeek[]
Channel identity attached to a video call	Requires a separate channels.list call	✅ Same fetch, zero extra requests
API key / Google Cloud project required	✅ Yes	❌ No
Quota units per request	Governed by Google's quota system	Not applicable — billed per processed URL
Setup	OAuth/API key + project setup	Paste watch URLs and run

❓ Why doesn't the official YouTube API expose the most-replayed graph?

The most-replayed heatmap is a client-rendered feature: YouTube's own frontend draws it from data embedded in the watch page's ytInitialData payload, and that payload was never mapped onto a public Data API v3 field. For any workflow that needs the actual replay curve — not just view/like/comment counts — there is no documented official endpoint to call at all, at any quota cost. This Actor closes that gap by parsing the same page a browser renders, and attaches the channel block that would otherwise need a second channels.list call.

Use the official API when you only need view/like/comment counts or channel metadata already covered by its documented fields and can accept its quota system. Use this Actor when you need the most-replayed graph, the heatmap curve, or channel identity fields attached to a video in a single call without a Google Cloud project.

---

🧭 How to use data extracted from YouTube

📈 Creator research and content strategy

Pull the most-replayed peaks for a batch of competitor or benchmark videos, then group results by channelId and subscriberCountText using the per-channel rollups. heatSeek[] shows exactly which second range holds attention, so a content team can compare which sections of a rival's videos get rewatched most before planning their own edit.

✂️ Clip and shorts sourcing agencies

Agencies cutting shorts or highlight reels from long-form video can feed a client's back catalogue through urls, filter to onlyVerifiedChannels: true if only official uploads are wanted, and use decorationTimeMillis from mostReplayed[] as the exact timestamp to center a clip on — repeatable for every new upload a client publishes.

🔬 Audience retention and trend research

Researchers studying what holds viewer attention across a topic or niche can run a list of URLs, then compare heatmapCoveragePercent and totalPeaks across the per-channel rollup output to quantify which creators or formats produce more rewatch-worthy moments, without needing YouTube Studio access to any of the channels involved.

🤖 AI agents and automated pipelines

An agent can call this Actor as a tool step, pass a batch of video URLs, and use mostReplayed[] timestamps to drive automatic highlight-reel generation or retention-aware summarization — the JSON output requires no additional parsing beyond reading the documented keys.

---

🔼 Input sample

urls is the only required parameter. Every other field has a default and can be left untouched for a first run.

Parameter	Required	Type	Description	Example value
urls	Yes	array of strings	Watch URLs to analyse, one per line. Default ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"].	["https://www.youtube.com/watch?v=x7X9w_GIm1s"]
videoUrls	No	array of strings	Second list, appended to urls and de-duplicated. No default — leave empty to ignore.	["https://www.youtube.com/watch?v=UsdedFoTA68"]
onlyVerifiedChannels	No	boolean	Keep and charge a video only if its channel is verified/official-artist. Default false.	true
channelNameKeywords	No	array of strings	Case-insensitive substring match on channel name/handle/URL; any match keeps the row. Default [].	["fireship"]
includeChannelRollups	No	boolean	Build the uncharged per-channel aggregate. Default true.	true
proxy	No	object	Proxy configuration (Apify Proxy editor). Default {} (direct connection).	{"useApifyProxy": true}
requestTimeoutSecs	No	integer	Per-request timeout in seconds. Default 20, minimum 5, maximum 120.	30
maxRetries	No	integer	Retries after the first attempt. Default 3, minimum 0, maximum 8. Backoff is 1.5^attempt, capped at 10 seconds.	5

{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=x7X9w_GIm1s"
  ],
  "videoUrls": [
    "https://www.youtube.com/watch?v=UsdedFoTA68"
  ],
  "onlyVerifiedChannels": true,
  "channelNameKeywords": ["fireship", "astley"],
  "includeChannelRollups": true,
  "proxy": {},
  "requestTimeoutSecs": 20,
  "maxRetries": 3
}

Common pitfall: onlyVerifiedChannels and channelNameKeywords both run before the charged push. If you set onlyVerifiedChannels: true and also supply keywords that match no verified channel, every row for that channel comes back as an uncharged skipped row instead of an error — check errorReason (FILTERED_NOT_VERIFIED or FILTERED_CHANNEL_KEYWORD) before assuming the URL itself failed.

---

🔽 Output sample

Output is typed, normalized JSON with a consistent schema across every row, regardless of rowStatus. Export it as JSON, CSV, Excel or XML from the Apify Console, or read it through the Apify API / apify-client.

{
  "channelOwner": "Rick Astley",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "videoId": "dQw4w9WgXcQ",
  "viewCount": "1799067526",
  "likes": "19296166",
  "comments": "2.4M",
  "dateText": "Oct 24, 2009",
  "relativeDate": "16 years ago",
  "mostReplayed": [
    {
      "visibleTimeRangeStartMillis": 0,
      "visibleTimeRangeEndMillis": 21286,
      "decorationTimeMillis": 8296
    }
  ],
  "heatSeek": [
    { "startMillis": 0, "durationMillis": 2128, "intensityScoreNormalized": 1.0 }
  ],
  "channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channelName": "Rick Astley",
  "channelHandle": "@RickAstleyYT",
  "channelUrl": "https://www.youtube.com/@RickAstleyYT",
  "channelAvatarUrl": "https://yt3.ggpht.com/MOWpaiGJdgN4aKMI-NGQLL4jMVP3aDORlQpOBWooi0GSE2TGt4_9ncyepk1pCh-yWQ795AhPbw=s176-c-k-c0x00ffffff-no-rj",
  "subscriberCountText": "4.52M subscribers",
  "isVerified": true,
  "channelBadges": ["Official Artist Channel"],
  "channelDetailsFetched": true,
  "rowStatus": "ok",
  "sourceUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "channelVideoIndex": 1
}

Rows that fail or get filtered carry the same schema plus error and errorReason, and are pushed without the row_result charged event — only rowStatus: "ok" rows are billed. Keep the filter expression rowStatus == "ok" when reading the dataset back if you only want billed rows.

When includeChannelRollups is true (default), the run also writes one uncharged aggregate record per channel to a child dataset named channel-rollups-<runId> and to channel_rollups.json in the key-value store:

{
  "channelKey": "UCsBjURrPoezykLs9EqgamOA",
  "channelId": "UCsBjURrPoezykLs9EqgamOA",
  "channelName": "Fireship",
  "channelHandle": "@Fireship",
  "channelUrl": "https://www.youtube.com/@Fireship",
  "channelAvatarUrl": "https://yt3.ggpht.com/example=s176-c-k-c0x00ffffff-no-rj",
  "subscriberCountText": "4.24M subscribers",
  "isVerified": true,
  "videosInRun": 2,
  "videoIds": ["x7X9w_GIm1s", "UsdedFoTA68"],
  "videosWithHeatmap": 2,
  "heatmapCoveragePercent": 100.0,
  "totalPeaks": 4,
  "viewCountsParsed": 2,
  "totalViewCount": 7436801,
  "averageViewCount": 3718400,
  "topVideoId": "UsdedFoTA68",
  "topVideoTitle": "Excel Pivot Table EXPLAINED in 10 Minutes",
  "topVideoViewCount": 4369781
}

The key-value store also holds most_replayed.json (all charged rows as one array) and OUTPUT (a run summary with total, succeeded, failed, chargedRows, unchargedErrorRows, unchargedFilteredRows, unchargedBotCheckBlockedRows, channelsFound, channelBlockCoverage, verifiedChannelRows, heatmapCoverage and channelRollupDatasetId).

---

🎯 How do you filter and target specific videos?

This Actor is URL-driven rather than search-driven: you supply the exact watch URLs you want, so there is no query-vs-category tradeoff to make — accuracy is guaranteed by giving the actual page address. Targeting instead happens on the channel attached to each video, using two filters, both applied before billing:

1. Verification quality threshold — onlyVerifiedChannels: true keeps only videos whose channel carries a verified or official-artist badge, discarding the rest as uncharged skipped rows. Use it to build a dataset limited to official/verified uploads only.
2. Channel keyword scope — channelNameKeywords narrows the run to channels whose name, handle or URL contains any of your keywords (case-insensitive substring match). Combine several keywords to cover known name variants of the same creator.
3. Volume control — there is no built-in cap on how many URLs urls + videoUrls can hold; every URL becomes exactly one page fetch and one dataset row, processed sequentially, one at a time — not in parallel. A longer list simply takes proportionally longer; there is no pagination to configure because each row maps 1:1 to an input URL.

{ "urls": ["https://www.youtube.com/watch?v=x7X9w_GIm1s"], "onlyVerifiedChannels": true }

{ "urls": ["https://www.youtube.com/watch?v=x7X9w_GIm1s"], "channelNameKeywords": ["fireship"] }

{ "urls": ["https://www.youtube.com/watch?v=x7X9w_GIm1s"], "onlyVerifiedChannels": true, "channelNameKeywords": ["fireship", "official"] }

---

▶️ Want to try other YouTube scrapers?

Scraper	What it extracts
YouTube Channel Scraper and Playlists	Channel profile fields, playlists tab, podcasts tab and per-series video listings
YouTube Video Scraper by Hashtag	Videos and Shorts discovered by hashtag, keyword or @handle search
TikTok Data Scraper	Video, hashtag and sound performance analytics on TikTok
TikTok Trending Creator Scraper	Per-video stats rolled up by trending TikTok creator

---

💻 How to extract YouTube data programmatically

This Actor runs like any Apify Actor: start it from the Apify Console, via a scheduled trigger, or through the Apify API using an API token, and read results back from its dataset once the run finishes.

Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "urls": ["https://www.youtube.com/watch?v=x7X9w_GIm1s"],
    "onlyVerifiedChannels": True,
    "channelNameKeywords": ["fireship"],
}

run = client.actor("youtube-most-replayed-scraper-with-channel-details").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("rowStatus") == "ok":
        print(item["videoId"], item["channelHandle"], len(item["heatSeek"]))

Export to spreadsheets or CRM

Every dataset can be exported directly as CSV from the Apify Console or API. Map videoId, title, channelName, channelHandle, channelUrl, subscriberCountText, isVerified, viewCount and channelVideoIndex to columns for a straightforward import into a spreadsheet or CRM for creator-outreach or content-benchmarking lists.

---

⚖️ Is it legal to scrape YouTube?

Scraping publicly available YouTube watch pages is generally lawful — video metadata and channel identity fields are published by their owners specifically to be seen by the public, with no login required to view them. Some fields returned here, however — channelName, channelHandle, channelAvatarUrl and subscriberCountText — can identify an individual creator rather than a company, so where personal data is involved, GDPR and CCPA principles apply to how you store, process and reuse it, not just how you collect it. Video-only fields like viewCount, likes and the heatmap arrays are engagement data about content, not about a person. Consult legal counsel for commercial applications involving bulk storage of personal data.

---

❓ FAQ

What happens if a video is deleted, private or age-restricted?

The row is not charged. The Actor detects YouTube's playability status, writes an uncharged row with rowStatus: "error" and an errorReason like PLAYABILITY_ERROR or PLAYABILITY_LOGIN_REQUIRED, and does not retry — an unplayable video is a property of the video itself, not of the network path, so retrying cannot change the outcome.

Can I get the channel's data along with the most-replayed peaks?

Yes, on every successful row, with no extra request or charge. channelId, channelName, channelHandle, channelUrl, channelAvatarUrl, subscriberCountText, isVerified and channelBadges come out of the same watch-page fetch used to read mostReplayed[] and heatSeek[].

How accurate is the heatmap and engagement data?

The Actor returns the exact values YouTube's watch page renders at request time — viewCount, likes, comments and the heatmap curve are read directly from the page's embedded JSON, not recomputed or estimated. subscriberCountText is YouTube's own rounded display text; no exact integer is derived from it. Because YouTube only publishes the most-replayed graph for a subset of videos (27 of 43, or 62.8%, on a probe set measured 2026-08-01), a video with empty mostReplayed/heatSeek arrays is not a scraping failure — YouTube has not generated that graph for it.

How many videos can I get per run?

There is no maxItems-style cap in the input schema — every URL you put in urls or videoUrls produces exactly one row. Processing is sequential (one URL at a time, not parallelized), so a longer list takes proportionally longer rather than hitting a hard limit.

How do I keep only verified channels or a specific creator's videos?

Set onlyVerifiedChannels: true to keep only videos whose channel carries a verified or official-artist badge, and/or add case-insensitive substrings to channelNameKeywords to match against the channel name, handle and URL. Both filters run before billing, so discarded rows never cost you a charge.

Am I charged for videos that fail or get filtered out?

No. Only rows with rowStatus: "ok" are pushed with the row_result charged event. Rows that error out (rowStatus: "error") or get removed by your channel filters (rowStatus: "skipped") are pushed without a charge, including rows blocked by YouTube's bot-check wall (errorReason: "BLOCKED_BOT_CHECK").

Do I need a proxy?

It is recommended but not required. Measured on 2026-08-01, YouTube serves a "Sign in to confirm you're not a bot" interstitial to some requests from datacenter exits, and which specific videos get walled differs from one exit IP to the next. The Actor detects this, retries with a fresh proxy session, and escalates permanently to the Apify Residential proxy group on the final retry if a proxy was configured; if it still cannot get through it writes an uncharged error row rather than fabricating data.

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

Yes, as a callable HTTP endpoint through the Apify API — any agent framework that can make an authenticated API call can start a run and read back the dataset. No MCP server is documented for this Actor.

Can I use it without a YouTube API key or Google developer account?

Yes. The Actor reads public watch pages directly; it needs no Google Cloud project, OAuth flow or API key. You only need an Apify account and (optionally) a proxy configuration to reduce bot-check blocks.

---

🏁 Conclusion

Youtube Most Replayed Scraper With Channel Details turns a list of YouTube watch URLs into structured rows carrying the most-replayed peaks, the full heatmap curve, and a complete channel identity block — all from a single page fetch, with verification and keyword filters applied before you're ever billed. It fits creator researchers, clip sourcers, and retention analysts who need channel context attached to engagement data without stitching together two separate scrapes. Paste your watch URLs into the Apify Console and start a run to see the first rows land in your dataset.