# YouTube Comments Scraper - Comments & Replies, No API Key (`alom/youtube-comments-scraper`) Actor

Scrape YouTube comments and replies from any video or Short: text, author, likes, reply count, date, pinned and creator-heart flags. Top or newest first, with an optional date limit. No API key, no quota, no login. Export to CSV, Excel or JSON.

- **URL**: https://apify.com/alom/youtube-comments-scraper.md
- **Developed by:** [Alom Dev](https://apify.com/alom) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.45 / 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: Comments & Replies, No API Key

Scrape the **comments and replies** of YouTube videos and Shorts into JSON, CSV or Excel. Paste video URLs and get
**one row per comment**: text, author, author channel, likes, reply count, date, pinned and creator-heart flags, and
the parent comment for every reply.

- **No API key, no quota, no login.** It reads what youtube.com shows a logged-out visitor.
- **Top comments or newest first**, the same two orders as the menu above YouTube's comments.
- **Replies included** on request, each linked to its parent comment (`replyToCid`).
- **Date limit:** only comments from the last 7 days, 30 days, or since a date.
- **Monitoring:** scheduled runs that return only comments you haven't received yet.
- You are never charged for errors: a deleted video gives no row and no charge.

This Actor is a focused version of the [YouTube Scraper](https://apify.com/alom/youtube-scraper) (same code). Use
the YouTube Scraper if you also need video, channel, Shorts, search or community-post rows, or comments of a whole
channel's videos.

### What can you use it for?

- **Sentiment and audience research:** what viewers say about a product launch, a trailer or a competitor's video.
- **Brand monitoring:** new comments on your own or your competitors' videos every day.
- **Community management:** find questions and complaints you haven't answered yet (newest first).
- **Datasets for analysis and AI:** thousands of real comments with likes and reply counts.

### Input

| Field | What it does |
|---|---|
| `startUrls` | Video or Shorts URLs (`youtube.com/watch?v=…`, `youtu.be/…`, `/shorts/…`) or bare video ids. |
| `maxComments` | Max comments per video (top-level comments; replies have their own limit). Default 100. |
| `sortCommentsBy` | `TOP_COMMENTS` or `NEWEST_FIRST` (default). |
| `includeReplies` | Also scrape the replies of each comment. Default off. |
| `maxRepliesPerComment` | With replies on: replies kept under each comment. Default 5, so 100 comments return at most 600 rows. |
| `oldestCommentDate` | Only comments posted after a date (`2026-01-31`) or an age (`7 days`, `2 weeks`). Forces newest first. |
| `onlyNewSinceLastRun` + `monitorName` | Skip comments an earlier run with the same monitoring name returned. |

```json
{ "startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }], "maxComments": 500, "sortCommentsBy": "TOP_COMMENTS", "includeReplies": true }
```

Coming from another comments scraper? `videoUrls` (a plain list of URLs), `commentsSortBy` (`"0"` = top,
`"1"` = newest) and `sort` (`top` / `newest`) are understood too. The field names above are the same as in the
YouTube Scraper, so an input works in both.

### Output example

```json
{
    "type": "comment",
    "cid": "Ugzge340dBgB75hWBm54AaABAg",
    "comment": "can confirm: he never gave us up",
    "author": "@YouTube",
    "authorChannelId": "UCBR8-60-B28hp2BmDPdntcQ",
    "authorAvatarUrl": "https://yt3.ggpht.com/…",
    "authorIsChannelOwner": false,
    "authorIsVerified": true,
    "hasCreatorHeart": true,
    "isPinned": true,
    "voteCount": 321000,
    "replyCount": 963,
    "date": "2025-09-30T11:38:17.654Z",
    "publishedTimeText": "1 year ago",
    "isReply": false,
    "replyToCid": null,
    "videoId": "dQw4w9WgXcQ",
    "pageUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
    "commentsCount": 2457929,
    "scrapedAt": "2026-09-30T11:40:00.000Z"
}
```

`commentsCount` is the video's total comment count. Replies have `isReply: true` and the parent's id in
`replyToCid`.

### How much does it cost?

Pay per result, platform usage (compute and proxy) included. One result = one
comment or reply row.

| Apify plan | Price per 1,000 results |
|---|---|
| Free | $1.00 |
| Starter (Bronze) | $0.75 |
| Scale (Silver) | $0.60 |
| Business (Gold) and above | $0.45 |

10,000 comments cost **$10** on the Free plan and **$4.50** on Business. Inputs that fail (a deleted video, an unknown channel, a URL this Actor doesn't take) produce no row and no
charge, and so do rows skipped by monitoring.

### Monitoring (only new comments)

Turn on **Only new comments since my last run**, give it a name (e.g. `launch-video`) and schedule the run. Each run
reads the newest `maxComments` comments of each video and returns only the ones no earlier run with that name
returned. Skipped comments are not charged. The memory is kept per name and is separate from the YouTube
Scraper's memory.

### Limitations

- **Comment dates are approximate.** YouTube only shows "3 days ago", so `date` is estimated from that text and the
  date limit is day/week/month precise. Like counts are rounded the way YouTube shows them ("321K").
- **Age-restricted videos** don't show comments to logged-out visitors. The YouTube Scraper has an optional
  own-cookie mode for those; this Actor does not.
- **Members-only and private videos** and videos with comments turned off give no rows.
- **Speed:** one video's comments are read page by page (about 20 per request). In our tests that was roughly 650
  top-level comments per minute per video, and about 200 per minute with many replies; several videos run in
  parallel. A run that hits its timeout ends as "partial" with everything scraped so far saved (and charged only for
  those rows).
- Only video and Shorts URLs are accepted. A channel or playlist URL is skipped and named in the status message
  (the YouTube Scraper can scrape the comments of a channel's latest videos).

### FAQ

**Do I need a YouTube account or an API key?** No.

**Is it legal?** It collects publicly visible data. Comments contain personal data (usernames and what people
wrote), so you are responsible for handling it lawfully, for example under GDPR.

**Why did my run say "partial"?** Some videos could not be finished (for example the run hit its timeout). All
comments scraped so far are in the dataset; the status message says what was missed.

### More scrapers from the same developer

- [YouTube Scraper](https://apify.com/alom/youtube-scraper): videos, channels, Shorts, comments, subtitles and community posts without the API quota
- [YouTube Channel Scraper](https://apify.com/alom/youtube-channel-scraper): every video of a channel with views, dates and the channel's stats
- [YouTube Shorts Scraper](https://apify.com/alom/youtube-shorts-scraper): Shorts from any channel or keyword search
- [Google Trends API & Scraper](https://apify.com/alom/google-trends-scraper): interest over time, regions, related queries and Trending Now, a pytrends alternative
- [Threads Scraper](https://apify.com/alom/threads-scraper): posts, profiles, replies and keyword search on Meta Threads, no login
- [Bilibili Scraper](https://apify.com/alom/bilibili-scraper): videos, creators, full comment threads and danmaku from B站, no login
- [Google Hotels Scraper](https://apify.com/alom/google-hotels-scraper): hotel prices from every booking site across dates, room rates and reviews
- [Google Ads Transparency Scraper](https://apify.com/alom/google-ads-transparency-scraper): every Google ad a competitor runs, with the real ad copy
- [Threads Account Finder](https://apify.com/alom/threads-lead-finder): Threads accounts by keyword with followers, bio links and the contacts they list
- [Threads Hashtag & Keyword Monitor](https://apify.com/alom/threads-keyword-monitor): only the new posts for your keywords and #hashtags, for scheduled runs
- [Google Flights Scraper](https://apify.com/alom/google-flights-scraper): flight prices, airlines, layovers and a cheapest-date calendar for any route

### Feedback

Missing a field, found a bug, or need a feature? Open an issue in the **Issues** tab and I'll take a look. If this
Actor saved you time, a short review on the Store page helps other people find it.

# Actor input Schema

## `startUrls` (type: `array`):

<b>Video</b> or <b>Shorts</b> URLs (<code>youtube.com/watch?v=…</code>, <code>youtu.be/…</code>, <code>/shorts/…</code>) or bare video ids.

## `maxComments` (type: `integer`):

How many comments to collect from each video. Replies are not counted here: they have their own limit, <b>Max replies per comment</b>.

## `sortCommentsBy` (type: `string`):

Same as the sort menu above YouTube's comments.

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

Also scrape the replies of each comment, up to <b>Max replies per comment</b> each.

## `maxRepliesPerComment` (type: `integer`):

With replies on: how many replies to keep under each comment. They do not count toward the comment limit, so 100 comments with up to 5 replies each return at most 600 rows.

## `oldestCommentDate` (type: `string`):

A date (<code>2026-01-31</code>) or an age (<code>7 days</code>, <code>2 weeks</code>). YouTube shows comment dates as "3 days ago", so this is day/week/month precise. Forces <b>Newest first</b>.

## `onlyNewSinceLastRun` (type: `boolean`):

Skip comments that an earlier run with the same <b>Monitoring name</b> already returned (they are not charged). Schedule the run for daily or weekly monitoring.

## `monitorName` (type: `string`):

Any name, e.g. <code>competitors-weekly</code>. Runs with the same name share their memory. Defaults to <code>default</code>.

## `maxConcurrency` (type: `integer`):

How many URLs are processed at the same time.

## `proxyConfiguration` (type: `object`):

The default (Apify datacenter proxy) works for YouTube and is included in the price. If YouTube starts blocking it, the run switches to residential proxies on its own and says so in the log.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "maxComments": 100,
  "sortCommentsBy": "NEWEST_FIRST",
  "includeReplies": false,
  "maxRepliesPerComment": 5,
  "onlyNewSinceLastRun": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alom/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 <APIFY_API_TOKEN>` 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/qHIChygIWfAKdIEtg/builds/7bGSESCRLw0EWUYvu/openapi.json