# YouTube Channel Videos Scraper (Fast & Cheap) (`juliob.rangel/youtube-channel-videos`) Actor

List every video from any YouTube channel: title, views, publish date, duration and thumbnail, plus channel subscribers. Videos, Shorts or live streams. Accepts @handles, channel URLs or IDs.

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

## Pricing

from $0.70 / 1,000 video scrapeds

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 Scraper (Fast & Cheap)

YouTube Channel Videos Scraper lists every video from any YouTube channel with title, views, publish date, duration and thumbnail, plus the channel's subscriber count. It works on the Videos, Shorts and Live tabs and accepts @handles, channel URLs or channel IDs. It is a YouTube channel scraper for creators, agencies and analysts who research competitors or vet creators, and a simple way to export all videos of a YouTube channel to Excel, CSV or JSON without an API key.

### What does YouTube Channel Videos Scraper do?

You give it one or more YouTube channels and pick a tab. For each channel, the scraper finds the channel ID, opens the chosen tab and keeps loading the next page of the video grid until it reaches your limit or the end of the tab. Every video becomes one row, with the channel's name, URL and subscriber count repeated on each row so the table is easy to filter.

It accepts these forms, mixed in the same list:

| Input form | Example |
|---|---|
| @handle | `@mkbhd` |
| Handle without @ | `mkbhd` |
| Channel URL with handle | `https://www.youtube.com/@mkbhd` |
| Channel URL with ID | `https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ` |
| Channel ID | `UCBJycsmduvYEL83R_U4JriQ` |

And these tabs:

| `tab` value | What you get |
|---|---|
| `videos` | Regular uploads (default) |
| `shorts` | Shorts, with `youtube.com/shorts/` links |
| `streams` | Live streams and past broadcasts |

No YouTube account, API key or API quota is needed.

### What data can you extract?

| Field | What it means | Example |
|---|---|---|
| `channelId` | YouTube channel ID | `UCBJycsmduvYEL83R_U4JriQ` |
| `channelName` | Channel name | `Marques Brownlee` |
| `channelUrl` | Channel link as YouTube gives it (can start with `http://`) | `http://www.youtube.com/@mkbhd` |
| `subscribers` | Subscriber count, from YouTube's rounded text | `21400000` |
| `channelVideoCount` | Video count from the channel header, rounded | `1800` |
| `videoId` | YouTube video ID | `3iRUwVzRDZQ` |
| `title` | Video title | `Xiaomi 18 Fold: How Does This Happen?` |
| `url` | Video link (`/watch?v=` or `/shorts/`) | `https://www.youtube.com/watch?v=3iRUwVzRDZQ` |
| `views` | View count as a number, from the rounded text | `10000000` |
| `viewsText` | View text exactly as YouTube shows it | `10M views` |
| `published` | Relative publish time as YouTube shows it | `5 days ago` |
| `duration` | Video length as shown on the thumbnail | `10:47` |
| `thumbnail` | Thumbnail image URL | `https://i.ytimg.com/vi/3iRUwVzRDZQ/hqdefault.jpg` |
| `scrapedAt` | When the row was collected | `2026-10-08T20:09:09.433Z` |
| `input` | Only on error rows: the line from your list | `@mkbhd` |
| `error` | Only on error rows: what went wrong | `Channel not found` |

On the Shorts tab, `published` and `duration` are `null` because YouTube does not show them in the Shorts grid.

### How to use YouTube Channel Videos Scraper

1. Open YouTube Channel Videos Scraper in Apify Console (sign in or create an Apify account).
2. In **Channels**, add @handles, channel URLs or channel IDs, one per line.
3. Pick the **Content type**: Videos, Shorts or Live streams.
4. Set **Max videos per channel**. Use a high number to get a channel's full catalog.
5. Click **Start**. The log shows how many videos were found for each channel.
6. Open the **Output** tab and click **Export** to download JSON, CSV, Excel or HTML.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `channels` | array of strings | `["@mkbhd"]` | @handles, channel URLs (`youtube.com/@name`, `/channel/UC...`) or channel IDs. |
| `tab` | string: `videos`, `shorts` or `streams` | `videos` | Which channel tab to list. |
| `maxVideos` | integer, minimum 1 | `50` | Stop after this many videos for each channel. |
| `proxy` | object | `{"useApifyProxy": true}` | Apify Proxy settings. |

