# YouTube Channel Videos Scraper — Videos, Shorts & Lives (`datakiln/youtube-channel-videos-scraper`) Actor

Get every video, Short and live stream of any YouTube channel with title, views, duration, publish date and thumbnail. Sort by latest, popular or oldest. Optional exact dates, likes and descriptions. No API key or quota.

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

## Pricing

Pay per event

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/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 — videos, Shorts & lives

Get the **full list of videos, Shorts and live streams of any public YouTube channel** — no YouTube account, no API key, no daily quota. Paste channel links or @handles and get clean, structured data for every upload: title, link, view count, publish time, duration and thumbnail. Sort by *Latest*, *Most popular* or *Oldest*, keep only recent uploads, and turn on *Fetch video details* for exact publish dates, likes, descriptions and tags.

**Pay only for what you get: $0.50 per 1,000 videos.** No monthly rental, no start fees.

### What can you do with it?

- 📊 **Competitor & channel research** — export a creator's whole catalogue and see which topics, formats and lengths get the most views.
- 🔥 **Find a channel's best performers** — sort by *Most popular* to get the top videos or Shorts first.
- 🔔 **Monitor new uploads** — set *Published after* and run on a schedule to catch new videos from a list of channels. With *Latest* sort the scraper stops as soon as it reaches older videos, so monitoring runs stay cheap.
- 🎬 **Shorts and live-stream analytics** — scrape the Shorts tab and the Live tab (past, current and upcoming streams) separately from regular videos.
- 🤖 **Feed AI and BI pipelines** — titles, descriptions and tags for thousands of videos, ready for your LLM, spreadsheet or dashboard.
- 🔗 **Build input lists for other tools** — pass the video URLs to a comments, transcript or download tool.

### How to use

1. Add one or more channels: `https://www.youtube.com/@mkbhd`, `@mkbhd`, `https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ`, `/c/…` and `/user/…` URLs, or just the channel ID.
2. Pick what to scrape (*Videos*, *Shorts*, *Live streams*), how many items per tab, and the sort order.
3. Optional: set *Published after* to keep only recent uploads, and turn on *Fetch video details* for exact dates, likes, descriptions and tags.
4. Click **Start**. Download the results as JSON, CSV, Excel or HTML, or connect them to Make, Zapier, n8n, Google Sheets or your API.

### Input example

```json
{
  "channels": ["@mkbhd", "https://www.youtube.com/@LofiGirl"],
  "contentTypes": ["videos", "shorts", "streams"],
  "maxVideosPerChannel": 200,
  "sortBy": "latest",
  "dateFrom": "2026-01-01",
  "fetchVideoDetails": false
}
```

### Output example

```json
{
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelTitle": "Marques Brownlee",
  "channelHandle": "@mkbhd",
  "channelUrl": "https://www.youtube.com/@mkbhd",
  "videoId": "_0G4OG39XjI",
  "url": "https://www.youtube.com/watch?v=_0G4OG39XjI",
  "type": "video",
  "title": "WTF is a Googlebook?",
  "position": 1,
  "viewCount": 3167206,
  "viewCountText": "3.1M views",
  "publishedText": "18 hours ago",
  "approxPublishedDate": "2026-10-08",
  "publishedAt": "2026-10-08T21:00:40+00:00",
  "durationText": "14:13",
  "durationSeconds": 852,
  "thumbnailUrl": "https://i.ytimg.com/vi/_0G4OG39XjI/hq720.jpg?…",
  "isLiveNow": false,
  "isUpcoming": false,
  "isMembersOnly": false,
  "watchingNow": null,
  "likes": 56831,
  "description": "New laptops are dropping left and right! Let's talk about Google's entry…",
  "keywords": ["Googlebook", "MKBHD"],
  "category": "Science & Technology",
  "liveStartedAt": null,
  "liveEndedAt": null,
  "detailsFetched": true,
  "scrapedAt": "2026-10-09T15:42:25+00:00"
}
```

Without *Fetch video details*, `publishedAt`, `likes`, `description`, `keywords` and `category` are `null`, and `viewCount` is the rounded number shown on the channel page (`3.1M` → `3100000`).

#### All fields

| Field | Description |
|---|---|
| `channelId`, `channelTitle`, `channelHandle`, `channelUrl` | The channel the item belongs to |
| `videoId`, `url` | Video ID and link — `watch?v=` for videos and streams, `/shorts/` for Shorts |
| `type` | `video`, `short` or `stream` (from the channel tab it was found in) |
| `title` | Video title |
| `position` | Position in the tab for the chosen sort order (1 = first) |
| `viewCount`, `viewCountText` | Views as a number, and as shown on YouTube. Exact with details on, otherwise rounded (`3.1M`) |
| `publishedText` | Publish time as shown on the channel page (`3 weeks ago`, `Streamed 2 years ago`, `Scheduled for …`) |
| `approxPublishedDate` | Date estimated from `publishedText` — approximate (YouTube only shows relative ages) |
| `publishedAt` | Exact publish date and time in UTC (ISO 8601) — with *Fetch video details*. Date only (`2026-10-08`) when YouTube withholds the time |
| `durationText`, `durationSeconds` | Length as shown (`14:13`) and in seconds. Shorts get a duration with details on |
| `thumbnailUrl` | Largest thumbnail shown on the channel page |
| `isLiveNow`, `watchingNow` | The stream is live right now, and how many people are watching |
| `isUpcoming` | Scheduled stream or premiere that hasn't started yet |
| `isMembersOnly` | Video is for channel members only |
| `likes`, `description`, `keywords`, `category` | Like count, full description, tags and YouTube category — with *Fetch video details* (tags/category when YouTube provides them) |
| `liveStartedAt`, `liveEndedAt` | Start / end time of live streams (UTC) — with *Fetch video details* |
| `detailsFetched` | `true` when the extra details were fetched for this item |
| `scrapedAt` | When the item was collected (ISO 8601, UTC) |

