# YouTube Comments Scraper: Replies, Shorts & Channels (`panix/youtube-comments-scraper`) Actor

Scrape YouTube comments and replies from videos, Shorts, channels, playlists or searches: likes, pinned and creator-heart flags, authors, video title. Keyword, likes and date filters, only-new monitoring. No API key. For brand monitoring, sentiment analysis and research.

- **URL**: https://apify.com/panix/youtube-comments-scraper.md
- **Developed by:** [PANIX AI LAB](https://apify.com/panix) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 comments

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, Shorts and whole channels

Find out what viewers really say. Export YouTube comments and replies from videos, Shorts, whole channels or search results into a spreadsheet for sentiment analysis, product research or an AI model.

- **Rich comment rows**: text, author, likes, reply count, date, pinned and "hearted by creator" flags, and a direct link to each comment.
- **Whole channels and searches in one run**, with the video's title, views and comment count on every row.
- **No YouTube account, Google API key or quota.** Monitoring runs return only new comments.

**Try it now:** the input is already filled in (one video, 50 comments). Click **Start** and the results appear in a table you can export to Excel, CSV or JSON. That example run costs a few cents, which the $5 of free monthly credit on Apify's free plan covers.

**Price:** from **$0.60 per 1,000 comments**, and you pay only for results you get. The full price table is in the Pricing section below.

### Example result

One result, shortened. Every field is described in the Output section below.

```json
{
  "commentId": "UgzuC3zzpRZkjc5Qzsd4AaABAg",
  "text": "We're so honored that the first ever YouTube video was filmed here!",
  "publishedAt": "2020-11-09T12:54:38Z",
  "likeCount": 4800000,
  "replyCount": 1000,
  "isPinned": true,
  "isHeartedByCreator": true,
  "authorName": "@SanDiegoZoo",
  "commentUrl": "https://www.youtube.com/watch?v=jNQXAC9IVRw&lc=UgzuC3zzpRZkjc5Qzsd4AaABAg",
  "videoTitle": "Me at the zoo",
  "videoViewCount": 389000000,
  "videoCommentCount": 10646286
}
```

### What you get

Scrape **YouTube comments and replies** from videos, **Shorts**, live-stream replays, **whole channels**, playlists or **search results** into clean rows: comment text, author and author channel, likes, reply count, **pinned** and **hearted by creator** flags, edited flag, date, a direct comment link, and the video's title, channel, views and exact comment count. It reads YouTube the way a logged-out visitor does, so you need **no YouTube account, no Google API key and no quota**.

You pay only for comments you get. Comments left out by your filters, duplicates, comments already delivered in earlier monitoring runs, and videos with comments turned off are free.

### What it does

1. Opens each video or Short you paste, or the newest videos of a channel, the videos of a playlist, or the top videos of a YouTube search.
2. Reads the comments in YouTube's **Top** or **Newest** order, 20 per page, as deep as you ask (millions of comments on big videos).
3. With **Include replies** on, adds the replies under each comment right after it.
4. Applies your filters: words or phrases the comment must contain, minimum likes, comments newer than a date.
5. Delivers one row per comment or reply to the dataset (JSON, CSV, Excel, Google Sheets, API), with a status line per video and per input.
6. With **Only new comments** on, scheduled runs return just the comments posted since the last run.

### Who uses it

- **Brand and social media teams**: track what people say about your product, or a competitor's, under review videos and launch videos, every day or week.
- **Market and product research**: collect feedback, feature requests and complaints from comment sections at scale ("battery", "price", "refund").
- **Sentiment analysis and AI/LLM teams**: comment text with likes and threads as training data, RAG input or for classification, from the API or the Apify MCP server.
- **Creators and agencies**: export a channel's comments, find the most-liked questions, see which comments you pinned or hearted, spot repeat commenters.
- **Influencer marketing**: check the audience reaction under a creator's sponsored videos before you book them.
- **Academic and media researchers**: public discussion around news, politics, music or games, with dates and engagement.
- **Moderation and trust and safety**: pull new comments from your videos on a schedule and flag spam or abuse.

### Why this YouTube comments scraper

- **Videos, Shorts, channels, playlists and searches in one Actor.** Paste a channel (`@TED`) and get the comments of its 10 newest videos (or Shorts, or past live streams). Paste a playlist or type a search term and get the comments of its videos. Any mix of inputs works in one run.
- **Replies included when you want them**, placed right after their comment, with `parentCommentId` and a per-comment replies cap.
- **Past YouTube's Top-comments limit.** YouTube's Top list ends after about 1,000 comments. When you ask for more, the Actor continues with the Newest list and skips duplicates, so large exports don't stop early.
- **Pinned, hearted and creator flags.** `isPinned`, `isHeartedByCreator`, `authorIsVideoCreator`, `authorIsVerified` and `authorIsArtist` on every row.
- **Video context on every row.** Video title, type (video or Short), channel, publish date, views, likes and the **exact comment count** (e.g. 2,461,539), so rows from many videos stay readable in one sheet.
- **Filters you don't pay for.** Keep only comments that contain your keywords, have at least N likes, or are newer than a date. Left-out comments are free.
- **Monitoring built in.** *Only new comments* remembers what each video delivered and returns only new comments on scheduled runs, so a daily brand-monitoring run costs cents.
- **Date cut-off that saves money.** With *Comments published after*, each video is read newest first and stops at the first older comments instead of paging through years of history.
- **Fast and cheap.** Plain HTTP on Apify datacenter proxies, no browser, 512 MB, 8 videos in parallel. In our tests 1,000 comments with replies took under 20 seconds.
- **Clear runs.** Unavailable videos and videos with comments turned off come back as **free error rows** with the reason, never as a failed run. `VIDEOS` shows each video's comment count, pages read and why it stopped.

### Coming from another YouTube comments scraper?

| Common problem in this category | How this Actor handles it |
|---|---|
| Only single video links are accepted | Channels, playlists, searches, Shorts and IDs work too |
| Replies missing, or mixed in without their parent | Optional replies, right after their comment, with `parentCommentId` |
| No way to tell pinned or creator-hearted comments | `isPinned`, `isHeartedByCreator`, `authorIsVideoCreator` on every row |
| Rows don't say which video they belong to | Video title, channel, views and comment count on every row |
| Paying for comments you filter out afterwards | Keyword, likes and date filters run before charging |
| Scheduled runs return the same comments again | *Only new comments* returns only new ones |
| A video with comments turned off fails the run | Free error row with the reason; the run continues |
| Exports stop at about 1,000 comments (YouTube's Top list ends) | Continues through the Newest list for the rest |
| Per-query or per-video fees on top of the comment price | No per-video fee: you pay per delivered comment |

### How to use it

1. Paste **YouTube links**: videos, Shorts, channels (or @handles), playlists, search pages. Or type **Search terms**.
2. Set **Max comments per video** and choose **Top comments** or **Newest first**.
3. Turn on **Include replies** if you want the threads.
4. For channels, playlists and searches, set **Max videos** (default 10) and the **Channel tab** (videos, Shorts or live streams).
5. Click **Start**, then download the dataset or connect it to Google Sheets, Make, n8n, Zapier or your code.

For daily monitoring: add your videos or channels, turn on **Only new comments**, give it a **Monitor name**, and create a schedule (Schedules -> Create new).

### Input examples

The top 500 comments of one video:

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

`startUrls` takes plain strings (links, video IDs, @handles) or `{ "url": "..." }` objects, so inputs written for other YouTube Actors work too.

Comments and their replies (up to 10 per comment) on a Short:

```json
{
  "startUrls": ["https://www.youtube.com/shorts/XZZ9gGpeSq4"],
  "includeReplies": true,
  "maxRepliesPerComment": 10,
  "maxComments": 300
}
```

The newest comments on a channel's 5 latest videos, from the last 7 days:

```json
{ "startUrls": ["@mkbhd"], "maxVideos": 5, "publishedAfter": "7 days", "maxComments": 1000 }
```

Feedback mentioning price or battery under the top 20 review videos for a product:

```json
{
  "searchTerms": ["iphone 17 review"],
  "maxVideos": 20,
  "keywords": ["price", "battery", "too expensive"],
  "maxComments": 2000
}
```

Daily brand monitor that returns only comments posted since the last run:

```json
{
  "startUrls": ["@yourchannel", "https://www.youtube.com/watch?v=VIDEO_ID"],
  "maxVideos": 10,
  "onlyNewComments": true,
  "monitorName": "my-brand",
  "maxComments": 2000
}
```

### Output

A comment row:

```json
{
  "type": "comment",
  "commentId": "UgzuC3zzpRZkjc5Qzsd4AaABAg",
  "parentCommentId": null,
  "text": "We're so honored that the first ever YouTube video was filmed here!",
  "publishedTimeText": "6 years ago",
  "publishedAt": "2020-11-09T12:54:38Z",
  "isEdited": false,
  "likeCount": 4800000,
  "likeCountExact": false,
  "replyCount": 1000,
  "isPinned": true,
  "isHeartedByCreator": true,
  "authorName": "@SanDiegoZoo",
  "authorChannelId": "UCYBAWs7r4_wbqL2C_LwOpVQ",
  "authorChannelUrl": "https://www.youtube.com/@SanDiegoZoo",
  "authorAvatarUrl": "https://yt3.ggpht.com/...=s88-c-k-c0x00ffffff-no-rj",
  "authorIsVerified": true,
  "authorIsVideoCreator": false,
  "authorIsArtist": false,
  "commentUrl": "https://www.youtube.com/watch?v=jNQXAC9IVRw&lc=UgzuC3zzpRZkjc5Qzsd4AaABAg",
  "rank": 1,
  "sortedBy": "top",
  "videoId": "jNQXAC9IVRw",
  "videoUrl": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "videoTitle": "Me at the zoo",
  "videoType": "video",
  "videoChannelName": "jawed",
  "videoChannelId": "UC4QobU6STFB0P71PMvOGN5A",
  "videoChannelHandle": "@jawed",
  "videoPublishedDate": "2005-04-23",
  "videoViewCount": 389000000,
  "videoLikeCount": 18000000,
  "videoCommentCount": 10646286,
  "input": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "scrapedAt": "2026-11-08T12:54:42Z"
}
```

A reply row has `"type": "reply"`, the parent's ID in `parentCommentId`, `rank` = its position in the thread and `"sortedBy": "thread"`.

A free error row (not charged):

```json
{
  "type": "error",
  "videoId": "qXcMNBQnQMM",
  "videoUrl": "https://www.youtube.com/watch?v=qXcMNBQnQMM",
  "videoTitle": "Wheels on the Bus | CoComelon Nursery Rhymes",
  "errorCode": "comments_off",
  "error": "Comments are turned off. Learn more",
  "input": "cocomelon nursery rhymes"
}
```

#### Main fields

| Field | What it is |
|---|---|
| `type` | `comment`, `reply` or `error` (free) |
| `commentId`, `parentCommentId`, `commentUrl` | YouTube's comment ID, the parent comment for replies, a link that opens the video at this comment |
| `text` | The comment as written (emoji and line breaks kept) |
| `publishedTimeText`, `publishedAt` | YouTube's "3 days ago" label and the date it points to (approximate: YouTube rounds down) |
| `likeCount`, `likeCountExact` | Likes. YouTube shows big numbers rounded ("71K"); `likeCountExact` is false then |
| `replyCount` | Replies under the comment (comment rows) |
| `isPinned`, `isHeartedByCreator`, `isEdited` | Pinned by the creator, hearted by the creator, edited |
| `authorName`, `authorChannelId`, `authorChannelUrl`, `authorAvatarUrl` | Who wrote it (public YouTube handle and channel) |
| `authorIsVerified`, `authorIsVideoCreator`, `authorIsArtist` | Verified badge, the video's own channel, official artist channel |
| `rank`, `sortedBy` | Position in Top or Newest order (replies: in their thread) |
| `videoId`, `videoUrl`, `videoTitle`, `videoType` | The video or Short |
| `videoChannelName`, `videoChannelId`, `videoChannelHandle` | The video's channel |
| `videoPublishedDate`, `videoViewCount`, `videoLikeCount`, `videoCommentCount` | Video stats; the comment count is exact |
| `input` | The link, channel or search term that led to this video |

The Output tab has views for **Comments**, **Authors**, **Videos and threads** and **Videos without readable comments**. The key-value store has `VIDEOS` (one status line per video), `INPUTS` (one per input) and `SUMMARY` (totals, comments left out per filter, request statistics).

### Pricing

Pay per event, no monthly fee:

| Event | Free plan | Starter (Bronze) | Scale (Silver) | Business (Gold) and up |
|---|---|---|---|---|
| Comment or reply (per 1,000) | $1.00 | $0.80 | $0.70 | $0.60 |
| Actor start (per run, per GB of memory) | $0.001 | $0.001 | $0.001 | $0.001 |

Free: comments left out by filters, duplicates, comments already delivered in earlier *Only new comments* runs, error rows for unavailable videos or videos with comments turned off, and channel, playlist or search pages. With the default 512 MB a run pays one start event. Set a spending limit on the run and the Actor stops before it.

Examples on the Starter plan: the top 1,000 comments of a video cost $0.80 plus $0.001; 100 comments on each of a channel's 10 newest videos cost $0.80; a daily monitor that finds 30 new comments costs $0.025 per day.

### Use it from code, n8n, Make, Zapier and AI agents

Python ([apify-client](https://pypi.org/project/apify-client/) 3.x):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("panix/youtube-comments-scraper").call(run_input={
    "startUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "maxComments": 200,
    "includeReplies": True,
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    if row["type"] != "error":
        print(row["likeCount"], row["authorName"], row["text"][:80])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('panix/youtube-comments-scraper').call({
    startUrls: ['@TED'], maxVideos: 3, maxComments: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.type === 'comment').map((r) => [r.videoTitle, r.likeCount, r.text]));
```

One HTTP call that runs the Actor and returns the rows (n8n HTTP Request node, Make HTTP module, any script):

```
POST https://api.apify.com/v2/acts/panix~youtube-comments-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>
Content-Type: application/json

{"startUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "maxComments": 50}
```

n8n, Make and Zapier also have Apify apps: choose **Run Actor**, pick `panix/youtube-comments-scraper`, paste the input JSON, then read the dataset items. AI agents can call it through the Apify MCP server (`https://mcp.apify.com`).

### FAQ

**Do I need a YouTube API key?** No. The Actor reads the comments YouTube shows to every logged-out visitor. No Google account, API key or daily quota.

**How many comments can I get from one video?** As many as YouTube shows, 20 per page. Set **Max comments per video** up to 100,000. YouTube's Top list stops after roughly 1,000 comments; when you ask for more, the Actor carries on through the Newest list and skips the ones it already has, so you still get the rest (those rows say `"sortedBy": "newest"`).

**Are like counts exact?** Below 1,000 they are exact. Above that YouTube shows rounded numbers such as "71K" or "4.8M"; the Actor converts them to numbers and sets `likeCountExact` to false.

**How exact are the comment dates?** YouTube only shows "2 days ago" or "6 years ago". `publishedAt` is the date that label points to, so it is precise for recent comments and approximate for old ones. `publishedTimeText` keeps YouTube's label.

**Do replies count toward Max comments per video?** Yes. A video with Max comments 100 and replies on returns 100 rows in total: comments, each followed by its replies.

**How does Only new comments work?** The Actor reads each video newest first and remembers the comment IDs it delivered in a key-value store in your account (`youtube-comments-memory`, or `youtube-comments-memory-<monitor name>`). The next run returns only comments it hasn't delivered before and stops at the first already-known ones. With replies on, replies are read for new comments only.

**Why did a video return an error row?** Its comments are turned off (common on made-for-kids videos), the video is private or removed, or it is an upcoming or live stream (YouTube shows live chat instead of comments). Error rows are free.

**Can I scrape live chat or community posts?** Not yet; this Actor reads video and Shorts comments.

### Limits

- Public comments only. Comments held for review, deleted comments and members-only videos are not visible logged out.
- Dates are relative ("3 weeks ago"), so date filters and `publishedAt` are approximate for older comments.
- YouTube decides the Top order and can change it between visits.
- Like counts above 1,000 are rounded by YouTube.
- YouTube changes its site at times. If a field stops filling, open an issue.

### Data and legal

The Actor collects comments that YouTube shows to every visitor. Author names are public YouTube handles and channel links; no email addresses, phone numbers or other contact data are collected. You are responsible for using the data lawfully, including YouTube's terms and data protection laws such as the GDPR where they apply. This Actor is not affiliated with YouTube or Google.

### Support

Open an issue on the Actor's **Issues** tab with the run ID; it is answered quickly. Feature requests are welcome.

# Actor input Schema

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

One per line: videos, Shorts, live-stream replays, channels (@handle or link; reads the channel's newest videos), playlists or YouTube search pages. Bare video IDs work too.

## `searchTerms` (type: `array`):

Read the comments of the top videos YouTube finds for each term (Max videos per channel, playlist or search sets how many).

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

Most rows to return per video, replies included. Huge videos have millions of comments; YouTube serves 20 per page.

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

Top comments (YouTube's ranking, most liked and discussed first) or newest first.

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

Also return the replies under each comment, right after their comment. Replies count toward Max comments per video.

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

Most replies to read under one comment (when Include replies is on).

## `maxVideos` (type: `integer`):

How many videos to read comments from for each channel (newest first), playlist or search term. Single video links always count as one video.

## `channelTab` (type: `string`):

Which channel videos to read: regular videos, Shorts or past live streams. A pasted channel link that ends in /shorts or /streams uses that tab.

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

Keep only comments (and replies) that contain at least one of these words or phrases, not case-sensitive. Comments left out are free.

## `minLikes` (type: `integer`):

Leave out comments with fewer likes.

## `publishedAfter` (type: `string`):

Only comments newer than this: YYYY-MM-DD or a relative time such as "7 days" or "2 weeks". Comments are then read newest first and each video stops at the first older ones, so runs stay short. YouTube shows comment dates as "3 days ago", so the cut-off is approximate.

## `onlyNewComments` (type: `boolean`):

For scheduled runs: return only comments that earlier runs with this option did not return. Comment IDs are remembered per video in your key-value store "youtube-comments-memory". The first run returns the newest comments up to Max comments per video.

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

Optional: keep separate memories for different schedules (e.g. "brand-a"), stored as youtube-comments-memory-<name>.

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

How many videos are read at the same time.

## `country` (type: `string`):

Two-letter country code YouTube uses for search results, e.g. US, GB, IN, DE.

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

Apify Proxy (datacenter) is used by default and works for comments. Requests that keep getting blocked move to residential IPs when your account has them.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "maxComments": 50,
  "sortBy": "top",
  "includeReplies": false,
  "maxRepliesPerComment": 20,
  "maxVideos": 10,
  "channelTab": "videos",
  "onlyNewComments": false,
  "maxConcurrency": 8,
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Delivered comments and replies, plus free error rows (type "error") for unavailable videos and videos with comments turned off.

## `videos` (type: `string`):

Title, comment count, pages read, comments delivered and why each video stopped.

## `inputs` (type: `string`):

Videos found and read, comments and replies delivered per link, channel, playlist or search.

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

Totals, comments left out per filter, failed videos, request statistics and warnings.

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

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

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

```

## MCP server setup

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