# YouTube Comments Scraper (with Replies) (`khadinakbar/youtube-comments-scraper`) Actor Extract comments and replies from YouTube videos by URL or ID. Returns author, text, likes, reply count, timestamps, pinned/hearted status. No API key required. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools. - **URL**: https://apify.com/khadinakbar/youtube-comments-scraper.md - **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community) - **Categories:** Videos, Social media, MCP servers - **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $2.00 / 1,000 scraped comments This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. 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 — Extract Comments & Replies, No API Key ### What does YouTube Comments Scraper do? YouTube Comments Scraper extracts structured comment data from any public YouTube video — including replies, author details, like counts, pinned status, and creator hearts — without requiring a YouTube Data API key or any login. Feed it a list of video URLs or bare video IDs and it returns a clean, AI-ready JSON dataset. ### Why use YouTube Comments Scraper? - **No API key needed** — unlike the official YouTube Data API (which has strict daily quotas of 10,000 units), this actor uses YouTube's internal InnerTube API via a real browser session, giving you unlimited access - **Replies included** — most basic scrapers only capture top-level comments; this actor optionally digs into reply threads too - **Video metadata included** — every comment record includes the video title and URL, so multi-video datasets stay organized - **MCP and AI-agent ready** — clean field names, consistent output schema, and no junk fields means Claude, ChatGPT, and other LLM tools can use this data directly ### What data can YouTube Comments Scraper extract? | Field | Type | Description | Example | |-------|------|-------------|---------| | `video_id` | string | YouTube video ID | `dQw4w9WgXcQ` | | `video_title` | string | Title of the video | `"Rick Astley - Never Gonna Give You Up"` | | `video_url` | string | Full video URL | `https://youtube.com/watch?v=dQw4w9WgXcQ` | | `comment_id` | string | Unique comment ID | `UgxK8eTB1234abcde` | | `comment_text` | string | Full comment text | `"This is a timeless classic!"` | | `author_name` | string | Commenter's display name | `John Doe` | | `author_channel_url` | string | Link to commenter's channel | `https://youtube.com/@johndoe` | | `author_channel_id` | string | Internal YouTube channel ID | `UCuAXFkgsw1L7xaCfnd5JJOw` | | `like_count` | integer | Number of likes on the comment | `142` | | `reply_count` | integer | Number of replies (top-level only) | `5` | | `is_reply` | boolean | True if this is a reply comment | `false` | | `parent_comment_id` | string | ID of the parent comment (replies only) | `null` | | `published_at` | string | Relative time posted (as shown by YouTube) | `"3 months ago"` | | `is_pinned` | boolean | True if pinned by the creator | `false` | | `is_hearted` | boolean | True if the creator gave it a heart | `true` | | `scraped_at` | string | ISO 8601 timestamp of scrape | `2026-04-09T12:00:00.000Z` | | `source_url` | string | The exact URL scraped | `https://youtube.com/watch?v=...` | --- ### How to Scrape YouTube Comments #### Step 1 — Add video URLs or IDs In the **YouTube Video URLs** field, paste one or more YouTube links: ```` https://www.youtube.com/watch?v=dQw4w9WgXcQ https://youtu.be/9bZkp7q19f0 https://www.youtube.com/shorts/abc123def45 ``` Alternatively, use the **Video IDs** field to paste bare 11-character IDs, one per line: ``` dQw4w9WgXcQ 9bZkp7q19f0 ```` You can use both fields simultaneously and the actor will deduplicate automatically. #### Step 2 — Configure limits Set **Max Comments per Video** to control how many comments to collect per video. The default is 100. For large comment sections, set it higher (up to 10,000). Each comment costs $0.002. #### Step 3 — Enable replies (optional) Toggle **Include Replies** to also collect reply threads under top-level comments. Replies count toward the `maxComments` limit and are each charged at the same rate. #### Step 4 — Run and export Click **Start** and the actor will run. When finished, your dataset is available to download as JSON, CSV, Excel, or HTML. You can also access it via the Apify API. --- ### Use Cases **Sentiment analysis and brand monitoring** — scrape comments from your brand's videos or competitors' videos to understand audience sentiment. Feed the comment_text field directly into an LLM for classification. **Content research** — analyze what viewers are asking, praising, or complaining about on tutorial and product-review videos. Find FAQ topics your own content should address. **AI training datasets** — build large corpora of human-written YouTube comments for fine-tuning language models, training toxicity classifiers, or creating synthetic conversation datasets. **Influencer analysis** — assess engagement quality on creator channels by analyzing comment-to-like ratios, creator heart frequency, and reply activity patterns. **Academic research** — scrape public comment sections for social media research, political discourse analysis, or online community studies. **Competitor monitoring** — collect comments from competitor product videos to understand pain points and feature requests you can act on. --- ### Pricing This actor uses **Pay-Per-Event** pricing — you only pay for what you actually scrape. | Event | Cost | |-------|------| | Actor start | $0.00005 per GB of memory | | Scraped comment | **$0.002 per comment** | #### Cost examples | Comments | Cost | |----------|------| | 100 comments | $0.20 | | 500 comments | $1.00 | | 1,000 comments | $2.00 | | 5,000 comments | $10.00 | You can cap spending using Apify's built-in **Max total charge** setting in the actor's run configuration. --- ### Input Parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `startUrls` | URL list | — | YouTube video URLs to scrape | | `videoIds` | String list | — | Bare video IDs (11-char strings) | | `maxComments` | Integer | 100 | Max comments per video (1–10,000) | | `includeReplies` | Boolean | false | Also scrape reply threads | --- ### Output Format Each record in the output dataset corresponds to one comment (or reply). Here is a sample output record: ```json { "video_id": "dQw4w9WgXcQ", "video_title": "Rick Astley - Never Gonna Give You Up (Official Music Video)", "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "comment_id": "UgxK8eTB9abc1234defg", "comment_text": "This song genuinely never gets old. It's been 35+ years and it still slaps.", "author_name": "Jane Smith", "author_channel_url": "https://www.youtube.com/@janesmith", "author_channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw", "like_count": 142, "reply_count": 5, "is_reply": false, "parent_comment_id": null, "published_at": "3 months ago", "is_pinned": false, "is_hearted": true, "scraped_at": "2026-04-09T12:00:00.000Z", "source_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ```` *** ### Running via the Apify API You can trigger this actor programmatically using the Apify JavaScript client: ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_API_TOKEN' }); const run = await client.actor('USERNAME/youtube-comments-scraper').call({ startUrls: [{ url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ' }], maxComments: 500, includeReplies: true, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` Or with curl: ```bash curl -X POST "https://api.apify.com/v2/acts/USERNAME~youtube-comments-scraper/runs?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "startUrls": [{"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"}], "maxComments": 200, "includeReplies": false }' ``` *** ### Technical Details This actor uses **PlaywrightCrawler** (a real Chromium browser) to open YouTube video pages and then issues API calls to YouTube's internal InnerTube endpoint (`/youtubei/v1/next`) from within the browser context. This approach: - Uses the browser's existing cookies and session tokens, so no API key is needed - Avoids bot detection because requests originate from a real browser - Handles comment pagination automatically by following continuation tokens - Gracefully handles videos with disabled comments **No login is required.** YouTube comments are publicly visible and this actor only accesses publicly available data. *** ### FAQ **Q: Do I need a YouTube API key?** No. This actor does not use the YouTube Data API. It uses YouTube's internal InnerTube API via a real browser session, which requires no API key and has no quota limits. **Q: Can it scrape comments from private videos?** No. Only publicly accessible video comments can be scraped. **Q: Why are some videos returning 0 comments?** Some video creators disable comments entirely. When this happens, the actor logs a warning and moves on to the next video. **Q: How accurate are the `published_at` timestamps?** YouTube returns relative timestamps (e.g. "3 months ago"), not absolute dates. This is a YouTube limitation — the platform does not expose the exact comment date to unauthenticated users in all cases. **Q: Is reply scraping slower?** Yes — fetching replies requires an additional API call per top-level comment that has replies. For large comment sections with many replies, expect longer run times. **Q: Can I scrape YouTube Shorts comments?** Yes — Shorts URLs (e.g. `youtube.com/shorts/VIDEO_ID`) are fully supported. **Q: What if I hit the charge limit mid-run?** The actor will stop cleanly and save all comments scraped up to that point. You will not be charged beyond the limit you set. *** ### Works Great With - **YouTube Scraper** (`streamers/youtube-scraper`) — extract video metadata (views, likes, subscriber counts) and pair it with comments from this actor for full video analytics - **AI Text Classifier** — feed `comment_text` fields into an LLM for automated sentiment analysis or topic classification *** ### Legal Disclaimer *This actor is designed for lawful extraction of publicly available data from YouTube. Users are solely responsible for ensuring their use complies with YouTube's Terms of Service, applicable copyright laws, data protection regulations (including GDPR and CCPA), and any other relevant laws in their jurisdiction. Do not use this actor to collect personally identifiable information in violation of privacy laws. Scraping for unauthorized commercial purposes or to circumvent access controls is prohibited.* # Actor input Schema ## `startUrls` (type: `array`): Use this field when the user provides full YouTube video URLs (e.g. https://youtube.com/watch?v=dQw4w9WgXcQ, youtu.be/dQw4w9WgXcQ, or YouTube Shorts URLs). Do NOT use this when the user only provides a bare video ID — use videoIds instead. You can add multiple URLs to scrape several videos in one run. ## `videoIds` (type: `array`): Use this field when the user provides bare YouTube video IDs (the 11-character alphanumeric strings, e.g. 'dQw4w9WgXcQ'). Do NOT use this for full URLs — use startUrls instead. One ID per line. ## `maxComments` (type: `integer`): Maximum number of comments to scrape per video. Includes reply comments if 'Include Replies' is enabled. Set to a higher number for comprehensive analysis. Each comment costs $0.002. ## `includeReplies` (type: `boolean`): When enabled, also scrapes reply comments nested under top-level comments. Replies count toward the maxComments limit. Each reply is also charged at $0.002. Disable for faster runs focused only on top-level comments. ## Actor input object example ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ], "videoIds": [], "maxComments": 100, "includeReplies": false } ``` # Actor output Schema ## `results` (type: `string`): Link to the dataset containing all scraped YouTube comments and replies. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ], "videoIds": [], "maxComments": 100, "includeReplies": false }; // Run the Actor and wait for it to finish const run = await client.actor("khadinakbar/youtube-comments-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }], "videoIds": [], "maxComments": 100, "includeReplies": False, } # Run the Actor and wait for it to finish run = client.actor("khadinakbar/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 '{ "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ], "videoIds": [], "maxComments": 100, "includeReplies": false }' | apify call khadinakbar/youtube-comments-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=khadinakbar/youtube-comments-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "YouTube Comments Scraper (with Replies)", "description": "Extract comments and replies from YouTube videos by URL or ID. Returns author, text, likes, reply count, timestamps, pinned/hearted status. No API key required. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.", "version": "1.0", "x-build-id": "xfTkcuBKcwbbRURwT" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/khadinakbar~youtube-comments-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~youtube-comments-scraper/runs": { "post": { "operationId": "runs-sync-khadinakbar-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/khadinakbar~youtube-comments-scraper/run-sync": { "post": { "operationId": "run-sync-khadinakbar-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", "properties": { "startUrls": { "title": "YouTube Video URLs", "type": "array", "description": "Use this field when the user provides full YouTube video URLs (e.g. https://youtube.com/watch?v=dQw4w9WgXcQ, youtu.be/dQw4w9WgXcQ, or YouTube Shorts URLs). Do NOT use this when the user only provides a bare video ID — use videoIds instead. You can add multiple URLs to scrape several videos in one run.", "default": [], "items": { "type": "object", "required": [ "url" ], "properties": { "url": { "type": "string", "title": "URL of a web page", "format": "uri" } } } }, "videoIds": { "title": "Video IDs", "type": "array", "description": "Use this field when the user provides bare YouTube video IDs (the 11-character alphanumeric strings, e.g. 'dQw4w9WgXcQ'). Do NOT use this for full URLs — use startUrls instead. One ID per line.", "default": [], "items": { "type": "string" } }, "maxComments": { "title": "Max Comments per Video", "minimum": 1, "maximum": 10000, "type": "integer", "description": "Maximum number of comments to scrape per video. Includes reply comments if 'Include Replies' is enabled. Set to a higher number for comprehensive analysis. Each comment costs $0.002.", "default": 100 }, "includeReplies": { "title": "Include Replies", "type": "boolean", "description": "When enabled, also scrapes reply comments nested under top-level comments. Replies count toward the maxComments limit. Each reply is also charged at $0.002. Disable for faster runs focused only on top-level comments.", "default": false } } }, "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 } } } } } } } } } } ```