### Pricing

Pay-per-result: **$0.50 per 1,000 videos ($0.0005/video)**, whether it's a video, Short or live stream. **+$0.001 per video when *Fetch video details* is on** — charged only for videos whose details were actually fetched. Platform usage is included. Cap the cost of any run with *Max total charge* in the run options — the scraper stops cleanly when the cap is reached.

### FAQ

**Do I need a YouTube account, API key or quota?** No. The scraper reads the same public channel pages anyone can see in a browser. There is no YouTube Data API quota to worry about.

**Are Shorts and live streams supported?** Yes. Choose *Shorts* and/or *Live streams* in *What to scrape*. The Live tab includes past streams, streams that are live right now (`isLiveNow`, `watchingNow`) and upcoming ones (`isUpcoming`).

**Can I get all videos of a channel?** Yes — set *Max items per channel* to `0`. The limit applies to each selected tab separately, so `100` with Videos + Shorts gives up to 100 of each.

**Why are dates approximate?** Channel pages only show relative ages such as *"3 weeks ago"*, and Shorts show no date at all. `approxPublishedDate` is estimated from that text. Turn on *Fetch video details* to get the exact `publishedAt` date and time for every item.

**How exact is the *Published after* filter?** With details off it's based on the relative age, so it can be a few days off near the cut-off date — when unsure, the video is kept rather than dropped. With *Fetch video details* on, the filter uses the exact publish date. For Shorts the exact date is always looked up, because the Shorts grid shows no dates. With *Latest* sort the scraper stops at the first older uploads; with other sort orders the whole tab is scanned and filtered.

**What exactly do I get with *Fetch video details*?** Always (when details load): the exact publish **date**, exact view count, like count and the full description. Usually also the exact publish **time**, tags, category, duration of Shorts and live-stream start/end times — but YouTube sometimes withholds this extended metadata from cloud servers. When it does, `publishedAt` is the date only (`2026-10-08`), `keywords` is empty and `category` is `null`; the run log tells you when this happens. If details can't be loaded at all for a video, it is still saved with the channel-page data, `detailsFetched` is `false`, and you're not charged the details fee for it.

**Why are view counts rounded?** The channel page shows rounded numbers (`3.1M views`). We convert them to integers. Turn on *Fetch video details* for exact counts.

**What if a channel doesn't exist or has no Shorts/Live tab?** The channel or tab is skipped with a clear note in the log, the rest of the run continues, and you're not charged for it.

**Is it legal?** It collects only publicly available information. You are responsible for using the data in line with YouTube's terms and the laws that apply to you, including data-protection rules such as GDPR when you process personal data.

### Related tools by DataKiln

- [YouTube Comments Scraper — comments, replies & likes of any video](https://apify.com/datakiln/youtube-comments-scraper)
- [YouTube Channel Email Finder — creator emails, socials & stats](https://apify.com/datakiln/youtube-channel-email-finder)

### Support

Found a bug or need a field that's missing? Open an issue on the **Issues** tab — we usually reply within 24 hours.

# Actor input Schema

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

YouTube channels to scrape. Paste channel URLs (https://www.youtube.com/@mkbhd, /channel/UC…, /c/…, /user/…), @handles or channel IDs starting with UC.

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

Which channel tabs to scrape: regular videos, Shorts and/or live streams (the channel's Live tab: past, current and upcoming streams).

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

How many items to save from each selected tab of each channel — e.g. 100 with Videos + Shorts gives up to 100 videos and 100 Shorts per channel. Set 0 to get everything.

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

Order in which the channel's items are returned — the same Latest / Popular / Oldest buttons you see on the channel page. If a tab doesn't offer the chosen order, Latest is used and the log says so.

## `dateFrom` (type: `string`):

Only return items published on or after this date (YYYY-MM-DD). With 'Latest' sort the scraper stops at the first older items, so recent-uploads monitoring is cheap. Channel pages only show relative dates ('3 weeks ago'), so the cut-off is approximate unless 'Fetch video details' is on — when unsure, the item is kept.

## `fetchVideoDetails` (type: `boolean`):

Also open every video to get its exact publish date, exact view count, like count and full description — plus, when YouTube provides them, the exact publish time, tags, category, Shorts duration and live-stream start/end times. Costs extra per video (see Pricing) and is slower.

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

How many channels and requests to process at the same time.

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

Not required — YouTube channel pages work without a proxy. Turn on Apify Proxy only if you see blocking on very large runs.

## Actor input object example

```json
{
  "channels": [
    "@mkbhd"
  ],
  "contentTypes": [
    "videos"
  ],
  "maxVideosPerChannel": 100,
  "sortBy": "latest",
  "fetchVideoDetails": false,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

All scraped videos, Shorts and live streams as structured JSON items.

## `videosTable` (type: `string`):

Videos in the overview table view.

# 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"
    ],
    "contentTypes": [
        "videos"
    ],
    "maxVideosPerChannel": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("datakiln/youtube-channel-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": ["@mkbhd"],
    "contentTypes": ["videos"],
    "maxVideosPerChannel": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("datakiln/youtube-channel-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": [
    "@mkbhd"
  ],
  "contentTypes": [
    "videos"
  ],
  "maxVideosPerChannel": 100
}' |
apify call datakiln/youtube-channel-videos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datakiln/youtube-channel-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/CEoKWAANJXbUeBEKs/builds/2DaugMxuIifEoAONd/openapi.json