# YouTube Comments Scraper: New Comments Alerts, Bulk by Video (`accountable_eel/youtube-comments-lookup`) Actor

Scrape YouTube comments for a list of videos, or only new comments since last run as alerts. One row per comment: text, likes, replies, author name and channel ID, pinned and creator flags. No login, no API key, no API quota. Comments to Google Sheets, Slack or n8n. Comments-off videos are free.

- **URL**: https://apify.com/accountable\_eel/youtube-comments-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 comment returneds

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: New Comments Alerts, Bulk by Video

Paste a list of YouTube videos and get one row per comment: the comment text, likes, reply count,
the author's public display name and channel ID, whether the author is verified or is the video's
own creator, whether the comment is pinned, and when it was posted. Scrape comments
**for a list of videos** in one run, or switch on monitoring and get
**only new comments since last run**, so a scheduled task becomes a comment alert for your brand's
videos. No login, no Google API key and
**no API quota**: it reads the same public comments a signed-out visitor sees, live, at request
time.

### Who it's for

A brand or creator team that wants to know what people said under its latest videos in the last
hour, without someone refreshing YouTube Studio: new comments land in Slack, a Sheet or an n8n
workflow on a schedule. A marketer or researcher who needs the top comments on twenty competitor
videos as a table, not twenty browser tabs. A social listening or sentiment pipeline that needs
comment text with a timestamp and an author channel ID in a fixed shape it can feed to a model. And
an agent that already knows which videos matter and needs one HTTP call that answers "what are
people saying under this video right now".

You pay per comment returned and nothing else: a video with comments turned off, a deleted video,
or a monitored video with nothing new costs nothing.

### Why this one

- **Only new comments since last run.** Turn on monitoring and each video's comments are checked
  against the comment IDs earlier runs already delivered. Already-seen comments are dropped before
  billing, so a quiet video costs nothing and your alert step only ever sees fresh comments.
  Memory is per video, so adding this week's upload to the list never re-sends last month's
  comments.
- **Cheap monitoring runs.** Sorted newest first, a monitor stops reading as soon as it reaches a
  comment it has already seen, usually after the first page of 20. It doesn't re-read hundreds of
  old comments every hour.
- **No API quota, no key.** The official YouTube Data API caps you at 10,000 quota units a day
  and needs a Google Cloud project. This reads the public watch page and YouTube's own comment
  feed, so there is no daily quota to budget and nothing to set up.
- **Comments-off videos are free.** A video with comments disabled is detected from the video page
  itself, before any comment request is made, and comes back as a free `NOT_FOUND` row that says
  so.
- **Privacy-minded author fields.** Each comment carries the author's public display name and
  channel ID, plus YouTube's own verified and creator flags. Avatar images and every other author
  detail are deliberately left out.
- **Newest or top.** Newest first for alerts and monitoring, or YouTube's own "Top comments"
  ranking for a one-off export of the most-liked discussion.

### What you get

Every row starts with the same five fields, then the video fields, then one comment.

| Field | Type | Description |
|---|---|---|
| `query` | text | The video you submitted, echoed back |
| `found` | boolean | `true` if the video's comments were read |
| `status` | text | `OK`, or `NOT_FOUND` / `BLOCKED` / `BAD_FORMAT` / `REQUEST_FAILED` on a miss |
| `message` | text | Plain-English reason for a miss, e.g. "Comments are turned off for this video" |
| `scrapedAt` | ISO 8601 datetime | When the video was fetched |
| `videoId` | text | The 11-character video ID |
| `videoTitle` | text | The video's title |
| `videoUrl` | link | The video's watch link |
| `sort` | text | `newest` or `top`, the order YouTube actually applied |
| `totalCommentCount` | number | Comments on the video in total, as YouTube counts them |
| `commentCount` | number | Comments returned for this video in this run (what you're billed for) |
| `newCommentCount` | number | With monitoring: comments not seen on an earlier run. Empty otherwise |
| `monitorStatus` | text | With monitoring: `NEW_COMMENTS`, `NO_NEW_COMMENTS` or `SEEDED` |
| `commentId` | text | YouTube's comment ID |
| `parentCommentId` | text | For a reply, the comment it replies to. Empty for a top-level comment |
| `isReply` | boolean | `true` for a reply |
| `text` | text | The comment text |
| `publishedText` | text | When it was posted, as YouTube shows it ("2 days ago", "3 weeks ago (edited)") |
| `publishedAtApprox` | ISO 8601 datetime | That text turned into a date at fetch time. **Approximate**: "1 year ago" only means 12 to 23 months |
| `likeCount` | number | Likes, as YouTube displays them (319K becomes 319,000) |
| `replyCount` | number | Replies under a top-level comment. Empty on a reply |
| `authorName` | text | The author's public display name (their @handle) |
| `authorChannelId` | text | The author's `UC...` channel ID |
| `authorIsVerified` | boolean | YouTube's verified badge |
| `authorIsCreator` | boolean | The author is the video's own channel |
| `isPinned` | boolean | The comment is pinned by the creator |
| `isNew` | boolean | With monitoring or a named watchlist: first time a run returned it. Empty otherwise |
| `firstSeenAt` | ISO 8601 datetime | With monitoring: the run that first returned it |

Turn off "One row per comment" to get one row per video instead, with the comments grouped in a
`comments` array. You pay per comment either way.

### Price

- **Comment returned**: $0.5 per 1,000 comments

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

1,000 comments cost about **$0.50** on the free plan, and less on a paid Apify plan. You're charged
per comment actually returned, after monitoring and keyword filters: a video with comments off, a
video that no longer exists, or a monitored video with nothing new is never billed. "Most comments
per video" is your budget control.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `videos` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~youtube-comments-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"videos":["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Paste your videos into "YouTube videos", one per line, as a link or a bare video ID.
2) Set "Most comments per video". Leave "Try it first" on for a first look: it reads at most 5
   videos and 20 comments per video.