`maxVideos` counts per channel, so 10 channels with `maxVideos` 100 can return up to 1,000 rows. There is no upper limit; the scraper stops early when the tab has no more videos.

Example input:

```json
{
  "channels": [
    "@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "tab": "videos",
  "maxVideos": 200,
  "proxy": {
    "useApifyProxy": true
  }
}
```

### Output example

A real row from the latest run:

```json
{
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelName": "Marques Brownlee",
  "channelUrl": "http://www.youtube.com/@mkbhd",
  "subscribers": 21400000,
  "channelVideoCount": 1800,
  "videoId": "3iRUwVzRDZQ",
  "title": "Xiaomi 18 Fold: How Does This Happen?",
  "url": "https://www.youtube.com/watch?v=3iRUwVzRDZQ",
  "views": 10000000,
  "viewsText": "10M views",
  "published": "5 days ago",
  "duration": "10:47",
  "thumbnail": "https://i.ytimg.com/vi/3iRUwVzRDZQ/hqdefault.jpg",
  "scrapedAt": "2026-10-08T20:09:09.433Z"
}
```

### How much does it cost?

YouTube Channel Videos Scraper uses pay per event pricing. You pay **$1.00 per 1,000 videos** returned ($0.001 per video) on the Free plan. Platform usage (compute and proxy) is included in that price.

| Apify plan | Price per 1,000 videos |
|---|---|
| Free | $1.00 |
| Bronze (10% off) | $0.90 |
| Silver (20% off) | $0.80 |
| Gold and higher (30% off) | $0.70 |

Worked examples on the Free plan:

- The default run (50 latest videos of one channel) = **$0.05**
- 20 competitor channels × 200 videos = 4,000 videos = **$4.00**
- 10,000 videos across a creator list = **$10.00** ($7.00 on Gold)

What you are **not** charged for:

- Error rows: "Channel not found" and "No videos found on this tab".
- Retries and page loads. You pay per video row, not per request.
- Videos repeated across pages of the same channel; they are removed before saving.

### Use cases

- **Competitor research.** See which topics, titles and lengths get the most views on a competitor's channel.
- **Creator vetting.** Check how a creator's recent videos perform before a sponsorship, not just the subscriber count.
- **Content planning.** Export a niche's top channels and sort by `views` to find formats that work.
- **Shorts strategy.** List a channel's Shorts with their view counts and compare them with its long videos.
- **Live stream history.** Pull past broadcasts from the Live tab with their views and length.
- **Pipeline input.** Feed the `url` list into the transcript, comments or video details scrapers for AI analysis.
- **Channel monitoring.** Schedule a daily run with a small `maxVideos` to catch new uploads.

### Tips and limits

- **Rounded numbers.** `views`, `subscribers` and `channelVideoCount` are parsed from YouTube's short text, so "10M views" becomes `10000000` and "1.8K videos" becomes `1800`. `viewsText` keeps the original text. For exact view counts per video, use YouTube Video Details Scraper.
- **Relative dates.** `published` is the text YouTube shows, such as "5 days ago", "Streamed 2 weeks ago" or "Premiered …", not an exact date. Combine it with `scrapedAt` if you need an approximate date.
- **Shorts.** On the Shorts tab, links use `youtube.com/shorts/…` and `published` and `duration` are `null`.
- **Live now.** When YouTube shows a "watching" count instead of views (a stream that is live at run time), that number goes into `views` and `viewsText`.
- **Order.** Videos come in the order the tab shows them (newest first in the default Videos tab).
- **What is not included.** Likes, comment counts, descriptions, tags, exact upload dates and transcripts are not part of this output. See the related scrapers below.
- **Duplicates.** Each channel line is processed separately and duplicate lines are not merged, so a channel listed twice is scraped and charged twice. Keep one line per channel.
- **Retries.** Each request is tried up to 3 times through your proxy settings and then once more through Apify residential proxy when it is available.
- **Error rows.** "Channel not found" means the handle, URL or ID could not be resolved. "No videos found on this tab" means the channel exists but the chosen tab is empty (for example a channel with no Shorts); that row still includes the channel's name and subscribers.

