# ⚡ Fast YouTube Channel Scraper (`citrine_venus/fast-youtube-channel-scraper`) Actor

Fast YouTube Channel Scraper: extract Videos, Shorts & Live from any channel URL or @handle — exact views, likes, comments, tags, category, transcripts, engagement rate & outlier score. No YouTube API key or quota. Bulk scrape into a clean Apify dataset.

- **URL**: https://apify.com/citrine\_venus/fast-youtube-channel-scraper.md
- **Developed by:** [Data Minds](https://apify.com/citrine_venus) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ⚡ Fast YouTube Channel Scraper — Videos, Shorts, Live, Stats & Insights

**Fast YouTube Channel Scraper** is a production-grade [Apify Actor](https://docs.apify.com/platform/actors) built for one job: turn a list of **YouTube channel links** into clean, structured **video and channel data** — no official Data API key or daily quota needed. Paste channel URLs or `@handles`, pick how many Videos / Shorts / Live streams you want per channel, and every finished result is **streamed straight to your Dataset** the moment it's ready.

> 💡 **Need a custom version, private integration, or a tailored pipeline?** Email **<hello.dataminds@gmail.com>**.

Built for **content & trend researchers**, **marketers & SEO teams**, **creator/influencer outreach**, **competitor benchmarking**, **social listening** and **AI/LLM data pipelines** — anyone who needs *"every recent upload from these channels, with exact stats, as clean rows"* without fighting API quotas or scrolling by hand.

***

### 📑 Table of contents

- [What is Fast YouTube Channel Scraper?](#-what-is-fast-youtube-channel-scraper)
- [Main features](#-main-features)
- [Who is this Actor for?](#-who-is-this-actor-for)
- [What the scraper does](#%EF%B8%8F-what-the-scraper-does)
- [Inputs it accepts](#-inputs-it-accepts)
- [Output format (Dataset)](#-output-format-dataset)
- [Example output (JSON)](#-example-output-json)
- [Quick start](#-quick-start)
- [Input parameters reference](#%EF%B8%8F-input-parameters-reference)
- [Reliability & anti-blocking](#%EF%B8%8F-reliability--anti-blocking)
- [Integrations & automation](#-integrations--automation)
- [Pricing & how to control cost](#-pricing--how-to-control-cost)
- [Frequently asked questions (FAQ)](#-frequently-asked-questions-faq)
- [Troubleshooting](#%EF%B8%8F-troubleshooting)
- [Help, support & custom builds](#-help-support--custom-builds)
- [Is scraping YouTube legal?](#%EF%B8%8F-is-scraping-youtube-legal)
- [SEO keywords targeted](#-seo-keywords-targeted)

***

### ⚡ What is Fast YouTube Channel Scraper?

The official YouTube Data API meters everything in daily quota units, hides fields you actually want (no outlier/virality signal, no sponsor detection, no easy Shorts-vs-Live split), and still needs a Google Cloud key to set up. This Actor is a drop-in, quota-free alternative purpose-built around **channels**:

- **Accepts any channel link** — `@handle`, `/channel/UC…`, `/c/…`, `/user/…`, or a bare handle/ID — bulk input supported.
- **Reads Videos, Shorts and Live tabs independently**, each with its own max-results limit and sort order (Newest / Popular / Oldest).
- **Returns the full video record** — exact view/like/comment counts, description, tags, category, thumbnail, duration, publish date, live/members-only flags.
- **Reads the channel About panel** — description, country, joined date, exact subscriber/view/video totals and every external link resolved to its real destination.
- **Computes an outlier score and engagement rate for free** — every video is compared against that channel's own collected median, no extra requests needed.
- **Flags sponsor & affiliate signals** — description phrasing and tracked/shortened links, so you can spot brand deals at a glance.
- **Pulls comments and transcripts on request** — top comments with author/likes/replies, and the caption track in text, timestamped, SRT or raw segment form.
- **Streams every finished result to your Dataset instantly** — export to **JSON**, **CSV**, **Excel**, **XML**, or pull it through the [Apify API](https://docs.apify.com/api/v2).

***

### ✨ Main features

- 🔗 **Any channel link accepted** — handle, `/channel/`, `/c/`, `/user/` or legacy URL — bulk input in one field.
- 🎬 📱 🔴 **Videos, Shorts and Live streams collected independently**, with their own per-channel limits.
- 🔃 **Sort order control** — Newest, Most popular or Oldest, validated live against that channel's own sort chips.
- 📅 **Date-cutoff filtering** — stop a channel's listing once videos get older than an absolute or relative date.
- 🔍 **Deep per-video enrichment (opt-in)** — exact counts, full description, tags, category, publish date, playability.
- 📺 **Channel About-panel enrichment** — description, country, joined date, exact totals, resolved external links.
- 💰 **Sponsor & affiliate detection** — structural + phrasing heuristics flag likely brand deals in the description.
- 📊 **Outlier score & engagement rate** — a video's views vs. the channel's own recent median, plus `(likes + comments) / views`, computed for free.
- 💬 **Comment extraction** — author, text, timestamp, likes, replies, pinned/verified flags.
- 📝 **Transcript/caption download** — any available track, in your choice of format.
- 🔁 **Monitor mode** — stop each channel's listing at a video ID you already have, and optionally fire a webhook with what's new.
- 🚦 **Automatic network fallback** — direct ➜ datacenter proxy ➜ residential proxy (3 retries, sticky), fully logged.
- 📦 **Live dataset writes**, **seven prebuilt table views**, and the exact `{channel, videos[]}` JSON shape also saved to the key-value store.
- 🧾 **Run summary** stored alongside your results, with per-run totals.

***

### 👥 Who is this Actor for?

- 🔬 **Content & trend researchers** — track what's performing on a channel or niche without manual scrolling.
- 📈 **Marketers & SEO teams** — mine titles, descriptions and tags at scale for content ideas and keyword research.
- 🤝 **Creator/influencer outreach & talent teams** — subscriber counts, upload cadence and engagement rate for shortlisting partners.
- 🕵️ **Competitor benchmarking** — track a competitor channel's upload frequency, view trends and sponsor activity over time.
- 👂 **Social listening tools** — pull comments for sentiment analysis and brand monitoring.
- 🤖 **AI / LLM data pipelines** — clean, structured video and transcript data for RAG and fine-tuning.
- 🗃️ **Analytics & BI teams** — feed a warehouse with view/like/comment time series per channel.
- 🧑‍💻 **Developers** — a dependable channel-level YouTube data source with no quota-limited API key to manage.

***

### ⚙️ What the scraper does

1. **Reads every channel URL you provide** — one bulk field, any link format welcome.
2. **Opens each channel once** and reads its live Videos/Shorts/Live tabs, honoring your sort order and limits.
3. **Collects the listing fields instantly** — title, approximate views, relative date, thumbnail, duration.
4. **Optionally enriches every video** with exact counts, full metadata, comments, transcript and sponsor detection.
5. **Scores each video** — outlier vs. the channel's own median, plus engagement rate — the moment its own data is in.
6. **Saves every finished result straight to your Dataset** — watch results land in the Console in real time, one channel after another.
7. **Keeps going even when a channel fails** — a private, deleted or unreachable channel is logged as a clear error row without stopping the run.
8. **Reports a full run summary** at the end — totals by type, network route used, and duration.

***

### 📥 Inputs it accepts

| Input type | Example |
|---|---|
| Channel handle | `https://www.youtube.com/@mkbhd` |
| Channel ID | `https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ` |
| Legacy custom URL | `https://www.youtube.com/c/MKBHD` |
| Legacy username URL | `https://www.youtube.com/user/marquesbrownlee` |

All the above can be mixed freely in a single run, and the field supports bulk paste or file upload. Each entry needs the full `https://` link — a bare `@handle` or channel ID on its own isn't accepted by the URL field.

***

### 📤 Output format (Dataset)

Every video record streams to the dataset the moment it's ready — one flat row per video, with the channel's own fields merged in — organized into **seven ready-made Console views**:

| View | What it shows |
|---|---|
| ✨ **Overview** | Type, title, channel, views, likes, comments, date, category, duration, link |
| 📊 **Insights** | Outlier flag/basis and engagement rate / views-to-subscribers ratio per video |
| 📺 **Channel** | Channel description, country, joined date, subscriber/view/video totals, links |
| 💰 **Sponsors** | Sponsor/affiliate signal object per video |
| 💬 **Comments & Transcript** | Comment count, top comments array, transcript text |
| 🎞️ **Media** | Duration, thumbnail, tags, description |
| ⚠️ **Errors** | Any channel or video that could not be processed, with a clear reason |

The exact `{ "channel": {...}, "videos": [...] }` shape — one object per channel — is **also** saved live to the key-value store under the `OUTPUT` record, updated as each channel finishes, so you get both a flat table for the Console/CSV and a nested JSON export in one run.

***

### 🧾 Example output (JSON)

```json
{
  "channelName": "Marques Brownlee",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelHandle": "@mkbhd",
  "channelUrl": "https://www.youtube.com/@mkbhd",
  "channelSubscriberCount": 21200000,
  "channelTotalViews": 5555015293,
  "channelCountry": "United States",
  "videoId": "ngPkbaZliaU",
  "title": "The Truth About the Bezelless Concept Phone",
  "url": "https://www.youtube.com/watch?v=ngPkbaZliaU",
  "type": "video",
  "duration": "6:29",
  "publishedAt": "2026-08-24T20:27:50.000Z",
  "viewCount": 3869243,
  "likeCount": 88657,
  "category": "Science & Technology",
  "tags": ["bezelless smartphone", "bezelless", "bezels", "MKBHD"],
  "sponsorSignal": { "hasSponsorSignal": false, "sponsorPhraseMatched": false, "affiliateLinks": [] },
  "engagementRate": 0.02291,
  "viewsToSubsRatio": 0.1825,
  "isOutlier": false,
  "outlierBasis": "median of 9 videos collected this run: 3,500,000 views"
}
```

***

### 🚀 Quick start

#### Apify Console

1. Log in at [console.apify.com](https://console.apify.com) → **Actors** → open **Fast YouTube Channel Scraper**.
2. Paste one or more channel links / `@handles`.
3. Set how many Videos / Shorts / Streams you want per channel, adjust any other options.
4. Click **Start**.
5. Watch the log and the **Output** tab fill up in real time.
6. Export to JSON, CSV or Excel when it's done.

#### API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~fast-youtube-channel-scraper/run-sync-get-dataset-items" \
     -H "Authorization: Bearer $APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"urls":[{"url":"https://www.youtube.com/@mkbhd"}],"maxResults":10}'
```

#### Python client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/fast-youtube-channel-scraper").call(run_input={
    "urls": [{"url": "https://www.youtube.com/@mkbhd"}],
    "maxResults": 10,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["viewCount"])
```

***

### ⚙️ Input parameters reference

#### 🚀 Start here

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | array | `[]` | Channel links / handles, bulk input |

#### 📬 How much to collect

| Field | Type | Default | Description |
|---|---|---|---|
| `maxResults` | integer | `10` | Max regular videos per channel |
| `maxResultsShorts` | integer | `0` | Max Shorts per channel |
| `maxResultStreams` | integer | `0` | Max streams per channel |
| `sortVideosBy` | string | `NEWEST` | NEWEST / POPULAR / OLDEST |
| `oldestPostDate` | string | — | Absolute (`YYYY-MM-DD`) or relative (`30 days`) cutoff |

#### 🔍 Enrichment

| Field | Type | Default | Description |
|---|---|---|---|
| `enrichVideos` | boolean | `true` | Exact counts, description, tags, category, publish date |
| `includeAboutInfo` | boolean | `true` | Channel About panel |
| `detectSponsors` | boolean | `true` | Sponsor/affiliate signal detection |

#### 💬 Comments & transcript

| Field | Type | Default | Description |
|---|---|---|---|
| `includeComments` | boolean | `false` | Collect top comments |
| `maxComments` | integer | `20` | Max comments per video |
| `includeTranscript` | boolean | `false` | Collect the caption track |
| `transcriptFormat` | string | `text` | text / timestamped / srt / segments |

#### 🔁 Monitor mode

| Field | Type | Default | Description |
|---|---|---|---|
| `monitorMode` | boolean | `false` | Stop each channel's listing at a known video ID |
| `sinceVideoId` | string | `""` | The video ID to stop at |
| `webhookUrl` | string | `""` | POSTed once per channel with any new videos found |

#### 🌍 Network & 📦 Advanced

| Field | Type | Default | Description |
|---|---|---|---|
| `proxyConfiguration` | object | no proxy | Automatic direct → datacenter → residential fallback unless overridden |
| `cookie` | string (secret) | — | Optional raw `Cookie` header for age/consent-gated channels |
| `outputFormat` | string | `nested` | Shape of the aggregate `OUTPUT` key-value record: `nested` / `flat` |

#### ⚡ Speed & reliability

| Field | Type | Default | Description |
|---|---|---|---|
| `maxConcurrency` | integer | `5` | Videos enriched in parallel per channel |
| `maxRetries` | integer | `3` | Retries per request on the current network route |
| `maxScrollRetries` | integer | `3` | Empty-page tolerance before a tab is considered exhausted |
| `maxScanned` | integer | `20000` | Safety cap on listing rows scanned per tab |

***

### 🛡️ Reliability & anti-blocking

This Actor starts every run on a **direct connection** — no proxy overhead unless it's actually needed. If YouTube pushes back, the run automatically and transparently escalates:

**Direct connection ➜ datacenter proxy ➜ residential proxy (3 retries)**

Once the run escalates to the residential route it **stays there** for every remaining request, so you don't pay for a slower route longer than necessary. Every fallback is logged clearly in the run log. You can also pin your own proxy group in **Proxy configuration** to skip the automatic ladder entirely.

The run also watches for a quieter failure mode than a hard block: a route that answers normally but hands back an incomplete video record (most often a missing like count and category). The first time that happens it escalates the network route automatically and re-checks that video — no separate setting needed. Listing-level fields (title, approximate views, thumbnail, duration, publish date) always come from the channel page itself and are unaffected either way; it's only the small set of exact per-video fields from deep enrichment that can occasionally come back `null` for a handful of videos in a run even after escalating — raising **Retries per request** or picking **Residential** proxy up front both reduce how often that happens.

***

### 🔌 Integrations & automation

- **Schedules** — run this Actor daily/weekly with **Monitor mode** on to only collect new uploads.
- **Webhooks** — fire `ACTOR.RUN.SUCCEEDED` to your own endpoint when a run finishes, or use the built-in `webhookUrl` for per-channel new-video notifications.
- **Zapier / Make / n8n** — feed dataset items straight into a spreadsheet, CRM or Slack alert.
- **MCP / AI agents** — call this Actor as a tool from Claude, Cursor or any MCP-compatible client via [mcp.apify.com](https://mcp.apify.com).
- **REST API** — pull dataset items directly: `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`.

***

### 💰 Pricing & how to control cost

This Actor runs on **Apify's pay-per-usage** pricing — you pay for the platform compute, proxy and storage your run consumes, no separate per-result fee. To control cost:

- Start with a low `maxResults` to sample a channel before a full run.
- Leave `includeComments` / `includeTranscript` off unless you need them — they add requests per video.
- Turn off `enrichVideos` for the fastest, cheapest listing-only run (title, approximate views, thumbnail, duration).
- Turn on **Monitor mode** for recurring runs so you only pay for new uploads each time.
- Leave **Proxy configuration** on automatic — it only escalates to a paid proxy route when actually needed.

***

### ❓ Frequently asked questions (FAQ)

**Does this need a YouTube Data API key or quota?**
No — it works without any Google API key or daily quota limit.

**Can I scrape an entire channel's uploads?**
Yes — paste the channel URL (or `@handle`) and raise `maxResults` (and `maxResultsShorts`/`maxResultStreams` if you also want those tabs).

**Can I scrape multiple channels in one run?**
Yes — the `urls` field accepts bulk input; every channel is processed and streamed to the same dataset.

**What's the outlier score?**
A video's view count compared against the median of the videos collected from that same channel in this run — a quick way to spot uploads that are over- or under-performing relative to that channel's normal reach.

**What's the sponsor signal?**
A heuristic (description phrasing + affiliate/tracking link patterns) that flags a *likely* brand deal — always a lead to verify, never a certainty.

**Can I get video transcripts?**
Yes — turn on `includeTranscript` and pick a format; only videos with an available caption track will return one.

**Does it work for private or age-restricted videos?**
No — only publicly available YouTube pages are read, same as any anonymous visitor would see (unless you supply your own `cookie`).

**What's the difference between the dataset and the `OUTPUT` key-value record?**
The dataset is a live table, one row per video, with per-section views. The `OUTPUT` record is the same run's data grouped back into `{ channel, videos[] }` objects — handy for a single JSON export per channel.

***

### 🛠️ Troubleshooting

| Symptom | Fix |
|---|---|
| A channel comes back as an error row | Check the ⚠️ **Errors** view for the reason — usually the handle/ID is wrong or the channel is unreachable |
| Fewer results than `maxResults` | The channel may simply have fewer videos than requested in that tab |
| No channel About info | `includeAboutInfo` may be off, or the channel doesn't expose an About panel |
| Run seems slow | Lower `maxConcurrency`, or turn off comments/transcript if you don't need them |
| Some videos have `likeCount`/`category` as `null` | Occasionally happens on a subset of videos even with deep enrichment on and after the automatic route escalation; picking **Residential** proxy in **Proxy configuration** up front, or raising `maxRetries`, both make it rarer |

***

### 🆘 Help, support & custom builds

Something not working, or need a custom field, private integration or a bespoke pipeline built on top of this Actor? Email **<hello.dataminds@gmail.com>** — we read every message.

***

### ⚖️ Is scraping YouTube legal?

This Actor only reads **publicly available** YouTube pages — the same pages any anonymous visitor's browser can load. It does not bypass logins, paywalls or private content. You are responsible for how you use the collected data — respect YouTube's Terms of Service, applicable copyright law, and privacy regulations (GDPR, CCPA, etc.) for your jurisdiction and use case.

***

### 🔑 SEO keywords targeted

youtube channel scraper, fast youtube channel scraper, youtube channel data scraper, youtube api alternative, youtube data api without key, youtube channel video scraper, youtube channel statistics scraper, youtube subscriber count scraper, youtube shorts scraper, youtube live stream scraper, youtube channel about scraper, youtube sponsor detector, youtube affiliate link scraper, youtube outlier score, youtube engagement rate calculator, youtube transcript scraper, youtube comments scraper, apify youtube actor, scrape youtube channel without api key, youtube channel monitoring tool, youtube competitor analysis tool.

# Actor input Schema

## `urls` (type: `array`):

📺 YouTube channel links to scrape — full URLs only, e.g. `https://www.youtube.com/@handle`, `https://www.youtube.com/channel/UC...`, `/c/...` or `/user/...`. One per line, bulk input supported.

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

📬 How many regular videos to collect from each channel's Videos tab. 0 = skip regular videos.

## `maxResultsShorts` (type: `integer`):

📱 How many Shorts to collect from each channel's Shorts tab. 0 = skip Shorts.

## `maxResultStreams` (type: `integer`):

🔴 How many live/upcoming/ended streams to collect from each channel's Live tab. 0 = skip streams.

## `sortVideosBy` (type: `string`):

🔃 Which order to read each tab in. Validated live against that channel's own sort options.

## `oldestPostDate` (type: `string`):

📅 Stop collecting once videos get older than this. Use `YYYY-MM-DD` or a relative value like `30 days`. Leave blank to disable. Automatically forces sort order to Newest.

## `enrichVideos` (type: `boolean`):

🔍 Fetch each video's own page for exact view/like counts, full description, tags, category and publish date. Required for comments, transcript and sponsor detection below.

## `includeAboutInfo` (type: `boolean`):

📺 Also read the channel's About panel — description, country, joined date, exact subscriber/view/video totals and external links.

## `detectSponsors` (type: `boolean`):

💰 Flag videos whose description contains sponsor phrasing or affiliate/tracking links (a lead to verify, not a certainty). Requires deep enrichment.

## `includeComments` (type: `boolean`):

💬 Collect each video's top comments — author, text, likes, replies, pinned flag.

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

🔢 Stop collecting comments for a video after this many.

## `includeTranscript` (type: `boolean`):

📝 Collect the video's caption track when one is available.

## `transcriptFormat` (type: `string`):

📄 File format for the collected transcript text.

## `monitorMode` (type: `boolean`):

🔁 Forces sort order to Newest and stops each channel's listing as soon as "Stop at this video ID" is reached — only videos newer than it are returned.

## `sinceVideoId` (type: `string`):

🆔 The 11-character video ID (from a previous run) to stop at when Monitor mode is on. Leave blank to just collect the newest videos every run.

## `webhookUrl` (type: `string`):

📡 When Monitor mode finds new videos for a channel, POST `{channel, newVideos}` once to this URL. Leave blank to disable.

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

🚦 By default every run starts on a direct connection with no proxy and automatically escalates to a datacenter, then a residential proxy only if YouTube pushes back. Pick your own route here to override that.

## `cookie` (type: `string`):

🍪 Advanced: a raw `Cookie` header value, used to unlock age/consent-gated channels. Stored encrypted.

## `outputFormat` (type: `string`):

📦 Shape of the extra full-run JSON saved to the key-value store's `OUTPUT` record (the live dataset table itself is always one flat row per video). `nested` = one object per channel with a `videos` array; `flat` = same flat rows as the dataset.

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

🏎️ How many videos to enrich at the same time, per channel.

## `maxRetries` (type: `integer`):

🛡️ Attempts before a single request is considered failed on the current network route.

## `maxScrollRetries` (type: `integer`):

♻️ Consecutive listing pages with no new videos allowed before a channel's tab is considered exhausted.

## `maxScanned` (type: `integer`):

🧮 Safety cap on how many listing rows are examined per tab before giving up — mainly relevant with a date cutoff on a very large channel.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/@mkbhd"
  ],
  "maxResults": 10,
  "maxResultsShorts": 0,
  "maxResultStreams": 0,
  "sortVideosBy": "NEWEST",
  "oldestPostDate": "",
  "enrichVideos": true,
  "includeAboutInfo": true,
  "detectSponsors": true,
  "includeComments": false,
  "maxComments": 5,
  "includeTranscript": false,
  "transcriptFormat": "text",
  "monitorMode": false,
  "sinceVideoId": "",
  "webhookUrl": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "outputFormat": "nested",
  "maxConcurrency": 5,
  "maxRetries": 3,
  "maxScrollRetries": 3,
  "maxScanned": 20000
}
```

# Actor output Schema

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

No description

## `overview` (type: `string`):

No description

## `insights` (type: `string`):

No description

## `channel` (type: `string`):

No description

## `sponsors` (type: `string`):

No description

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

No description

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

No description

## `aggregateOutput` (type: `string`):

No description

## `runSummary` (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 = {
    "urls": [
        "https://www.youtube.com/@mkbhd"
    ],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("citrine_venus/fast-youtube-channel-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 = {
    "urls": ["https://www.youtube.com/@mkbhd"],
    "maxResults": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("citrine_venus/fast-youtube-channel-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 '{
  "urls": [
    "https://www.youtube.com/@mkbhd"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call citrine_venus/fast-youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,citrine_venus/fast-youtube-channel-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/y58dHJcQ7q6G9HNHj/builds/sqKKrDFpqOAytHhbw/openapi.json