# YouTube Comments Scraper — Export Comments & Replies (`logiover/youtube-comments-scraper`) Actor
Scrape YouTube comments without API key. Export comments and replies to CSV, JSON, Excel — a YouTube Data API alternative for sentiment research.
- **URL**: https://apify.com/logiover/youtube-comments-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media, Videos, Marketing
- **Features:** Limited permissions
- **Stats:** 31 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 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.
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 — Bulk Export Comments & Replies (No API Key)
    
Export **all YouTube comments and replies from any video in bulk**. This YouTube comment scraper — also a comment exporter and extractor — pulls every comment and reply with the **author, text, likes, reply count, dates and verified/creator flags** — with **no login, no cookies and no Google API key**. One run can return **tens of thousands of comments** from a single popular video, ready for sentiment analysis, audience research and brand monitoring. Paste video URLs or IDs and export to CSV, JSON or Excel.
> ### 🏆 Why this YouTube comments scraper?
>
> **Unlimited comments per video** · comments + threaded replies · author, likes, reply count & verified/creator flags · no login, no cookies, **no YouTube Data API key, no quota** · top / newest sorting · export to JSON / CSV / Excel. The unofficial **YouTube Data API alternative** for comment sentiment, audience research and moderation datasets.
***
### ✨ What this Actor does / Key features
- 💬 **Every comment & reply** — top-level comments plus threaded replies (tagged with `parentCommentId`).
- 👤 **Author context** — author name, channel ID, verified-badge flag and a creator flag (true when the video's creator posted it).
- 👍 **Engagement** — like count normalized to an integer (`243K` → `243000`) and reply count per thread.
- 🎬 **Source context** — video title, video ID and video URL on every row.
- 🔀 **Sort options** — `top` (highest engagement) or `newest` first.
- 🔗 **Flexible input** — full watch URLs, `youtu.be` short links, Shorts URLs or bare 11-character IDs; add as many as you like.
- 🧯 **Graceful handling** — built-in retries; videos with comments disabled are skipped cleanly.
- 🔑 **No API key, no quota** — talks to YouTube's internal data layer with a fresh key per run; only an Apify account required.
### 🚀 Quick start (3 steps)
1. **Configure** — paste your video URLs or IDs into **Video URLs or IDs**. Optionally set `sortBy`, toggle `includeReplies` and set `maxCommentsPerVideo`.
2. **Run** — click **Start**. The Actor loads each comment section, paginates with continuation tokens and streams comments into your dataset.
3. **Get your data** — open the **Output** tab and export to **JSON, CSV, Excel, HTML or RSS**, or pull it via the Apify API.
### 📥 Input
Give the Actor at least one video in `videos`. Everything else is optional.
#### Example — newest comments + replies for a couple of videos
```json
{
"videos": [
"https://www.youtube.com/watch?v=dQw4w9WgXcQ",
"https://youtu.be/9bZkp7q19f0"
],
"maxCommentsPerVideo": 5000,
"sortBy": "newest",
"includeReplies": true
}
```
#### Example — every comment from one video (full export)
```json
{
"videos": ["dQw4w9WgXcQ"],
"maxCommentsPerVideo": 0,
"sortBy": "top"
}
```
#### Example — top comments across many videos with a global cap
```json
{
"videos": ["VIDEO_ID_1", "VIDEO_ID_2", "VIDEO_ID_3"],
"sortBy": "top",
"maxCommentsPerVideo": 2000,
"maxResults": 10000
}
```
| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `videos` | array | Video URLs or 11-char IDs (watch, `youtu.be`, Shorts all supported). **Required.** | – |
| `maxCommentsPerVideo` | integer | Cap per video (top-level + replies). 0 = unlimited. | `1000` |
| `sortBy` | string | `top` (highest engagement) or `newest`. | `top` |
| `includeReplies` | boolean | Also fetch replies (tagged with `parentCommentId`). | `false` |
| `maxResults` | integer | Global cap across all videos. 0 = unlimited. | `0` |
> **Tip:** `includeReplies` can multiply volume on threads with thousands of replies — cap it with `maxCommentsPerVideo`. Comments are public only; disabled or members-only comments yield nothing for that video.
### 📤 Output
Each comment (and reply) is saved as one structured row. Here is a trimmed sample:
```json
{
"videoId": "dQw4w9WgXcQ",
"videoTitle": "Rick Astley - Never Gonna Give You Up",
"videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
"author": "@musicfan",
"authorChannelId": "UCabc123def456",
"authorIsVerified": false,
"authorIsCreator": false,
"text": "This song is timeless 🔥",
"likeCount": 1240,
"replyCount": 7,
"publishedTime": "2 months ago",
"isReply": false,
"parentCommentId": null,
"scrapedAt": "2026-07-06T07:30:00.000Z"
}
```
📋 Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `author` | Comment author name (e.g. `@musicfan`) |
| `authorChannelId` | The author's channel ID |
| `authorIsVerified` | Verified-badge flag |
| `authorIsCreator` | True when the video's creator posted it |
| `text` | Full comment text |
| `likeCount` | Like count, normalized to an integer (`243K` → `243000`) |
| `replyCount` | Number of replies on the thread |
| `publishedTime` | Relative publish time (`"1 year ago"`) |
| `isReply` | Whether the row is a reply or a top-level comment |
| `parentCommentId` | The parent comment a reply belongs to |
| `videoTitle` / `videoId` / `videoUrl` | The source video |
| `scrapedAt` | Scrape timestamp (use as the reference for relative dates) |
#### Additional output fields
These fields are also present in the dataset:
| Field | Type | Description |
|---|---|---|
| `channelTitle` | string | Uploader channel name |
| `channelId` | string | Uploader UC… channel ID |
| `videoViewCount` | number | View count of the source video as a number |
| `commentId` | string | Unique comment ID |
| `likeCountText` | string | Raw like count label |
| `authorAvatar` | string | Author avatar image URL |
### 🔍 How it works
This comment extractor talks to YouTube's internal data layer (the same one the website uses), fetching a fresh access key on each run so it keeps working as YouTube changes. It loads the comment section, paginates with continuation tokens until the video is exhausted or your cap is hit, and resolves replies through the parent/reply comment-ID convention. Built-in retries handle hiccups; videos with comments disabled are skipped gracefully.
### 💡 Use cases
- **Sentiment analysis** — export every comment on a launch, trailer or review and run NLP/LLM sentiment scoring.
- **Brand & reputation monitoring** — track what audiences say under your own or a competitor's videos.
- **Audience & market research** — mine feature requests, complaints and the exact language your customers use.
- **Creator & influencer analytics** — measure real engagement quality, not just view counts.
- **Content moderation & AI datasets** — pull comments for spam/abuse filtering or to assemble conversational training data.
### 👥 Who uses it
Social-media and brand teams · market researchers & data analysts · creators and influencer-marketing agencies · NLP/ML engineers building sentiment and moderation datasets · PR and reputation-management teams.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** model — you pay only for the comments you actually get, with no proxy fees and no YouTube API costs. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### ❓ Frequently Asked Questions
**Do I need a YouTube API key or login to scrape comments?**
No. There's no login, no cookie, and no YouTube Data API key — and none of the official API's comment quota limits.
**Is this a YouTube Data API alternative for comments?**
Yes. It works as a YouTube Data API alternative — no Google Cloud project, no API key, and none of the official quota limits, so you can scrape YouTube comments without an API key.
**Can I scrape YouTube comments without login or cookies?**
Yes. There is no login, no cookies and no account needed — paste video URLs or IDs and the comment extractor pulls public comments and replies directly.
**How many YouTube comments can I scrape?**
As many as the video has publicly. Viral videos return tens of thousands. Use `maxCommentsPerVideo` to cap cost.
**Does it scrape replies too?**
Yes. Set `includeReplies: true`; replies carry `isReply: true` and a `parentCommentId` linking them to the top-level comment.
**How do I export every comment from a YouTube video to CSV?**
Paste the video URL into `videos`, set `maxCommentsPerVideo` to 0 for all, and run to stream every comment into a dataset you can download as CSV or JSON.
**Why is the date "2 years ago" instead of an exact date?**
YouTube only exposes a relative time on comments. Use the `scrapedAt` timestamp as the reference point to convert it.
**How do I export YouTube comments to CSV or JSON?**
Run the Actor, then download the dataset as CSV, JSON or Excel from the run's Storage tab, or pull the comment dataset via the Apify API. Every field exports as one structured row.
### 🔗 The complete YouTube scraping toolkit by logiover
Pair the comments scraper with the rest of the YouTube suite:
| Actor | What it does |
|---|---|
| [YouTube Channel Scraper](https://apify.com/logiover/youtube-channel-scraper) | Every video of a channel |
| [YouTube Search Scraper](https://apify.com/logiover/youtube-search-scraper) | Find videos by keyword |
| [YouTube Creator Email Finder](https://apify.com/logiover/youtube-creator-email-finder) | Creator business emails for outreach |
| [TikTok Hashtag Video Scraper](https://apify.com/logiover/tiktok-hashtag-video-scraper) | TikTok videos & metrics by hashtag |
| [Threads Scraper](https://apify.com/logiover/threads-scraper) | Threads posts, replies & engagement |
| [Reddit Search Scraper](https://apify.com/logiover/reddit-search-scraper) | Reddit posts & comments by keyword |
| [Twitch Scraper](https://apify.com/logiover/twitch-scraper) | Streams, channels & metadata |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to track comments on your videos or a competitor's daily or weekly. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your database, BI/NLP tools and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** to automate a YouTube comment export on a schedule.
### 🤖 AI Agents, MCP & RAG Integration
**YouTube Comments Scraper** works natively as an on-demand data tool for AI assistants and autonomous workflows.
Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** — no custom wrapper code needed:
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com?tools=logiover/youtube-comments-scraper"
}
}
}
```
- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.
### 💬 Support, Issues & Reviews
Found a bug or need an extra field (whole-channel comments, exact timestamps, built-in sentiment scoring)? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/youtube-comments-scraper/issues) with your **Run ID** or sample input — we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/youtube-comments-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/youtube-comments-scraper/reviews) or bookmarking [logiover/youtube-comments-scraper](https://apify.com/logiover/youtube-comments-scraper) — organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.
### ⚖️ Legal
This Actor collects only publicly visible comment data. You are responsible for using it in line with YouTube's Terms and applicable privacy laws (GDPR/CCPA) — avoid using personal data for unsolicited contact.
***
This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by YouTube Comments; YouTube Comments and all other trademarks mentioned here are the property of their respective owners.
### How much YouTube data can you extract in one run?
A single run returned **1,000 comments** in 79 seconds on the example input, and it was still going when the measurement stopped — raise the result limit and it keeps paginating. That is roughly **759 comments a minute**.
There is no hard ceiling built into this Actor. What bounds a run is the result limit you set, the breadth of the input you give it, and how much YouTube itself publishes. Because billing is per result, a wider run costs proportionally more and a narrow one costs almost nothing — so it is worth starting small and scaling once the output looks right.
### YouTube scraping — frequently asked questions
#### Do I need a YouTube API key, account or login?
No. This Actor reads publicly available pages and feeds, so there is nothing to register for and no credentials to manage.
#### How do I export YouTube data to CSV, Excel, JSON or Google Sheets?
Open the **Storage** tab after a run and pick the format you want — CSV, Excel, JSON, XML or an HTML table. For Google Sheets, Airtable or a database, use the dataset URL or the Apify API so the sheet refreshes itself on every run.
#### Can I schedule this YouTube scraper to run daily or hourly?
Yes. Use the **Schedules** tab and pick a cadence. Daily is enough for most tracking work; pick hourly only if the comments you care about really do change that fast.
#### How many comments can I get, and what does it cost?
See the volume section above for a measured figure. Billing is per result, so you pay for the rows you actually receive and a run that finds nothing costs nothing.
#### Is scraping YouTube legal?
This Actor collects only information that YouTube publishes publicly. It does not log in, does not defeat access controls and does not touch private data. You remain responsible for how you use the output, including under GDPR and similar rules where personal data is involved.
#### What happens if YouTube blocks the run or changes its layout?
A refused exit IP is swapped for a fresh one within a quarter of a second and retried, and rate limiting is waited out rather than fought. If nothing gets through, the run **fails with the reason** instead of reporting success with zero rows — so an empty result always means "no matches", never "the source would not answer".
#### Can I use this with an AI agent, LangChain or an MCP client?
Yes. The Actor is callable over the Apify API and through Apify's MCP server, so an agent can run it and read the dataset back as a tool call.
### 📝 Changelog
#### 2026-11-11
- Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration.
- Added direct Issues & Reviews support links and refreshed live maintenance verification.
#### 2026-11-01
- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: 3 links to retired Actors removed; independence disclaimer added; documented 6 additional output fields.
#### 2026-10-15
- Every request now has a hard time limit, so a proxy connection that stalls can no longer hold up the run or push it past its timeout.
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Runs with a short timeout (API and AI-agent calls) now finish inside it with what they collected, instead of being cut off.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
#### 2026-09-23
- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 20 columns returned, 95.0% of cells populated.
- Run reliability reviewed: 100.0% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
- Noted that 1 column(s) came back empty in this sample (`parentCommentId`); these are under review.
#### 2026-09-01
- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs — unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.
#### 2026-08-11
- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
#### 2026-07-06
- ✨ README overhaul: richer output sample, three ready-to-run example scenarios, expanded YouTube/social cross-links, and clearer quick-start.
#### 2026-07-01
- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.
#### 2026-06-15
- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.
#### 2026-06-07
- Docs: added coverage for using this as a YouTube Data API alternative, scraping comments without an API key or login, and exporting the comment dataset to CSV/JSON.
#### 2026-06-05
- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.
#### 2026-06-04
- Verified live & refreshed build — reliability/maintenance pass.
***
\*Maintained: last verified 2026-11-11 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).
# Changelog
This Actor's version history is a separate document: https://apify.com/logiover/youtube-comments-scraper/changelog.md
# Actor input Schema
## `videos` (type: `array`):
YouTube videos to scrape comments from. Accepts full watch URLs (https://www.youtube.com/watch?v=...), youtu.be short links, Shorts URLs, or bare 11-character video IDs. Add as many as you like. Leave EMPTY to scrape comments from a popular default video.
## `sortBy` (type: `string`):
'top' = highest-engagement comments first (YouTube default). 'newest' = most recent first.
## `includeReplies` (type: `boolean`):
Also fetch replies under each comment thread (tagged with parentCommentId). Increases volume and run time substantially on threads with many replies.
## `language` (type: `string`):
Interface language for the request (YouTube 'hl' parameter). Affects localized labels such as relative dates.
## `maxCommentsPerVideo` (type: `integer`):
Hard cap on comments saved per video (top-level + replies combined). Set 0 for unlimited (scrapes every comment — popular videos can have tens of thousands).
## `maxResults` (type: `integer`):
Global cap across all videos in the run. 0 = unlimited.
## Actor input object example
```json
{
"videos": [
"https://www.youtube.com/watch?v=dQw4w9WgXcQ"
],
"sortBy": "top",
"includeReplies": false,
"language": "en",
"maxCommentsPerVideo": 1000,
"maxResults": 200
}
```
# Actor output Schema
## `results` (type: `string`):
All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.
# 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 = {
"videos": [
"https://www.youtube.com/watch?v=dQw4w9WgXcQ"
],
"sortBy": "top",
"language": "en",
"maxResults": 200
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
"videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
"sortBy": "top",
"language": "en",
"maxResults": 200,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
"videos": [
"https://www.youtube.com/watch?v=dQw4w9WgXcQ"
],
"sortBy": "top",
"language": "en",
"maxResults": 200
}' |
apify call logiover/youtube-comments-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/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/7MBvAtHMGbzRrkBm1/builds/wiCkuhJKqxa41beAx/openapi.json