# YouTube Channel Scraper | Videos, Shorts and Views (`silentflow/youtube-channel-scraper`) Actor

Extract every video, Short and live stream from any YouTube channel: exact publish date, views, likes, duration, description, tags and category, plus subscribers, total views, country and social links for the channel. No API key, no login. Filter by date for daily monitoring of new uploads.

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

## Pricing

from $0.68 / 1,000 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

**Turn any YouTube channel into a table: every video, short and live stream with its exact publish date, views and likes, and the channel's own numbers on each row.** 50 videos with full details in 4 seconds.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/YXm81xySHg6uRkewS/records/youtube-channel-scraper-how-it-works-v1.png)

1. **You paste one or more channels.** A channel address, an `@handle` or a channel id all work, in the same field.
2. **The channel is read tab by tab.** Videos, Shorts and Live streams, in the order you choose: latest, most popular or oldest. A date floor keeps only what was published after the day you pick.
3. **One row comes back per video.** 33 fields: the video with its exact numbers, and the channel it belongs to with subscribers, total views, country and links. Ready for a spreadsheet, a database or an AI pipeline.

### ✨ Why teams choose this over other YouTube channel scrapers

Copying view counts from a channel page into a spreadsheet, one video at a time? Getting dates back as "3 weeks ago" and wondering how to sort them? Running one tool for the videos and another for the channel stats, then joining the two by hand?

- 📅 **Dates you can sort and filter.** Every row carries the exact publish date and time in RFC 3339 (`2026-09-16T12:01:27Z`), not a label like "6 days ago". Filter a quarter, chart a cadence, join on a calendar, no cleaning needed.
- 🎯 **Exact numbers, not rounded ones.** A channel page shows "8M views". The row says `8009051` views and `124170` likes, the values YouTube publishes for the video itself.
- 📺 **The video and its channel in the same row.** 21 video fields and 12 channel fields together: subscribers, total videos, total views, country, joined date, verified badge and the links of the About panel. One dataset answers both "how did this video do" and "how big is this creator".
- 🎬 **Videos, Shorts and Live streams in one run.** Pick one, two or all three types. Each type gets its own cap, so Shorts never crowd out long videos.
- ⏱️ **Built for daily monitoring.** Set `publishedAfter` to `1 day` on a schedule and each run returns only the new uploads. With the latest sort the run stops at the first older video, so watching 100 channels stays quick.
- 🧹 **A clean dataset, every time.** One row is one real video. A channel that does not exist or a tab a channel does not have produces no row and a clear message on the run. Unknown values are `null`, never an empty string, and no video appears twice.
- 🔑 **No API key, no login.** Nothing to create in a cloud console, no daily quota to watch, no account to connect. Paste a channel and press Start.

### 🎯 What you can do with YouTube channel data

| Team | What they build |
|------|-----------------|
| Influencer marketing | A vetting sheet per creator before a deal: median views of the last 30 videos, likes per view, upload cadence, country and contact links |
| Competitive research | A weekly digest of everything rival channels published, with the videos that beat the channel's average |
| Content and SEO | A ranked list of a niche's most viewed videos by channel, with titles, descriptions and tags to find the topics that work |
| Social listening | A daily feed of new uploads from a watchlist of 200 channels, pushed to Slack or a database |
| Data and AI | A full catalogue of a channel (titles, descriptions, durations, dates) as the index for transcripts, search or RAG |
| Media and sponsorship sales | A report of a partner channel's Shorts and long videos with exact views 7 and 30 days after release |
| Lead generation | A list of channels in a vertical with subscribers, country and the website and social links from the About panel |

### 📥 Input parameters

#### Essentials