### Use it from the API, Python or JavaScript

JavaScript (Node.js) with the official `apify-client` package:

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const input = { channels: ['@mkbhd'], tab: 'videos', maxVideos: 100 };

(async () => {
    const run = await client.actor('juliob.rangel/youtube-channel-videos').call(input);
    const { items } = await client.dataset(run.defaultDatasetId).listItems();
    console.log(items);
})();
```

Python with the official `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run_input = {'channels': ['@mkbhd'], 'tab': 'shorts', 'maxVideos': 100}

run = client.actor('juliob.rangel/youtube-channel-videos').call(run_input=run_input)
items = client.dataset(run['defaultDatasetId']).list_items().items
for item in items:
    print(item.get('title'), item.get('views'))
```

Plain HTTP, running the scraper and getting the rows in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/juliob.rangel~youtube-channel-videos/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channels": ["@mkbhd"], "maxVideos": 20}'
```

The scraper also works with Make, Zapier and n8n, can export results to Google Sheets, can call your webhook when a run finishes, and can be used by AI agents through the Apify MCP server.

### FAQ

#### Do I need a YouTube API key or login?

No. The scraper reads public channel pages without logging in, and there is no YouTube API quota to manage. You only need an Apify account.

#### Can I export all videos of a YouTube channel to Excel or CSV?

Yes. Set `maxVideos` higher than the channel's video count, run it, then export the dataset from the Output tab as Excel, CSV, JSON or HTML.

#### How many videos can I get per channel?

As many as the tab lists. The scraper keeps loading the next page until it reaches `maxVideos` or the end of the tab.

#### Can I scrape Shorts or live streams?

Yes. Set `tab` to `shorts` or `streams`. Run the scraper once per tab if you need all three.

#### Why is `published` "5 days ago" instead of a date?

That is the text YouTube shows in the channel grid. The scraper keeps it as is. For exact dates, pass the video URLs to YouTube Video Details Scraper.

#### Is it legal to scrape YouTube?

The scraper only collects publicly available data. You are responsible for complying with YouTube's terms and with privacy laws such as GDPR and LGPD. Personal data needs a legitimate reason to be collected and processed.

#### Why did I get a row with an `error` field?

The channel could not be found, or the chosen tab has no videos. Error rows are not charged.

### Related scrapers

- [YouTube Channel Info Scraper (Subscribers, Views, Links)](https://apify.com/juliob.rangel/youtube-channel-info)
- [YouTube Video Details Scraper (Views, Likes, Comments)](https://apify.com/juliob.rangel/youtube-video-details)
- [YouTube Comments Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-comments-fast)
- [YouTube Transcript Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-transcript-fast)
- [YouTube Playlist Scraper (All Videos, Views, Duration)](https://apify.com/juliob.rangel/youtube-playlist-scraper-fast)
- [YouTube Shorts Scraper (Channels & Hashtags)](https://apify.com/juliob.rangel/youtube-shorts-scraper)

***

## Vídeos de Canais do YouTube

Lista todos os vídeos de um canal (vídeos, Shorts ou lives) com título, visualizações, data, duração e inscritos do canal. Para pesquisa de concorrentes e avaliação de criadores. Sem chave de API; você paga só por vídeo retornado.

# Actor input Schema

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

@handles, channel URLs (youtube.com/@name, /channel/UC...) or channel IDs.

## `tab` (type: `string`):

Which tab to list.

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

Stop after this many videos for each channel.

## `proxy` (type: `object`):

Apify Proxy settings.

## Actor input object example

```json
{
  "channels": [
    "@mkbhd"
  ],
  "tab": "videos",
  "maxVideos": 50,
  "proxy": {
    "useApifyProxy": 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 = {
    "channels": [
        "@mkbhd"
    ],
    "maxVideos": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("juliob.rangel/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 = {
    "channels": ["@mkbhd"],
    "maxVideos": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("juliob.rangel/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 '{
  "channels": [
    "@mkbhd"
  ],
  "maxVideos": 50
}' |
apify call juliob.rangel/youtube-channel-videos --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,juliob.rangel/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/8djUKkbSYWEz8ablA/builds/K8PHy28Y6lzGlJEuT/openapi.json