# YouTube Channel Scraper: New Videos, Stats & Comments (`kizukidata/youtube-channel-monitor`) Actor

Monitor YouTube channels without login or API key: recent videos with views, likes, length and comment count, subscribers, and the newest comments. The Only new videos and comments option returns and charges only what is new since your last run. No transcripts. Not affiliated with YouTube or Google.

- **URL**: https://apify.com/kizukidata/youtube-channel-monitor.md
- **Developed by:** [Kizuki](https://apify.com/kizukidata) (community)
- **Categories:** Social media, Videos, AI
- **Security:** 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 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Channel Scraper: New Videos, Stats & Comments

**YouTube Channel Scraper** watches channels and videos **without a login and without an API key**, and returns three kinds of row as **JSON or CSV**: **new videos of a channel** with title, exact publication time, view count, likes, length, hashtags, comment count, thumbnail and description; **channel facts** from the About page (subscribers, total views, video count, description, country, join date, avatar); and the **newest comments** of a video, requested newest first, with the text, author, likes and reply count in a shape a sentiment step can use directly.

With **Only new videos and comments**, the Actor remembers what it already returned per channel and per video, so a scheduled run reads the channel's video list, finds that nothing is new, and returns — and charges — nothing.

It runs in the cloud: no browser, no account, no API key. Status rows (comments turned off, a bot check, an unreadable response) are written for visibility and are **not charged**. This Actor is an independent tool. It is **not affiliated with, endorsed by or sponsored by** YouTube or Google.

### Use cases

- **Creator and competitor monitoring.** A daily run that returns only the videos and comments that arrived since the last one.
- **Engagement tracking.** Views, likes and comment counts per video, kept as a time series.
- **Community sentiment.** Fetch the newest comments of a video and hand them to a summariser or a classifier.
- **Channel research.** Subscriber count, total views, video count and description for a list of channels in one table.
- **Agent and MCP use.** One channel with a small `maxVideosPerChannel` returns a readable list of new uploads.

### What data can you get?

| Row kind | Fields |
|---|---|
| Every row | `type` (`channel`, `video`, `comment`), `id`, `url`, `isNew` (with `onlyNewItems`), `error` |
| `channel` | `channelId`, `handle`, `title`, `subscribers`, `subscriberText`, `totalViews`, `videoCount`, `description`, `country`, `joinedAt`, `avatarUrl` |
| `video` | `videoId`, `title`, `channelId`, `publishedAt`, `publishedText`, `publishedAtIsEstimate`, `views`, `likeCount`, `commentCount`, `durationSeconds`, `isShort`, `hashtags`, `videoStatsReason`, `thumbnailUrl`, `description` |
| `comment` | `commentId`, `videoId`, `videoTitle`, `channelId`, `author`, `authorChannelId`, `text`, `likeCount`, `replyCount`, `publishedText`, `publishedAt`, `publishedAtIsEstimate`, `isPinned`, `isOwner`, `sort` |

Every row has every field; a value a row does not carry is `null`. Comments carry public text and public author names only. Replies themselves are not fetched (their `replyCount` is), and no personal contact data is collected.

`likeCount` is the video's likes on a video row and the comment's likes on a comment row. `commentCount` is the number of comments on the video; `durationSeconds` its length; `isShort` says whether the channel lists it on the Shorts tab (a Short has no length on YouTube's tabs, so `durationSeconds` stays `null`); `hashtags` the `#tags` written in its description (`[]` when there are none). When a row has no likes, length, hashtags or count, `videoStatsReason` says why in a fixed-format sentence.

`subscribers` is approximate because YouTube shows it rounded (`12.3K subscribers`); `subscriberText` keeps the text as shown. A comment has no exact timestamp on YouTube, so `publishedAt` is computed from the relative text (`2 days ago`) and `publishedAtIsEstimate` is `true` in that case; `publishedText` keeps the original text.

### How to use YouTube Channel Scraper

1. Put **Channels** (`channels`: `@handle`, `/channel/` URL, `/c/` or `/user/` URL, or channel ID) and/or **Videos** (`videos`: watch URL, `youtu.be`, Shorts or the 11-character ID) into the input.
2. Choose **what to return**: `videos` (the default: channel and video rows), `comments`, or `both`.
3. Set **videos per channel**, **comments per video** and **comment pages per video** to bound the run.
4. Keep **includeVideoStats** on to have likes, length, hashtags and the comment count on every video row, or turn it off for a large, fast run.
5. Run it. The dataset holds one row per channel, video and comment; the run summary is in the `OUTPUT` record.

An empty input (`{}`) reads one sample video, so the default MCP call returns a row quickly. A channel-only input does not add the sample.

#### Input example

```json
{
    "channels": ["https://www.youtube.com/@TED"],
    "videos": [],
    "mode": "both",
    "includeChannelInfo": true,
    "maxVideosPerChannel": 5,
    "maxCommentsPerVideo": 20,
    "maxCommentPages": 2,
    "onlyNewItems": true,
    "maxItems": 50,
    "includeVideoStats": true
}
```

### Input

| Field | Default | What it does |
|---|---|---|
| `channels` | `[]` | Channel URL, `@handle`, `/c/` or `/user/` URL, or channel ID |
| `videos` | `[]` | Video URLs, Shorts links or 11-character IDs |
| `mode` | `videos` | `videos`, `comments` or `both` |
| `includeChannelInfo` | `true` | Return the channel row (subscribers, views, description) |
| `maxVideosPerChannel` | `5` | Videos per channel, newest first (1 to 15) |
| `maxCommentsPerVideo` | `20` | Comments per video (1 to 100) |
| `maxCommentPages` | `2` | Comment pages per video (1 to 5, about 20 comments per page) |
| `onlyNewItems` | `false` | Return only channels, videos and comments that earlier runs have not returned |
| `maxItems` | `20` | Maximum rows written (1 to 500) |
| `includeVideoStats` | `true` | Add likes, length, hashtags and the comment count to video rows |
| `debugSnapshot` | `false` | Diagnostic snapshot of a page that could not be read. Normally not needed |
| `proxyConfiguration` | direct connection | Proxy settings (country, groups, custom proxy URLs) |

### Output

One row per channel, video and comment. A video whose comments are **explicitly** turned off, a bot-check page or a comment response that is not usable is returned as a row with `error.type` (`comments-disabled`, `bot-check`, `consent`, `comments-unavailable`, `video-unavailable`) and a fixed sentence. Those **status rows are not charged** and are not remembered, so the next run retries the video.

#### Output example

Values below are illustrative; this one is a comment row.

```json
{
    "type": "comment",
    "id": "comment:UgxNEWCOMMENT01",
    "url": "https://www.youtube.com/watch?v=VC4g2l47rzc&lc=UgxNEWCOMMENT01",
    "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
    "videoId": "VC4g2l47rzc",
    "videoTitle": "How Imaginary Worlds Help Every Kid Belong | Anna Rainio | TED",
    "commentId": "UgxNEWCOMMENT01",
    "author": "@alice",
    "authorChannelId": "UC7WUE3coJ7m27rfLscKnu_g",
    "text": "The newest comment on the video.",
    "likeCount": 12,
    "replyCount": 3,
    "publishedText": "51 minutes ago",
    "publishedAt": "2026-11-05T18:55:00.000Z",
    "publishedAtIsEstimate": true,
    "isPinned": false,
    "isOwner": false,
    "sort": "newest",
    "error": null,
    "isNew": true
}
```

### Likes, length and the comment count

`includeVideoStats` (default `true`) adds four fields to every returned video row: likes, length, hashtags and the comment count. The channel's `Videos` tab carries the length of every video on it, so the length costs one read per channel rather than one per row; a video that is not on that tab gets its length from the `Shorts` tab, where a Short has none (`isShort: true`). Likes, the description and the comment count come from a read of the video itself. Requests go out one at a time, at least one second apart:

| Rows | Added time |
|---|---|
| 10 videos (1 channel) | about 25 s |
| 100 videos (1 channel) | about 3.5 min |

The default is on because these four fields give a fuller picture of each returned video; set it to `false` for a large monitor that only needs titles, dates and view counts. A named video already has the fields from its own row, whatever the setting. In `both` mode the comment step reads the video page, but the stats do not, so nothing is read twice. Hashtags need no read of their own: the channel feed's description carries them.

### Newest first, comments and `onlyNewItems`

A comment monitor needs the comments that arrived since the last run, not the all-time top comments. The Actor asks for YouTube's **Newest** sort when available. `sort` on each comment row says which order was used (`newest`, or `top` when YouTube offered no sort menu).

`onlyNewItems` keeps a per-input state record in a named key-value store (per channel for videos, per video for comments) for 90 days. A row is remembered only after it was written and charged; a status row is not remembered. The state key includes the mode, so a `videos` run never hides the comments of a later `comments` run. Do not run the same input concurrently: both runs read the old state and both return the same new rows.

Up to `maxCommentPages` pages are read per video (about 20 comments per page). If a video receives more new comments than that between two runs, raise `maxCommentPages` (up to 5) or run more often; comments beyond the pages read are not returned.

### How much does it cost?

YouTube Channel Scraper uses **pay-per-event** pricing: you pay only for the rows returned, not for the time it runs. At the Free tier 1,000 rows cost $1.10; at Gold, $0.60.

| Apify plan (discount tier) | Price per 1,000 rows | Price per row |
|---|---|---|
| **Free** | $1.10 | $0.0011 |
| **Starter (Bronze)** | $1.00 | $0.001 |
| **Scale (Silver)** | $0.80 | $0.0008 |
| **Business (Gold)** | $0.60 | $0.0006 |

Apify's Free plan includes USD 5 of monthly usage, which covers about 4,545 rows at the Free tier price, run
start fees aside.

- **Run start fee**: the platform default per run (see the Pricing tab).
- Status rows (comments turned off, bot check, consent, unreadable response) are written but **not charged**.
- Rows beyond `maxItems`, videos beyond `maxVideosPerChannel` and comments beyond `maxCommentsPerVideo` are not fetched and **not charged**.
- With `onlyNewItems`, unchanged channels and videos already returned are **not charged**.

### Use with AI agents (MCP)

YouTube Channel Scraper works as a tool for AI agents such as Claude, Cursor and n8n agents through the Apify MCP server. Load only this Actor with this server URL:

```text
https://mcp.apify.com?tools=kizukidata/youtube-channel-monitor
```

- **Claude Code**: run `claude mcp add apify "https://mcp.apify.com?tools=kizukidata/youtube-channel-monitor" -t http`.
- **Claude (web or desktop app)**: open **Customize → Connectors**, choose **Add custom connector**, name it `Apify` and paste the server URL above.
- **Cursor**: add the server to `~/.cursor/mcp.json` (or `.cursor/mcp.json` in a project):

```json
{
    "mcpServers": {
        "apify": { "url": "https://mcp.apify.com?tools=kizukidata/youtube-channel-monitor" }
    }
}
```

- **n8n**: add the Apify node (on self-hosted n8n, install the community package `@apify/n8n-nodes-apify`) and choose **Run an Actor and get dataset**; for an n8n AI Agent, add **Apify Tool** as a tool.

The server signs you in to Apify with OAuth. A client that cannot use OAuth can send your Apify API token in an `Authorization: Bearer <APIFY_TOKEN>` header instead.

#### What to send from an agent

Pass one channel and a small `maxVideosPerChannel` (or one video with `mode: "comments"`); the result is the dataset URL. `{}` returns the one sample video. `maxItems` bounds the rows written, and only data rows are charged. Keep `maxItems` small (the default is 20) so the call returns inside the MCP timeout.

### Integrations and API

Run the Actor from your own code or from an automation tool. Replace `<APIFY_TOKEN>` with your API token.

#### Zapier, Make and n8n

Use the Apify integration, choose **Run Actor**, and pass one channel plus `onlyNewItems: true`. Add **Get dataset items** and use the new comment rows as the trigger for a Slack message, a sheet row or an AI summary step. A daily schedule is usually enough for a channel monitor.

#### LangChain

Load the comment rows as documents: `text` as `page_content`; `author`, `videoTitle`, `likeCount`, `publishedAt` and `url` as metadata. Because the rows are already newest-first and carry the relative time, a summariser can group by `videoId` and describe what people said since the previous run.

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/kizukidata~youtube-channel-monitor/runs" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"channels":["https://www.youtube.com/@TED"],"mode":"comments","maxVideosPerChannel":1,"onlyNewItems":true}'
```

Poll `GET https://api.apify.com/v2/actor-runs/<RUN_ID>` for the status, read `defaultDatasetId`, then fetch `GET https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json`.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("kizukidata/youtube-channel-monitor").call(run_input={"channels": ["https://www.youtube.com/@TED"], "mode": "comments", "maxVideosPerChannel": 1})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["type"] == "comment":
        print(item["author"], item["text"][:80])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('kizukidata/youtube-channel-monitor').call({ videos: ['dQw4w9WgXcQ'], mode: 'comments', maxCommentsPerVideo: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((row) => row.type === 'comment').map((row) => row.text));
```

### Limitations

- **No login, no cookies, no API key.** Only publicly accessible video and channel metadata are requested, and nothing is written to YouTube.
- **No browser and no video or audio download.** The channel listings, the About metadata and the video pages are fetched; the media is not.
- **No replies and no writes**: no likes, favourites or subscriptions. Replies themselves are not fetched, only their count.
- **Video lists**: a channel's feed lists about 15 recent videos, and one run returns at most that many per channel (`maxVideosPerChannel`, 1 to 15). Some channels no longer answer it (404); for them the channel's own video list is read instead, which gives the title, a relative age (the row flags the date as an estimate) and a rounded view count, and has no description or thumbnail.
- **Comment timestamps are estimates**: YouTube shows relative text, not an exact time, so `publishedAt` is computed and `publishedAtIsEstimate` says so.
- A request that is challenged is retried once; an unreadable comment section becomes an uncharged `bot-check` row rather than a silent gap.
- Each run writes an `OUTPUT` record with the counts, the enrich-request totals and the reasons behind uncharged rows.

### FAQ

#### Do I need a YouTube API key?

No. The Actor reads public channel and video pages; there is no key to create, no quota to manage and no account to connect.

#### Why is `publishedAt` marked as an estimate on some rows?

YouTube shows a relative age (`2 days ago`) for comments, and some channel listings give a relative age too. The Actor computes a timestamp from it and sets `publishedAtIsEstimate: true`; `publishedText` keeps the original wording.

#### Why did a row come back with `error`?

The comment section is turned off for that video, YouTube answered with a bot check or a consent page, or the response was not usable. The row says which, it is **not charged**, and the next run retries it.

#### Can I get only new videos and comments since the last run?

Yes: set `onlyNewItems` to `true`, save the input as a Task and schedule it. See **Newest first, comments and `onlyNewItems`**.

#### Is it legal to use this data?

The Actor reads public channel listings, public About metadata and public video pages, without logging in. YouTube's Terms of Service prohibit accessing the service with automated means except as authorised, and whether your use is permitted is your decision. Comment rows contain public usernames and text, which can be personal data under the GDPR and similar laws; handle them accordingly. This is not legal advice.

### Related Kizuki Actors

Other Actors from Kizuki that work well with this one:

- [YouTube Transcript Scraper](https://apify.com/kizukidata/youtube-transcripts) — the spoken text of those videos, with timestamps and chunks.
- [Google News Scraper](https://apify.com/kizukidata/google-news-feed) — news coverage of the same brands and topics.

### Your feedback

Bugs, a field that stopped coming back, and feature requests go to the Actor's **Issues** tab in Apify Console. A channel owner who wants a channel left out can open an Issue with the channel URL and the reason: the opt-out is recorded in the Actor source and applied in the next build, and a request from a third party is not applied.

# Actor input Schema

## `channels` (type: `array`):

YouTube channels: an @handle, a /channel/ URL, a /c/ or /user/ URL, or a channel ID. Up to 20 per run. The recent videos are read from the channel's public feed (about 15, newest first); for a channel whose feed answers 404 they are read from the channel's video list, with an estimated date and a rounded view count, and the subscriber count, total views and description from the About page. Entries that are not a channel are skipped and listed in OUTPUT.

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

Specific videos: a watch URL, a youtu.be link, a Shorts link or the 11-character ID. Up to 100 per run. Useful for the comments of one video without naming its channel. When both Channels and Videos are empty, one sample video is used.

## `mode` (type: `string`):

videos: channel rows and the recent videos from the channel's video list. comments: the newest comments of the named channels' recent videos and of the named videos. both: videos and comments in one run. comments is the mode for a comment monitor, because it reads one video page per video.

## `includeChannelInfo` (type: `boolean`):

Read the About page once per channel and return one channel row with the subscriber count, total views, video count, description, country and join date. Turn it off to skip that page read. Comments mode never returns channel rows.

## `maxVideosPerChannel` (type: `integer`):

How many of the channel's recent videos to return (and, in comments mode, how many video pages to read), from 1 to 15. The feed holds about 15. maxItems still bounds the whole run.

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

How many comments to return per video, from 1 to 100. Comments are requested newest first, so the newest comments arrive first. maxItems bounds the whole run.

## `maxCommentPages` (type: `integer`):

How many pages of comments to read per video, from 1 to 5 (about 20 comments per page). More pages cost more requests; raise it when a video receives many comments between runs.

## `onlyNewItems` (type: `boolean`):

Skip videos and comments that an earlier run with the same input already returned. State is kept per channel and per video in a named key-value store for 90 days. Status rows are not remembered, so a video that was blocked or comment-less is retried.

## `maxItems` (type: `integer`):

Maximum rows written in one run, from 1 to 500. Channel rows, video rows, comment rows and uncharged status rows share this budget, so the dataset never holds more than maxItems rows. Only rows with data are charged.

## `includeVideoStats` (type: `boolean`):

Read the likes, length, description hashtags and comment count of each returned video, and whether it is a Short. This costs the channel's Videos tab (about 1.5 MB), its Shorts tab (about 1.3 MB) when a returned video is a Short, and one or two small responses (about 0.65 MB) per video row: 100 videos take roughly 3 to 4 minutes. Turn it off for a large monitor that only needs titles, dates and view counts; the fields are then null, with videoStatsReason saying why.

## `debugSnapshot` (type: `boolean`):

Diagnostic. Saves a page snapshot when a video page has unreadable comments. Normally not needed; snapshots are never in the dataset and never charged.

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

Proxy settings. The default is a direct connection; a datacenter proxy is available when a page has to be read from another country.

## Actor input object example

```json
{
  "channels": [
    "https://www.youtube.com/@TED"
  ],
  "videos": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "mode": "videos",
  "includeChannelInfo": true,
  "maxVideosPerChannel": 5,
  "maxCommentsPerVideo": 20,
  "maxCommentPages": 2,
  "onlyNewItems": false,
  "maxItems": 20,
  "includeVideoStats": true,
  "debugSnapshot": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Channel, video and comment rows returned by this run.

## `runSummary` (type: `string`):

Status code, counters and skipped input entries of this run.

# 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 = {
    "channels": [],
    "videos": [],
    "mode": "videos",
    "includeChannelInfo": true,
    "maxVideosPerChannel": 5,
    "maxCommentsPerVideo": 20,
    "maxCommentPages": 2,
    "onlyNewItems": false,
    "maxItems": 20,
    "includeVideoStats": true,
    "debugSnapshot": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kizukidata/youtube-channel-monitor").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 = {
    "channels": [],
    "videos": [],
    "mode": "videos",
    "includeChannelInfo": True,
    "maxVideosPerChannel": 5,
    "maxCommentsPerVideo": 20,
    "maxCommentPages": 2,
    "onlyNewItems": False,
    "maxItems": 20,
    "includeVideoStats": True,
    "debugSnapshot": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kizukidata/youtube-channel-monitor").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 '{
  "channels": [],
  "videos": [],
  "mode": "videos",
  "includeChannelInfo": true,
  "maxVideosPerChannel": 5,
  "maxCommentsPerVideo": 20,
  "maxCommentPages": 2,
  "onlyNewItems": false,
  "maxItems": 20,
  "includeVideoStats": true,
  "debugSnapshot": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kizukidata/youtube-channel-monitor --silent --output-dataset

```

## MCP server setup

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

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/PqDFuCIowEy50TfMO/builds/n8ivD3phxw2GRXFZt/openapi.json