| Field | Type | Description |
|-------|------|-------------|
| `channelUrls` | array, required | Channels to read, one per line. Accepts a channel address (`https://www.youtube.com/@mkbhd`, with or without `/videos`), a handle (`@mkbhd`) or a channel id (`UCBJycsmduvYEL83R_U4JriQ`). Older `/c/name` and `/user/name` addresses work too. |
| `maxItems` | integer, default `50` | Maximum rows per channel, for each selected video type. `50` with Videos and Shorts selected returns up to 100 rows per channel. |

#### 🔍 Filters

| Field | Type | Description |
|-------|------|-------------|
| `videoTypes` | array, default `["videos"]` | Tabs to read: `videos`, `shorts`, `streams`. A channel without one of these tabs returns nothing for it. |
| `sortBy` | string, default `latest` | `latest` (newest first), `popular` (most viewed of all time) or `oldest` (first uploads of the channel). The order decides what the cap keeps. |
| `publishedAfter` | string | Keep only videos published after a date (`2026-01-31`) or within an age (`7 days`, `2 weeks`, `3 months`, `1 year`). |

#### 📄 Output

| Field | Type | Description |
|-------|------|-------------|
| `includeDetails` | boolean, default `true` | On: exact date and time, exact views, likes, description, tags, hashtags, category. Off: a faster listing with title, rounded views, duration and an estimated date. |

#### ⚙️ Advanced

| Field | Type | Description |
|-------|------|-------------|
| `debugMode` | boolean, default `false` | Adds detailed lines to the run log. Leave it off for normal runs. |

### 📊 Output data

Each row is one video. With details on (the default), a regular video looks like this:

```json
{
  "id": "ohqxP8EEumo",
  "url": "https://www.youtube.com/watch?v=ohqxP8EEumo",
  "title": "iPhone 18 Pro Review: All About that Chip",
  "type": "video",
  "description": "iPhone 18 Pro is basically an S year upgrade. And one part of it is really impressive.\n\n0:00 Intro\n1:21 This Camera\n6:47 The Chip\n10:20 Battery Boost\n13:04 The Little Things\n14:22 Conclusion",
  "category": "Science & Technology",
  "tags": null,
  "hashtags": null,
  "duration": "00:16:35",
  "durationSeconds": 995,
  "isLive": false,
  "isMembersOnly": false,
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelName": "Marques Brownlee",
  "channelUsername": "@mkbhd",
  "channelUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
  "channelDescription": "MKBHD: Quality Tech Videos | YouTuber | Geek | Consumer Electronics | Tech Head | Internet Personality!",
  "channelLocation": "United States",
  "channelJoinedDate": "2008-03-21T00:00:00Z",
  "numberOfSubscribers": 21200000,
  "channelTotalVideos": 1851,
  "channelTotalViews": 5658099674,
  "isChannelVerified": true,
  "channelLinks": [
    { "text": "Twitter", "url": "http://twitter.com/MKBHD" },
    { "text": "Instagram", "url": "http://instagram.com/MKBHD" },
    { "text": "Discord", "url": "http://discord.gg/MKBHD" }
  ],
  "viewCount": 8009051,
  "likes": 124170,
  "date": "2026-09-16T12:01:27Z",
  "thumbnailUrl": "https://i.ytimg.com/vi/ohqxP8EEumo/maxresdefault.jpg",
  "channelAvatarUrl": "https://yt3.googleusercontent.com/qu4TmIaYUlS41-dJ9gZ7DUR3nilvmB5_11i6OKSdvNnBNiyOusZP1bMN6ICnuxtjFBb6ioKgRQ=s900-c-k-c0x00ffffff-no-rj",
  "channelBannerUrl": "https://yt3.googleusercontent.com/zi_48HwHU4s0Hnb6tZuvRzTfCPHrLEnrtIMDLzMauDEyDmURh9JZ4wrNd3lKr7m9uVnT4YjYKw=w2560-fcrop64=1,00005a57ffffa5a8-k-c0xffffffff-no-nd-rj",
  "order": 0,
  "input": "https://www.youtube.com/@mkbhd",
  "scrapedAt": "2026-09-17T13:17:10Z"
}
```

