# YouTube Channel Scraper: No API Key (`themineworks/youtube-channel`) Actor

Scrape YouTube channel metadata and video list: subscriber count, view count, video titles, view counts and publish dates. No API key needed. Works as MCP tool in Claude.

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

## Pricing

$5.00 / 1,000 channels

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: Subscribers, Videos & Stats (No API Key)

### Overview

YouTube Channel Scraper is a fast, no-login tool that turns any YouTube channel URL, `@handle`, or channel ID into clean, structured JSON. Every record includes subscriber count, total video count, description, country, avatar, banner, and the channel's recent video list with views and publish dates.

No YouTube Data API key, no OAuth, no quota. Paste channels, get data. You are billed per channel returned, nothing else.

✅ No login required | ✅ No API key | ✅ Pay only for successful channels | ✅ MCP-ready for AI agents

### Features

Bulk channel enrichment. Pass many channels per run and get flat records back.
No Data API quota. Reads public channel surfaces without touching Google's key system.
Videos tab included. Up to 200 recent uploads with views, duration, thumbnails, Shorts flag.
Handles every input shape. Full URLs, `@handles`, or raw `UC...` channel IDs.
Free failure handling. Not-found or errored channels are never charged.

### How it works

The official YouTube Data API makes you register a project, generate an API key, and live inside a 10,000-unit daily quota that a handful of channel lookups can burn through. This scraper reads the same public channel surfaces YouTube already serves to logged-out visitors: no key, no OAuth screen, no quota ceiling.

Each input is resolved to the canonical channel, the About panel is parsed for subscriber count, video count, country, description, avatar and banner, and the Videos tab is walked for the most recent uploads. Failed lookups are surfaced with `status: not-found` or `status: error` and are never billed.

### 🧾 Input configuration

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast",
    "@veritasium"
  ],
  "maxVideos": 30,
  "includeVideos": true
}
````

### 📤 Output format

```json
{
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "channelHandle": "@MrBeast",
  "channelName": "MrBeast",
  "subscriberCountText": "508M subscribers",
  "subscriberCount": 508000000,
  "videoCount": 992,
  "description": "SUBSCRIBE FOR A COOKIE!",
  "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
  "avatarUrl": "https://yt3.googleusercontent.com/nxYrc_1_2f77DoBadyxMTmv7ZpRZapHR5jbuYe7PlPd5cIRJxtNNEYyOC0ZsxaDyJJzXrnJiuDE=s160-c-k-c0x00ffffff-no-rj",
  "bannerUrl": "https://yt3.googleusercontent.com/mHMO_eEMp0dPvh0ADwXhPXNYb_GnjSVsLI8biqF1CpxT8OPl7izhNQsDPD3JHhd5y5Mg9GrP=w2560-fcrop64=1,00005a57ffffa5a8-k-c0xffffffff-no-nd-rj",
  "videos": [
    {
      "videoId": "iYlODtkyw_I",
      "title": "Survive 30 Days Chained To A Stranger, Win $250,000",
      "url": "https://www.youtube.com/watch?v=iYlODtkyw_I",
      "viewCountText": "71 million views",
      "publishedTimeText": "2 weeks ago",
      "duration": "35:05",
      "thumbnailUrl": "https://i.ytimg.com/vi/iYlODtkyw_I/hqdefault.jpg?sqp=-oaymwEcCNACELwBSFXyq4qpAw4IARUAAIhCGAFwAcABBg==&rs=AOn4CLBr_mSSbkEXsEQf8rxuahzMDeW9Jg",
      "isShort": false
    }
  ],
  "videoCount_fetched": 2,
  "status": "ok",
  "charged": true,
  "scrapedAt": "2026-07-15T04:16:13.023Z"
}
```

This is a live capture from a real run against `@MrBeast`, with `maxVideos` set to 2 for a small, cheap test. Note that `country` is omitted here: this actor only includes fields YouTube actually publishes, and MrBeast's channel does not have a public country set at the time of capture. `charged` is `true` because the lookup returned `status: ok`: every channel that resolves is billed.

Every channel record contains these fields:

| Field | Description |
| --- | --- |
| 🏷️ `channelId` | Canonical UC... channel ID |
| 🆔 `channelHandle` | @handle |
| 📛 `channelName` | Display name |
| 👥 `subscriberCountText` | Rounded YouTube label (e.g. "200M subscribers") |
| 🔢 `subscriberCount` | Parsed numeric subscriber count |
| 🎬 `videoCount` | Total uploads on channel |
| 📝 `description` | About text |
| 🌍 `country` | Channel country |
| 🔗 `channelUrl` | Canonical channel URL |
| 🖼️ `avatarUrl` / `bannerUrl` | Profile and banner images |
| 🎞️ `videos[]` | Recent uploads (see per-video schema below) |
| 🚦 `status` | `ok` / `error` / `not-found` |
| 🕒 `scrapedAt` | ISO 8601 extraction timestamp |

