# YouTube Comments Scraper (Fast & Cheap) (`juliob.rangel/youtube-comments-fast`) Actor

Extract comments from any YouTube video: text, author, likes, reply count, date and whether the creator hearted or pinned it. Sort by top or newest. Great for sentiment analysis, AI training and audience research.

- **URL**: https://apify.com/juliob.rangel/youtube-comments-fast.md
- **Developed by:** [Julio Barcellos Rangel](https://apify.com/juliob.rangel) (community)
- **Categories:** Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 comment scrapeds

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 (Fast & Cheap)

YouTube Comments Scraper extracts the public comments of any YouTube video: text, author, likes, reply count, date and pinned status, sorted by top or newest. It is made for marketers, researchers, data teams and creators who want to download YouTube comments and export them to Excel, CSV or JSON without a YouTube API key or quota.

### What does YouTube Comments Scraper do?

You give it a list of YouTube videos and it returns one row per comment. For each video it opens the comment section, follows the "load more" pages and stops when it reaches your limit or when YouTube has no more comments.

It accepts:

- Watch URLs: `https://www.youtube.com/watch?v=aircAruvnKk`
- Short links: `https://youtu.be/aircAruvnKk`
- Shorts URLs: `https://www.youtube.com/shorts/<id>`
- Embed and live URLs: `/embed/<id>`, `/live/<id>`
- Plain 11-character video IDs: `aircAruvnKk`

You can mix all of these in the same run. If the same video appears twice in your list, it is scraped only once.

What comes out: the comment text, the author's handle and channel ID, whether the author is the video's creator or verified, the like count, the number of replies, the date as YouTube shows it ("5 years ago"), whether the comment is pinned, a direct link to the comment, and the time it was scraped.

You don't need a Google account, cookies or a YouTube Data API key.

### What data can you extract?

Every comment is one item in the dataset with these fields:

| Field | What it means | Example |
|---|---|---|
| `videoId` | ID of the video the comment belongs to | `aircAruvnKk` |
| `commentId` | YouTube's ID of the comment | `UgwEXAMPLEcommentId4AaABAg` |
| `text` | Full text of the comment | `Bio teacher: what is a neuron?…` |
| `author` | Display handle of the person who wrote it | `@example_user` |
| `authorChannelId` | Channel ID of the author | `UCexampleChannelId000000` |
| `isCreator` | `true` if the author is the video's creator | `false` |
| `isVerified` | `true` if the author has a verified badge | `false` |
| `likes` | Number of likes (YouTube rounds big numbers, e.g. "3K" becomes 3000) | `3000` |
| `replyCount` | Number of replies to the comment | `35` |
| `publishedTime` | Date as shown by YouTube, relative and in English | `7 years ago` |
| `isPinned` | `true` if this is the comment pinned by the creator | `false` |
| `url` | Direct link that opens the video at this comment | `https://www.youtube.com/watch?v=aircAruvnKk&lc=…` |
| `scrapedAt` | When the comment was collected (ISO 8601, UTC) | `2026-10-08T20:09:08.128Z` |
| `error` | Only on error items: why a video gave no comments | `Comments are turned off or not available` |

The default table view in the Console shows `videoId`, `author`, `text`, `likes`, `replyCount`, `publishedTime`, `isPinned` and `commentId`. All fields are always in the full JSON, CSV and Excel exports.

### How to use YouTube Comments Scraper

1. Open the robot in Apify Console and go to the **Input** tab.
2. In **Video URLs or IDs**, paste one video per line (any of the URL forms above, or IDs).
3. Set **Max comments per video**. The default is 100.
4. Choose **Sort by**: `top` (YouTube's "Top comments") or `newest` (newest first).
5. Leave **Proxy** on the default Apify Proxy.
6. Click **Start** and wait for the run to finish. You can watch the comments appear in the **Output** tab.
7. Click **Export** and download the results as JSON, CSV, Excel, HTML or XML, or read them through the API.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `videos` | array of strings | `["https://www.youtube.com/watch?v=aircAruvnKk"]` | Video URLs (watch, youtu.be, shorts, embed, live) or 11-character IDs. |
| `maxComments` | integer, minimum 1 | `100` | Stop after this many comments for each video. There is no upper limit in the input; the robot also stops when YouTube has no more comments. |
| `sort` | `top` or `newest` | `top` | Order in which YouTube serves the comments. |
| `proxy` | object | `{ "useApifyProxy": true }` | Apify Proxy settings. |

Example input:

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=aircAruvnKk",
    "https://youtu.be/dQw4w9WgXcQ"
  ],
  "maxComments": 500,
  "sort": "newest",
  "proxy": { "useApifyProxy": true }
}
```

### Output example

One real item from a recent run on the 3Blue1Brown video "But what is a neural network?" (the author's handle and IDs are replaced because the commenter is a private person):

```json
{
  "videoId": "aircAruvnKk",
  "commentId": "UgwEXAMPLEcommentId4AaABAg",
  "text": "Bio teacher: what is a neuron?\nMe: a thing that holds a number between 0 and 1",
  "author": "@example_user",
  "authorChannelId": "UCexampleChannelId000000",
  "isCreator": false,
  "isVerified": false,
  "likes": 3000,
  "replyCount": 35,
  "publishedTime": "7 years ago",
  "url": "https://www.youtube.com/watch?v=aircAruvnKk&lc=UgwEXAMPLEcommentId4AaABAg",
  "isPinned": false,
  "scrapedAt": "2026-10-08T20:09:08.128Z"
}
```

When a video gives no comments, you get one error item instead:

```json
{
  "videoId": "aircAruvnKk",
  "error": "Comments are turned off or not available"
}
```

### How much does it cost?

The robot uses pay per event pricing. You pay only for the comments you get, and Apify platform usage is already included in the price.

| Event | Price (Free plan) |
|---|---|
| Comment scraped | $0.0008 per comment, which is **$0.80 per 1,000 comments** |

Paid Apify plans get a discount on this price:

| Plan | Price per 1,000 comments |
|---|---|
| Free | $0.80 |
| Bronze (-10%) | $0.72 |
| Silver (-20%) | $0.64 |
| Gold and higher (-30%) | $0.56 |

Worked examples on the Free plan:

- One video with the default limit of 100 comments: 100 × $0.0008 = **$0.08**.
- 10,000 comments from one big video: **$8.00** ($5.60 on Gold).
- 50 videos × 500 comments = 25,000 comments: **$20.00** ($18.00 on Bronze, $16.00 on Silver, $14.00 on Gold).

What is NOT charged:

- Error items (the video could not be loaded, or comments are turned off).
- Comments the robot already returned for that video (duplicates are dropped before saving).
- Lines in your input that are not a YouTube video URL or ID (they are skipped).

If a video has fewer comments than your limit, you pay only for the comments it really has.

### Use cases

- **Sentiment analysis**: download every comment on a product launch, trailer or ad and score it as positive, negative or neutral.
- **Audience research**: read what viewers ask in the comments to find content ideas, FAQ topics and pain points.
- **AI and NLP datasets**: build labelled text datasets for classification, topic modeling or training chatbots.
- **Brand and campaign monitoring**: run it on a schedule with `sort` set to `newest` to follow new reactions to your videos or your competitors' videos.
- **Influencer vetting**: check whether a creator's audience writes real comments, and how often the creator answers (`isCreator`).
- **Community management**: find the most liked comments and those with many replies (`replyCount`) to see which discussions matter.
- **Competitor research**: compare what people praise and complain about under competitors' videos.

### Tips and limits

- **Top-level comments only.** The robot reads the main comment list. It does not open reply threads, so replies are not returned as items. Use `replyCount` to see how many replies a comment has.
- **Dates are relative.** `publishedTime` is the text YouTube shows, such as `7 years ago` or `5 years ago (edited)`. YouTube does not show an exact date for comments in this list, so the robot does not invent one. Use `scrapedAt` as your reference point.
- **Like counts are rounded** the way YouTube displays them. A comment with "13K" likes is saved as `13000`.
- **Newest first** uses YouTube's own "Newest first" menu. If YouTube does not offer that menu for a video, the comments come in the default order.
- **You may get fewer comments than `maxComments`.** The robot stops when YouTube returns no more pages, and it counts top-level comments only.
- **Videos are processed one after another.** Large lists take longer, but each video's comments are saved as soon as each page is read.
- **Error items.** You get an item with an `error` field when the video could not be loaded (`Could not load video`) or when the comment section is turned off or missing (`Comments are turned off or not available`). These items are free.
- **Proxy.** Requests go through Apify Proxy. When a request fails, the robot retries with new IPs, and uses the Residential proxy group as a last try when your account has access to it.
- **Text is in English** where YouTube adds its own words (for example `years ago`).

### Use it from the API, Python or JavaScript

You can start the robot and read its results with the official Apify clients.

JavaScript (Node.js):

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const input = {
  videos: ['https://www.youtube.com/watch?v=aircAruvnKk'],
  maxComments: 200,
  sort: 'top',
};
const run = await client.actor('juliob.rangel/youtube-comments-fast').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'comments');
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run_input = {
    'videos': ['https://www.youtube.com/watch?v=aircAruvnKk'],
    'maxComments': 200,
    'sort': 'top',
}
run = client.actor('juliob.rangel/youtube-comments-fast').call(run_input=run_input)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(len(items), 'comments')
```

