# YouTube Channel Scraper | Details, Videos, Shorts, Streams (`genial_candlestand/youtube-channel-details-videos-scraper`) Actor

Get YouTube channel details (subscriberCount, exact viewCount, videoCount, country, links, business-email flag) plus videos, Shorts and streams with exact views, likes and publish date. Many handles or URLs per run, no login or API key.

- **URL**: https://apify.com/genial_candlestand/youtube-channel-details-videos-scraper.md
- **Developed by:** [Flowo](https://apify.com/genial_candlestand) (community)
- **Categories:** Social media, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 channel or videos

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Channel Scraper | Details, Videos, Shorts, Streams

![YouTube Channel Scraper | Details, Videos, Shorts, Streams](https://api.apify.com/v2/key-value-stores/Ll7RrWtDkZYOrBvfE/records/youtube-com-profile-page-channel-details-banner-1f50bc29.png)

This actor returns one row per YouTube channel with subscriber count, exact total views, video count, join date, country, external links and a business-email flag. It can also return one row per video, Short and live stream with title, exact views, likes, publish date and live status. Give it handles, channel URLs or channel IDs. No login and no API key are needed.

### What does YouTube Channel Scraper do?

For every channel you list, the actor saves:

- **A flat channel row** with subscribers, exact total views, exact public video count, join date, country, external links (real target URLs), a business-email flag, avatar, banner, keywords, verified badge and RSS feed URL.
- **Video rows** from the Videos tab, **Short rows** from the Shorts tab and **stream rows** from the Live tab (live now, upcoming and past streams). Each tab has its own limit.
- With **Exact stats** on (default), every video, Short and stream gets exact views, exact likes and a real publish date, Shorts included, at no extra charge.

You can sort by latest, popular or oldest, and keep only items published after a date (for example `7 days`). It suits marketers, analysts and developers who need YouTube channel data in a table or an API.

### How to scrape YouTube channel details, videos and Shorts

![How YouTube Channel Scraper works: Resolves each handle or URL to a channel ID; Reads channel details and the About tab; Pages the Videos, Shorts and Live tabs up to your limits; Returns one flat row ](https://api.apify.com/v2/key-value-stores/Ll7RrWtDkZYOrBvfE/records/youtube-com-profile-page-channel-details-how-a3c32f67.png)

1. Open the actor and add channels to **Channels**: `@MrBeast`, `https://www.youtube.com/@NASA`, `youtube.com/channel/UC…`, `/c/name`, `/user/name` or a bare channel ID.
2. Set the per-tab limits (**Max videos**, **Max Shorts**, **Max live streams**). Set all three to 0 to get only the channel details rows.
3. Optionally choose **Sort videos by** and **Published after**.
4. Run it and download the dataset as JSON, CSV, Excel or HTML, or call it through the API.

The default Apify datacenter proxy is enough; no residential proxy is needed.

### How much does it cost to scrape YouTube channels?

Price per event by Apify plan:

| Event | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Actor start | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| Channel or video | $0.90 per 1,000 | $0.81 per 1,000 | $0.72 per 1,000 | $0.63 per 1,000 |

A test run with the API example input below returned 152 rows in 33 s.

You pay per event:

- **$0.0009 per row** ($0.90 per 1,000 rows on the Free plan). A row is one channel details row or one video, Short or stream row. Exact views, likes and dates cost nothing extra.
- **$0.00005** per run start.
- Channels that are not found, missing tabs and skipped links are free.

Cost scenarios on the Free plan (start fee included):

| Scenario | Rows | Cost |
|---|---|---|
| 3 channels, details only (all limits 0) | 3 | about $0.003 |
| 1 channel with the defaults (30 videos + 30 Shorts + 30 streams, if it has them) | up to 91 | about $0.082 |
| 10 channels, 50 videos each | 510 | about $0.46 |
| 100 channels, 30 videos each | 3,100 | about $2.79 |

### Input

![YouTube Channel Scraper input example: Channels, Max videos per channel, Max Shorts per channel, Max live streams per channel, Sort videos by, Exact stats and dates](https://api.apify.com/v2/key-value-stores/Ll7RrWtDkZYOrBvfE/records/youtube-com-profile-page-channel-details-input-a604a073.png)

| Field | Meaning |
|---|---|
| `channels` | Handles, channel URLs or channel IDs, one per line |
| `startUrls` | The same as a URL list; merged with `channels`, duplicates scraped once |
| `maxVideos` / `maxShorts` / `maxStreams` | Rows per channel and tab (0–5000, default 30 each; 0 skips the tab) |
| `sortBy` | `latest` (default), `popular` or `oldest` |
| `publishedAfter` | Absolute date (`2026-10-01`) or relative (`7 days`, `3 months`). Needs Latest; live and upcoming streams are always kept |
| `exactStats` | On by default: exact views, likes and publish date for each item |
| `maxItems` | Total row cap, channel rows included |
| `proxyConfiguration` | Apify datacenter proxy by default |

Example input:

```json
{
  "channels": ["@MrBeast", "https://www.youtube.com/@NASA"],
  "maxVideos": 30,
  "maxShorts": 30,
  "maxStreams": 0,
  "sortBy": "latest"
}
```

### What data can you extract from YouTube channels?

![YouTube Channel Scraper output example: Type, Title, Channel ID, Views, Likes](https://api.apify.com/v2/key-value-stores/Ll7RrWtDkZYOrBvfE/records/youtube-com-profile-page-channel-details-output-f08d3f19.png)

Every row has `type` (`channel`, `video`, `short` or `stream`), `id`, `url`, `query`, `channelId` and `scrapedAt`. The other fields depend on the row type:

| Row type | Fields |
|---|---|
| `channel` | `title`, `handle`, `description`, `subscriberCount`, `subscriberCountText`, `videoCount`, `viewCount` (exact channel total), `joinedAt`, `country`, `location`, `isVerified`, `imageUrl` (avatar), `bannerUrl`, `tags`, `isFamilySafe`, `links`, `hasBusinessEmail`, `rssUrl`, `tabs` |
| `video`, `short`, `stream` | `title`, `author`, `authorUrl`, `position`, `imageUrl` (thumbnail), `viewCount`, `viewCountText`, `isViewCountExact`, `likeCount`, `publishedAt`, `dateText`, `publishedTimeText`, `liveStatus`, `badges` |
| `video`, ended `stream` | `durationSeconds`, `durationText` (not set on Shorts or on live and upcoming streams) |
| live or upcoming `stream` | `watchingCount` (people watching or waiting; null on other rows); `viewCount` is null |
| upcoming `stream` or premiere | `scheduledAt` (start date); `publishedAt` is null; null on other rows |

`liveStatus` is `none` (regular upload), `live`, `upcoming` or `ended`.

Example video row (from a real run):

```json
{
  "type": "video",
  "id": "_c2e1NcI3Sc",
  "url": "https://www.youtube.com/watch?v=_c2e1NcI3Sc",
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "query": "@MrBeast",
  "title": "Beat LeBron James In Basketball, Win $100,000",
  "author": "MrBeast",
  "position": 1,
  "viewCount": 55786202,
  "viewCountText": "55M views",
  "isViewCountExact": true,
  "likeCount": 886619,
  "publishedAt": "2026-10-31",
  "publishedTimeText": "2 days ago",
  "durationSeconds": 1348,
  "durationText": "22:28",
  "liveStatus": "none",
  "watchingCount": null,
  "scheduledAt": null,
  "scrapedAt": "2026-11-03T05:30:45.347Z"
}
```

Example channel row (shortened): `{"type": "channel", "title": "MrBeast", "handle": "@MrBeast", "subscriberCount": 525000000, "videoCount": 1011, "viewCount": 145642371073, "joinedAt": "2012-02-19", "country": "US", "isVerified": true, "hasBusinessEmail": true}`.

### Use cases

- **Influencer and creator vetting:** size, country, links, verified badge and business-email flag in one row per channel.
- **Competitor and media analysis:** what channels publish and how each video, Short or stream performs.
- **Upload monitoring:** schedule a run with `publishedAfter: "7 days"` to get only new items.
- **Top content:** sort by `popular` to list the most viewed videos and Shorts.
- **Creator databases and AI agents:** flat JSON rows that join on `channelId`.

### Limitations

- Subscriber counts are rounded by YouTube itself ("15.8M subscribers").
- The business email address is not returned, only whether the channel lists one (YouTube shows it to signed-in users only).
- With Exact stats off, views are rounded list values, there are no likes, and Shorts have no date.
- `likeCount` is `null` when the creator hides likes on a video.
- Titles and date texts are returned in English.
- Video, Shorts and playlist links are not channels and are skipped with a warning. Unknown channels give a warning, no row.
- Channels with very few uploads have no sort options and come in the default (latest) order. Topic channels may have no videos.
- Up to 5,000 rows per tab and channel.

### Tips and troubleshooting

- **Only new uploads:** use `sortBy: latest` with `publishedAfter` such as `7 days`; the date filter needs Latest order. Live and upcoming streams are always kept.
- **Only channel details:** set `maxVideos`, `maxShorts` and `maxStreams` to 0.
- **Fewer rows than expected:** the channel may have fewer items, or no such tab; missing tabs are skipped and not charged. Check `maxItems`, which caps all rows together.
- **A channel gives no row:** it was not found, or the link was a video, Short or playlist URL. Use a handle, channel URL or channel ID and check the run log warnings.
- **Missing dates or likes:** with `exactStats` off there are no likes and Shorts have no date; turn it back on (it costs nothing extra).
- **Proxy:** the default Apify datacenter proxy works; no residential proxy is needed.

### API, MCP and integrations

Run the actor from your code with the same JSON input as in Console. Your API token is in [Console → Settings → API & Integrations](https://console.apify.com/settings/integrations).

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("genial_candlestand/youtube-channel-details-videos-scraper").call(run_input={"channels": ["@MrBeast", "https://www.youtube.com/@NASA"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**Node.js** (`npm install apify-client`):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('genial_candlestand/youtube-channel-details-videos-scraper').call({"channels": ["@MrBeast", "https://www.youtube.com/@NASA"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**HTTP** — one request runs the actor and returns the results (runs up to 5 minutes; longer ones: [run asynchronously](https://docs.apify.com/api/v2/act-runs-post)):

```bash
curl -X POST "https://api.apify.com/v2/acts/genial_candlestand~youtube-channel-details-videos-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channels":["@MrBeast","https://www.youtube.com/@NASA"]}'
```

**AI agents (MCP).** Add the actor as a tool of the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=genial_candlestand/youtube-channel-details-videos-scraper"
```

Claude Desktop, Cursor or VS Code: `{"mcpServers": {"apify": {"url": "https://mcp.apify.com?tools=genial_candlestand/youtube-channel-details-videos-scraper"}}}`. Then ask, for example:

- "Get subscriber count and country of @MrBeast and @NASA"
- "List the 50 most viewed videos of @veritasium"
- "Get videos and Shorts published in the last 7 days by @NASA"

**Integrations.** Run it on a schedule with [Apify Schedules](https://docs.apify.com/platform/schedules) and send the results to Google Sheets, Slack, Zapier, Make, n8n or your webhook — see [Apify integrations](https://docs.apify.com/platform/integrations).

### FAQ

**Is it legal to scrape YouTube?**<br>
The actor reads only publicly visible channel data and needs no login. Check YouTube's terms and the rules on personal data (such as GDPR) for your use, and consult a lawyer if unsure.

**How is it different from other YouTube channel actors?**<br>
Channel details come as their own flat row instead of being nested and repeated on every video row. Shorts get an exact date and likes when Exact stats is on, and no residential proxy is needed.

**Do I need a proxy or API key?**<br>
No key. The default Apify datacenter proxy is sufficient.

**Can I get only channel details?**<br>
Yes, set the three limits to 0.

**Why is `viewCount` null on a live stream?**<br>
Live and upcoming streams show viewers in `watchingCount`, not views.

### Also useful

- [YouTube Comments Scraper](https://apify.com/genial_candlestand/youtube-comments-and-replies-scraper) — get comments and replies for the videos and Shorts you found
- [Google Trends Scraper](https://apify.com/genial_candlestand/google-trends-scraper) — compare search interest in a creator or topic over time
- [Google Trends Trending Now Scraper](https://apify.com/genial_candlestand/google-trending-now-scraper) — spot trending searches by country for content ideas

# Actor input Schema

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

YouTube channels, one per line: a @handle (@MrBeast), a channel URL (youtube.com/@NASA, /channel/UC…, /c/name, /user/name, m.youtube.com works too) or a channel ID (UC + 22 characters). Video, Shorts and playlist links are not channels and are skipped with a warning. Fill this or Start URLs.

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

The same as Channels, as a URL list (handy for imports and calls written for other channel scrapers). Both lists are merged; a channel given twice is scraped once.

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

Regular videos (Videos tab) per channel. 0 = skip videos. Set all three limits to 0 to get only the channel details row.

## `maxShorts` (type: `integer`):

Shorts (Shorts tab) per channel. 0 = skip Shorts.

## `maxStreams` (type: `integer`):

Live streams (Live tab: live now, upcoming and past streams) per channel. 0 = skip streams.

## `sortBy` (type: `string`):

Order of videos, Shorts and streams in every tab, as on YouTube: latest first, most popular first or oldest first. Channels with very few uploads have no sort options: they come in YouTube's default (latest) order with a warning. Published after works only with Latest.

## `publishedAfter` (type: `string`):

Only videos, Shorts and streams published on or after this date: an absolute date (2026-10-01) or a relative one (7 days, 2 weeks, 3 months = that long ago). Needs Sort by Latest. Turns Exact stats on, because Shorts have no date in the list. Live and upcoming streams are always kept. Empty = no date filter.

## `exactStats` (type: `boolean`):

Adds the exact view count, like count and publish date to every video, Short and stream (one small extra request per item, same price). Off = faster, with rounded views ("54M views"), no likes and no dates for Shorts.

## `maxItems` (type: `integer`):

Stop after this many rows in total (channel rows included). Empty = no total limit; the per-channel limits still apply.

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

Apify datacenter proxy is enough for YouTube (no residential proxy needed).

## Actor input object example

```json
{
  "channels": [
    "@MrBeast",
    "https://www.youtube.com/@NASA"
  ],
  "maxVideos": 30,
  "maxShorts": 30,
  "maxStreams": 30,
  "sortBy": "latest",
  "exactStats": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All rows: channel details rows (type channel) and video, Short and stream rows (type video, short, stream)

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

All rows with the most useful columns

# 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": [
        "@MrBeast",
        "https://www.youtube.com/@NASA"
    ]
};

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

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

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

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

```

## CLI example

```bash
echo '{
  "channels": [
    "@MrBeast",
    "https://www.youtube.com/@NASA"
  ]
}' |
apify call genial_candlestand/youtube-channel-details-videos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,genial_candlestand/youtube-channel-details-videos-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bxGv6Emk9fhY9JTSh/builds/09TRlOgfa8kC1e2tm/openapi.json