With details off, a Short from the listing keeps the same 33 columns. What the listing does not show reads `null` (channel block shortened here):

```json
{
  "id": "tI704AA0B2I",
  "url": "https://www.youtube.com/shorts/tI704AA0B2I",
  "title": "Web scraping: which websites can't you scrape?  #apify #webscraping #coding",
  "type": "short",
  "description": null,
  "duration": null,
  "viewCount": 725,
  "likes": null,
  "date": null,
  "channelName": "Apify",
  "numberOfSubscribers": 26000,
  "thumbnailUrl": "https://i.ytimg.com/vi/tI704AA0B2I/frame0.jpg",
  "order": 0,
  "input": "@Apify",
  "scrapedAt": "2026-09-17T13:17:21Z"
}
```

### 🗂️ Data fields

33 fields per row: 4 identity, 8 content, 12 channel, 2 measures, 1 date, 3 media, 3 meta. `channelLinks` is the only nested field, a list of `{ text, url }` pairs.

| Group | Fields |
|-------|--------|
| Identity | `id`, `url`, `title`, `type` (`video`, `short` or `stream`) |
| Content | `description`, `category`, `tags`, `hashtags`, `duration` (`HH:MM:SS`), `durationSeconds`, `isLive`, `isMembersOnly` |
| Channel | `channelId`, `channelName`, `channelUsername`, `channelUrl`, `channelDescription`, `channelLocation`, `channelJoinedDate`, `numberOfSubscribers`, `channelTotalVideos`, `channelTotalViews`, `isChannelVerified`, `channelLinks` |
| Measures | `viewCount`, `likes` |
| Time | `date` (RFC 3339, UTC) |
| Media | `thumbnailUrl`, `channelAvatarUrl`, `channelBannerUrl` |
| Meta | `order` (position in the channel listing, per type), `input` (the channel as you typed it), `scrapedAt` (RFC 3339, UTC) |

Good to know when you store the data:

- `id` is YouTube's permanent video id and `channelId` the permanent channel id. Both survive a title change or a handle change. `url` and `channelUrl` are built from them and are permanent.
- `date` is the release date of a video and the start of the broadcast for a live stream.
- `thumbnailUrl`, `channelAvatarUrl` and `channelBannerUrl` are image links served by YouTube. They stay valid as long as the creator keeps the image.
- `tags` and `hashtags` are filled when the creator publishes them. Many channels publish none, and the fields then read `null`.
- `numberOfSubscribers` is rounded by YouTube itself (`21200000` for "21.2M"). Total views and total videos are exact.
- A stream that is live right now has `isLive: true` and no `duration` yet.
- A video reserved for the paying members of a channel is listed with `isMembersOnly: true`. YouTube publishes its title, date, duration and likes, and no view count, so `viewCount` reads `null`. Filter on this flag before computing averages.

### 🚀 Examples

#### Get the 50 latest videos of a channel

```json
{
  "channelUrls": ["https://www.youtube.com/@mkbhd"]
}
```

#### Find the 100 most viewed videos of two competitors

```json
{
  "channelUrls": ["@LinusTechTips", "@mkbhd"],
  "sortBy": "popular",
  "maxItems": 100
}
```

#### Pull only what a watchlist published since yesterday

Put this on a daily schedule. Each run returns the new uploads and nothing else.

```json
{
  "channelUrls": ["@mkbhd", "@LinusTechTips", "@veritasium", "@TED"],
  "publishedAfter": "1 day",
  "maxItems": 20
}
```

#### Export a channel's Shorts and long videos together

```json
{
  "channelUrls": ["https://www.youtube.com/@MrBeast"],
  "videoTypes": ["videos", "shorts"],
  "maxItems": 200
}
```

#### List a channel's live streams, past and current, as fast as possible

```json
{
  "channelUrls": ["@LofiGirl"],
  "videoTypes": ["streams"],
  "includeDetails": false,
  "maxItems": 100
}
```