You can also call it over plain HTTP with the Apify API (for example the `run-sync-get-dataset-items` endpoint of `juliob.rangel~youtube-comments-fast`).

The robot works with Make, Zapier, n8n, Google Sheets export, webhooks (to get notified when a run finishes) and AI agents through the Apify MCP server.

### FAQ

**Do I need a login, cookies or a YouTube API key?**
No. The robot reads the public comment section the same way a logged-out visitor sees it. You only need an Apify account.

**Can I export YouTube comments to Excel or CSV?**
Yes. After the run, click **Export** in the Output tab and choose Excel, CSV, JSON, HTML or XML. You can also pull the dataset through the API.

**How many comments can I get per video?**
As many as YouTube serves in its comment list, up to your `maxComments` value. There is no fixed cap in the input. Very large comment sections take longer and cost more, so start with a smaller limit to test.

**Does it scrape replies?**
No. It returns top-level comments with their `replyCount`. Reply threads are not opened.

**Can I get the exact date of each comment?**
No. YouTube shows comment dates as relative text (`2 weeks ago`), and the robot saves that text in `publishedTime`.

**Why did I get an error item?**
The video could not be loaded after several retries, or the video has its comments turned off. Check that the video is public and opens in a browser. Error items are not charged.

**Is scraping YouTube comments legal?**
The robot only collects publicly available data. You are responsible for complying with YouTube's terms and with privacy laws such as GDPR and LGPD. Comments are personal data of their authors, so you need a legitimate reason to collect and store them.

