YouTube Channel Scraper: New Videos, Stats & Comments

YouTube Channel Scraper watches channels and videos without a login and without an API key, and returns three kinds of row as JSON or CSV: new videos of a channel with title, exact publication time, view count, likes, length, hashtags, comment count, thumbnail and description; channel facts from the About page (subscribers, total views, video count, description, country, join date, avatar); and the newest comments of a video, requested newest first, with the text, author, likes and reply count in a shape a sentiment step can use directly.

With Only new videos and comments, the Actor remembers what it already returned per channel and per video, so a scheduled run reads the channel's video list, finds that nothing is new, and returns — and charges — nothing.

It runs in the cloud: no browser, no account, no API key. Status rows (comments turned off, a bot check, an unreadable response) are written for visibility and are not charged. This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by YouTube or Google.

Use cases

• Creator and competitor monitoring. A daily run that returns only the videos and comments that arrived since the last one.
• Engagement tracking. Views, likes and comment counts per video, kept as a time series.
• Community sentiment. Fetch the newest comments of a video and hand them to a summariser or a classifier.
• Channel research. Subscriber count, total views, video count and description for a list of channels in one table.
• Agent and MCP use. One channel with a small maxVideosPerChannel returns a readable list of new uploads.

What data can you get?

Row kind	Fields
Every row	type (channel, video, comment), id, url, isNew (with onlyNewItems), error
channel	channelId, handle, title, subscribers, subscriberText, totalViews, videoCount, description, country, joinedAt, avatarUrl
video	videoId, title, channelId, publishedAt, publishedText, publishedAtIsEstimate, views, likeCount, commentCount, durationSeconds, isShort, hashtags, videoStatsReason, thumbnailUrl, description
comment	commentId, videoId, videoTitle, channelId, author, authorChannelId, text, likeCount, replyCount, publishedText, publishedAt, publishedAtIsEstimate, isPinned, isOwner, sort

Every row has every field; a value a row does not carry is null. Comments carry public text and public author names only. Replies themselves are not fetched (their replyCount is), and no personal contact data is collected.

