YouTube Comment Scraper & Downloader: Export Video Comments

This YouTube comment scraper downloads the top-level comments from one public YouTube video and returns structured dataset rows. Each row includes the comment text, author handle, channel identifier, displayed likes, reply count, and the pinned and creator-heart flags. Supply a video URL or video ID, choose how many comments you want, and download the results from your run as JSON, CSV or Excel.

The Actor preserves the existing video and max_comments inputs. It also keeps the original thirteen output fields and adds fields that make it easier to join comments with video and channel datasets. Comments arrive in YouTube's default Top comments order. This order is selected by YouTube and can change between runs; it is not a chronological archive or a promise that every comment will appear.

YouTube comment scraper input

Field	Type	Default	Description
video	string	Required	A watch, youtu.be, shorts or embed URL, or the video's 11-character ID.
max_comments	integer	100	Maximum top-level comments to collect, from 1 to 2,000.

The following input was used in the migration baseline and local verification:

{
  "video": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "max_comments": 100
}

You can omit max_comments to keep the default of 100. The returned video_url is always the canonical watch URL, including when the supplied address is a short link or a Shorts URL. The Actor processes one video per run. Use separate runs for a collection of video URLs.

Output fields and exports

Results go to the default Apify dataset, with one row for each delivered top-level comment. The following row is an actual response collected on 3 October 2026. Relative publication text, likes and reply counts may change when you collect the same comment again.

{
  "comment_id": "Ugzge340dBgB75hWBm54AaABAg",
  "author": "@YouTube",
  "author_channel_id": "UCBR8-60-B28hp2BmDPdntcQ",
  "author_is_verified": true,
  "text": "can confirm: he never gave us up",
  "published_text": "1 year ago",
  "like_count": "323K",
  "reply_count": 962,
  "is_pinned": true,
  "is_hearted": true,
  "video_id": "dQw4w9WgXcQ",
  "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "fetched_in_seconds": 13.33,
  "source": "youtube-comments",
  "platform": "youtube",
  "fetched_at": "2026-10-03T20:23:42.459Z",
  "post_id": "dQw4w9WgXcQ",
  "post_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "author_handle": "@YouTube",
  "author_id": "UCBR8-60-B28hp2BmDPdntcQ",
  "likes": 323000,
  "comment_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ&lc=Ugzge340dBgB75hWBm54AaABAg",
  "parent_comment_id": null
}

The original fields remain available: comment_id, author, author_channel_id, author_is_verified, text, published_text, like_count, reply_count, is_pinned, is_hearted, video_id, video_url and fetched_in_seconds.

like_count is a string containing YouTube's displayed abbreviated count. It can be empty when no count is shown. The added likes field is an integer estimate parsed from that abbreviation, rather than a promise of an exact unrounded count. reply_count is an integer; it counts replies but does not include their text. published_text preserves YouTube's English relative label, including an edited label where present. No exact publication date is inferred from text such as a number of years ago.

The added fields are source, platform, fetched_at, post_id, post_url, author_handle, author_id, likes, comment_url and parent_comment_id. The fetch timestamp is UTC. post_id matches video_id, which lets you join comments with a video export. author_id matches author_channel_id for channel joins. parent_comment_id is always null because these rows describe top-level comments. comment_url links to the comment on its video.

Export your dataset as JSON, JSONL, CSV or Excel from Apify. You can also read the dataset through the Apify API and pass the comment text to your own analysis tools. A run summary is available in the key-value store as summary; it includes itemCount and errorCount. The OUTPUT record adds delivery counts and completion information. The errors record appears when collection encountered a problem.

Use cases

• Sentiment and opinion analysis. Feed the text column into a sentiment model or a language model to see how viewers react to a product launch, a trailer or a campaign video.
• Audience and product research. Read what viewers ask, praise and complain about under a review video. Comments with many likes or replies show which points resonate most.
• Creator and brand monitoring. Collect the comments on your own uploads or on a competitor's video, then compare snapshots over time with comment_id and fetched_at.
• AI and NLP datasets. Build training or evaluation sets of real, public YouTube comments with author, likes and reply counts attached to every row.
• Influencer vetting. Check whether the comment section of a sponsored video looks engaged, and whether the channel pins or hearts comments from its audience.

How this compares to other ways to get YouTube comments

	This Actor	YouTube Data API	Browser extensions	Copy and paste
API key or Google project	Not needed	Required	Not needed	Not needed
Daily quota	None	Yes	No	No
Structured export (JSON, CSV, Excel)	Yes	JSON, you write the code	Usually CSV	No
Runs on a schedule or from your code	Yes, Apify API and schedules	Yes, your own code	No	No
Cost	$0.0017 per delivered comment	Free within quota	Varies	Your time

Other comment downloaders in the Apify Store also cover replies or several videos per run. This Actor focuses on a predictable job: one video, its top-level comments in YouTube's Top order, and a flat row per comment that drops straight into a spreadsheet or a database. If you need reply text, combine it with a tool that expands threads; reply_count shows where that pays off.

Pricing

The existing pay-per-event price is $0.0017 per delivered comment. There is no Actor start fee. A run with no delivered comments has no comment charges. For example, 100 delivered comments incur $0.17 in comment events; the total follows the number actually returned rather than the requested maximum. Apify platform usage may be shown separately.

Users without a paid Apify plan receive at most ten comments per run. Paid users can request up to 2,000, subject to what YouTube makes available. If a video supplies fewer comments, the Actor returns those available comments and only charges for the delivered rows. The Actor does not expand reply threads or charge for the number in reply_count.

FAQ

Does this YouTube comment scraper include replies?

It returns top-level comments and their reply counts. Reply text and nested reply trees are not included. Each dataset row is one top-level comment, even if its reply count is large.

Can I use a youtu.be link or a Shorts URL?

Yes. Watch URLs, youtu.be links, Shorts URLs, embed URLs and bare video IDs are accepted. The output records the extracted ID and a canonical watch URL for the same video.

Why did my run return no comments?

YouTube may not expose a comment section for a missing video, disabled comments or restricted content. The run succeeds with an empty dataset and a no_comments record. Invalid video input produces bad_input. An initial collection failure produces fetch_failed. No delivered comments means no comment-event charge.

Is there a YouTube comments API I can call from my code?

Yes. Every Apify Actor can be started through the Apify API with the same input as in the console. Send video and max_comments, wait for the run to finish, and read the dataset items as JSON. You do not need a YouTube Data API key or a Google Cloud project.

What happens if collection stops partway through?

Comments already collected remain available and are charged according to the delivered rows. A failed subsequent page is recorded as fetch_warning. Check the errors and run output before treating a partial collection as a complete snapshot.

Are likes and publication times exact?

The original like_count and published_text fields reproduce the displayed values. Abbreviated likes lose precision, and relative dates do not provide an exact publication instant. Use fetched_at to record when you collected a snapshot and comment_id to compare the same comment across later runs.

Do I need to manage pagination on Apify?

No. Set your desired max_comments and run the Actor. Collection follows the available comment pages automatically. The maximum is a limit, not a guarantee of that many rows: YouTube's accessible feed and the available comments determine the final count.