**Can I run it every day?**
Yes. Create a schedule in Apify Console with `sort` set to `newest` to track new comments over time.

### Related scrapers

- [YouTube Transcript Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-transcript-fast)
- [YouTube Video Details Scraper (Views, Likes, Comments)](https://apify.com/juliob.rangel/youtube-video-details)
- [YouTube Search Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-search-fast)
- [YouTube Channel Videos Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-channel-videos)
- [YouTube Shorts Scraper (Channels & Hashtags)](https://apify.com/juliob.rangel/youtube-shorts-scraper)
- [TikTok Comments Scraper (Text, Likes, Replies, Users)](https://apify.com/juliob.rangel/tiktok-comments-scraper-fast)

***

## Comentários do YouTube

Comentários de qualquer vídeo do YouTube, por relevância ou mais recentes: texto, autor, curtidas, respostas e data. Para análise de sentimento, ideias de conteúdo e dados para IA. Sem login e sem chave de API; você paga só por comentário retornado.

# Actor input Schema

## `videos` (type: `array`):

YouTube video URLs (watch, youtu.be, shorts) or 11-character IDs.

## `maxComments` (type: `integer`):

Stop after this many comments for each video.

## `sort` (type: `string`):

Top comments or newest first.

## `proxy` (type: `object`):

Apify Proxy settings.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=aircAruvnKk"
  ],
  "maxComments": 100,
  "sort": "top",
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "videos": [
        "https://www.youtube.com/watch?v=aircAruvnKk"
    ],
    "maxComments": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("juliob.rangel/youtube-comments-fast").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "videos": ["https://www.youtube.com/watch?v=aircAruvnKk"],
    "maxComments": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("juliob.rangel/youtube-comments-fast").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 '{
  "videos": [
    "https://www.youtube.com/watch?v=aircAruvnKk"
  ],
  "maxComments": 100
}' |
apify call juliob.rangel/youtube-comments-fast --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,juliob.rangel/youtube-comments-fast"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/Yw0LGujPLT7rhjsJc/builds/zxcHKjGb2aRSgLxgs/openapi.json