# YouTube Comments Scraper - Comments & Replies (`legend006/youtube-comments-scraper`) Actor

Scrape YouTube comments from any video URL or ID via the official YouTube Data API v3. Optionally include reply threads. Returns text, author, likes, timestamps, language, and channel info. Built for sentiment analysis, AI training, brand monitoring, and creator research.

- **URL**: https://apify.com/legend006/youtube-comments-scraper.md
- **Developed by:** [NIJ KANANI](https://apify.com/legend006) (community)
- **Categories:** Videos, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 📺 YouTube Comments Scraper

Scrape **YouTube comments and replies** from any video URL or ID using the official YouTube Data API v3. Returns text, author, likes, timestamps, language, and channel info — JSON or CSV.

> 🎯 Built for sentiment analysis, AI/LLM training datasets, brand monitoring, creator research, and audience insights.

---

### ✨ What you can do

- 🎥 **Multiple videos per run** — paste any list of URLs or IDs
- 💬 **Top-level comments + reply threads** — flattened with `parentId` for tree reconstruction
- 🔎 **Optional substring filter** — only return comments containing your keywords
- 📊 **Sort by relevance** (top) or **time** (newest)
- 📺 **Includes video metadata** — title, channel, view/like/comment counts

---

### 🚀 Quick start

```json
{
    "videoUrlsOrIds": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "kffacxfA7G4"
    ],
    "apiKey": "AIzaSy...",
    "includeReplies": true,
    "order": "relevance",
    "maxCommentsPerVideo": 500,
    "searchTerms": ["amazing", "great"]
}
````

***

### 🔑 Get the API key (free, 5 min)

1. Open **https://console.cloud.google.com/**
2. Create a project (any name)
3. Search **"YouTube Data API v3"** → click → **Enable**
4. Left sidebar: **APIs & Services → Credentials**
5. Click **"+ Create credentials" → "API key"**
6. Recommended: **Restrict key** → API restrictions → YouTube Data API v3
7. Paste the `AIzaSy...` key into the input form

**Free quota:** 10,000 units/day per project.

- 1 page of comments (~100) = 1 unit
- Average video (500 comments) = ~5 units
- 2,000 average videos/day for free

***

### 📥 Input

| Field | Description |
|---|---|
| `videoUrlsOrIds` | List of YouTube URLs or 11-char video IDs |
| `apiKey` | **Required** — your YouTube Data API v3 key |
| `includeReplies` | Fetch reply threads (default true) |
| `order` | `relevance` (top) or `time` (newest) |
| `maxCommentsPerVideo` | Cap on top-level comments per video |
| `searchTerms` | Optional substring filter |

URL formats supported: `youtube.com/watch?v=ID`, `youtu.be/ID`, `youtube.com/shorts/ID`, `youtube.com/embed/ID`.

***

### 📤 Output (per comment)

```json
{
    "videoId": "dQw4w9WgXcQ",
    "videoTitle": "Rick Astley - Never Gonna Give You Up",
    "channelTitle": "Rick Astley",
    "commentId": "Ugw...",
    "parentId": null,
    "isReply": false,
    "author": "@username",
    "authorChannelId": "UC123...",
    "authorProfileImage": "https://...",
    "text": "Comment text",
    "textOriginal": "Comment text",
    "likeCount": 234,
    "publishedAt": "2026-04-15T...",
    "updatedAt": "2026-04-15T...",
    "totalReplyCount": 5,
    "scrapedAt": "2026-05-06T..."
}
```

***

### 🎯 Use cases

| Who | Why |
|---|---|
| 🤖 AI / sentiment teams | Real audience reactions for training/benchmarking |
| 🎨 Creators & marketers | Audience insights, content optimization |
| 🏢 Brand teams | Track mentions on competitors' / influencers' videos |
| 📊 Researchers | Study online discourse around news/topics/products |

***

### ⚙️ Tech notes

- Uses YouTube Data API v3 — official, terms-compliant
- Each user provides their own API key (we never store it)
- Auto-handles videos with disabled comments — logs and skips, doesn't fail
- Pagination via `nextPageToken` until cap or end

***

### ❓ FAQ

**Will it use up my quota?**
A typical video scrape costs ~5 quota units. 10,000/day = ~2,000 typical scrapes.

**What about comment replies?**
We fetch them automatically when `includeReplies` is on. They appear as separate items with `isReply: true` and `parentId` set.

**Hidden / spam comments?**
The API only returns publicly visible comments. Hidden ones aren't included.

# Actor input Schema

## `videoUrlsOrIds` (type: `array`):

Full YouTube URLs (https://youtube.com/watch?v=...) or just video IDs (11-char strings). One scrape per video.

## `apiKey` (type: `string`):

Required. Free key in 5 min: 1) Go to https://console.cloud.google.com/  2) Create project  3) Search 'YouTube Data API v3' → Enable  4) Credentials → Create credentials → API key  5) Restrict to YouTube Data API v3. Free quota: 10,000 units/day per project.

## `includeReplies` (type: `boolean`):

Fetch reply threads under each top-level comment (uses extra API quota).

## `order` (type: `string`):

Sort order. 'time' = newest first; 'relevance' = top-rated.

## `maxCommentsPerVideo` (type: `integer`):

Cap on top-level comments per video. Replies are fetched additionally for each top-level if includeReplies is on.

## `searchTerms` (type: `array`):

Optional case-insensitive substring filter — only return comments containing any of these terms.

## Actor input object example

```json
{
  "videoUrlsOrIds": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "includeReplies": true,
  "order": "relevance",
  "maxCommentsPerVideo": 200,
  "searchTerms": []
}
```

# 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 = {};

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

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("legend006/youtube-comments-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call legend006/youtube-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=legend006/youtube-comments-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Comments Scraper - Comments & Replies",
        "description": "Scrape YouTube comments from any video URL or ID via the official YouTube Data API v3. Optionally include reply threads. Returns text, author, likes, timestamps, language, and channel info. Built for sentiment analysis, AI training, brand monitoring, and creator research.",
        "version": "0.1",
        "x-build-id": "dshhQFGadrtyLyyvo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/legend006~youtube-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-legend006-youtube-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/legend006~youtube-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-legend006-youtube-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/legend006~youtube-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-legend006-youtube-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "videoUrlsOrIds",
                    "apiKey"
                ],
                "properties": {
                    "videoUrlsOrIds": {
                        "title": "Video URLs or IDs",
                        "type": "array",
                        "description": "Full YouTube URLs (https://youtube.com/watch?v=...) or just video IDs (11-char strings). One scrape per video.",
                        "default": [
                            "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "apiKey": {
                        "title": "YouTube Data API key ⚠️ Required",
                        "type": "string",
                        "description": "Required. Free key in 5 min: 1) Go to https://console.cloud.google.com/  2) Create project  3) Search 'YouTube Data API v3' → Enable  4) Credentials → Create credentials → API key  5) Restrict to YouTube Data API v3. Free quota: 10,000 units/day per project."
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Fetch reply threads under each top-level comment (uses extra API quota).",
                        "default": true
                    },
                    "order": {
                        "title": "Comment order",
                        "enum": [
                            "time",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order. 'time' = newest first; 'relevance' = top-rated.",
                        "default": "relevance"
                    },
                    "maxCommentsPerVideo": {
                        "title": "Max comments per video",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap on top-level comments per video. Replies are fetched additionally for each top-level if includeReplies is on.",
                        "default": 200
                    },
                    "searchTerms": {
                        "title": "Search terms (optional)",
                        "type": "array",
                        "description": "Optional case-insensitive substring filter — only return comments containing any of these terms.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