likeCount is the video's likes on a video row and the comment's likes on a comment row. commentCount is the number of comments on the video; durationSeconds its length; isShort says whether the channel lists it on the Shorts tab (a Short has no length on YouTube's tabs, so durationSeconds stays null); hashtags the #tags written in its description ([] when there are none). When a row has no likes, length, hashtags or count, videoStatsReason says why in a fixed-format sentence.

subscribers is approximate because YouTube shows it rounded (12.3K subscribers); subscriberText keeps the text as shown. A comment has no exact timestamp on YouTube, so publishedAt is computed from the relative text (2 days ago) and publishedAtIsEstimate is true in that case; publishedText keeps the original text.

How to use YouTube Channel Scraper

1. Put Channels (channels: @handle, /channel/ URL, /c/ or /user/ URL, or channel ID) and/or Videos (videos: watch URL, youtu.be, Shorts or the 11-character ID) into the input.
2. Choose what to return: videos (the default: channel and video rows), comments, or both.
3. Set videos per channel, comments per video and comment pages per video to bound the run.
4. Keep includeVideoStats on to have likes, length, hashtags and the comment count on every video row, or turn it off for a large, fast run.
5. Run it. The dataset holds one row per channel, video and comment; the run summary is in the OUTPUT record.

An empty input ({}) reads one sample video, so the default MCP call returns a row quickly. A channel-only input does not add the sample.

Input example

{
    "channels": ["https://www.youtube.com/@TED"],
    "videos": [],
    "mode": "both",
    "includeChannelInfo": true,
    "maxVideosPerChannel": 5,
    "maxCommentsPerVideo": 20,
    "maxCommentPages": 2,
    "onlyNewItems": true,
    "maxItems": 50,
    "includeVideoStats": true
}

Input

Field	Default	What it does
channels	[]	Channel URL, @handle, /c/ or /user/ URL, or channel ID
videos	[]	Video URLs, Shorts links or 11-character IDs
mode	videos	videos, comments or both
includeChannelInfo	true	Return the channel row (subscribers, views, description)
maxVideosPerChannel	5	Videos per channel, newest first (1 to 15)
maxCommentsPerVideo	20	Comments per video (1 to 100)
maxCommentPages	2	Comment pages per video (1 to 5, about 20 comments per page)
onlyNewItems	false	Return only channels, videos and comments that earlier runs have not returned
maxItems	20	Maximum rows written (1 to 500)
includeVideoStats	true	Add likes, length, hashtags and the comment count to video rows
debugSnapshot	false	Diagnostic snapshot of a page that could not be read. Normally not needed
proxyConfiguration	direct connection	Proxy settings (country, groups, custom proxy URLs)

Output

One row per channel, video and comment. A video whose comments are explicitly turned off, a bot-check page or a comment response that is not usable is returned as a row with error.type (comments-disabled, bot-check, consent, comments-unavailable, video-unavailable) and a fixed sentence. Those status rows are not charged and are not remembered, so the next run retries the video.

Output example

Values below are illustrative; this one is a comment row.

{
    "type": "comment",
    "id": "comment:UgxNEWCOMMENT01",
    "url": "https://www.youtube.com/watch?v=VC4g2l47rzc&lc=UgxNEWCOMMENT01",
    "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
    "videoId": "VC4g2l47rzc",
    "videoTitle": "How Imaginary Worlds Help Every Kid Belong | Anna Rainio | TED",
    "commentId": "UgxNEWCOMMENT01",
    "author": "@alice",
    "authorChannelId": "UC7WUE3coJ7m27rfLscKnu_g",
    "text": "The newest comment on the video.",
    "likeCount": 12,
    "replyCount": 3,
    "publishedText": "51 minutes ago",
    "publishedAt": "2026-11-05T18:55:00.000Z",
    "publishedAtIsEstimate": true,
    "isPinned": false,
    "isOwner": false,
    "sort": "newest",
    "error": null,
    "isNew": true
}

Likes, length and the comment count

includeVideoStats (default true) adds four fields to every returned video row: likes, length, hashtags and the comment count. The channel's Videos tab carries the length of every video on it, so the length costs one read per channel rather than one per row; a video that is not on that tab gets its length from the Shorts tab, where a Short has none (isShort: true). Likes, the description and the comment count come from a read of the video itself. Requests go out one at a time, at least one second apart:

Rows	Added time
10 videos (1 channel)	about 25 s
100 videos (1 channel)	about 3.5 min

The default is on because these four fields give a fuller picture of each returned video; set it to false for a large monitor that only needs titles, dates and view counts. A named video already has the fields from its own row, whatever the setting. In both mode the comment step reads the video page, but the stats do not, so nothing is read twice. Hashtags need no read of their own: the channel feed's description carries them.

Newest first, comments and onlyNewItems

A comment monitor needs the comments that arrived since the last run, not the all-time top comments. The Actor asks for YouTube's Newest sort when available. sort on each comment row says which order was used (newest, or top when YouTube offered no sort menu).

onlyNewItems keeps a per-input state record in a named key-value store (per channel for videos, per video for comments) for 90 days. A row is remembered only after it was written and charged; a status row is not remembered. The state key includes the mode, so a videos run never hides the comments of a later comments run. Do not run the same input concurrently: both runs read the old state and both return the same new rows.

Up to maxCommentPages pages are read per video (about 20 comments per page). If a video receives more new comments than that between two runs, raise maxCommentPages (up to 5) or run more often; comments beyond the pages read are not returned.

How much does it cost?

YouTube Channel Scraper uses pay-per-event pricing: you pay only for the rows returned, not for the time it runs. At the Free tier 1,000 rows cost $1.10; at Gold, $0.60.

Apify plan (discount tier)	Price per 1,000 rows	Price per row
Free	$1.10	$0.0011
Starter (Bronze)	$1.00	$0.001
Scale (Silver)	$0.80	$0.0008
Business (Gold)	$0.60	$0.0006

Apify's Free plan includes USD 5 of monthly usage, which covers about 4,545 rows at the Free tier price, run start fees aside.

• Run start fee: the platform default per run (see the Pricing tab).
• Status rows (comments turned off, bot check, consent, unreadable response) are written but not charged.
• Rows beyond maxItems, videos beyond maxVideosPerChannel and comments beyond maxCommentsPerVideo are not fetched and not charged.
• With onlyNewItems, unchanged channels and videos already returned are not charged.

Use with AI agents (MCP)

YouTube Channel Scraper works as a tool for AI agents such as Claude, Cursor and n8n agents through the Apify MCP server. Load only this Actor with this server URL:

https://mcp.apify.com?tools=kizukidata/youtube-channel-monitor

• Claude Code: run claude mcp add apify "https://mcp.apify.com?tools=kizukidata/youtube-channel-monitor" -t http.
• Claude (web or desktop app): open Customize → Connectors, choose Add custom connector, name it Apify and paste the server URL above.
• Cursor: add the server to ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
    "mcpServers": {
        "apify": { "url": "https://mcp.apify.com?tools=kizukidata/youtube-channel-monitor" }
    }
}

