# YouTube Comments Scraper — Comments & Replies (`webdatatools/youtube-comments-scraper`) Actor

Comments Scraper extracts comments, replies, likes and author details from any YouTube video URL or ID — no YouTube Data API key or quota needed.

- **URL**: https://apify.com/webdatatools/youtube-comments-scraper.md
- **Developed by:** [Murat Uzun](https://apify.com/webdatatools) (community)
- **Categories:** Social media, Videos, Marketing
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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

### What is YouTube Comments Scraper?

**Recorded price: $0.0005 per accepted comment or reply ($0.50 per 1,000) on the Free plan, plus $0.00005 per run.** Source: November 4, 2026 pricing readback recorded below; confirm current plan rates in the [Pricing tab](https://apify.com/webdatatools/youtube-comments-scraper/pricing) before running. Diagnostics are not billable comment rows.

**YouTube Comments Scraper extracts comments, replies, likes, and author details from any public YouTube video** — no YouTube Data API key, no daily quota, and no browser required. Paste a video URL or ID and get one structured row per comment: text, author, like count, reply count, pinned/hearted flags, and an approximate publish date. Point it at [any YouTube video](https://www.youtube.com) and run it on Apify with scheduling, API access, and webhook integrations built in.

Under the hood it talks directly to YouTube's own `youtubei/v1/next` endpoint — the same JSON API the youtube.com website itself uses to load comments — so there's nothing to authenticate and no per-request cost from Google.

### Why use YouTube Comments Scraper?

- **Sentiment and brand monitoring** — sample available comments on a product review or ad campaign video to gauge audience reaction without opening YouTube.
- **Keyword monitoring that only charges for matches** — enter your brand, product or competitor names in **Only comments containing** and get just the comments that mention them; the Actor scans the rest for free, so you don't pay for thousands of unrelated comments.
- **Creator research** — see what an audience actually says about a channel's videos before a sponsorship or collab deal.
- **Lead generation** — commenters who ask questions about a product or service under a competitor's video are warm leads; export their channel names and profile links.
- **Community management at scale** — export pinned/hearted comments and top replies for a weekly highlights digest.

### How to use YouTube Comments Scraper

1. Click **Try for free** (or **Run** if you already have it open).
2. In **Videos**, paste one or more YouTube URLs or bare video IDs.
3. Set **Max comments per video**, choose whether to **include replies**, and pick a sort order (**Top** or **Newest**).
4. Click **Start** and watch rows appear in the **Dataset** tab as they're scraped.
5. Export the results as JSON, CSV, Excel, or HTML, or pull them via the API.

### Input

| Field                        | Type        | Description                                                                                                                  |
| ---------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `videos`                     | array       | Video IDs or URLs (watch, shorts, `youtu.be`). Default: `["dQw4w9WgXcQ"]`.                                                   |
| `proxyConfiguration`         | object      | Apify Proxy settings — required for platform runs, see **Proxy requirement** below. Default: Residential proxy.              |
| `maxCommentsPerVideo`        | integer     | Cap per video, 1–10,000. Default `100`.                                                                                      |
| `includeReplies`             | boolean     | Also fetch replies (counts toward the cap). Default `false`.                                                                 |
| `sortBy`                     | enum        | `top` or `newest`. Default `top`.                                                                                            |
| `maxConcurrency`             | integer     | Videos scraped in parallel, 1–10. Default `3`.                                                                               |
| `language`                   | string      | UI language code for relative-time text. Default `en`.                                                                       |
| `keywords`, `keywordMatch`   | array, enum | Optional: only comments containing these words/phrases (`any` or `all`) are output and charged; rows list `matchedKeywords`. |
| `oldestCommentDate`          | string      | Optional: only comments on or after a date (`2026-03-01`) or within an age (`7 days`). Forces newest-first.                  |
| `maxScannedCommentsPerVideo` | integer     | Filter mode only: comments read per video while looking for matches, 1–5,000. Default `1000`.                                |

See the **Input** tab for the full schema with examples.

#### Example input

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

#### Keyword and date filters: pay only for matching comments

Fill **Only comments containing** (`keywords`) to turn the Actor into a mention monitor. It reads up to `maxScannedCommentsPerVideo` comments per video (and replies, if enabled), keeps only comments whose text contains a keyword, and adds a `matchedKeywords` field listing which ones matched. **Only matching comments are pushed to the dataset, so only matches are charged**; scanned comments that don't match cost nothing. Matching ignores upper/lower case and accents (`cafe` matches `Café`), collapses repeated spaces, and is a plain substring match, so `apple` also matches `pineapple`. Use `keywordMatch: "all"` to require every keyword in the same comment.

```json
{
    "videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "keywords": ["never gonna", "rickroll"],
    "maxCommentsPerVideo": 100,
    "maxScannedCommentsPerVideo": 2000
}
```

`maxCommentsPerVideo` caps the matches you pay for; `maxScannedCommentsPerVideo` caps how far down the comment list the Actor looks. `OUTPUT` reports `scannedComments`, `matchedComments`, `noMatchVideos` and `scanLimitedVideos`. A video with no match adds a `NO_KEYWORD_MATCH` note to `ERRORS`; a video where the scan limit stopped the search adds `FILTER_SCAN_LIMIT`, so you know later comments were not checked. If nothing matched anywhere, the run still **succeeds** with `zeroResultReason: "NO_KEYWORD_MATCH"` in `OUTPUT` instead of failing.

**Only recent comments:** set `oldestCommentDate` to a date (`2026-03-01`) or an age (`7 days`, `2 weeks`, `3 months`, `1 year`) to keep only comments published on or after it. The Actor switches to newest-first order and stops paging at the first older comment (an old pinned comment does not end the window), so a weekly monitoring run reads only the new part of the thread. Reply threads are opened only for comments inside the window. YouTube shows only relative times ("3 weeks ago"), so the cut-off uses `publishedAtApprox` and has YouTube's granularity: a comment shown as "1 month ago" counts as 30.4 days old. It combines with `keywords` (both must pass). An empty window succeeds with `zeroResultReason: "NO_COMMENT_IN_DATE_RANGE"`. An unreadable value stops the run before any request, with a message saying which formats work.

### Proxy requirement

YouTube can block comment requests from datacenter IPs. The input schema defaults to Apify Residential Proxy. For each video, the Actor creates one proxy session and reuses its connection across sequential comment and reply pages, then closes it. Parallel videos have separate sessions. A block or transport failure can rotate the session; a failed reused connection falls back to the existing one-shot proxy path, which can ultimately try a direct request. Proxy initialization failure also falls back to direct requests.

This is the recorded source behavior, not a guarantee of access. Proxy group availability and cost depend on the account and platform configuration; neither Residential nor datacenter access is guaranteed to bypass YouTube restrictions.

### Output

One row per accepted comment (or reply when `includeReplies` is on). This illustrative excerpt uses captured fixture values, not a fresh live result; the full schema includes additional author/channel fields:

```json
{
    "videoId": "dQw4w9WgXcQ",
    "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "videoTitle": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
    "channelName": "Rick Astley",
    "commentId": "Ugzge340dBgB75hWBm54AaABAg",
    "parentCommentId": null,
    "isReply": false,
    "text": "can confirm: he never gave us up",
    "author": "@YouTube",
    "authorChannelId": "UCBR8-60-B28hp2BmDPdntcQ",
    "authorIsVerified": true,
    "likeCount": 314000,
    "replyCount": 963,
    "publishedTimeText": "1 year ago",
    "publishedAtApprox": "2025-09-12T00:00:00.000Z",
    "isPinned": true,
    "isHearted": true,
    "scrapedAt": "2026-09-12T00:00:00.000Z",
    "error": null,
    "errorCode": null
}
```

You can download the dataset in various formats such as JSON, CSV, Excel, or HTML.

#### Data table

| Field                                                            | Description                                                      |
| ---------------------------------------------------------------- | ---------------------------------------------------------------- |
| `videoId`, `videoUrl`, `videoTitle`                              | The video the comment belongs to                                 |
| `channelName`, `channelId`                                       | The video's uploading channel                                    |
| `commentId`, `parentCommentId`, `isReply`                        | Comment identity and threading                                   |
| `text`, `author`, `authorChannelId`, `authorUrl`, `authorAvatar` | Comment content and author                                       |
| `authorIsVerified`, `authorIsCreator`                            | Author badges                                                    |
| `likeCount`, `replyCount`                                        | Engagement counts                                                |
| `publishedTimeText`, `publishedAtApprox`                         | When it was posted (exact text + approximate ISO date)           |
| `isPinned`, `isHearted`                                          | Creator moderation signals                                       |
| `error`, `errorCode`                                             | Null on comment rows; failures use the `ERRORS` key-value record |

### Pricing

This Actor uses **Pay-per-event** pricing: **$0.0005 per comment row on the Free plan ($0.50 per 1,000 rows)**. Per 1,000 rows, the other plan rates are **Starter $0.40, Scale $0.35, and Business $0.30**. Every plan also has an **Actor Start event of $0.00005 per run**, charged once per run, not per video or comment. Scraping 100 comments from each of 10 videos in a single run (1,000 rows) on the Free plan costs **$0.50 + $0.00005 = $0.50005**. These rates reflect the November 4, 2026 pricing readback; see the [live Pricing tab](https://apify.com/webdatatools/youtube-comments-scraper/pricing) for current plan-specific rates. There is no separate compute-unit charge on top — the price already covers it.

The source checks capacity against `apify-default-dataset-item` and sends only accepted, usable comment rows to the dataset. `ERRORS` diagnostics are stored separately. Numeric event prices and the Actor Start fee are platform configuration, not constants in the scraper code. The historical readback above is not a new live billing measurement; proxy usage and plan allowances should be checked in your account rather than estimated from older test runs.

### YouTube Comments Scraper vs. the YouTube Data API

The official YouTube Data API v3 `commentThreads.list` endpoint requires a Google Cloud project, an API key, and burns your daily quota (10,000 units — a few thousand comment reads) fast. This Actor reads the same public data YouTube's own website loads, with no key, no quota, and results delivered as a ready-to-export dataset instead of raw API pages you have to paginate yourself.

### JavaScript, Python and CLI examples

These examples use the same small input and the Apify synchronous dataset endpoint. They start a real, potentially billable run when executed; they were not executed for this documentation update. Supply your own token through `APIFY_TOKEN` in your local environment. The response is dataset items only: use the run in Apify Console to inspect `OUTPUT`, `ERRORS` and terminal status, including when the dataset is empty. For larger jobs use asynchronous runs and retrieve the dataset after completion; do not blindly retry a timed-out synchronous request, since the original run may still exist.

Save this as `input.json` for the CLI example:

```json
{
    "videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "maxCommentsPerVideo": 10,
    "includeReplies": false,
    "sortBy": "top",
    "maxConcurrency": 1
}
```

#### JavaScript (Node.js with built-in fetch)

```javascript
const response = await fetch(
    'https://api.apify.com/v2/acts/webdatatools~youtube-comments-scraper/run-sync-get-dataset-items',
    {
        method: 'POST',
        headers: {
            Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            videos: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
            maxCommentsPerVideo: 10,
            includeReplies: false,
            sortBy: 'top',
            maxConcurrency: 1,
        }),
    },
);
if (!response.ok) throw new Error(`Run request returned HTTP ${response.status}`);
console.log(await response.json());
```

#### Python (standard library)

```python
import json
import os
from urllib.request import Request, urlopen

request = Request(
    'https://api.apify.com/v2/acts/webdatatools~youtube-comments-scraper/run-sync-get-dataset-items',
    data=json.dumps({
        'videos': ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
        'maxCommentsPerVideo': 10,
        'includeReplies': False,
        'sortBy': 'top',
        'maxConcurrency': 1,
    }).encode('utf-8'),
    headers={
        'Authorization': 'Bearer ' + os.environ['APIFY_TOKEN'],
        'Content-Type': 'application/json',
    },
    method='POST',
)
with urlopen(request, timeout=300) as response:
    print(json.load(response))
```

#### CLI (curl)

```bash
curl --fail-with-body --request POST \
  'https://api.apify.com/v2/acts/webdatatools~youtube-comments-scraper/run-sync-get-dataset-items' \
  --header "Authorization: Bearer ${APIFY_TOKEN}" \
  --header 'Content-Type: application/json' \
  --data-binary @input.json
```

### Using YouTube Comments Scraper with AI agents / MCP

In a client connected to the [Apify MCP Server](https://mcp.apify.com), select or discover `webdatatools/youtube-comments-scraper`. Tool availability depends on the client's Apify connection and enabled tools. Example request:

> Run webdatatools/youtube-comments-scraper for https://www.youtube.com/watch?v=dQw4w9WgXcQ with maxCommentsPerVideo 10, includeReplies false, sortBy top and maxConcurrency 1. Report the returned comments and check OUTPUT and ERRORS for empty or partial results. Do not describe a capped export as the video's complete comment history.

This is a client prompt example, not a claim that an MCP run or live acceptance has been performed.

### FAQ

**Do I pay for comments that don't match my keywords or date window?** No. With `keywords` or `oldestCommentDate` set, only matching comments become dataset rows, and you are charged per dataset row (plus the per-run start fee). Non-matching comments are read and discarded. Scanning is bounded by `maxScannedCommentsPerVideo` (max 5,000 per video), and `OUTPUT` tells you how many comments were scanned versus matched.

**What does a small run cost?** At the recorded Free-plan rate, 10 accepted comment/reply rows cost $0.005 plus the $0.00005 start event, or $0.00505 in listed events. This is an arithmetic example, not a measured invoice or proxy-cost estimate. Confirm current rates in the Pricing tab.

**Do failed pages, empty results or replies cost extra?** Replies count as comment rows and share `maxCommentsPerVideo`. Diagnostics and rejected duplicate rows are not sent to the billable dataset. A run with zero accepted comments can still incur its start event; zero results do not mean zero total cost. Check `OUTPUT`, `ERRORS` and the run's charge details together.

**Is this legal?** The Actor reads publicly visible comments the same way a browser loading youtube.com does. Respect YouTube's Terms of Service and applicable data-protection law for how you store and use the results.

**Why is `publishedAtApprox` approximate?** YouTube never sends an exact comment timestamp to the client — only relative text like "2 years ago". The date is computed by subtracting that duration from the scrape time, so treat it as a good estimate, not an exact value.

**Will large batches get rate-limited?** The Actor routes requests through Apify Proxy by default (see **Proxy requirement** above) — each parallel video gets one session reused across its comment and reply pages, with rotation on certain failures. For very large batches, keep `maxConcurrency` at 2–3; on an HTTP 429 the Actor waits 5 seconds and retries once before giving up on that page.

**What about private, deleted, restricted videos or disabled comments?** When comments cannot be read, the failure goes into `ERRORS`, outside the billable dataset. A run with no usable comments fails on invalid input or source failures; reached pages with no comments succeed; mixed runs retain usable comments. Start fees may still apply.

**How do budgets and incomplete exports work?** The Actor reserves comment capacity before fetching each video and passes that limit into pagination. Unused capacity is available to later videos. Tight budgets reduce concurrency. `OUTPUT` reports requested/attempted/skipped videos, budget-limited videos, delivered comments, diagnostic rows and partial output. Failed or repeated continuation pages retain collected comments and add an `ERRORS` diagnostic. Comment IDs are deduplicated within each video. An uncertain dataset write sets `deliveryUnconfirmed`, stops further work and is not retried automatically. These counters describe this process attempt, not guaranteed totals across migrations; capped or partial exports are not complete comment histories.

**Can I use this in n8n, Make, or Zapier?** Yes — call the Actor via its Apify API endpoint from any of these tools' native Apify integration or a generic HTTP node, or trigger it from a webhook.

### Related Actors

Part of the **webdatatools** web-intelligence suite — every Actor is pay-per-event, reads public data
without a login, and returns one clean row per entity:

Browse the whole suite at [webdatatools](https://paulet4a-commits.github.io/webdatatools/), or call ten of
these Actors straight from Claude, Cursor or Cline with the
[webdatatools MCP server](https://github.com/paulet4a-commits/webdatatools-mcp-server).

**Website & domain intelligence**

- [Email Extractor — Website Contact & Social Finder](https://apify.com/webdatatools/contact-extractor) — e-mails, phones and social profiles per domain
- [Tech Stack Detector — Wappalyzer & BuiltWith Alternative](https://apify.com/webdatatools/tech-stack-detector) — CMS, e-commerce, analytics, pixels and payments per domain
- [Domain DNS & Email Security Checker](https://apify.com/webdatatools/dns-email-security-checker) — SPF, DKIM, DMARC, MX provider, registrar and domain age
- [Domain Security Audit (TLS, HTTP headers, redirects, robots)](https://apify.com/webdatatools/domain-security-audit) — TLS expiry, security headers, redirect chain, robots and llms.txt
- [Subdomain Finder (Certificate Transparency)](https://apify.com/webdatatools/subdomain-finder) — every subdomain seen in CT logs, with a live DNS check
- [Bulk Core Web Vitals & PageSpeed Audit](https://apify.com/webdatatools/core-web-vitals-audit) — Lighthouse scores, LCP, CLS, INP and top fixes per URL
- [On-Page SEO Audit](https://apify.com/webdatatools/seo-page-audit) — title, meta, headings, links, images and schema issues per page
- [Sitemap URL Extractor & Change Monitor](https://apify.com/webdatatools/sitemap-extractor) — every sitemap URL, or new and removed pages between runs
- [Wayback Machine Snapshot & Page Change Tracker](https://apify.com/webdatatools/wayback-page-diff) — how a page changed over time, or every archived snapshot
- [Bulk Domain WHOIS & RDAP Lookup](https://apify.com/webdatatools/domain-whois-rdap) — registrar, dates, status and nameservers per domain
- [Web Scraper — CSS Selector & Data Extractor](https://apify.com/webdatatools/css-selector-extractor) — pull any CSS selector off any page, one row per URL
- [Website Screenshot Generator](https://apify.com/webdatatools/website-screenshot) — full-page or viewport PNG/JPEG screenshots of any URL

**Content for AI, LLMs and RAG**

- [AI Web Search & Read: Google results as clean Markdown](https://apify.com/webdatatools/ai-web-search) — a query turned into clean Markdown from the top search results
- [Website to Markdown — Content Crawler for LLM & RAG](https://apify.com/webdatatools/website-to-markdown) — any site as clean Markdown per page, no browser
- [llms.txt Generator (Website to llms.txt & llms-full.txt)](https://apify.com/webdatatools/llms-txt-generator) — llms.txt and llms-full.txt for any website or docs site
- [PDF to Markdown Converter (Text, Headings, Metadata)](https://apify.com/webdatatools/pdf-to-markdown) — PDF files to clean Markdown with headings, metadata and token counts
- [RAG Text Chunker (Markdown to Chunks, Token Counts)](https://apify.com/webdatatools/rag-text-chunker) — heading-aware RAG chunks with exact GPT token counts from any dataset
- [Article & News Extractor (clean text, author, date, markdown)](https://apify.com/webdatatools/article-extractor) — clean article text, author, date and Markdown per URL
- [Structured Data & JSON-LD Extractor (Schema.org, Open Graph)](https://apify.com/webdatatools/structured-data-extractor) — Schema.org and Open Graph data from any page
- [Google News Scraper (RSS search by keyword, topic, site)](https://apify.com/webdatatools/google-news-scraper) — news results by keyword, topic or site
- [Press Release Monitor: PR Newswire, BusinessWire, GlobeNewswire](https://apify.com/webdatatools/press-release-monitor) — PR Newswire, Business Wire and GlobeNewswire releases

**Search, video and social**

- [YouTube Shorts Scraper](https://apify.com/webdatatools/youtube-shorts-scraper) — Shorts from channels, hashtags and searches with view counts
- [Pinterest Pins Scraper](https://apify.com/webdatatools/pinterest-pins-scraper) — latest pins of public Pinterest profiles and boards
- [YouTube Transcript Scraper](https://apify.com/webdatatools/youtube-transcript-scraper) — captions and subtitles as text + timed segments, per video or channel
- [Google Search Results Scraper — SERP API](https://apify.com/webdatatools/google-search-scraper) — organic SERP results per keyword and country
- [YouTube Channel Latest Videos (RSS, no API key)](https://apify.com/webdatatools/youtube-channel-videos) — the latest 15 videos of any channel from RSS
- [YouTube Channel Scraper (videos, shorts, live)](https://apify.com/webdatatools/youtube-channel-scraper) — a channel's full video, shorts and stream list
- [YouTube Search Results Scraper (videos, channels, no API key)](https://apify.com/webdatatools/youtube-search-scraper) — videos, channels and playlists per query
- [YouTube Video Details Scraper (views, likes, description, tags)](https://apify.com/webdatatools/youtube-video-details) — views, likes, description, tags and chapters per video
- [Apple Podcasts Lookup & Episodes Scraper](https://apify.com/webdatatools/podcast-lookup) — podcast metadata and episodes from iTunes and RSS
- [Bluesky Post, Search & Profile Scraper](https://apify.com/webdatatools/bluesky-scraper) — posts, profiles, followers and threads from the AT Protocol API
- [X Tweet Scraper (Twitter Posts by URL, No Login)](https://apify.com/webdatatools/x-tweet-scraper) — X (Twitter) posts by URL with likes, replies, author, media and MP4 links
- [TikTok Profile Scraper (Followers, Likes, Bio, Video Stats)](https://apify.com/webdatatools/tiktok-profile-scraper) — TikTok profiles with exact follower and like counts, plus video stats
- [Telegram Channel Posts Scraper](https://apify.com/webdatatools/telegram-channel-scraper) — posts, views and media flags from any public channel
- [Substack Publication & Posts Scraper](https://apify.com/webdatatools/substack-scraper) — archive, authors and paywall status per publication
- [Google Play Reviews Scraper](https://apify.com/webdatatools/google-play-reviews-scraper) — reviews, ratings, replies and app versions per app
- [App Store Reviews Scraper](https://apify.com/webdatatools/app-store-reviews-scraper) — iOS reviews and ratings per app and country
- [Trustpilot Reviews Scraper (Ratings, Replies, No Login)](https://apify.com/webdatatools/trustpilot-reviews-scraper) — Trustpilot reviews with stars, full text, verification and company replies
- [Google Trends Scraper](https://apify.com/webdatatools/google-trends-scraper) — interest over time, by region, and related queries per keyword
- [Google Ads Transparency Scraper](https://apify.com/webdatatools/google-ads-transparency-scraper) — ads any advertiser runs on Google, with format and dates
- [Keyword Suggestions Scraper (Google, YouTube, Amazon, Bing)](https://apify.com/webdatatools/keyword-suggestions-scraper) — autocomplete keyword ideas from four search engines
- [Bilibili Scraper (Videos, Search, Popular)](https://apify.com/webdatatools/bilibili-scraper) — Chinese video platform: views, likes, coins, danmaku, uploader
- [Mastodon Scraper (Hashtags, Accounts, Trending)](https://apify.com/webdatatools/mastodon-scraper) — public fediverse posts by hashtag, account or trending
- [Meetup Events Scraper (Search by Keyword & City)](https://apify.com/webdatatools/meetup-events-scraper) — upcoming events with RSVPs, fees, venues and groups
- [Eventbrite Scraper (Events by Keyword & City)](https://apify.com/webdatatools/eventbrite-scraper) — events by keyword and city with venue, dates and organizer

**Leads, jobs and company data**

- [Career Site Jobs API (Greenhouse, Lever, Ashby, Workday +1)](https://apify.com/webdatatools/career-site-jobs-api) — company domains in, their open jobs out, ATS detected automatically
- [Workday Jobs Scraper](https://apify.com/webdatatools/workday-jobs-scraper) — jobs with full descriptions from any Workday career site
- [Google Maps Scraper](https://apify.com/webdatatools/google-maps-scraper) — businesses with phone, website, address, rating and coordinates per search
- [2GIS Places Scraper (Phones, Websites, Ratings, Hours)](https://apify.com/webdatatools/2gis-places-scraper) — 2GIS businesses in Russia, Kazakhstan, UAE and more with phones, website, rating and hours
- [LinkedIn Jobs Scraper](https://apify.com/webdatatools/linkedin-jobs-scraper) — job titles, companies, locations and full descriptions from LinkedIn job search
- [Company 360: full company profile from a domain](https://apify.com/webdatatools/company-360) — one row per domain: contacts, tech, security, hiring and company facts
- [Hiring Signals Scraper (Greenhouse, Lever, Ashby, Workable)](https://apify.com/webdatatools/hiring-signals) — open jobs and hiring velocity from 10 public ATS boards
- [Y Combinator Companies & Founders Scraper](https://apify.com/webdatatools/yc-companies-scraper) — YC startups by batch, industry and hiring status
- [Wikidata Entity & Company Enrichment (facts, IDs, links)](https://apify.com/webdatatools/wikidata-entity-enrichment) — HQ, founders, employees, revenue and social IDs per company
- [Email Validator & Verifier — Bulk Email Check](https://apify.com/webdatatools/email-validator) — syntax, MX, disposable, role and free-provider checks
- [OpenStreetMap POI Extractor (Overpass API: shops, amenities)](https://apify.com/webdatatools/overpass-poi-extractor) — shops and amenities by radius, bbox or area
- [Stock, Crypto & FX Quotes](https://apify.com/webdatatools/market-quotes) — one row per symbol from Yahoo, Binance and ECB rates
- [Yahoo Finance Scraper (Quotes, Fundamentals, Financials, News)](https://apify.com/webdatatools/yahoo-finance-scraper) — Yahoo Finance fundamentals, analyst targets, financial statements, ownership, news and history per ticker
- [DexScreener Scraper (DEX Pairs, Prices, Liquidity, Boosts)](https://apify.com/webdatatools/dexscreener-scraper) — DEX pairs with price, volume, liquidity, FDV and boosted tokens across chains
- [Polymarket Scraper (Prediction Markets, Odds, Volume)](https://apify.com/webdatatools/polymarket-scraper) — Polymarket markets and events with outcome prices, volume and liquidity
- [StockTwits Scraper (Messages, Sentiment, Trending)](https://apify.com/webdatatools/stocktwits-scraper) — StockTwits messages with Bullish/Bearish sentiment and trending symbols
- [Economic Calendar Scraper (Forex Events, Impact, Forecasts)](https://apify.com/webdatatools/economic-calendar-scraper) — This week's macro events with impact, forecast and previous values
- [Crypto Fear & Greed Index](https://apify.com/webdatatools/crypto-fear-greed-index) — Daily Crypto Fear & Greed Index values with full history
- [Remote Jobs Aggregator (RemoteOK, WWR, Hacker News)](https://apify.com/webdatatools/remote-jobs-aggregator) — one clean row per remote job, de-duplicated across feeds
- [Greenhouse Jobs Scraper](https://apify.com/webdatatools/greenhouse-jobs-scraper) — jobs with descriptions from any Greenhouse job board
- [Lever Jobs Scraper](https://apify.com/webdatatools/lever-jobs-scraper) — jobs with descriptions from any Lever careers page
- [Ashby Jobs Scraper](https://apify.com/webdatatools/ashby-jobs-scraper) — jobs, salaries and descriptions from any Ashby job board
- [SmartRecruiters Jobs Scraper](https://apify.com/webdatatools/smartrecruiters-jobs-scraper) — jobs with descriptions from any SmartRecruiters company
- [Seek Jobs Scraper (Australia & New Zealand)](https://apify.com/webdatatools/seek-jobs-scraper) — Seek job ads with salary, work type and location
- [Dice Jobs Scraper](https://apify.com/webdatatools/dice-jobs-scraper) — US tech jobs from Dice with salary and remote flag
- [AutoScout24 Scraper](https://apify.com/webdatatools/autoscout24-scraper) — European car listings with price, mileage and seller
- [Rightmove Scraper](https://apify.com/webdatatools/rightmove-scraper) — UK property for sale or rent with price and agent
- [Wellfound Jobs Scraper (AngelList Startup Jobs)](https://apify.com/webdatatools/wellfound-jobs-scraper) — startup jobs with salary and equity ranges, company size and stage
- [Yandex Maps Scraper (Places, Ratings, Phones)](https://apify.com/webdatatools/yandex-maps-scraper) — businesses in Russia, Türkiye and the CIS with phones, ratings, hours
- [Craigslist Scraper (Listings, Prices, Locations)](https://apify.com/webdatatools/craigslist-scraper) — listings in any area and category with price, date and coordinates
- [JobStreet Scraper (Malaysia, Singapore, PH, ID + JobsDB)](https://apify.com/webdatatools/jobstreet-scraper) — JobStreet and JobsDB jobs in 6 Asian countries with parsed salaries
- [InfoJobs Scraper (Spain Jobs, Salaries, Companies)](https://apify.com/webdatatools/infojobs-scraper) — Spanish jobs with salary range, contract type and full description
- [StepStone Scraper (Germany, Austria, Belgium Jobs)](https://apify.com/webdatatools/stepstone-scraper) — StepStone jobs in Germany, Austria and Belgium by keyword and city
- [Naukri Jobs Scraper (Salary, Skills, Company Rating)](https://apify.com/webdatatools/naukri-jobs-scraper) — Naukri.com jobs in India with salary range, experience, skills and company rating
- [Zillow Scraper (Homes for Sale, Rent & Sold, Zestimates)](https://apify.com/webdatatools/zillow-scraper) — Zillow homes for sale, rent or sold with Zestimates, beds, baths and photos
- [Zillow Home Details Scraper (Description, Photos, History)](https://apify.com/webdatatools/zillow-detail-scraper) — full Zillow property pages: description, photos, HOA, tax rate, agent
- [Redfin Scraper (Homes for Sale, Prices, Details)](https://apify.com/webdatatools/redfin-scraper) — US homes for sale or sold from any Redfin search, with price and details
- [Kleinanzeigen Scraper (Ads, Prices, Locations)](https://apify.com/webdatatools/kleinanzeigen-scraper) — German classifieds with price, VB flag, ZIP, city and seller type

**Developer, app and research data**

- [npm, PyPI & Crates.io Package Health Checker](https://apify.com/webdatatools/package-health-checker) — releases, downloads, deprecation and a health score
- [GitHub Repository Health & Activity Report](https://apify.com/webdatatools/github-repo-health) — stars, commits, contributors and risk flags per repo
- [VS Code Marketplace Extension Scraper (installs, ratings)](https://apify.com/webdatatools/vscode-marketplace-extensions) — installs, ratings and versions per extension
- [Chrome Web Store Extension Scraper (installs, ratings)](https://apify.com/webdatatools/chrome-web-store-extensions) — users, rating, version and developer per extension
- [Google Play Scraper](https://apify.com/webdatatools/google-play-scraper) — apps, ratings, installs, developer contact and reviews
- [App Store (iOS) App Metadata, Ratings & Top Charts Lookup](https://apify.com/webdatatools/app-store-lookup) — ratings, price, version and charts per app
- [CrossRef DOI & Citation Metadata Lookup](https://apify.com/webdatatools/crossref-doi-lookup) — papers, authors, journals and citation counts
- [FDA Recalls & Adverse Events Monitor (openFDA)](https://apify.com/webdatatools/openfda-recall-monitor) — food, drug and device recalls from openFDA
- [iCal / ICS Calendar Feed to Events Extractor](https://apify.com/webdatatools/ical-calendar-extractor) — any public calendar feed as event rows
- [Shopify Store Products Scraper](https://apify.com/webdatatools/shopify-products-scraper) — catalog, prices, variants and stock per store
- [Hacker News Search & Front Page Scraper](https://apify.com/webdatatools/hacker-news-scraper) — stories, comments and points by query or front page
- [GitHub Trending Repositories Scraper](https://apify.com/webdatatools/github-trending-scraper) — trending repos and developers by language and period
- [Stack Overflow & Stack Exchange Q\&A Scraper](https://apify.com/webdatatools/stackexchange-scraper) — questions, answers and scores by query, tag or site
- [Bulk Image Downloader](https://apify.com/webdatatools/bulk-image-downloader) — download image URLs to storage with size, dimensions and a ZIP
- [Google Flights Scraper (Prices, Airlines, Stops)](https://apify.com/webdatatools/google-flights-scraper) — flight prices, airlines, times, stops and CO2 by route and date
- [Google Hotels Scraper (Prices, Ratings, Reviews)](https://apify.com/webdatatools/google-hotels-scraper) — hotel prices per night, stars, rating and reviews by city and dates
- [Booking.com Scraper (Hotel Prices, Ratings, Availability)](https://apify.com/webdatatools/booking-scraper) — Booking.com hotels for any city and dates with prices, scores and deals
- [Airbnb Scraper (Listings, Prices, Ratings, Coordinates)](https://apify.com/webdatatools/airbnb-scraper) — Airbnb stays for any city and dates with prices, ratings and coordinates
- [AliExpress Scraper (Search Products & Prices)](https://apify.com/webdatatools/aliexpress-scraper) — AliExpress search results with USD price, discount and rank
- [Lazada Scraper (Products, Prices, Sold, Ratings)](https://apify.com/webdatatools/lazada-scraper) — Lazada products in 6 countries with price, rating, units sold and seller
- [Trendyol Scraper (Turkey Products, Prices, Ratings)](https://apify.com/webdatatools/trendyol-scraper) — Trendyol products with price, basket discount, rating and promotions

### Support

Found a bug or have a feature request? Open an issue on the Actor's **Issues** tab in Apify Console. Custom scraping solutions are also available on request.

#### Diagnostic codes and legacy error consumers

Accepted dataset comments retain all existing fields, including `error: null`, and add
`errorCode: null`. Diagnostics are **not dataset items** and incur no dataset-item event.
This is a compatibility change for integrations that previously filtered dataset rows by
`error`: read the default key-value store's `ERRORS` record as well. Each diagnostic keeps
all legacy row field names (unavailable values are null), `error` contains human-readable
text, and `errorCode` is a stable machine-readable code. Input diagnostics also retain
`query`. For a legacy combined export, concatenate dataset items and `ERRORS` locally;
do not push diagnostics back into the billable dataset. Start fees may still apply.

| errorCode                  | Meaning                                                                                               |
| -------------------------- | ----------------------------------------------------------------------------------------------------- |
| `INVALID_INPUT`            | Empty input or unrecognisable video URL/ID.                                                           |
| `ACCESS_BLOCKED`           | Source returned HTTP 403 or 429 after retries.                                                        |
| `RUN_TIMEOUT`              | Run collection deadline reached; time reserved for saving diagnostics.                                |
| `REQUEST_TIMEOUT`          | Source request exhausted retries with a timeout/abort.                                                |
| `REQUEST_FAILED`           | Other HTTP, network or JSON response failure.                                                         |
| `COMMENTS_UNAVAILABLE`     | Source reports disabled/unavailable comments.                                                         |
| `NO_COMMENTS`              | No comments could be read; does not prove the video has none.                                         |
| `CONTINUATION_REPEATED`    | A continuation token repeated; export may be incomplete.                                              |
| `PAGINATION_STALLED`       | Pagination yielded no new comments; export may be incomplete.                                         |
| `DUPLICATE_COMMENT`        | Repeated comment ID was rejected within a video.                                                      |
| `UNUSABLE_COMMENT`         | A row lacks a comment ID or usable text.                                                              |
| `DELIVERY_UNCONFIRMED`     | Dataset write failed; delivery is uncertain and not retried.                                          |
| `NO_KEYWORD_MATCH`         | Filter mode: no scanned comment contained the keywords (information, not a failure; nothing charged). |
| `NO_COMMENT_IN_DATE_RANGE` | Filter mode: no comment inside `oldestCommentDate` (information, not a failure).                      |
| `FILTER_SCAN_LIMIT`        | Filter mode: `maxScannedCommentsPerVideo` stopped the search; later comments were not checked.        |
| `INTERNAL_ERROR`           | Unexpected processing failure.                                                                        |

`OUTPUT.status` and the terminal status message distinguish `SUCCEEDED`, `PARTIAL`,
`NO_RESULTS` and `FAILED`. Access blocks use `FAILED` with `ACCESS_BLOCKED` diagnostics. `OUTPUT.statusMessage` includes accepted count,
rejected diagnostic count and codes, skipped video count, and limit reasons.
`rejectedRows` counts diagnostic records, **not missing comments or failed videos**;
`rejectionReasons` groups those records by code. One failed page is one diagnostic even
when the number of missing comments is unknown. Existing summary counters remain.
`limitReasons` identifies `BUDGET_LIMIT` or `RUN_STOPPED`; zero budget is `NO_RESULTS`
with skipped videos and no source requests. Mixed results remain available as `PARTIAL`.
Reached pages diagnosed only as `NO_COMMENTS` or `COMMENTS_UNAVAILABLE` succeed with zero accepted comments; their diagnostic counts and reasons remain visible. Zero-result batches containing invalid input or source failures fail the Actor. `NO_RESULTS` is reserved for no-attempt results such as zero budget. `ERRORS` is written even when empty.
The Output tab links both records. These are process-attempt counts, not migration totals.

#### Run deadline and diagnostic shutdown

The Actor logs its effective `timeoutAt` and its source. It uses the run environment's
`timeoutAt` when available; otherwise it uses `.actor/actor.json`'s
`defaultRunOptions.timeoutSecs` (3600 seconds), measured from environment `startedAt`
when available or process orchestration start. This fallback cannot detect a shorter
platform override when the environment omits its deadline.

Collection stops 10 seconds before that deadline, reserving time for `ERRORS`, `OUTPUT`
and the terminal message. `OUTPUT` adds `timeoutAt`, `timeoutSource`, `shutdownReserveMs`
and `timedOut`; `RUN_TIMEOUT` appears in diagnostics and limit reasons. Delivered comments
remain available as `PARTIAL`; a timeout with no delivered comments is `FAILED`.
Reached empty pages and invalid/access-blocked inputs retain their documented behavior.
Only accepted comment rows use the existing dataset-item event.

Each closing write gets a share of the remaining time, retaining one second for exit.
A failed or hanging closing write does not prevent attempts at subsequent writes, but
causes the run to fail rather than claiming that finalization succeeded. Remote writes
cannot be recalled: a dataset write that exceeds the collection deadline is marked
`deliveryUnconfirmed`, is not counted as confirmed delivery and is never retried.
If the platform deadline has already passed, persistence cannot be guaranteed.

If you have used this Actor, please leave an honest review on its Apify Store page.

# Actor input Schema

## `videos` (type: `array`):

Enter YouTube video IDs or URLs, one row is returned per comment. Accepts a bare ID (dQw4w9WgXcQ), a watch URL, a shorts URL, or a youtu.be link, e.g. https://www.youtube.com/watch?v=dQw4w9WgXcQ.

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

YouTube's comment endpoint blocks requests from Apify's datacenter IPs, so Apify Proxy is required for this Actor to work on the platform — leave Residential proxy selected (the default) unless you know a datacenter group works for your account. Not needed when running locally with your own IP.

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

Enter the maximum number of comment rows to return per video, e.g. 100. Replies count toward this cap when 'Include replies' is on. Raise this for deep sentiment analysis, lower it to sample large channels cheaply.

## `keywords` (type: `array`):

Optionally enter words or phrases, e.g. your brand or product name. Only comments that contain them are output and charged; scanned comments that do not match are skipped and not charged. Matching ignores case and accents and is a plain substring match. Leave empty to export every comment.

## `keywordMatch` (type: `string`):

Choose whether a comment must contain any one of the keywords or all of them. Used only when keywords are given.

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

Optionally enter a date like 2026-03-01 or an age like 7 days, 2 weeks, 3 months or 1 year. Only comments published on or after it are output and charged. Turns on Newest-first sorting. Uses YouTube's approximate relative times ("3 weeks ago").

## `maxScannedCommentsPerVideo` (type: `integer`):

Enter how many comments (and replies, if enabled) to read per video while looking for keyword or date matches, e.g. 1000. Bounds run time when matches are rare. Used only when a keyword or date filter is set.

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

Keep this off to fetch only top-level comments (fastest, cheapest). Turn it on to also fetch replies to each comment thread — every reply needs one extra request, so runs take longer and replies count toward the per-video cap above.

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

Choose 'top' for YouTube's featured/most-relevant comments first, or 'newest' to get the most recently posted comments first — useful for monitoring what people are saying about a video right now.

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

Enter how many videos to scrape in parallel, e.g. 3. Each parallel request uses its own Apify Proxy session, but YouTube still rate-limits hard, so keep this at 2-3 for large batches to avoid HTTP 429s.

## `language` (type: `string`):

Enter a 2-letter language code YouTube should localize its UI text to, e.g. en. This affects labels like relative-time text ('2 days ago'), not the comments themselves.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "jNQXAC9IVRw"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxCommentsPerVideo": 100,
  "keywordMatch": "any",
  "maxScannedCommentsPerVideo": 1000,
  "includeReplies": false,
  "sortBy": "top",
  "maxConcurrency": 3,
  "language": "en"
}
```

# Actor output Schema

## `comments` (type: `string`):

All scraped comments — download as JSON, CSV, Excel or HTML.

## `summary` (type: `string`):

OUTPUT: status, statusMessage, rejectedRows, rejectionReasons, limitReasons, timeoutAt, timeoutSource, shutdownReserveMs, timedOut and existing counters. RUN_TIMEOUT indicates collection stopped to reserve time for diagnostic writes.

## `errors` (type: `string`):

ERRORS: legacy row fields plus errorCode and human-readable error. Not dataset items.

# 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 = {
    "videos": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "jNQXAC9IVRw"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "maxCommentsPerVideo": 100,
    "includeReplies": false,
    "sortBy": "top",
    "maxConcurrency": 3,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatatools/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 = {
    "videos": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "jNQXAC9IVRw",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "maxCommentsPerVideo": 100,
    "includeReplies": False,
    "sortBy": "top",
    "maxConcurrency": 3,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("webdatatools/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",
    "jNQXAC9IVRw"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxCommentsPerVideo": 100,
  "includeReplies": false,
  "sortBy": "top",
  "maxConcurrency": 3,
  "language": "en"
}' |
apify call webdatatools/youtube-comments-scraper --silent --output-dataset

```

## MCP server setup

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