# YouTube Channel Videos & Shorts Stats (`getdataforu/youtube-channel-videos`) Actor

Latest videos, Shorts and live streams of any list of YouTube channels with exact views and likes, post dates and durations, plus a per-channel report with median views, like rate and upload pace. No API key.

- **URL**: https://apify.com/getdataforu/youtube-channel-videos.md
- **Developed by:** [EMT Crawler](https://apify.com/getdataforu) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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.
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 Videos & Shorts Stats

Paste a list of YouTube channels. Get back their latest **videos, Shorts and live streams** with **exact views and likes**, post date, length and description — plus a report that compares the channels on median views, like rate and upload pace.

No YouTube API key, no Google account, no quota.

### Exact numbers, not "1.1M views"

A channel page only shows rounded counts. This actor reads each video's exact figures: **1,206,162 views and 29,431 likes**, not "1.2M views". That is the difference between a guess and a number you can put in a report or an invoice.

### What it's for

- **Influencer vetting** — before you book a creator, see what their last 30 videos and Shorts really did. Median views tells you what a typical post gets; one viral hit can't inflate it.
- **Competitor tracking** — run weekly on rival channels and see which formats and topics are working for them.
- **Content strategy** — compare long videos vs Shorts on the same channel, and how often top channels post.
- **Agency reporting** — one table for a whole roster of creators.

### What you get for each video

| | |
|---|---|
| **Performance** | Exact views, exact likes, like rate (likes ÷ views); concurrent viewers for live streams |
| **Video** | Type (video, Short, stream), title, description, length, thumbnail, link |
| **Timing** | Post date, position on the channel tab |
| **Channel** | Name, @handle, channel ID, subscribers |

Real rows from a test run of 7 channels:

| Channel | Type | Title | Views | Likes |
|---|---|---|---|---|
| MrBeast | video | $1 vs $1,000,000,000 Nuclear Bunker! | 196,896,298 | 3,092,581 |
| Veritasium | video | Why does every mammal get 1 billion heartbeats? | 6,645,239 | 153,565 |
| Marques Brownlee | video | Apple Homeview Impressions: Not Convinced! | 1,206,162 | 29,431 |
| NASA | short | Moon Rocket on the Move | 484,279 | 14,938 |

### The channel report

Every run writes a **`CHANNEL_REPORT`** to the key-value store, one entry per channel: subscribers, videos checked, total, **median** and average views, average likes, like rate, **uploads per week**, newest and oldest post, the top 5 videos, and the same numbers split by **videos vs Shorts**. From the test run:

| Channel | Subscribers | Median views | Like rate | Uploads / week |
|---|---|---|---|---|
| Marques Brownlee | 21.4M | 5,840,816 | 2.5% | 1.0 |
| Veritasium | 21.4M | 5,414,429 | 2.2% | 1.2 |
| NASA | 15.1M | 294,405 | 2.8% | 0.4 |
| TED | 27.9M | 41,919 | 1.0% | 10.9 |

### Input

```json
{
  "channelUrls": ["https://www.youtube.com/@MKBHD", "@NASA", "UCBJycsmduvYEL83R_U4JriQ"],
  "contentTypes": ["videos", "shorts"],
  "maxVideosPerChannel": 30,
  "newerThanDays": 90
}
```

| Field | Default | Notes |
|---|---|---|
| `channelUrls` | — | **Required.** @handle links, /channel/, /c/ and /user/ links, bare @handles or UC... IDs. |
| `contentTypes` | videos, Shorts | Any of `videos`, `shorts`, `streams` (past live streams). |
| `maxVideosPerChannel` | `30` | Per channel **and** per type: 30 means up to 30 videos and 30 Shorts. |
| `newerThanDays` | — | Only items posted in the last N days. Older ones are skipped and never charged. |
| `includeDescription` | `true` | Full video descriptions. |
| `includeLiveAndUpcoming` | `false` | Also save streams that are live now or scheduled. |
| `maxConcurrency` | `10` | Videos read in parallel (up to 10). |

### Speed and cost

Measured: **420 videos and Shorts from 7 channels, every one with exact views and likes.** A batch of 3 channels (180 videos) finished in 90 seconds. The actor talks to YouTube directly and only falls back to a proxy when YouTube refuses a request, which keeps runs fast and cheap.

### You only pay for videos you get

Channels that don't exist, wrong links and videos outside your date filter are never written to the dataset, so they are never charged. Failed channels are listed with the reason in `CHANNEL_REPORT.failed`.

### Limitations

- **Subscriber counts are rounded** ("21.4M") — YouTube does not publish exact ones.
- Comment counts are not included; use the companion **YouTube Comments Scraper** for comments.
- Shorts have no length in the channel listing, so `durationSeconds` is empty for them.
- Members-only and private videos are not visible to logged-out visitors and are skipped.

### Legal

Reads only what YouTube shows any visitor without logging in. You are responsible for how you use the data.

# Actor input Schema

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

Channel links (@handle, /channel/, /c/ or /user/ links), bare @handles or UC... channel IDs, one per line.

## `contentTypes` (type: `array`):

Which tabs of each channel to read. Each is collected separately, newest first.

## `maxVideosPerChannel` (type: `integer`):

For example 30 means up to 30 latest videos and 30 latest Shorts per channel.

## `newerThanDays` (type: `integer`):

Skip anything older. Leave empty to take the latest items regardless of date. Older items are never charged.

## `includeDescription` (type: `boolean`):

Add each video's full description - links, sponsors, hashtags.

## `includeLiveAndUpcoming` (type: `boolean`):

Also save streams that are live right now (with concurrent viewers) or scheduled. They have no final view count yet.

## `maxConcurrency` (type: `integer`):

How many videos are read at the same time.

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

Requests go out directly. This proxy is only used when YouTube refuses one, so most runs use no proxy traffic at all.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MKBHD",
    "@NASA",
    "UCBJycsmduvYEL83R_U4JriQ"
  ],
  "contentTypes": [
    "videos",
    "shorts"
  ],
  "maxVideosPerChannel": 30,
  "includeDescription": true,
  "includeLiveAndUpcoming": false,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `videos` (type: `string`):

Every video, Short and stream collected: exact views and likes, like rate, post date, duration, description and channel.

## `channelReport` (type: `string`):

Per channel: subscribers, median and average views, like rate, uploads per week, videos vs Shorts, top videos, and channels that failed.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "channelUrls": [
        "https://www.youtube.com/@MKBHD",
        "@NASA"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "channelUrls": [
        "https://www.youtube.com/@MKBHD",
        "@NASA",
    ] }

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

```

## MCP server setup

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

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/mYQjS0nallDUfpnK5/builds/xsmYu65VdaKu1kWGS/openapi.json