• n8n: add the Apify node (on self-hosted n8n, install the community package @apify/n8n-nodes-apify) and choose Run an Actor and get dataset; for an n8n AI Agent, add Apify Tool as a tool.

The server signs you in to Apify with OAuth. A client that cannot use OAuth can send your Apify API token in an Authorization: Bearer <APIFY_TOKEN> header instead.

What to send from an agent

Pass one channel and a small maxVideosPerChannel (or one video with mode: "comments"); the result is the dataset URL. {} returns the one sample video. maxItems bounds the rows written, and only data rows are charged. Keep maxItems small (the default is 20) so the call returns inside the MCP timeout.

Integrations and API

Run the Actor from your own code or from an automation tool. Replace <APIFY_TOKEN> with your API token.

Zapier, Make and n8n

Use the Apify integration, choose Run Actor, and pass one channel plus onlyNewItems: true. Add Get dataset items and use the new comment rows as the trigger for a Slack message, a sheet row or an AI summary step. A daily schedule is usually enough for a channel monitor.

LangChain

Load the comment rows as documents: text as page_content; author, videoTitle, likeCount, publishedAt and url as metadata. Because the rows are already newest-first and carry the relative time, a summariser can group by videoId and describe what people said since the previous run.

cURL

curl -X POST "https://api.apify.com/v2/acts/kizukidata~youtube-channel-monitor/runs" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"channels":["https://www.youtube.com/@TED"],"mode":"comments","maxVideosPerChannel":1,"onlyNewItems":true}'

Poll GET https://api.apify.com/v2/actor-runs/<RUN_ID> for the status, read defaultDatasetId, then fetch GET https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json.

Python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("kizukidata/youtube-channel-monitor").call(run_input={"channels": ["https://www.youtube.com/@TED"], "mode": "comments", "maxVideosPerChannel": 1})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["type"] == "comment":
        print(item["author"], item["text"][:80])

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('kizukidata/youtube-channel-monitor').call({ videos: ['dQw4w9WgXcQ'], mode: 'comments', maxCommentsPerVideo: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((row) => row.type === 'comment').map((row) => row.text));

Limitations

• No login, no cookies, no API key. Only publicly accessible video and channel metadata are requested, and nothing is written to YouTube.
• No browser and no video or audio download. The channel listings, the About metadata and the video pages are fetched; the media is not.
• No replies and no writes: no likes, favourites or subscriptions. Replies themselves are not fetched, only their count.
• Video lists: a channel's feed lists about 15 recent videos, and one run returns at most that many per channel (maxVideosPerChannel, 1 to 15). Some channels no longer answer it (404); for them the channel's own video list is read instead, which gives the title, a relative age (the row flags the date as an estimate) and a rounded view count, and has no description or thumbnail.
• Comment timestamps are estimates: YouTube shows relative text, not an exact time, so publishedAt is computed and publishedAtIsEstimate says so.
• A request that is challenged is retried once; an unreadable comment section becomes an uncharged bot-check row rather than a silent gap.
• Each run writes an OUTPUT record with the counts, the enrich-request totals and the reasons behind uncharged rows.

FAQ

Do I need a YouTube API key?

No. The Actor reads public channel and video pages; there is no key to create, no quota to manage and no account to connect.

Why is publishedAt marked as an estimate on some rows?

YouTube shows a relative age (2 days ago) for comments, and some channel listings give a relative age too. The Actor computes a timestamp from it and sets publishedAtIsEstimate: true; publishedText keeps the original wording.

Why did a row come back with error?

The comment section is turned off for that video, YouTube answered with a bot check or a consent page, or the response was not usable. The row says which, it is not charged, and the next run retries it.

Can I get only new videos and comments since the last run?

Yes: set onlyNewItems to true, save the input as a Task and schedule it. See Newest first, comments and onlyNewItems.

Is it legal to use this data?

The Actor reads public channel listings, public About metadata and public video pages, without logging in. YouTube's Terms of Service prohibit accessing the service with automated means except as authorised, and whether your use is permitted is your decision. Comment rows contain public usernames and text, which can be personal data under the GDPR and similar laws; handle them accordingly. This is not legal advice.

Related Kizuki Actors

Other Actors from Kizuki that work well with this one:

• YouTube Transcript Scraper — the spoken text of those videos, with timestamps and chunks.
• Google News Scraper — news coverage of the same brands and topics.

Your feedback

Bugs, a field that stopped coming back, and feature requests go to the Actor's Issues tab in Apify Console. A channel owner who wants a channel left out can open an Issue with the channel URL and the reason: the opt-out is recorded in the Actor source and applied in the next build, and a request from a third party is not applied.