Per-video fields: `videoId`, `title`, `url`, `viewCountText`, `publishedTimeText`, `duration`, `thumbnailUrl`, `isShort`.

### 💼 Common use cases

**Competitor monitoring**
Schedule daily or weekly runs to chart subscriber and upload trends against rivals.
Compare cadence, Shorts vs. long mix, and top-performing titles at a glance.

**Influencer discovery and vetting**
Pull stats for a list of channels, then score on size, cadence, and content mix.
Enrich a prospect list with audience size and channel metadata.

**Content research**
Study which video titles, durations, and posting rhythms correlate with high view counts in a niche.
Feed dashboards with structured channel + video data.

**AI knowledge bases**
Feed channel and video metadata into RAG pipelines and agent workflows.
Combine with the YouTube Transcript Scraper for full context.

### 🚀 Getting started

1. Open the actor in Apify Console (or call it via API or MCP).
2. Under channel URLs or handles, paste one or more channels: full URL, `@handle`, or channel ID. Bulk-add as many as you like.
3. Set max videos per channel (0 to 200) to control how many recent videos come back.
4. Leave Include video list on to get the Videos tab, or turn it off for channel metadata only.
5. Click Save and Start, then download the dataset as JSON, CSV, or Excel, or pull via API or MCP.

### FAQ

**Do I need a YouTube API key or account?**
No. The scraper reads only public channel pages. No API key, no login, no OAuth, and no Data API quota.

**What can I pass as input?**
Any mix of full channel URLs (`youtube.com/@name`, `youtube.com/channel/UC…`), bare `@handles`, or raw channel IDs. Each resolves to the canonical channel automatically.

**How many videos can I get per channel?**
Up to 200 of the most recent uploads from the channel's Videos tab, controlled by max videos per channel. Set it to 0 to skip videos and fetch channel metadata only.

**Why are subscriber counts sometimes approximate?**
YouTube publicly displays rounded figures (e.g. "200M subscribers"). We return both the exact text in `subscriberCountText` and a best-effort parsed `subscriberCount` number.

**How is it priced?**
Pay per result. You are charged per channel that returns `status: ok`. There is no free tier. Not-found or errored channels are never charged.

**Can I use it inside an AI agent?**
Yes. It is exposed as an MCP tool. See below.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/youtube-channel
```

Or call it programmatically with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/youtube-channel').call({
  channelUrls: ['https://www.youtube.com/@MrBeast'],
  maxVideos: 30,
  includeVideos: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Complete your YouTube pipeline

Pair the channel scraper with the rest of the video suite:

- **[YouTube Transcript Scraper](https://apify.com/themineworks/youtube-transcript-scraper)**: timestamped captions as clean JSON for RAG and LLMs.
- **[Threads Scraper](https://apify.com/themineworks/threads-scraper)**: posts, profiles, hashtags and search on Meta Threads.
- **[Instagram Profile Scraper](https://apify.com/themineworks/instagram-profile)**: followers, bio, and stats for any public account.

Typical flow: youtube-channel maps who the creators are, youtube-transcript-scraper pulls the words, and the social suite covers cross-platform reach.

Found a bug or have a feature request? Open an issue on the actor's Apify Console page or reach out through the Apify profile.

# Actor input Schema

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

YouTube channel URLs, handles (@name) or channel IDs. E.g. \["https://www.youtube.com/@MrBeast", "@veritasium"]

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

Maximum number of videos to return per channel (from the Videos tab)

## `includeVideos` (type: `boolean`):

Fetch the channel Videos tab and include video metadata in output

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxVideos": 5,
  "includeVideos": true
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "channelUrls": [
        "https://www.youtube.com/@MrBeast"
    ],
    "maxVideos": 5,
    "includeVideos": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/youtube-channel").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/@MrBeast"],
    "maxVideos": 5,
    "includeVideos": True,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/youtube-channel").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/@MrBeast"
  ],
  "maxVideos": 5,
  "includeVideos": true
}' |
apify call themineworks/youtube-channel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Scraper: No API Key",
        "description": "Scrape YouTube channel metadata and video list: subscriber count, view count, video titles, view counts and publish dates. No API key needed. Works as MCP tool in Claude.",
        "version": "0.1",
        "x-build-id": "6tLdg4XveDe40I4yu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~youtube-channel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-youtube-channel",
                "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/themineworks~youtube-channel/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-youtube-channel",
                "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/themineworks~youtube-channel/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-youtube-channel",
                "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",
                "properties": {
                    "channelUrls": {
                        "title": "Channel URLs or handles",
                        "type": "array",
                        "description": "YouTube channel URLs, handles (@name) or channel IDs. E.g. [\"https://www.youtube.com/@MrBeast\", \"@veritasium\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Max videos per channel",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of videos to return per channel (from the Videos tab)",
                        "default": 30
                    },
                    "includeVideos": {
                        "title": "Include video list",
                        "type": "boolean",
                        "description": "Fetch the channel Videos tab and include video metadata in output",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```