# YouTube Channel & Video Scraper - Views, Likes, Dates (`renzomacar/youtube-scraper`) Actor

Scrape YouTube channels and videos without an API key or quota. Subscribers, every upload with views, duration and date, plus likes, comment counts and descriptions when you turn on video details. Pay per result.

- **URL**: https://apify.com/renzomacar/youtube-scraper.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Videos, Social media, AI
- **Features:** Limited permissions
- **Stats:** 120 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.

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 & Video Scraper -- Views, Likes, Comment Counts and Dates

### Extract Channel Statistics and Video Metadata at Scale

Turn any YouTube channel or video URL into structured data in minutes. For a channel you get its subscriber count and its uploads; for each video you get views, publish date and duration, plus likes, comment count and description when the video is opened -- what you need for competitive analysis, influencer vetting or content research, without manual data entry.

Whether you are benchmarking competitor channels, auditing creator performance for influencer partnerships, or building a dataset of trending content in your niche, this actor delivers clean, export-ready data at a fraction of the cost of commercial analytics tools.

### What data can you extract?

#### Channel data

| Field | Type | Description |
|-------|------|-------------|
| `dataType` | string | Record type identifier (`channel`) |
| `channelName` | string | Display name of the YouTube channel |
| `channelUrl` | string | Full URL to the channel page |
| `subscriberCount` | string | Formatted subscriber count (e.g., "300M subscribers") |
| `totalViews` | string | Reserved. Currently empty: YouTube does not show lifetime views on the page this Actor reads |
| `videoCount` | integer | Number of public videos, as YouTube displays it (rounded for large channels: "1K videos" becomes 1000) |
| `subscriberCountNumeric` | integer | Subscriber count parsed into a plain number (e.g., 300000000) |
| `channelDescription` | string | Channel's About section text |
| `joinDate` | string | Reserved. Currently empty |
| `country` | string | Filled only when YouTube lists a single country for the channel; otherwise empty |
| `thumbnailUrl` | string | URL of the channel's profile image |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was collected |

#### Video data

| Field | Type | Description |
|-------|------|-------------|
| `dataType` | string | Record type identifier (`video`) |
| `channelName` | string | Name of the channel that uploaded the video |
| `channelUrl` | string | URL of the channel |
| `videoTitle` | string | Title of the video |
| `videoUrl` | string | Direct link to the video |
| `viewCount` | string | Views as YouTube gives them: `"89M views"` in a channel listing, the full figure when the video is opened (`"89,423,104 views"` or plain digits). Use `viewCountNumeric` to sort |
| `viewCountNumeric` | integer | View count parsed into a plain number |
| `likeCount` | string | Likes as displayed (`"1.2M"`). Needs the video to be opened: `videoUrls`, or `includeVideoDetails` for channels |
| `commentCount` | string | Number of comments as displayed (`"62K"`). The count only, not the comment texts. Needs the video to be opened |
| `publishDate` | string | Publish date as YouTube gives it: relative in a channel listing (`"3 weeks ago"`), a date when the video is opened (its format varies; use `publishDateIso` to sort) |
| `publishDateIso` | string | The same date as `YYYY-MM-DD`. Exact when the video is opened; estimated from the relative text in a plain channel listing |
| `duration` | string | Video length (e.g., "12:34") |
| `videoDescription` | string | Video description text (up to 2,000 characters). Needs the video to be opened |
| `tags` | array | Tags the creator set. YouTube does not always expose them to this Actor, so the list is often empty |
| `thumbnailUrl` | string | URL of the video thumbnail image |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was collected |

### Use cases

- **Competitor benchmarking** -- Track rival channels over time to understand their growth trajectory, posting frequency, and top-performing content formats.
- **Influencer vetting** -- Pull real subscriber counts, view averages, and engagement data before committing budget to a creator partnership.
- **Content strategy research** -- Analyze which topics, titles, thumbnails, and video lengths generate the most views in your niche.
- **Market trend analysis** -- Build datasets of trending content across multiple channels to identify emerging topics before they peak.
- **Academic and media research** -- Collect structured YouTube data for studies on media consumption, algorithmic reach, or creator economics.

### Two modes, and which fields each one returns

This is the thing to get right before your first run, because it decides what lands in your export.

**`channelUrls` — the inventory pass.** Give it channels and it walks their uploads. Every row carries `channelName`, `subscriberCount`, `videoTitle`, `videoUrl`, `viewCount`, `publishDate`, `publishDateIso` (estimated) and `duration`. On its own it does **not** open each video, so `likeCount`, `commentCount` and `videoDescription` stay empty. That is the fast option: 360 videos of 3 channels took under 10 seconds in our test.