#### Rebuild the first year of a channel from its very first upload

```json
{
  "channelUrls": ["UCBJycsmduvYEL83R_U4JriQ"],
  "sortBy": "oldest",
  "maxItems": 150
}
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT or Cursor to give it full context about this scraper:

```
You have access to the Youtube Channel Scraper on Apify: silentflow/youtube-channel-scraper

Input schema:
- channelUrls (required, array of strings): channel addresses, @handles or channel ids (UC...)
- maxItems (integer, default 50): max rows per channel, for each selected video type
- videoTypes (array, default ["videos"]): any of "videos", "shorts", "streams"
- sortBy (string, default "latest"): "latest", "popular" or "oldest"
- publishedAfter (string, optional): "2026-01-31" or an age like "7 days", "2 weeks", "3 months", "1 year"
- includeDetails (boolean, default true): exact date, exact views, likes, description, tags, hashtags, category
- debugMode (boolean, default false)

Output, one row per video (33 fields, null when unknown):
- id (string), url (string), title (string), type ("video" | "short" | "stream")
- description (string), category (string), tags (string[]), hashtags (string[])
- duration ("HH:MM:SS"), durationSeconds (integer), isLive (boolean), isMembersOnly (boolean)
- channelId, channelName, channelUsername, channelUrl, channelDescription, channelLocation (strings)
- channelJoinedDate (RFC 3339), numberOfSubscribers, channelTotalVideos, channelTotalViews (integers)
- isChannelVerified (boolean), channelLinks ({text, url}[])
- viewCount (integer), likes (integer)
- date (RFC 3339 UTC)
- thumbnailUrl, channelAvatarUrl, channelBannerUrl (strings)
- order (integer), input (string), scrapedAt (RFC 3339 UTC)

No API key and no login needed. Use apify-client for Python or JavaScript.
```

### 💻 Integrations

#### Score a creator before a sponsorship deal (Python)

```python
from statistics import median
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("silentflow/youtube-channel-scraper").call(run_input={
    "channelUrls": ["@mkbhd"],
    "maxItems": 30,
})
videos = list(client.dataset(run["defaultDatasetId"]).iterate_items())

public = [v for v in videos if not v["isMembersOnly"] and v["viewCount"]]
views = [v["viewCount"] for v in public]
likes = [v["likes"] or 0 for v in public]
channel = videos[0]
print(channel["channelName"], channel["numberOfSubscribers"], "subscribers,", channel["channelLocation"])
print("Median views, last 30 videos:", median(views))
print("Likes per 1,000 views:", round(1000 * sum(likes) / sum(views), 1))
```

#### Post new uploads from a watchlist to Slack (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('silentflow/youtube-channel-scraper').call({
    channelUrls: ['@LinusTechTips', '@mkbhd', '@veritasium'],
    publishedAfter: '1 day',
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const video of items) {
    await fetch(process.env.SLACK_WEBHOOK_URL, {
        method: 'POST',
        body: JSON.stringify({ text: `${video.channelName} published "${video.title}" ${video.url}` }),
    });
}
```

#### Find the videos that beat a channel's average (Python, CSV export)

```python
import csv
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("silentflow/youtube-channel-scraper").call(run_input={
    "channelUrls": ["@veritasium"],
    "maxItems": 200,
})
videos = list(client.dataset(run["defaultDatasetId"]).iterate_items())
average = sum(v["viewCount"] or 0 for v in videos) / len(videos)
winners = sorted((v for v in videos if (v["viewCount"] or 0) > 2 * average), key=lambda v: -v["viewCount"])

with open("winners.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["title", "date", "viewCount", "likes", "url"])
    for v in winners:
        writer.writerow([v["title"], v["date"], v["viewCount"], v["likes"], v["url"]])
```

### 📈 Performance

Measured on 17 September 2026 on real channels.

