# YouTube Comments Scraper (`knotless_cadence/youtube-comments-scraper`) Actor

Extract YouTube comments at scale — text, likes, replies, authors. 3+ runs for sentiment analysis and audience research. JSON/CSV. Custom scraper in 48h, $100 pilot. Email: spinov001@gmail.com • Tips: t.me/scraping\_ai

- **URL**: https://apify.com/knotless\_cadence/youtube-comments-scraper.md
- **Developed by:** [Alex](https://apify.com/knotless_cadence) (community)
- **Categories:** Social media, Marketing, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 — No API Key, No Quota Limits

Extract YouTube comments using **YouTube's internal Innertube API** — the same API that youtube.com uses. No YouTube Data API key needed, no quota limits, no rate throttling.

### Why This Scraper?

Other YouTube scrapers use the official YouTube Data API which has strict **quota limits** (10,000 units/day free). This scraper uses YouTube's **Innertube API** — the internal API that loads comments when you scroll on youtube.com. Benefits:

- ✅ **No API key needed** — zero setup, just paste video URLs
- ✅ **No quota limits** — YouTube Data API gives you 10K units/day. We have no such limit.
- ✅ **Latest comment format** — parses `commentEntityPayload` (2025+ format), not the deprecated `commentRenderer`
- ✅ **Sorting support** — Top comments or Newest first
- ✅ **Batch processing** — multiple videos in one run
- ✅ **Cloud-tested** — verified on Apify Cloud ✅

### Output Data

```json
{
  "videoId": "dQw4w9WgXcQ",
  "commentId": "Ugzge340dBgB75hWBm54AaABAg",
  "author": "@YouTube",
  "text": "can confirm: he never gave us up",
  "likes": 200,
  "publishedAt": "10 months ago",
  "isReply": false,
  "replyCount": 961,
  "scrapedAt": "2026-03-18T05:37:18.571Z"
}
````

### Features

- **Author name and channel ID** for each comment
- **Like count** and reply count
- **Nested replies** detection
- **Sorting** — Top (most liked) or Newest first
- **Pagination** — automatically fetches all pages
- **Multiple videos** — process 10+ videos in one run
- **Rate limiting** — built-in delays to avoid detection

### Use Cases

- **Sentiment analysis** — analyze audience reactions to content
- **AI training data** — build NLP datasets from real YouTube conversations
- **Competitor monitoring** — track comments on competitor videos
- **Influencer research** — study audience engagement patterns
- **Content ideas** — discover what viewers want to see next
- **Brand monitoring** — find mentions in YouTube comments
- **Academic research** — collect social media data for studies

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `videoUrls` | Array | required | YouTube video URLs or video IDs |
| `maxCommentsPerVideo` | Number | `100` | Max comments per video (1-5000) |
| `sortBy` | String | `"top"` | Sort: `top` or `newest` |

### Technical Details

- **Method:** YouTube Innertube API (`/youtubei/v1/next`)
- **Format:** Parses `frameworkUpdates.entityBatchUpdate.mutations` with `commentEntityPayload` (2025+ format)
- **No heavy dependencies:** Pure `fetch()` — no Cheerio, no Playwright, no browser automation
- **Rate limiting:** Random delays 0.8-2s between pagination requests

### Cost Estimation

- \~$0.30 per 100 comments
- Free tier available on Apify free plan

### FAQ

**Q: Why not use the YouTube Data API?**
A: The YouTube Data API has a strict quota of 10,000 units per day. Each comment list request costs 1 unit, but with pagination and multiple videos, you can easily hit the limit. Our Innertube API approach has no such quota.

**Q: Will this stop working if YouTube changes their API?**
A: The Innertube API is YouTube's core internal API — they can't remove it without breaking youtube.com itself. We parse the latest format (`commentEntityPayload`) which has been stable since 2025.

**Q: Can I get replies to comments?**
A: Currently we detect if a comment is a reply and include reply counts. Full reply thread extraction is on the roadmap.

***

*Part of 30+ data collection tools by knotless\_cadence. See also: [Reddit Scraper Pro](https://apify.com/knotless_cadence/reddit-scraper-pro), [Bluesky Scraper](https://apify.com/knotless_cadence/bluesky-scraper), [Trustpilot Scraper](https://apify.com/knotless_cadence/trustpilot-review-scraper)*

### YouTube Tool Family

- [YouTube Channel Scraper](https://apify.com/knotless_cadence/youtube-channel-scraper)
- [YouTube Search Scraper](https://apify.com/knotless_cadence/youtube-search-scraper)
- [YouTube Transcript Scraper](https://apify.com/knotless_cadence/youtube-transcript-scraper)

### More

- [60+ scrapers](https://github.com/spinov001-art/awesome-web-scraping-2026) | [Reports](https://payhip.com/aimarketintel) | [MCP Servers](https://github.com/spinov001-art/mcp-servers-collection)

# Actor input Schema

## `videoUrls` (type: `array`):

List of YouTube video URLs to scrape comments from. Supports formats: https://www.youtube.com/watch?v=VIDEO\_ID, https://youtu.be/VIDEO\_ID, or just the VIDEO\_ID.

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

Maximum number of top-level comments to extract per video. Set to 0 for unlimited (may take a long time for popular videos). Replies are extracted in addition to this limit.

## `sortBy` (type: `string`):

How to sort comments. 'top' returns most popular/relevant comments first. 'newest' returns most recent comments first.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "maxCommentsPerVideo": 100,
  "sortBy": "top"
}
```

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("knotless_cadence/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 = { "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"] }

# Run the Actor and wait for it to finish
run = client.actor("knotless_cadence/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 '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ]
}' |
apify call knotless_cadence/youtube-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Comments Scraper",
        "description": "Extract YouTube comments at scale — text, likes, replies, authors. 3+ runs for sentiment analysis and audience research. JSON/CSV. Custom scraper in 48h, $100 pilot. Email: spinov001@gmail.com • Tips: t.me/scraping_ai",
        "version": "1.0",
        "x-build-id": "RK30a1RwceYqkkxOb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/knotless_cadence~youtube-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-knotless_cadence-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/knotless_cadence~youtube-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-knotless_cadence-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/knotless_cadence~youtube-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-knotless_cadence-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": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "YouTube Video URLs",
                        "type": "array",
                        "description": "List of YouTube video URLs to scrape comments from. Supports formats: https://www.youtube.com/watch?v=VIDEO_ID, https://youtu.be/VIDEO_ID, or just the VIDEO_ID.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommentsPerVideo": {
                        "title": "Max Comments Per Video",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to extract per video. Set to 0 for unlimited (may take a long time for popular videos). Replies are extracted in addition to this limit.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort Comments By",
                        "enum": [
                            "top",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to sort comments. 'top' returns most popular/relevant comments first. 'newest' returns most recent comments first.",
                        "default": "top"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```