**`channelUrls` + `includeVideoDetails` — the full pass.** Turn the option on and every video of the channel is opened as well, which adds `likeCount`, `commentCount`, `videoDescription` and the exact date. It is slower (200 videos took about 40 seconds in our test) and videos keep only the listing fields when YouTube does not serve their page. Now and then YouTube answers a whole run with "too many requests"; the run then stops asking, says so in the log and returns the listing fields for every video. In our tests that happened in 1 run out of 8, and running again got the details. The number of rows, and so the price, is the same either way.

**`videoUrls` — the detail pass.** Give it specific videos (watch links, `youtu.be` links or Shorts links) and each one is opened, so you get the full record: `likeCount` (`"19M"`), `commentCount` (`"2.4M"`), `videoDescription` and the exact date.

If you only need depth on a few videos, run `channelUrls` first, sort by `viewCountNumeric`, then feed the top URLs back through `videoUrls`.

### Scraping channel statistics in bulk

`channelUrls` takes a list, so a competitive set is one run. Every row repeats `channelName` and `subscriberCount` alongside the video data, which means the export is already joined — no separate channel table to merge.

`subscriberCount` arrives as the displayed string and `subscriberCountNumeric` as a number, so sorting and filtering work without parsing `"12.4M"` yourself. Same for views: `viewCount` and `viewCountNumeric`.

Use `maxVideosPerChannel` to control depth. Twenty is usually enough to see a channel's current direction; fifty covers a year for most creators.

### Exporting video metadata to a spreadsheet

The dataset is flat, so CSV and Excel exports open with no nested columns to flatten.

For a content audit, the columns that carry the analysis are `publishDateIso`, `duration` and `viewCountNumeric`. Group by month to see cadence, and plot duration against views to find the length that actually performs for that channel.

`tags` is the one field that comes back as an array, and it is often empty. Most spreadsheet tools join it with commas automatically; in pandas it stays a list you can explode.

### Finding creators for sponsorship outreach

Sponsorship qualification is a ratio, not a subscriber count.

Pull a set of channels with `channelUrls`, then compare `viewCountNumeric` on recent uploads against `subscriberCountNumeric`. A channel whose typical video reaches a healthy share of its subscriber base has an audience that shows up. One with a large following and thin views is renting attention it no longer has — the exact deal that looks good in a media kit and underperforms.

`publishDateIso` is the second filter: a creator who has not uploaded in four months is not a campaign partner, whatever the subscriber number says.

One honest limit: this Actor returns what YouTube shows publicly. It does not extract creator email addresses — those live on the channel's about page behind a captcha, or in a media kit. Use the channel URL as your starting point for contact.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `channelUrls` | array | No | `[]` | List of YouTube channel URLs to scrape (e.g., `https://www.youtube.com/@MrBeast`) |
| `videoUrls` | array | No | `[]` | List of individual video URLs to extract metadata from |
| `maxVideosPerChannel` | integer | No | `50` | Maximum number of videos to collect per channel (1--500) |
| `includeVideoDetails` | boolean | No | `false` | Open each channel video to add likes, comment count, description and the exact date. Slower |
| `maxConcurrency` | integer | No | `3` | Number of channels or videos processed in parallel (1--10) |

At least one channel URL or video URL must be provided.

### Example output

A channel row, then one of its videos with `includeVideoDetails` on (real output, November 2026; description shortened here):

```json
{
    "dataType": "channel",
    "channelName": "MrBeast",
    "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
    "subscriberCount": "526M subscribers",
    "subscriberCountNumeric": 526000000,
    "videoCount": 1000,
    "channelDescription": "SUBSCRIBE FOR A COOKIE! New MrBeast or MrBeast Gaming video every single Saturday...",
    "totalViews": "",
    "joinDate": "",
    "country": "",
    "scrapedAt": "2026-11-11T04:52:53.119Z"
}
```

```json
{
    "dataType": "video",
    "channelName": "MrBeast",
    "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
    "subscriberCount": "526M subscribers",
    "subscriberCountNumeric": 526000000,
    "videoTitle": "Beat Professional Athlete, Win $100,000",
    "videoUrl": "https://www.youtube.com/watch?v=_c2e1NcI3Sc",
    "viewCount": "89,423,104 views",
    "viewCountNumeric": 89423104,
    "likeCount": "1.2M",
    "commentCount": "62K",
    "publishDate": "Oct 31, 2026",
    "publishDateIso": "2026-10-31",
    "duration": "22:28",
    "videoDescription": "Is it possible for me to beat the world's best athletes in a...",
    "tags": [],
    "thumbnailUrl": "https://i.ytimg.com/vi/_c2e1NcI3Sc/hqdefault.jpg",
    "scrapedAt": "2026-11-11T04:52:53.919Z"
}
```

### How much does it cost?

This actor uses a pay-per-event pricing model. You are charged a small start fee per run plus a fee for each data record (channel or video) that is successfully extracted. Current rates are shown on the Pricing tab of the Actor page.