| Run | Rows | Time |
|-----|------|------|
| 1 channel, 50 latest videos, details on (the default input) | 50 | 4 seconds |
| 2 channels, 200 videos each, details on | 400 | 38 seconds |
| 2 channels, Shorts and Live streams by popularity, details off | 60 | 2 seconds |
| 2 channels, videos of the last 30 days, details on | 27 | 3 seconds |
| 1 channel, its whole catalogue of long videos, details off | 1,719 | 47 seconds |

| Metric | Value |
|--------|-------|
| Fields per row | 33 |
| Videos per listing page | about 30 |
| Columns filled on the default run | all, except `tags` and `hashtags` when the creator sets none |
| Limit per run | no fixed limit: the cap is per channel and per type, and you choose it |

### 💾 Data export

Every run stores its rows in a dataset you can download as JSON, CSV, Excel, XML or HTML from the Storage tab, or pull from the API:

```
https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv&token=YOUR_TOKEN
```

The dataset has two ready-made table views: **Videos** (title, channel, type, views, likes, published, duration, URL) and **Channel stats** (channel, handle, subscribers, videos, total views, country, joined, URL). Schedules, webhooks and the Apify integrations (Google Sheets, Slack, Zapier, Make, n8n) work on top of the same dataset.

### 💡 Tips for best results

1. **Monitoring? Combine `publishedAfter` with the latest sort.** `"publishedAfter": "1 day"` on a daily schedule reads only the top of each channel and returns only new uploads.
2. **Keep details on when dates matter.** Exact dates, exact views and likes come with details. Turn details off only for a fast inventory of titles and rounded views.
3. **Use channel ids for long-lived pipelines.** A creator can change an `@handle`. The `UC...` id never changes, and every row gives it to you in `channelId`.
4. **Size `maxItems` per type.** With Videos and Shorts both selected, `maxItems: 100` means up to 100 of each per channel.
5. **Use `popular` to benchmark, `oldest` to study a launch.** The most viewed videos show what a channel is known for. The first uploads show how it started.
6. **Group rows by `channelId` for channel-level reports.** The channel block is identical on every row of a channel, so the first row of each group is the channel's profile.

### ❓ FAQ

**What does this scraper extract?**
Every public video, Short and live stream of the channels you list, one row each, with 33 fields: the video (title, exact date, views, likes, duration, description, tags, hashtags, category, thumbnail) and its channel (name, handle, subscribers, total videos, total views, country, joined date, verified badge, links, avatar, banner).

**What can I type in the channel field?**
A channel address in any form (`https://www.youtube.com/@name`, with or without a tab like `/videos`, `/channel/UC...`, `/c/name`, `/user/name`), a handle (`@name`) or a channel id (`UC...`). Anything else is skipped and named in the run log.

**Do I need a YouTube account or an API key?**
No. The scraper reads public channel pages. There is no login, no key and no quota to manage.

**How fresh is the data?**
Live. Every run reads YouTube at run time, nothing is served from a cache. `scrapedAt` tells you when each row was read.

**Is there a limit on the number of videos?**
No fixed limit. `maxItems` is per channel and per type, and a run walks a channel page by page until that cap or the end of the channel. A whole catalogue of 1,719 long videos was exported in 47 seconds with details off.

**Can I scrape many channels in one run?**
Yes. List as many channels as you need. A channel named twice, for instance once by handle and once by id, is read once, and no video is ever delivered twice in a run.

**How do the filters combine?**
They stack. `videoTypes: ["shorts"]` with `sortBy: "popular"` and `maxItems: 25` returns the 25 most viewed Shorts of each channel. Adding `publishedAfter: "3 months"` keeps only those released in the last three months.

**Why are `tags` or `hashtags` null on some rows?**
Because the creator set none, or keeps them private. Hashtags are read from the description, tags are the public keywords of the video. Many large channels publish neither.

