YouTube Comment Scraper API
Our YouTube comment scraper tool pulls every public comment from a video as structured JSON: author, text, likes, published time, and reply count. One GET request, cursor paging handled with a page token, no OAuth and no 10,000-unit daily cap. It is free to start: 1,000 requests on the free tier, no credit card, so you can scrape a real comment section before you pay anything.
Why YouTube Comment data is hard to get
Comments are one of YouTube’s richest signals and one of the hardest to export at scale. The official commentThreads.list method draws on a fixed 10,000-unit daily quota, returns at most 100 threads per call with only partial replies inline, and a video with comments disabled answers 403 commentsDisabled instead of data.
The YouTube Comment Scraper API in one request
curl "https://api.youtubescraperapi.com/api/v1/youtube/comments?video_id=dQw4w9WgXcQ&api_key=$API_KEY"import requests
API = "https://api.youtubescraperapi.com/api/v1/youtube/comments"
KEY = "YOUR_API_KEY"
def scrape_comments(video_id):
"""Page through every comment on a video using cursor pagination."""
comments = []
params = {"video_id": video_id, "api_key": KEY}
while True:
data = requests.get(API, params=params).json()
comments.extend(data["comments"])
# follow the cursor until has_more is false
if not data.get("has_more") or not data.get("next_page_token"):
break
# pass next_page_token back as page_token to fetch the next page
params = {"page_token": data["next_page_token"], "api_key": KEY}
return comments
all_comments = scrape_comments("dQw4w9WgXcQ")
print(f"pulled {len(all_comments)} comments")
for c in all_comments[:5]:
print(c["likes"], c["author"], "-", c["text"][:80])Parameters
| Parameter | Required | Default | Notes |
|---|---|---|---|
video_id | required | - | The video id, the 11-character value after watch?v=. Required unless you pass url. |
url | optional | - | A full watch URL. We extract the video id from it, so use this in place of video_id. |
page_token | optional | - | Cursor token returned as next_page_token in the previous response. Pass it back to fetch the next page of comments. The applied sort is carried inside the token. |
sort | optional | top | Comment order: top or newest. Applies to page 1; later pages inherit the sort from the token. |
api_key | required | - | Your API key. Get one free, no credit card. |
What the YouTube Comment Scraper API returns
{
"video_id": "dQw4w9WgXcQ",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
"sort_applied": "top",
"comment_count": 2300000,
"comment_count_text": "2.3M",
"results_count": 20,
"comments": [
{
"author": "@example_viewer",
"text": "Still a classic in 2026.",
"likes": 1840,
"published_time": "3 weeks ago",
"reply_count": 12
}
],
"page": 1,
"next_page_token": "eyJjIjoiRWcwU0MyUlJkelIzT1ZkbldHTlJ...",
"next_page_url": "/api/v1/youtube/comments?page_token=eyJjIjoiRWcwU0MyUlJkelIzT1ZkbldHTlJ...",
"has_more": true
}| Field | Type | Description |
|---|---|---|
video_id | string | The video the comments belong to. |
sort_applied | string | The order the comments were returned in, either top or newest. |
comment_count | integer | Total comments on the video, as reported by YouTube. May be null on some videos. |
comment_count_text | string | The comment total as YouTube displays it, for example "2.3M". |
results_count | integer | Number of comments returned in this page of the response. |
comments | array | The comments on this page. Each item has author, text, likes, published_time, and reply_count. |
comments[].author | string | Comment author handle, for example @example_viewer. |
comments[].text | string | Full comment text. |
comments[].likes | integer | Like count on the comment. |
comments[].published_time | string | Relative publish time as shown on YouTube, for example "3 weeks ago". |
comments[].reply_count | integer | Number of replies under the comment. |
page | integer | The page number of this response, starting at 1. |
next_page_token | string | Cursor token for the next page. Pass it back as page_token. Null when there are no more comments. |
next_page_url | string | Ready-made path for the next page, /api/v1/youtube/comments?page_token= |
has_more | boolean | True while more pages remain, false on the last page. |
What you can build using the API
Comment sentiment analysis
Moderation and brand safety
Audience research
Creator analytics
Influencer vetting
Trend and product feedback
Why teams choose our YouTube Comment Scraper API
Our YouTube comment scraper runs on our infrastructure: one API key, rotating datacenter-to-premium proxies, rendering, and auto-retry, so transient blocks never surface as failures. The median end-to-end response is 2.6 seconds and you only pay for successful requests.
Free to start, no credit card
Threaded comments, no extra calls
Built-in paging
No OAuth, no daily quota
Anti-bot and proxy rotation
Validated JSON
YouTube Comment Scraper API vs the official YouTube API
| Our comment API | DIY (requests + headless) | YouTube Data API v3 | |
|---|---|---|---|
| Auth | One api_key in the query string | None, but you manage proxies and headers | OAuth or API key plus a Google Cloud project |
| Daily limit | Pay per successful request, no unit cap | Bounded only by your proxy pool | 10,000 units per day, audit needed to raise |
| Comments per call | A full page, plus a next_page_token cursor | Whatever you scroll and parse | Up to 100 threads, default 20, then paginate |
| Replies | reply_count on every comment | Parse each reply thread yourself | Partial inline, separate comments.list calls for the rest |
| Comments disabled | Returns what is publicly visible | Returns what is publicly visible | 403 commentsDisabled error, no data |
| Blocks and proxies | Handled for you, auto-retry | You build rotation and retry logic | Not applicable, but quota is the wall |
| Output | Clean threaded JSON | Raw HTML you parse | JSON you assemble across paged calls |
Start free, scale when ready
| Plan | Price | Best for |
|---|---|---|
| Free | 1,000 requests | Testing and small jobs |
| Pro | $0.60 / 1k | Production workloads |
| Pay-as-you-go | $0.90 / 1k | Spiky or one-off volume |
Median response 2.6s. You only pay for successful requests.
FAQ
Yes. This is a free YouTube comment scraper tool to start: the free tier gives you 1,000 requests with no credit card, which is enough to pull a real comment section or run a one-off export end to end. After that it continues on usage-based pricing, and you only pay for successful requests. There is no software to install and nothing to host, so you can be scraping comments from one GET request in a few minutes.
Both, depending on how you use it. It is a hosted YouTube comment scraper tool, so there is no extension to install, no headless browser to run, and no proxies to manage. Under the hood it is a plain REST API: send a GET request with a video_id and your api_key, get threaded comments back as JSON. That makes it easy enough for a quick manual pull and stable enough to wire into a script or pipeline.
No. Our YouTube comment scraper uses a single api_key query parameter on your account. There is no Google Cloud project, no OAuth consent screen, and no YouTube Data API quota to manage. You send a video_id and get threaded comments back as JSON.
The official commentThreads.list method costs 1 unit per call but draws from a fixed 10,000-unit daily budget, returns at most 100 threads per call, and only includes a partial set of replies inline. Our endpoint returns a full page of threaded comments with a reply_count on each comment and a next_page_token cursor (plus a ready-made next_page_url) for the next page, with no daily unit cap.
Every comment in the response carries a reply_count field showing how many replies it has, so you can identify and prioritize the deepest threads. The official API requires a separate comments.list call per parent comment to retrieve all replies, which our threaded output and paging are designed to avoid.
Each response includes a next_page_token and a next_page_url. Pass the token back as the page_token parameter (or just follow next_page_url) to fetch the following page, and repeat while has_more is true. The Python sample on this page loops through every page automatically.
If a channel owner turns comments off, there is nothing public to return. The YouTube Data API responds with a 403 commentsDisabled error in that case. Our scraper returns whatever is publicly visible on the watch page, which is what a logged-out viewer would see.
Collecting publicly visible YouTube comments for research, sentiment analysis, or moderation is generally treated as legal, provided you respect YouTube's Terms of Service and avoid gathering private or personal data. You are responsible for how you store and use the data, especially under privacy rules like the GDPR. This is general information and does not constitute legal advice.