YouTube Channel Scraper: Subscribers, Video Stats and Channel Data Without a YouTube API Key

The YouTube Data API v3 allocates 10,000 quota units per day per Google Cloud project. A single channel lookup costs 1 unit; a video list request costs 1 unit per page. In practice, pulling a channel’s full video list plus metadata burns through your daily quota in minutes at any real scale — and Google has not increased the default quota allocation in years.

The YouTube Channel Scraper extracts channel metadata and video lists without touching the YouTube Data API. It reads the same ytInitialData JSON payload that YouTube embeds in every channel page and that the browser already parses to render the page — no API key, no quota consumption, no Google Cloud project. Each channel costs $0.005, nothing charged on failed loads.

What You Get Per Channel

Channel-level data:

• channelId and handle (@username format)
• name — channel display name
• description — full About text
• subscriberCount — displayed subscriber figure (rounded for large channels)
• videoCount — total number of public videos
• viewCount — total channel lifetime views
• country — registered country from the About tab
• avatarUrl — channel profile image
• bannerUrl — channel banner image
• verifiedBadge — boolean, true for verified channels

Per video in the video list:

• videoId and full url
• title
• viewCount — total views
• publishedAt — publish date
• duration — formatted duration string (e.g. “12:34”)
• thumbnailUrl — high-resolution thumbnail

Scrape a Channel in Python

import os
from apify_client import ApifyClient

apify = ApifyClient(os.environ["APIFY_TOKEN"])

# Accepts @handle, channel ID or full URL
run = apify.actor("themineworks/youtube-channel").call(run_input={
    "channelUrl": "https://www.youtube.com/@MrBeast",
    "maxVideos": 50,
})

result = next(apify.dataset(run["defaultDatasetId"]).iterate_items(), None)

if result:
    print(f"Channel: {result['name']}")
    print(f"Subscribers: {result['subscriberCount']}")
    print(f"Total videos: {result['videoCount']}")
    print(f"Country: {result.get('country', 'N/A')}")
    print(f"\nFirst 5 videos:")
    for video in result.get("videos", [])[:5]:
        print(f"  {video['title'][:60]}")
        print(f"    Views: {video.get('viewCount', 0):,}  Duration: {video.get('duration', '')}")
        print(f"    Published: {video.get('publishedAt', '')}")

A confirmed run against the MrBeast channel returned 505M subscribers, 990 videos, and the full video list populated correctly.

Scrape Multiple Channels at Once

channels = [
    "https://www.youtube.com/@MrBeast",
    "https://www.youtube.com/@veritasium",
    "https://www.youtube.com/@kurzgesagt",
]

results = []
for channel_url in channels:
    run = apify.actor("themineworks/youtube-channel").call(run_input={
        "channelUrl": channel_url,
        "maxVideos": 10,
    })
    item = next(apify.dataset(run["defaultDatasetId"]).iterate_items(), None)
    if item:
        results.append(item)

# Compare channels
for ch in sorted(results, key=lambda c: c.get("subscriberCount", 0), reverse=True):
    print(f"{ch['name']}: {ch['subscriberCount']} subscribers, {ch['videoCount']} videos")

How It Works

YouTube embeds a ytInitialData JSON object in every public channel page — the same data structure that YouTube’s own frontend JavaScript uses to render the page. The actor fetches the channel page over HTTP (no browser required), parses that JSON, and extracts the channel metadata and video list from the nested structure.

This is the same technique used in the YouTube Transcript Scraper — both actors read from the ytInitialData and ytInitialPlayerResponse payloads that YouTube itself ships with every page. The two actors compose naturally: use the channel scraper to discover which videos a channel has published, then pass those videoId values to the transcript scraper to pull the full spoken-word content of each video.

Wire It Into a Claude Agent via MCP

{
  "mcpServers": {
    "youtube-channel": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-client"],
      "env": {
        "APIFY_TOKEN": "your-token-here",
        "MCP_ACTOR_URL": "https://mcp.apify.com/?tools=themineworks/youtube-channel"
      }
    }
  }
}

With the MCP server connected to Claude Desktop or a Claude agent, you can ask Claude to research a creator’s channel — subscriber trajectory context, video catalogue, posting frequency, most-viewed content — and get a structured answer in one prompt. Claude calls the actor, reads the JSON response, and synthesises the findings without any intermediate scripting.

Use Cases

Influencer vetting. Before committing to a paid partnership, pull the channel’s subscriber count, video count and recent publishing cadence. Compare view counts on recent uploads against the subscriber base to identify channels with strong engagement versus those with inflated historical subscriber numbers and declining recent reach.

Competitor channel analysis. Track how competitors are using YouTube: how often they post, which video formats get the most views, and whether their channel is growing or plateauing. The video list with view counts makes it easy to identify their breakout content.

Content strategy. Find channels in your niche and pull their 50 most-viewed videos. Sort by view count to see which topics and formats resonate at the top of the category — a data-driven input to your own content calendar.

Lead-gen channel research. Many B2B channels include a business email or website link in the channel description. The description field gives you that text programmatically. Combine with a list of niche channels from your market research and you have the raw material for an outreach list.

YouTube Shorts identification. The duration field lets you filter Shorts (under 60 seconds) from regular videos. If you are building a dataset for a model that needs to distinguish short-form from long-form YouTube content, this field is the discriminating feature.

Channel monitoring. Schedule daily runs for a set of channels you track. Store the results in a spreadsheet or database. Detect new video uploads (titles and video IDs that weren’t in yesterday’s run) and trigger downstream actions — notification, transcript pull, or competitive alert.

Pricing

Each channel costs $0.005. Pulling metadata and up to 50 videos from 100 channels costs $0.50 (100 × $0.005). Channels that fail to load due to a network error are not charged.

Frequently Asked Questions

Do I need a YouTube Data API key?

No. The actor extracts data from the ytInitialData JSON payload that YouTube embeds in every public channel page — the same data structure the browser uses to render the page. No API key, no Google Cloud project, no quota required.

What input formats does the actor accept?

Channel handles (e.g. @MrBeast), channel IDs in the UC... format, and full channel URLs are all accepted. The actor normalises them internally before fetching.

Does the video list include YouTube Shorts?

Yes. Shorts appear in the video list alongside regular uploads. The duration field distinguishes them — Shorts are always under 60 seconds, formatted as a short string like “0:45”.

How accurate is the subscriber count?

YouTube publicly displays rounded subscriber counts for channels above 1,000 subscribers — for example “505M” rather than the precise figure. The actor records the displayed value. For channels below 1,000 subscribers, YouTube shows the exact count and the actor captures that.

Can I scrape private or unlisted channels?

No. The actor only accesses publicly visible channel pages. Private channels return no data. Unlisted videos do not appear in the public video list and are not captured.

What is the maximum number of videos I can pull per channel?

YouTube’s channel page loads videos in batches as you scroll. The actor automates that pagination. Set maxVideos to control how many you retrieve per run — most channels have a practical limit of several thousand publicly accessible uploads.