3) Pick "Newest first" for alerts, or "Top comments" for an export of the most-liked discussion.
   Tick "Include replies" if you want reply threads too.
4) For alerts, tick "Only return comments that are new since the last run" and save the input as a
   Task with a schedule (see "Monitoring" below).

Typical uses: a new-comment alert on your brand's latest videos, exporting comments to Google
Sheets for a sentiment review, collecting the top comments for a list of competitor videos, and a
keyword-filtered comment feed ("refund", "broken", your product name) into Slack.

### Input

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ]
}
```

One video per line: a full link (watch, youtu.be, Shorts, live or embed) or just the 11-character video ID. No login, no API key and no API quota: this reads the same public comments a signed-out visitor sees. Accepted formats: https://www.youtube.com/watch?v=dQw4w9WgXcQ, https://youtu.be/dQw4w9WgXcQ, https://www.youtube.com/shorts/dQw4w9WgXcQ, dQw4w9WgXcQ.

A fuller input, for a monitor that alerts on complaints:

```json
{
  "videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "https://youtu.be/jNQXAC9IVRw"],
  "maxComments": 100,
  "sort": "newest",
  "includeReplies": false,
  "deltaMode": true,
  "skipFirstRun": true,
  "includeKeywords": ["refund", "broken", "doesn't work"]
}
```

### Sample output

By default you get **one row per comment** (turn off "One row per comment" for one row per video):

| query | found | status | videoId | videoTitle | videoUrl | sort | totalCommentCount | commentCount | newCommentCount | monitorStatus | comments | commentId | parentCommentId | isReply | text | publishedText | publishedAtApprox | likeCount | replyCount | authorName | authorChannelId | authorIsVerified | authorIsCreator | isPinned | isNew | firstSeenAt | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| https://www.youtube.com/watch?v=dQw4w9WgXcQ | true | OK | <video id> | <video title> | <video link> | <sort order used> | <comments on the video in total> | <comments returned> | <new comments since last run> | <monitor status> | \<all comments found (full list)> | <comment id> | \<replying to comment id (empty for top-level)> | <is a reply> | <comment text> | \<posted (as youtube shows it)> | \<posted at (approximate)> | <likes> | <replies> | \<author (public display name)> | <author channel id> | <author is verified> | \<written by the video's creator> | <pinned comment> | \<is this comment new?> | <first seen on a run> | 1970-01-01T00:00:00.000Z |

A real row from a live run (2026-09-23, newest first; the pinned comment always leads):

```json
{
  "query": "dQw4w9WgXcQ",
  "found": true,
  "status": "OK",
  "videoId": "dQw4w9WgXcQ",
  "videoTitle": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "sort": "newest",
  "totalCommentCount": 2457522,
  "commentCount": 20,
  "newCommentCount": null,
  "monitorStatus": null,
  "commentId": "Ugzge340dBgB75hWBm54AaABAg",
  "parentCommentId": null,
  "isReply": false,
  "text": "can confirm: he never gave us up",
  "publishedText": "1 year ago",
  "publishedAtApprox": "2025-09-23T17:07:00.951Z",
  "likeCount": 319000,
  "replyCount": 1000,
  "authorName": "@YouTube",
  "authorChannelId": "UCBR8-60-B28hp2BmDPdntcQ",
  "authorIsVerified": true,
  "authorIsCreator": false,
  "isPinned": true,
  "isNew": null,
  "firstSeenAt": null,
  "scrapedAt": "2026-09-23T17:07:00.950Z"
}
```

A video with comments turned off comes back as a single free row:
`{"query": "XqZsoesa55w", "found": false, "status": "NOT_FOUND", "message": "Comments are turned off for this video ..."}`.

### Monitoring: only new comments since last run

Turn on **Only return comments that are new since the last run** and this actor becomes a comment
alert. Each video's comments are checked against the comment IDs earlier runs already delivered,
and anything seen before is dropped before billing. A video with nothing new still returns one
free row with `monitorStatus: NO_NEW_COMMENTS`, so it never silently vanishes. Each run logs a
count like `3 new of 20 comments fetched`.

The first run for a video has nothing to compare against. By default it returns every comment it
reads and remembers them; tick **Seed silently** and it remembers them but returns and bills none,
so alerts start from the next run.

To turn that into an alert:

1. Save your video list as a task with monitoring on and "Newest first".
2. Add a **Schedule** to that task, hourly or daily.
3. Add a webhook on **Run succeeded**, pointing at Slack, n8n, Make or Zapier, or use Apify's
   Google Sheets integration to append each run's rows (comments to Google Sheets, no code).

Memory lives in a named key-value store, `youtube-comments-lookup-delta`, one record per video,
holding up to 5,000 comment IDs. It is kept per video, not per list: add or remove videos freely.
A comment no run has read for 90 days is forgotten. Leave monitoring off but fill in **Watchlist
name** and every comment comes back stamped with `isNew` and `firstSeenAt` for you to filter
yourself.

Sorted newest first with replies off, a monitoring run stops paging at the first page that
contains a comment it has already seen, which is what keeps an hourly monitor cheap. With replies
on it reads the full "Most comments per video" window, so new replies under recent comments are
caught too.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~youtube-comments-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"videos":["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~youtube-comments-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"videos":["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~youtube-comments-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"videos":["{{video}}"]}`, mapping the row's video into the `videos` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "YouTube Comments Scraper: New Comment Alerts | Apify" — the agent will find and run this actor.