**What happens with details off?**
You get the listing as the channel page shows it: title, rounded views (`8000000` for "8M views"), duration and a date estimated from the age label ("11 days ago"). Shorts show neither age nor duration in the listing, so those two fields read `null`. If you set `publishedAfter`, the date of each Short is still read exactly, so the filter stays correct.

**What if a channel does not exist or has no Shorts tab?**
No row is written for it. The run log names the channel, and a run that ends with no rows at all says why on the run itself. Your dataset never contains error rows.

**Are the URLs permanent?**
`url` and `channelUrl` are permanent. Image links (`thumbnailUrl`, avatar, banner) stay valid as long as the creator keeps the image.

**Does it get comments, transcripts or the video file?**
No. This scraper is about channel catalogues and performance. For transcripts, see the related scrapers below.

### ⚖️ Legal

This Actor extracts publicly available data from YouTube. It does not bypass any login, paywall or CAPTCHA, and it does not download video files. Users are responsible for complying with YouTube's terms of service and with applicable data protection laws (GDPR, CCPA, and PIPL where relevant). The output contains creator information that creators publish themselves (channel name, description, country, links); when you process it as personal data, handle it accordingly. The data returned is informational; verify accuracy for regulated use cases.

### 🔗 Related scrapers

- [YouTube Transcript Scraper](https://apify.com/silentflow/youtube-transcript-scraper): the transcript of any video, in batch. Feed it the `url` column of this scraper.
- [TikTok Scraper](https://apify.com/silentflow/tiktok-scraper): videos and profiles from TikTok.
- [Instagram Engagement Scraper](https://apify.com/silentflow/instagram-engagement-scraper): likes and comments behind Instagram posts.
- [Facebook Search Scraper](https://apify.com/silentflow/facebook-search-scraper): posts, pages and videos from Facebook search.

### 📬 Support

Need something this scraper does not do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing details live on the Monetization tab of the actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

The channels to read, one per line. Paste a channel address (<code>https://www.youtube.com/@MrBeast</code>), a handle (<code>@MrBeast</code>) or a channel id (<code>UCX6OQ3DkcsbYNE6H8uQQuVA</code>). Every video of every channel becomes one row.

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

How many rows to save for each channel and for each selected video type. With <code>50</code> and both Videos and Shorts selected, a channel returns up to 100 rows. A channel lists about 30 videos per page, so 50 videos take a few seconds.

## `videoTypes` (type: `array`):

Which tabs of the channel to read. <b>Videos</b> are the regular uploads, <b>Shorts</b> the vertical clips, <b>Live streams</b> the broadcasts, live now or past. A channel that does not have a tab simply returns nothing for it.

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

The order videos are read in, which decides what the cap keeps. <code>latest</code> returns the newest uploads, <code>popular</code> the most viewed of all time, <code>oldest</code> the first videos of the channel.

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

Only keep videos published after this date. Pick a date (<code>2026-01-31</code>) or an age (<code>7 days</code>, <code>3 months</code>). With the latest sort the run stops at the first older video, which makes a daily schedule fast: <code>1 day</code> returns only what is new since yesterday.

## `includeDetails` (type: `boolean`):

On: every row carries the exact publish date and time, exact views, likes, full description, tags, hashtags and category. Off: a faster listing with title, rounded views, duration and an estimated date.

## `debugMode` (type: `boolean`):

Adds detailed lines to the run log. Leave it off for normal runs.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxItems": 50,
  "videoTypes": [
    "videos"
  ],
  "sortBy": "latest",
  "includeDetails": true,
  "debugMode": false
}
```

# Actor output Schema

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

Every video with id, url, title, type, date, viewCount, likes, duration, description, tags, hashtags, category, thumbnailUrl and the full channel block.

## `channels` (type: `string`):

The channel columns of each row: name, handle, subscribers, total videos, total views, country, joined date and channel URL.

# 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/@MrBeast"
    ]
};

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

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

```

## MCP server setup

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