There are no monthly subscriptions or minimum commitments. You only pay for the data you extract.

### Tips and tricks

- **Start with a small run.** Test with one channel and 10 videos to verify the output format meets your needs before scaling up.
- **Turn on `includeVideoDetails` when you need engagement.** A plain channel listing has title, views, date and duration. Likes, comment counts and descriptions need each video to be opened, which is what the option does.
- **Shorts go through `videoUrls`.** The channel mode reads the Videos tab of a channel, which does not list Shorts. A Shorts link passed in `videoUrls` works like any other video.
- **Schedule recurring runs.** Set up a daily or weekly schedule on Apify to track channel growth and new video performance over time. Export results to Google Sheets or a database via Apify integrations.

### FAQ

**How do I scrape YouTube channels and video metadata?**
Add one or more channel URLs (like `https://www.youtube.com/@MrBeast`) or individual video URLs, set how many videos you want per channel, and click Start. You get subscriber counts, views, likes, comment counts, titles, descriptions and publish dates as a clean dataset you can export to JSON, CSV, or Excel.

**Do I need an API key or Google login to use this YouTube scraper?**
No. There is no YouTube Data API key, Google Cloud project, or login required. Provide channel or video URLs and the actor returns the public data directly.

**Why use this instead of the official YouTube Data API?**
The official YouTube Data API has a daily quota that large channel scrapes burn through quickly and requires a Google Cloud project and API key. This scraper has no quota or key to manage and lets you collect channel stats plus video metadata across many channels in one run. The official API remains the better source for tags, comment texts and exact lifetime channel views.

**What is a good YouTube Data API alternative for competitor research?**
This actor is a no-key YouTube Data API alternative: instead of provisioning a Google Cloud project and rationing quota units, you get subscriber counts, view and like counts, comment counts and descriptions ready for benchmarking and influencer vetting.

**How fresh is the scraped YouTube data and can I track channels over time?**
Every run reads YouTube live, so data is current at run time. Schedule daily or weekly runs to track subscriber growth, new uploads, and video performance, building a time series for competitor benchmarking.

**Is scraping public YouTube data legal?**
This tool collects only publicly available channel and video data. You are responsible for complying with YouTube's terms, applicable laws such as GDPR and CCPA, and using the data ethically. Do not collect personal data without a lawful basis.

### Automate it

Add this YouTube scraper to an Apify **Schedule** to track competitor channels, new uploads, and video performance automatically every day or week — ideal for ongoing competitor benchmarking and influencer monitoring. Connect the output to **Make, n8n, Zapier, Google Sheets, Slack, or a webhook** through Apify integrations so fresh channel and video data flows straight into your dashboards, client reports, or alerts. Recurring runs turn one-off snapshots into a growth time series.

### Related actors

- [TikTok Profile & Post Scraper](https://apify.com/renzomacar/tiktok-scraper) -- Extract TikTok creator profiles, follower metrics, and video post data for cross-platform social media analysis.
- [Reddit Scraper](https://apify.com/renzomacar/reddit-scraper) -- Collect Reddit posts and comments by subreddit or search query to complement your YouTube research with community discussion.
- [Instagram Scraper](https://apify.com/renzomacar/instagram-scraper) -- Pull Instagram profiles and posts to vet creators across YouTube and Instagram in one influencer workflow.
- [Telegram Channel Scraper](https://apify.com/renzomacar/telegram-channel-scraper) -- Monitor public Telegram channels (messages, views, media) alongside your YouTube channel tracking.
- [Apple Podcasts Scraper](https://apify.com/renzomacar/apple-podcasts-scraper) -- Add podcast metadata and rankings for creators who publish across YouTube and audio platforms.

# Actor input Schema

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

YouTube channel URLs to extract channel info and videos from.

## `videoUrls` (type: `array`):

Individual YouTube video URLs (watch, youtu.be or Shorts links) to extract full details from.

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

Maximum number of videos to extract per channel.

## `includeVideoDetails` (type: `boolean`):

Opens each video of the channel to add likes, comment count, description and the exact publish date. Slower: one extra page per video. Off = title, views, duration and approximate date only.

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

Number of channels or videos to process in parallel. With full details on, each channel also opens up to 5 of its videos at a time.

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

Optional. YouTube is usually reachable without a proxy; enable one only if you hit blocks.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxVideosPerChannel": 12,
  "includeVideoDetails": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per channel or video with its stats.

# 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"
    ],
    "maxVideosPerChannel": 12,
    "includeVideoDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/youtube-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"],
    "maxVideosPerChannel": 12,
    "includeVideoDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/youtube-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"
  ],
  "maxVideosPerChannel": 12,
  "includeVideoDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call renzomacar/youtube-scraper --silent --output-dataset

```

## MCP server setup

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