### Tips

- For alerts, keep "Most comments per video" at 100 or more on busy videos. A monitor only needs to
  reach the newest comment it already knows, and a bigger window covers a burst between runs.
- `likeCount` and `replyCount` are YouTube's own displayed figures: "319K" becomes 319,000, not an
  exact count.
- `publishedAtApprox` is only as precise as YouTube's wording. Use it to sort and bucket, not to
  audit.
- Keyword filters match the comment text and the author name, case-insensitively. A comment that a
  filter drops is not billed.
- A `BLOCKED` row means YouTube refused the request. Lower "Max concurrency" and try again later.
  A `NOT_FOUND` row says why: comments off, video unavailable, or no comments section.
- The pinned comment is always first in YouTube's feed, whatever the sort. It is flagged
  `isPinned` so you can filter it out.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`youtube-comments-lookup`) | $0.50 per 1,000 comments (free plan, less on paid plans), nothing for a miss | One row per comment with author channel ID, creator/pinned flags, approximate date; newest or top; replies optional; **only new comments since last run** | Signed-out view only; like and reply counts are YouTube's rounded display figures |
| **streamers/youtube-comments-scraper** | Pay per comment, see its Store page | The most-used YouTube comments actor on Apify | No built-in "only new since last run" memory: a monitor re-bills comments you already have |
| **apidojo YouTube comments** | $0.50 per 1,000 comments plus $1 per 1,000 video queries | Comments per video | A per-video fee on top of the per-comment price |
| **YouTube Data API v3** | Free up to 10,000 quota units a day | Official comment threads | Needs a Google Cloud project and key, and a daily quota you have to budget |

Prices for third-party tools are their published figures as of September 2026 and are not tracked
here; check the vendor before relying on the comparison.

### FAQ

**Why does a row say `found: false`?**
The `message` column says why: comments are turned off, the video isn't available, the input
isn't a YouTube video, or YouTube refused the request. None of these are billed.

**Am I charged for comments I already had?**
Not with monitoring on. Already-seen comments are dropped before billing. Without monitoring, every
comment returned is billed.

