# YouTube Channel Scraper – Profiles & Stats (`chronometrica/youtube-channel-scraper`) Actor

Get clean public YouTube channel rows from URLs and handles, with stable IDs, links, audience stats, and a clear result for every input.

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

## Pricing

from $0.35 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 – Profiles & Stats

### 📊 What does YouTube Channel Scraper do?

Paste public YouTube channel URLs or handles and get clean channel profiles in
bulk. Use the data to enrich creator lists, compare audiences, find public
identity links, and refresh channel records.

Every unique input gets one flat, matched row. The row keeps the original
`input`, canonical `channelUrl`, stable channel identity, public profile facts,
audience counts, precision labels, and a clear `status` and `statusReason`.

This Actor does not log in, use cookies, download videos, collect private
subscriber lists, or access YouTube Studio. It reads public channel pages only.

With YouTube Channel Scraper, you can:

- 🆔 Match channels with stable IDs, handles, and canonical URLs.
- 📈 Compare subscriber, video, and total view counts.
- 🔗 Find public owner links, websites, and social profiles.
- 🌏 Collect declared country, language, keywords, and join date.
- 🖼️ Save public avatar and banner URLs.
- 🚦 Keep missing, blocked, and unavailable profiles as clear status rows.
- 📦 Export results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### 📦 What YouTube channel data can I extract?

Each dataset row represents one attempted YouTube channel input.

| Data group      | Example fields                                                     |
| --------------- | ------------------------------------------------------------------ |
| 🆔 Identity     | `channelId`, `channelUrl`, `handle`, `rssUrl`, `uploadsPlaylistId` |
| 🧾 Profile      | `displayName`, `description`, `detectedEmails`, `detectedLinks`    |
| 🔗 Public links | `ownerUrls`, `externalLinks`, `hasBusinessEmail`                   |
| 🖼️ Media        | `avatarUrl`, `bannerUrl`                                           |
| 📊 Counts       | `subscribersCount`, `videosCount`, `viewsCount`                    |
| 🎯 Quality      | `countPrecision`, display-text count fields                        |
| 🚦 Result       | `status`, `statusReason`, `observedAt`                             |

Missing public values stay `null`. Rounded public counts are labeled
`display_rounded`; they are not presented as exact values.

### ⚙️ Can I use this Actor through an API?

Yes. Run it in Apify Console or through the Apify API, Python SDK, Node.js SDK,
webhooks, schedules, and Apify integrations.

### 🎯 Why collect YouTube channel profiles?

| Use case               | How the data helps                                                        |
| ---------------------- | ------------------------------------------------------------------------- |
| 📋 Creator enrichment  | Add stable IDs, audience size, links, and channel facts to creator lists. |
| 📣 Campaign planning   | Compare channel fit and public reach before outreach.                     |
| 🕵️ Competitor research | Track public channel size and activity over time.                         |
| 🔗 Identity matching   | Use owner links to connect a channel with public profiles elsewhere.      |
| 🧱 Data products       | Load stable profile rows into databases, dashboards, and internal tools.  |

### 💵 Pricing

Each useful profile row triggers one `profile` event. Prices per 1,000 useful
rows are:

| Plan                    | Price |
| ----------------------- | ----: |
| Free                    | $0.50 |
| Bronze                  | $0.45 |
| Silver                  | $0.40 |
| Gold, Platinum, Diamond | $0.35 |

Apify platform usage is charged separately. There is no paid Actor start event.
One useful row is an `ok` or `partial` channel snapshot written to the default
dataset. Invalid, missing, blocked, and failed inputs are not charged as profile
results. Each dataset row includes `isBillable` so this rule is visible.

### 🚀 How do I use YouTube Channel Scraper?

1. Open **YouTube Channel Scraper – Profiles & Stats** in Apify Console.
2. Paste one or more public channel URLs or handles.
3. Click **Start**.
4. Open **Output** to inspect the rows and run summary.
5. Download the dataset or connect it to your workflow.

### ⬇️ Input

Add 1 to 1,000 values in `startUrls`:

