# YouTube Comments Scraper: Comments + Replies, $1/1K (`transparent_meteorite/youtube-comments-scraper`) Actor
Scrape public YouTube comments and replies from videos, Shorts, channels, playlists or searches: text, author, likes, reply count, creator heart, pinned, date. Top or newest, keyword/likes/date filters, monitor mode. No login.
- **URL**: https://apify.com/transparent_meteorite/youtube-comments-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.60 / 1,000 comments
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## YouTube Comments Scraper: Comments and Replies from Videos, Shorts, Channels and Search
[](https://console.apify.com/actors/u5lldCrepOymI4dy7/input)
| Price per 1,000 comments | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$1.00** | **$0.90** | **$0.80** | **$0.60** |
| Most-used alternative | $2.00 | $1.50 | $1.20 | $0.90 |
Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-13; check the Pricing tab for the current figure.
Scrape public YouTube comments, and the replies under them if you want them, from any video, Short, channel, playlist or search. Every row has the comment text, the author's handle and channel, the like count, the reply count, whether the creator hearted or pinned it, and when it was posted. You can sort by top or newest, filter by keyword, likes or date, and switch on monitor mode to get only new comments on a schedule. You don't need a login, a YouTube API key or a daily quota.
- **In short:** YouTube Comments Scraper (Apify actor `transparent_meteorite/youtube-comments-scraper`) reads the public comment section that a logged-out visitor sees. It returns one flat row per comment or reply.
- **Who it is for:**
- brand and product teams doing sentiment analysis
- creators and agencies studying their audience
- researchers building opinion datasets
- AI teams collecting training or retrieval data
- AI agents that need "what are people saying about this video" as a tool
- **Input:**
- URLs: video, Shorts, channel, playlist or search page
- or plain search words, or bare video IDs
- comments per video, sorted by top or newest
- replies on or off, with a cap per comment
- filters: keyword, minimum likes, "newer than" date
- monitor mode to get only new comments
- **Output:** 33 fields per row, including:
- commentId, text, author, authorChannelId, authorAvatar
- likeCount, replyCount, hasCreatorHeart, isPinned, isEdited
- publishedTimeText, plus an approximate ISO date
- isReply and parentCommentId
- direct comment link
- video title, channel, views and total comment count
- **Pricing:** pay per event, from $1.00 per 1,000 comments on the Free plan down to $0.30 per 1,000 on Diamond, plus a $0.00005 start event. Rows that your filters remove and comments already seen in monitor mode are never charged.
- **Limits:** public comments only. Videos with comments turned off return no rows and cost nothing. YouTube shows comment age as "3 days ago", so dates are approximate.
**Key facts**
- Data source: the public YouTube comment section (the same requests the YouTube web page makes)
- Output formats: JSON, CSV, Excel, XML, HTML table (Apify dataset)
- Access: Apify Console, REST API, JavaScript/Python clients, schedules, webhooks, Apify MCP server
- Login, cookies or YouTube API key needed: no
- Also known as: YouTube comment scraper, YouTube comments downloader, YouTube comment extractor, YouTube comments API alternative, YouTube comment exporter
### Run in 30 seconds
1. Open [YouTube Comments Scraper](https://apify.com/transparent_meteorite/youtube-comments-scraper) and press **Try for free**.
2. Keep the prefilled video, or paste any YouTube URL, then press **Start**. 100 comments take about 4 seconds.
3. Open the **Output** tab. Use the table, or download the results as CSV, Excel or JSON.
```json
{
"startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }],
"maxComments": 100,
"includeReplies": true
}
```
### What can it scrape?
| You paste | What you get |
|---|---|
| Video, Shorts or live URL (`watch?v=`, `youtu.be/`, `/shorts/`) | The comments on that video |
| Channel (`@handle`, `/channel/UC...`) | Comments on the channel's latest videos, Shorts or streams (`maxVideosPerSource`) |
| Playlist URL | Comments on every video in the playlist, up to your limit |
| Search URL or search words | Comments on the top videos for that search |
| Bare video ID (`dQw4w9WgXcQ`) | Same as a video URL |
### Input
| Field | Default | What it does |
|---|---|---|
| `startUrls` | example video | Any mix of video, Shorts, channel, playlist and search URLs |
| `searchQueries` | none | Search words. The top videos for each one are scraped |
| `maxVideosPerSource` | 10 | Videos taken from each channel, playlist or search |
| `maxComments` | 100 | Top-level comments per video. 0 = all. Replies are extra |
| `sortBy` | `TOP` | `TOP` (YouTube's ranking) or `NEWEST` |
| `includeReplies` / `maxRepliesPerComment` | off / 20 | Also scrape the replies, each as its own row |
| `maxItems` | 0 | Hard cap on rows for the whole run, so you control the cost |
| `newerThan` | none | `7 days`, `2 months` or `2026-01-31` |
| `keywords` / `minLikes` | none / 0 | Keep only matching comments (the rest are free) |
| `monitorMode` | off | Only comments not seen in earlier runs |
### Output
One row per comment or reply:
```json
{
"commentId": "UgzB5Hn0hc1b1Bk4dYF4AaABAg",
"text": "Great breakdown, thanks!",
"author": "@example_viewer",
"authorChannelId": "UC...",
"authorChannelUrl": "https://www.youtube.com/channel/UC...",
"authorIsChannelOwner": false,
"authorIsVerified": false,
"likeCount": 15000,
"replyCount": 214,
"hasCreatorHeart": true,
"isPinned": false,
"isEdited": false,
"publishedTimeText": "2 years ago",
"publishedAtApprox": "2024-10-13T12:00:00.000Z",
"isReply": false,
"parentCommentId": null,
"commentUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ&lc=UgzB5Hn0hc1b1Bk4dYF4AaABAg",
"videoId": "dQw4w9WgXcQ",
"videoTitle": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
"channelName": "Rick Astley",
"channelUrl": "https://www.youtube.com/@RickAstleyYT",
"videoViewCount": 1826323732,
"videoCommentsCount": 2459088,
"sortBy": "TOP",
"scrapedAt": "2026-10-13T23:50:00.000Z"
}
```
Comment and author values above are placeholders; the video fields are real. The run summary (videos, comments off, filtered, blocked requests) is saved as `OUTPUT` in the key-value store.
#### Field names compared with other YouTube comment scrapers
If you are switching from another actor, here is how the fields map:
| Other actors | This actor |
|---|---|
| `comment` | `text` |
| `cid` | `commentId` |
| `voteCount` | `likeCount` |
| `replyToCid` | `parentCommentId` |
| `title` / `pageUrl` | `videoTitle` / `videoUrl` |
| `commentsCount` | `videoCommentsCount` |
| not available | `authorChannelId`, `authorAvatar`, `authorIsVerified`, `isPinned`, `isEdited`, `publishedAtApprox`, `commentUrl` |
### Pricing
You pay per comment row delivered, and it gets cheaper on higher Apify plans:
| Apify plan | Per comment | Per 1,000 comments |
|---|---|---|
| Free | $0.001 | $1.00 |
| Bronze | $0.0009 | $0.90 |
| Silver | $0.0008 | $0.80 |
| Gold | $0.0006 | $0.60 |
| Platinum | $0.0005 | $0.50 |
| Diamond | $0.0003 | $0.30 |
There's also a $0.00005 start event per run. Rows removed by your filters, comments already seen in monitor mode, and videos with comments turned off cost nothing. Set `maxItems` to put a hard cap on a run.
### Use it from code, schedules or AI agents
- **API:** `POST https://api.apify.com/v2/acts/transparent_meteorite~youtube-comments-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN` with the input JSON as the body returns the rows directly.
- **Schedules:** run it daily on a video or channel with `monitorMode: true` to receive only new comments.
- **MCP / AI agents:** add `https://mcp.apify.com?actors=transparent_meteorite/youtube-comments-scraper` to Claude, Cursor or any MCP client, then ask something like "summarize what people say in the comments of this video".
### Who uses it and why
- **Brands and community managers** read what viewers say under their own videos and under competitors' videos, filter by keyword (for example a product name or "refund"), and route the matches to support or product teams.
- **Creators** export the comments of their latest uploads sorted by newest, spot recurring questions, and turn them into the next video topic.
- **Market and sentiment researchers** collect comments on product reviews, launches or news coverage and feed the text into their own sentiment or topic models.
- **Moderation and trust teams** set `minLikes` and `keywords` to find high-visibility comments that mention scams, links or specific phrases.
- **Academics and data journalists** build comment datasets around public events. The `publishedAtApprox` field gives a usable date, and `commentUrl` links every row back to the original comment.
- **AI agents** use the actor through MCP to answer "what do viewers think of this video" with real text instead of a guess.
### How the input fields work together
Pick sources with `startUrls`, `videoIds` and `searchQueries`. You can use all three in one run. A video, Shorts or live URL is scraped directly. A channel, playlist or search is first expanded into a list of videos, limited by `maxVideosPerSource` (1 to 5,000, default 10). For channel URLs, `channelTab` chooses the Videos, Shorts or Streams tab. Duplicate videos across sources are scraped once.
For each video, `maxComments` counts top-level comments only (default 100, 0 means all). Replies are extra: switch on `includeReplies` and set `maxRepliesPerComment` (default 20, 0 means all replies). Each reply is its own row with `isReply` set to true and `parentCommentId` pointing to the comment it answers. When you want a single total, use `maxItems`, which caps comments plus replies across the whole run.
`sortBy` is `TOP` for YouTube's own ranking or `NEWEST` for newest first. `newerThan` takes a relative period (`7 days`, `2 months`) or a date (`2026-01-31`). Because YouTube only shows "3 days ago", the cut is approximate. With newest-first sorting the run stops reading as soon as it reaches older comments, which saves time. Pinned comments are never used as the stopping point.
`keywords` keeps comments that contain any listed word, case-insensitively. `minLikes` keeps comments with at least that many likes. Comments removed by these filters are not delivered and not charged. `language` and `country` set YouTube's interface language and region. Leave them at `en` and `US` if you want `publishedAtApprox` to be parsed.
### Worked examples
**Customer voice: newest comments mentioning a topic on a product review**
```json
{
"startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }],
"maxComments": 200,
"sortBy": "NEWEST",
"keywords": ["price", "worth it", "refund"]
}
```
**Channel pulse: top comments on a creator's latest five videos**
```json
{
"startUrls": [{ "url": "https://www.youtube.com/@RickAstleyYT" }],
"maxVideosPerSource": 5,
"maxComments": 50,
"minLikes": 10
}
```
**Daily feed: only comments you have not seen before**
```json
{
"startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }],
"maxComments": 0,
"sortBy": "NEWEST",
"monitorMode": true,
"monitorStoreName": "my-launch-video"
}
```
With `monitorMode`, the actor remembers comment IDs per video in the named key-value store and delivers only new ones on later runs. Use one `monitorStoreName` per project so separate schedules do not hide each other's comments.
### Tips to keep runs fast and cheap
- Test with `maxComments` of 20 and `maxVideosPerSource` of 2 before a large run.
- Always set `maxItems` for unattended schedules. It is a hard stop for the whole run.
- Use `keywords` and `minLikes` to pay only for the comments you will read.
- Raise `videoConcurrency` (1 to 5, default 3) for many videos with few comments each. Large single videos are limited by YouTube's page size of about 20 comments, so more concurrency does not help there.
- Leave replies off unless you need threads. A busy video can have many more replies than top-level comments.
### Limits and honest caveats
- Only public comment sections are read. If comments are turned off, the video is private, or it only has live chat, the video is skipped with a warning and nothing is charged.
- Dates are approximate. YouTube exposes "2 years ago", not a timestamp, so `publishedAtApprox` is only as precise as that text.
- YouTube decides which comments are returned for `TOP`, and the order can change between runs. Use `NEWEST` plus monitor mode for repeatable collection.
- Comments hold personal data such as display names and channel links. Keep them in line with privacy law and store only what you need.
- The run summary, including counts of comments-off videos, filtered rows and blocked requests, is saved as `OUTPUT` in the key-value store and warnings are printed in the log.
### More questions
**How do I export YouTube comments to Excel or CSV?** Run the actor on the video URL, open the Output tab and use the export menu for CSV, Excel, JSON, XML or HTML.
**Can I get comments from many videos at once?** Yes. Paste several URLs, or give a channel, playlist or search and set `maxVideosPerSource`.
**Can I scrape replies only?** Replies are fetched under top-level comments, so turn on `includeReplies`. You can then filter on `isReply` in the dataset.
**Why did a video return no rows?** Check the log and the `OUTPUT` record. Common causes are comments turned off, a filter that matched nothing, or monitor mode finding nothing new.
**Can I call it from Python?**
```python
from apify_client import ApifyClient
client = ApifyClient("APIFY_TOKEN")
run = client.actor("transparent_meteorite/youtube-comments-scraper").call(
run_input={
"startUrls": [{"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"}],
"maxComments": 100,
}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
print(row["likeCount"], row["text"])
```
### FAQ
**Do I need a YouTube API key or quota?** No. The actor reads the same public comment section a logged-out browser loads, so the 10,000-unit daily API quota doesn't apply.
**How many comments can I get?** Set `maxComments: 0` to get all of them. YouTube serves 20 per page, so very large videos take longer; a run of a few thousand comments usually finishes in about a minute.
**Does `maxComments` include replies?** No. It counts top-level comments. Replies come on top of that, limited by `maxRepliesPerComment`. Use `maxItems` if you need one total cap.
**Why is a comment's text empty?** Some comments contain only a sticker or an image. They are kept so that the counts match YouTube.
**How exact are the dates?** YouTube only shows "3 days ago" or "2 years ago". `publishedAtApprox` converts that to a date, so it is accurate to the unit YouTube shows.
**Do I need a proxy?** No, not for normal runs. If YouTube starts refusing requests, the run switches to Apify residential proxy on its own. Turn `autoProxyFallback` off to prevent this.
**Is scraping YouTube comments legal?** The actor collects public information only. You are responsible for using the data in line with YouTube's terms and privacy laws such as GDPR, especially because comments carry usernames.
**Something missing or broken?** Open an issue on the Issues tab with the run URL and we will reply there.
New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.
# Actor input Schema
## `startUrls` (type: `array`):
Video (watch, youtu.be, Shorts, live), channel (@handle, /channel/UC..., /c/...), playlist or search-results URLs. Channels, playlists and searches are expanded to their videos (see 'Videos per channel / playlist / search').
## `videoIds` (type: `array`):
Optional: bare 11-character video IDs, e.g. dQw4w9WgXcQ.
## `searchQueries` (type: `array`):
Optional: YouTube searches, e.g. "iphone 17 review". The top videos of each search are scraped.
## `maxVideosPerSource` (type: `integer`):
How many videos to take from each channel, playlist or search (newest first for channels).
## `channelTab` (type: `string`):
Which tab of a channel URL to read videos from.
## `maxComments` (type: `integer`):
Top-level comments per video (replies are extra). 0 = all comments.
## `sortBy` (type: `string`):
Top comments (YouTube's ranking) or newest first.
## `includeReplies` (type: `boolean`):
Also scrape the replies under each comment (each reply is its own row with parentCommentId).
## `maxRepliesPerComment` (type: `integer`):
Only with 'Include replies'. 0 = all replies.
## `maxItems` (type: `integer`):
Hard cap on rows (comments + replies) for the whole run, to control cost. 0 = no cap.
## `newerThan` (type: `string`):
Relative ("7 days", "2 months") or a date (2026-01-31). YouTube shows comment age as "3 days ago", so the cut is approximate. With 'Newest first' the scraper stops paging at the first older comment.
## `keywords` (type: `array`):
Keep comments that contain any of these words (case-insensitive).
## `minLikes` (type: `integer`):
Keep only comments with at least this many likes.
## `monitorMode` (type: `boolean`):
Remember comment IDs between runs (named key-value store) and output only comments not seen before. Schedule the actor daily to get new comments only; seen comments are free.
## `monitorStoreName` (type: `string`):
Use a different name per project to keep separate memories.
## `language` (type: `string`):
YouTube interface language (hl), affects '3 days ago' texts. Keep 'en' for parsed dates.
## `country` (type: `string`):
Two-letter country (gl) for search results.
## `videoConcurrency` (type: `integer`):
How many videos are read at the same time.
## `proxyConfiguration` (type: `object`):
Not needed normally: requests go direct. Pick a proxy only if your runs get blocked.
## `autoProxyFallback` (type: `boolean`):
If YouTube refuses a request twice, retry it through Apify residential proxy (only when your plan includes it).
## Actor input object example
```json
{
"startUrls": [
{
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}
],
"maxVideosPerSource": 10,
"channelTab": "videos",
"maxComments": 100,
"sortBy": "TOP",
"includeReplies": false,
"maxRepliesPerComment": 20,
"maxItems": 0,
"minLikes": 0,
"monitorMode": false,
"monitorStoreName": "youtube-comments-monitor",
"language": "en",
"country": "US",
"videoConcurrency": 3,
"proxyConfiguration": {
"useApifyProxy": false
},
"autoProxyFallback": true
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
## `summary` (type: `string`):
No description
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"startUrls": [
{
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}
],
"proxyConfiguration": {
"useApifyProxy": false
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/youtube-comments-scraper").call(input);
// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.dir(item);
});
// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs
```
## Python example
```python
from apify_client import ApifyClient
# Initialize the ApifyClient with your Apify API token
# Replace '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }],
"proxyConfiguration": { "useApifyProxy": False },
}
# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/youtube-comments-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"startUrls": [
{
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}
],
"proxyConfiguration": {
"useApifyProxy": false
}
}' |
apify call transparent_meteorite/youtube-comments-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/youtube-comments-scraper"
}
}
}
```
The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/u5lldCrepOymI4dy7/builds/H69wELJL6DoLBycZO/openapi.json