**How many comments can I get per video?**
Up to 1,000 per video per run, top-level comments and replies together. Set it with "Most comments
per video".

**Does it need my Google account or an API key?**
No. It reads public comments the way a signed-out visitor does. There's no API quota to run out
of.

**How exact is the posted date?**
Approximate. YouTube only shows relative times ("3 weeks ago"), so `publishedAtApprox` is that
text converted to a date at fetch time; `publishedText` keeps YouTube's own wording.

**Is this GDPR-relevant?**
Comments are public, but they are written by people. This actor returns only the author's public
display name and channel ID, never avatars or other profile details. You remain responsible for
how you store and use the data.

**Can I get comments to Google Sheets?**
Yes. Use Apify's Google Sheets integration on the task, or pull the dataset as CSV. Each run
appends one row per comment.

**Can an AI agent call this directly?**
Yes. It's on the Apify MCP server, or call the REST endpoint above from any script or workflow
tool.

### Related actors

- [YouTube Channel Lookup](https://apify.com/accountable_eel/youtube-channel-lookup): subscriber
  count, views and recent uploads for a list of channels. Feed its newest `videoId`s into this
  actor to monitor comments on every new upload.

# Actor input Schema

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

One video per line: a full link (watch, youtu.be, Shorts, live or embed) or just the 11-character video ID. No login, no API key and no API quota: this reads the same public comments a signed-out visitor sees. Accepted formats: https://www.youtube.com/watch?v=dQw4w9WgXcQ, https://youtu.be/dQw4w9WgXcQ, https://www.youtube.com/shorts/dQw4w9WgXcQ, dQw4w9WgXcQ. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

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

You pay per comment returned, so this is also your budget control. Counts top-level comments and replies together. Leave at 100 for a monitor; the first run of a monitor fetches up to this many, later runs usually stop as soon as they reach comments you already have.

## `sort` (type: `string`):

Newest first is what a monitor wants: new comments arrive at the top, so each run reads only as far as it needs. Top comments is YouTube's own ranking, useful for a one-off export of the most-liked discussion.

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

Also read the replies under each comment, each as its own row with 'Replying to comment ID' filled in. Replies count toward 'Most comments per video' and are billed like any other comment.

## `deltaMode` (type: `boolean`):

Turns this actor into a comment monitor. A comment counts as new when its YouTube comment ID has not been returned for that video by an earlier run of the same watchlist. Already-seen comments are dropped and never billed, so your Slack, Sheets or n8n step only sees fresh ones. Memory is kept per video: adding a new video to your list never re-sends the other videos' old comments. The first run returns every comment it reads (or none, with 'Seed silently' on) and remembers them.

## `skipFirstRun` (type: `boolean`):

With monitoring on, the first run for each video remembers every comment it reads but returns and bills none of them. From the next run on you get only comments posted since. Use this when you want alerts, not an initial backlog.

## `deltaName` (type: `string`):

Leave empty for one shared memory per video across all your runs. Type a name to keep a separate memory, for example when two schedules watch the same video for different teams. Naming a watchlist with monitoring off returns every comment but still stamps each with 'Is this comment new?' and 'First seen', so you can filter them yourself in Sheets, n8n or Make. A comment no run has read for 90 days is forgotten.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each comment found gets its own row instead of being grouped under its video. You're still only charged once per video, no matter how many rows it produces.

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

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "maxComments": 100,
  "sort": "newest",
  "includeReplies": false,
  "deltaMode": false,
  "skipFirstRun": false,
  "deltaName": "",
  "columns": [
    "videoId",
    "videoTitle",
    "videoUrl",
    "sort",
    "totalCommentCount",
    "commentCount",
    "newCommentCount",
    "monitorStatus",
    "comments",
    "commentId",
    "parentCommentId",
    "isReply",
    "text",
    "publishedText",
    "publishedAtApprox",
    "likeCount",
    "replyCount",
    "authorName",
    "authorChannelId",
    "authorIsVerified",
    "authorIsCreator",
    "isPinned",
    "isNew",
    "firstSeenAt"
  ],
  "expandRows": true,
  "maxConcurrency": 3,
  "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 = {
    "videos": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/youtube-comments-lookup").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"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/youtube-comments-lookup").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"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/youtube-comments-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/youtube-comments-lookup"
        }
    }
}
```

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/g8bdsgj0L9Ua3LVYn/builds/0uGlkWfztylbr7Mbb/openapi.json