```json
{
  "startUrls": ["https://www.youtube.com/@MrBeast", "@HikakinTV"]
}
````

Accepted inputs include channel URLs, `@handles`, and channel URLs ending in
`/videos`, `/shorts`, `/streams`, or `/about`. Exact duplicate values run once.

### ⬆️ Output sample

```json
{
  "platform": "youtube",
  "input": "https://www.youtube.com/@MrBeast",
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "uploadsPlaylistId": "UUX6OQ3DkcsbYNE6H8uQQuVA",
  "channelUrl": "https://www.youtube.com/@MrBeast",
  "handle": "@MrBeast",
  "displayName": "MrBeast",
  "subscribersCount": 508000000,
  "subscribersText": "508M subscribers",
  "countPrecision": {
    "subscribersCount": "display_rounded"
  },
  "status": "ok",
  "statusReason": null,
  "observedAt": "2026-07-16T00:00:00.000Z"
}
```

#### 📌 Run summary

The `OUTPUT` record reports input counts, output rows, billable rows, status
counts, useful rates, and run time. It does not contain raw pages, cookies, or
private request details.

### 🎯 Status and quality fields

- `ok`: the public channel identity was found.
- `partial`: useful public channel facts were found, but some facts are missing.
- `not_found`, `private`, or `login_required`: YouTube did not expose a usable
  public profile for this request.
- `blocked`, `challenge`, or `rate_limited`: the public source refused the
  request at that time.
- `parser_miss`: a page loaded, but the Actor could not safely tie profile facts
  to the requested channel.
- `invalid_input` or `failed`: the input was not a channel or the request failed.

### 🔒 Source boundary and limits

- Public logged-out channel pages only.
- Subscriber lists are private to the channel owner and are not returned.
- Public subscription lists may exist for channels that choose to show them,
  but this Actor does not return a full following graph.
- Business email text may require owner or viewer sign-in. The Actor reports
  only whether YouTube shows the public contact action.
- `detectedEmails` and `detectedLinks` are unverified clues from the public
  description and public link fields. They can be missing or wrong.
- The Actor does not open or crawl detected links.
- YouTube can hide, delay, or round public values.

### ❓ FAQ

#### Does this Actor need login, cookies, or an API key?

No.

#### Why are some fields missing?

YouTube did not expose those fields publicly for that channel at collection
time. Check `status`, `statusReason`, and `countPrecision`.

#### How are duplicates handled?

Exact duplicate inputs are checked once. Use `channelId` as the strongest
cross-run dedupe key when it is present.

### 🛟 Support

Send the run ID, input URL, expected channel, and observed row. Do not send
passwords, cookies, or account credentials.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.
- [Facebook Comments Scraper](https://apify.com/chronometrica/facebook-comments-scraper)
  — collect public comments, replies, authors, dates, and reactions from known
  Facebook content.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.
- [Instagram Comments Scraper](https://apify.com/chronometrica/instagram-comments-scraper)
  — collect public comments, authors, dates, likes, and reply counts from posts
  and Reels.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Comments Scraper](https://apify.com/chronometrica/tiktok-comments-scraper)
  — collect public comments, replies, authors, likes, and thread links.
- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
  — extract public caption text and timestamped segments from TikTok videos.

# Actor input Schema

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

Add 1 to 1,000 public YouTube channel URLs or handles. Duplicate inputs are checked once. Each unique input creates one result row and adds usage.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.youtube.com/@MrBeast"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "startUrls": [
        "https://www.youtube.com/@MrBeast"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/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 = { "startUrls": ["https://www.youtube.com/@MrBeast"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/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 '{
  "startUrls": [
    "https://www.youtube.com/@MrBeast"
  ]
}' |
apify call chronometrica/youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Scraper – Profiles & Stats",
        "description": "Get clean public YouTube channel rows from URLs and handles, with stable IDs, links, audience stats, and a clear result for every input.",
        "version": "0.1",
        "x-build-id": "1zsYRZefy0p9WZGNb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~youtube-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-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/chronometrica~youtube-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-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/chronometrica~youtube-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "YouTube channel URLs or handles",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add 1 to 1,000 public YouTube channel URLs or handles. Duplicate inputs are checked once. Each unique input creates one result row and adds usage.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://www.youtube.com/@MrBeast"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
