# YouTube Channel Details Scraper (`receptional_blender/youtube-channel-info`) Actor

Turn any YouTube channel URL, @handle or UC… id into a clean structured profile — title, handle, description, subscriber and view counts, video count, country, join date, links, keywords, avatar and banner. Uses YouTube’s own InnerTube endpoint — no Data API key, no headless browser.

- **URL**: https://apify.com/receptional\_blender/youtube-channel-info.md
- **Developed by:** [Assia Fadli](https://apify.com/receptional_blender) (community)
- **Categories:** Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## YouTube Channel Details Scraper

**YouTube Channel Details Scraper** turns any YouTube channel link into a clean, structured profile.
Give it a channel URL, an `@handle`, or a `UC...` channel id — one at a time or a whole list — and
get back the numbers and metadata you actually need: display name, handle, description, subscriber
count, total views, video count, country, join date, external links, keywords, avatar and banner.

No YouTube Data API key. No headless browser. No login. It talks directly to YouTube's own internal
**InnerTube** API (the same endpoints the YouTube website uses), so it's fast, lightweight and cheap
to run.

Built for creators, analysts, agencies and developers who need dependable channel data without
maintaining scraping infrastructure.

### What you get

One dataset record per channel:

| Field | Description |
| --- | --- |
| `channelId` | The channel's `UC...` id |
| `title` | Channel display name |
| `handle` | `@handle`, e.g. `"@NASA"` |
| `description` | Full channel description |
| `subscribers` | Subscriber count text, e.g. `"15M subscribers"` |
| `subscriberCount` | Subscribers as a number (abbreviated values are approximate) |
| `videoCount` | Video count text, e.g. `"6,139 videos"` |
| `videoCountInt` | Video count as an exact number |
| `viewCount` | Total view count text, e.g. `"1,121,215,020 views"` |
| `viewCountInt` | Total views as an exact number |
| `country` | Channel country, when the channel makes it public |
| `joinedDate` | Join date text, e.g. `"Joined Jun 3, 2008"` |
| `keywords` | Channel keywords/tags (space-separated string) |
| `isFamilySafe` | Whether YouTube marks the channel family-safe |
| `availableCountryCodes` | ISO codes where the channel is available |
| `avatar` | Highest-resolution avatar URL |
| `banner` | Highest-resolution banner URL |
| `links` | External links as `[{ title, url }]` (resolved past YouTube's redirect) |
| `vanityUrl` | The channel's vanity URL |
| `url` | Canonical channel URL |

If a channel can't be read (doesn't exist, an invalid reference, or a temporary block), the actor
still writes a row — `{ "channel": "...", "error": "..." }` — so the rest of the batch always
completes.

### Input

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `channels` | array of strings | ✅ | `["https://www.youtube.com/@NASA", "MrBeast"]` | One or more channel references: URLs (`/@handle`, `/channel/UC...`, `/c/...`, `/user/...`), bare `@handle`/name, or `UC...` ids |
| `channel` | string | — | – | A single channel; merged with `channels` |
| `proxyCountryCode` | string | — | `US` | Two-letter residential-proxy country code; leave empty to let Apify choose |
| `language` | string | — | `en` | Interface language code (`hl`) for language-dependent text |

#### Example input

```json
{
    "channels": ["https://www.youtube.com/@NASA", "MrBeast"],
    "proxyCountryCode": "US"
}
```

#### Example output row

```json
{
    "channelId": "UCLA_DiR1FfKNvjuUpBHmylQ",
    "title": "NASA",
    "handle": "@NASA",
    "description": "NASA's mission is to pioneer the future in space exploration...",
    "subscribers": "15M subscribers",
    "subscriberCount": 15000000,
    "videoCount": "6,139 videos",
    "videoCountInt": 6139,
    "viewCount": "1,121,215,020 views",
    "viewCountInt": 1121215020,
    "country": null,
    "joinedDate": "Joined Jun 3, 2008",
    "keywords": "nasa space iss shuttle astronauts planets earth rockets hubble",
    "isFamilySafe": true,
    "availableCountryCodes": ["US", "GB", "DE"],
    "avatar": "https://yt3.googleusercontent.com/....=s900-c-k-c0x00ffffff-no-rj",
    "banner": "https://yt3.googleusercontent.com/....=w2276-...-no-nd-rj",
    "links": [
        { "title": "nasa.gov", "url": "https://www.nasa.gov" },
        { "title": "Instagram", "url": "https://www.instagram.com/nasa" }
    ],
    "vanityUrl": "http://www.youtube.com/@NASA",
    "url": "https://www.youtube.com/channel/UCLA_DiR1FfKNvjuUpBHmylQ"
}
```

### How it works

1. **Resolve the channel.** If the input already contains a `UC...` id (bare or inside a `/channel/`
   URL) it is used directly. Otherwise the actor POSTs to `youtubei/v1/navigation/resolve_url` to
   turn an `@handle` / `/c/` / `/user/` reference into a `UC...` browse id.
2. **Browse the channel.** It POSTs to `youtubei/v1/browse` with the channel's browse id and reads
   `metadata.channelMetadataRenderer` (title, description, keywords, avatar, vanity URL, available
   countries) and the page header (handle, subscribers, video count, banner).
3. **Read the About panel.** It follows the channel's "About" continuation to fetch exact
   subscriber / view / video counts, the join date, the country and the external links.

Requests are routed through Apify residential proxies when available, with an automatic fallback to a
direct connection so a blocked or absent proxy never crashes the run. Each channel is fetched
independently, so one failure never affects the rest of the batch.

### Pricing

This actor uses Apify's **pay-per-event** model. You're charged once per successfully scraped channel
(`channel-scraped`); error rows are never billed, and the run stops automatically once your budget is
reached.

### Notes & limitations

- `subscribers` is returned as YouTube's own abbreviated display text (e.g. `"15M subscribers"`);
  `subscriberCount` is derived from it and is therefore approximate. `viewCount`/`viewCountInt` and
  `videoCount`/`videoCountInt` are exact.
- `country` and `links` are only present when the channel makes them public.
- One row is emitted per input channel; if a channel can't be resolved the row is
  `{ channel, error }` and the run continues.
- YouTube can change its internal API at any time; this actor tolerates several response shapes but
  is not covered by an official API contract.

### Use cases

- Enrich a list of creators with subscriber, view and video counts for research or outreach
- Build channel dashboards, catalogues or competitive-analysis datasets
- Monitor channel growth and metadata over time
- Feed clean channel metadata into downstream ML / data pipelines

### Tech

Written in **TypeScript** on the Apify SDK. HTTP-only, so builds are fast and runs are cheap.

### License

MIT © Assia Fadli

# Actor input Schema

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

One or more YouTube channels to scrape. Each entry can be a channel URL (https://www.youtube.com/@NASA, /channel/UC..., /c/..., /user/...), a bare @handle or name (@NASA, MrBeast), or a UC... channel id. Each channel becomes one dataset row.

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

Convenience field for scraping a single channel. Same accepted formats as an entry in "YouTube channels". Merged with the "channels" list.

## `proxyCountryCode` (type: `string`):

Optional 2-letter country code (e.g. US, GB, DE) for the Apify residential proxy. Leave empty to let Apify pick automatically. If the proxy is unavailable the actor falls back to a direct request.

## `language` (type: `string`):

Optional interface language code (hl) passed to YouTube, e.g. "en", "es", "de". Affects language-dependent text such as the join date. Defaults to English.

## Actor input object example

```json
{
  "channels": [
    "https://www.youtube.com/@NASA",
    "MrBeast"
  ],
  "proxyCountryCode": "US",
  "language": "en"
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "channels": [
        "https://www.youtube.com/@NASA",
        "MrBeast"
    ],
    "proxyCountryCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("receptional_blender/youtube-channel-info").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "channels": [
        "https://www.youtube.com/@NASA",
        "MrBeast",
    ],
    "proxyCountryCode": "US",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/bNUUYyo5wUlZ1angx/builds/ha5dz3IyFHipBW7OP/openapi.json