# YouTube Channel Scraper (`electrabot.info/youtube-channel-scraper`) Actor

Scrape any YouTube channel: subscriber count, channel info, and every video with views, duration, and thumbnails. Optional detailed mode adds upload date, likes, comment counts, tags, category, and full descriptions. Batch multiple channels, no browser. Pay per video.

- **URL**: https://apify.com/electrabot.info/youtube-channel-scraper.md
- **Developed by:** [electra bot](https://apify.com/electrabot.info) (community)
- **Categories:** Videos, Social media, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## YouTube Channel Scraper

Scrape any **YouTube channel** — subscriber count, channel info, and every
video with views, duration, and thumbnails — as JSON, CSV, or Excel.

Turn on **Detailed mode** and every video also carries **upload date, likes,
comment count, tags, category, and the full description**.

Paste one channel or many. Up to 1,000 videos per channel. No browser.

**Pay per result** — you're charged per video delivered. Failed channels cost
nothing.

---

### What can I use it for?

- **Competitor & creator analysis** — a channel's entire catalogue with view counts, ranked and filterable in seconds.
- **Content research** — find what performs: sort by views, spot the outliers, read the tags and categories that work (Detailed mode).
- **Influencer discovery & vetting** — subscriber counts, upload cadence, real engagement (likes/comments per video).
- **Trend tracking** — snapshot channels over time to watch topics and performance move.
- **AI & LLM datasets** — clean, structured video metadata; pair with our transcript actors for full text.

---

### Input

| Field | Required | Description |
|-------|----------|-------------|
| **Channel URLs** | ✅ | One or more channels: `@handle`, `/channel/UC…`, `/c/…`, `/user/…`. Each video is one result. |
| **Max videos per channel** | – | 1–1,000 (default 50). Newest first. |
| **Which videos** | – | `videos` (default), `shorts`, or `streams`. |
| **Detailed mode** | – | Off (fast): title, views, duration, thumbnail — the whole channel in one request. **On:** additionally fetches upload date, likes, comment count, tags, category, and full description per video (~2s/video). |
| **Proxy configuration** | – | **Automatic by default:** datacenter proxy first, escalating to RESIDENTIAL only if YouTube blocks it. |

### Output

One record per video. Channel fields are attached to every record, so a single
export is self-contained:

```json
{
  "videoId": "eWKY0OnPByg",
  "videoUrl": "https://www.youtube.com/watch?v=eWKY0OnPByg",
  "title": "Apple Lost the AI Race",
  "viewCount": 1727074,
  "durationSeconds": 423,
  "thumbnailUrl": "https://i.ytimg.com/vi/eWKY0OnPByg/hqdefault.jpg",
  "isLive": false,

  "uploadDate": "2026-07-08",
  "likeCount": 80760,
  "commentCount": 5800,
  "tags": ["Apple", "AI race", "new siri", "MKBHD"],
  "category": "Science & Technology",
  "description": "Apple lost the AI race. Actually, Apple won the AI race...",

  "channelName": "Marques Brownlee",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
  "subscriberCount": 21100000
}
````

The five fields in the middle block (`uploadDate` … `description`) are filled
in **Detailed mode**; in fast mode they are `null` — the dataset shape never
changes, so your downstream code doesn't care which mode you ran.

***

### Why this scraper is reliable

- **Reads YouTube directly** — not a third-party analytics site that can vanish or block you. Built on an extraction engine whose maintainers track YouTube's changes daily.
- **No browser** — fast cold starts, low cost, fewer moving parts to break.
- **Block-aware with automatic escalation** — if YouTube blocks the cheap proxy tier, the scraper retries through a residential proxy, then a fresh IP, before giving up.
- **Honest run statuses** — a channel that can't be resolved is reported in the `SUMMARY` and never charged; a run with zero videos is **Failed**, never a silent empty dataset. Videos whose detail fetch fails are still delivered with their basic fields rather than dropped.
- **Batch-safe** — videos are saved incrementally and runs are checkpointed: an interruption never loses finished work or double-charges you.

### Tips & limits

- **Fast vs Detailed:** fast mode pulls an entire channel in one request — use it when you need the catalogue and view counts. Detailed mode costs ~2s per video but gives you upload dates, likes, tags, and descriptions that fast mode can't see.
- Newest videos come first; set **Max videos** to what you actually need.
- Members-only and private videos aren't listed publicly and so aren't returned.

### Use it from code

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("electrabot.info/youtube-channel-scraper").call(
    run_input={"channelUrls": ["https://www.youtube.com/@mkbhd"],
               "maxVideos": 100, "detailed": True}
)
for v in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(v["uploadDate"], f"{v['viewCount']:>10,}", v["title"])
```

### The rest of the family

- [YouTube Transcript Scraper](https://apify.com/electrabot.info/youtube-transcript-scraper) — transcripts for specific videos
- [YouTube Channel Transcript Scraper](https://apify.com/electrabot.info/youtube-bulk-video-transcript) — transcripts for a whole channel
- [YouTube Comments Scraper](https://apify.com/electrabot.info/youtube-video-comments) — comments with sentiment analysis

### FAQ

**Does it get Shorts?**
Yes — set **Which videos** to `shorts` (or `streams` for live streams).

**Why is `likeCount` null?**
You ran in fast mode. Turn on **Detailed mode** to fetch likes, comment counts, upload dates, tags, and descriptions.

**How current are view counts?**
They're read live from YouTube at run time.

**Is this legal?**
This actor accesses only publicly available channel and video data. You are responsible for complying with applicable laws and YouTube's Terms of Service.

***

### Disclaimer

**This is an unofficial tool. It is not affiliated with, endorsed by, sponsored by,
or in any way officially connected to YouTube or Google LLC.** "YouTube" and all
related names, marks, and logos are trademarks of their respective owners and are
used here for descriptive purposes only.

This actor only accesses **publicly available** information. You are responsible
for ensuring your use complies with applicable laws, YouTube's Terms of Service,
and any applicable rate-limiting rules. Use it ethically and at your own risk.

# Actor input Schema

## `channelUrls` (type: `array`):

One or more YouTube channels: @handle, /channel/UC…, /c/…, or /user/… links. Each video found is one result.

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

How many of the channel's newest videos to return (1-1000). Each video is one billable result.

## `tab` (type: `string`):

Which tab of the channel to scrape.

## `detailed` (type: `boolean`):

Off (fast): title, views, duration, thumbnail — the whole channel in one request. On: additionally fetches upload date, like count, comment count, tags, category, and full description for every video (~2s per video, slower but far richer).

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

Default (recommended): automatic tiering — cheap datacenter proxy first, auto-escalating to RESIDENTIAL only if YouTube blocks it.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@mkbhd"
  ],
  "maxVideos": 50,
  "tab": "videos",
  "detailed": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `transcripts` (type: `string`):

One record per video: full plain-text transcript, timed segments, language info, and video metadata.

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

Requested/scraped/failed counts and per-video failure reasons.

# 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 = {
    "channelUrls": [
        "https://www.youtube.com/@mkbhd"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("electrabot.info/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 = {
    "channelUrls": ["https://www.youtube.com/@mkbhd"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("electrabot.info/youtube-channel-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channelUrls": [
    "https://www.youtube.com/@mkbhd"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call electrabot.info/youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=electrabot.info/youtube-channel-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Scraper",
        "description": "Scrape any YouTube channel: subscriber count, channel info, and every video with views, duration, and thumbnails. Optional detailed mode adds upload date, likes, comment counts, tags, category, and full descriptions. Batch multiple channels, no browser. Pay per video.",
        "version": "1.0",
        "x-build-id": "F0cGd6g1CdruqBRU2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/electrabot.info~youtube-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-electrabot.info-youtube-channel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/electrabot.info~youtube-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-electrabot.info-youtube-channel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/electrabot.info~youtube-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-electrabot.info-youtube-channel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channelUrls"
                ],
                "properties": {
                    "channelUrls": {
                        "title": "Channel URLs",
                        "type": "array",
                        "description": "One or more YouTube channels: @handle, /channel/UC…, /c/…, or /user/… links. Each video found is one result.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Max videos per channel",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many of the channel's newest videos to return (1-1000). Each video is one billable result.",
                        "default": 50
                    },
                    "tab": {
                        "title": "Which videos",
                        "enum": [
                            "videos",
                            "shorts",
                            "streams"
                        ],
                        "type": "string",
                        "description": "Which tab of the channel to scrape.",
                        "default": "videos"
                    },
                    "detailed": {
                        "title": "Detailed mode (upload date, likes, tags, description)",
                        "type": "boolean",
                        "description": "Off (fast): title, views, duration, thumbnail — the whole channel in one request. On: additionally fetches upload date, like count, comment count, tags, category, and full description for every video (~2s per video, slower but far richer).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Default (recommended): automatic tiering — cheap datacenter proxy first, auto-escalating to RESIDENTIAL only if YouTube blocks it.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```