YouTube Channel Finder With Subscriber Counts

YouTube Scraper — Extract Channels, Growth Metrics and Search Results

YouTube Channel Finder With Subscriber Counts discovers YouTube channels by keyword or URL and returns structured channel data — subscriber counts, view and video totals, join dates, bios and links — as typed JSON, no API key or login required. Re-run it later and it does what a single lookup cannot: persist a snapshot per channel and compute subscriberDelta, viewsDelta, videosDelta and growthRatePerDay against the last run. Unlike scraping frameworks that return raw HTML, it returns clean, typed JSON ready for your database or pipeline. This guide covers every input, every output field, and three deployment strategies for tracking growth over time.

🧭 What Does YouTube Channel Finder With Subscriber Counts Do?

YouTube Channel Finder With Subscriber Counts discovers YouTube channels — by keyword search or by direct channel/video URL — and returns their public profile data plus cross-run growth metrics. No YouTube account, login, or API key is required: channel discovery uses yt-dlp's keyword search and channel details come from a keyless HTTP fetch of the channel's public /about page.

• Discovers channels by keyword (keywords, yt-dlp ytsearch powered) or direct channel/video URL (urls), usable together in one run
• Returns channel profile fields: channelName, userName, channelId, canonicalChannelUrl, description, location, links, joinedDateIso
• Returns subscriber, view and video totals, including subscriberCountInt parsed from YouTube's own display text into a real integer
• Persists a per-channel snapshot in a named key-value store and computes subscriberDelta, viewsDelta, videosDelta and growthRatePerDay on every re-run
• Filters output by channel join-date range (fromDate/toDate), minimum subscriber growth, or "only changed" channels
• Falls back automatically to Apify Residential proxy when a request looks blocked

⚡ Features & Capabilities

YouTube Channel Finder With Subscriber Counts groups its capabilities into channel discovery, profile/metric extraction, and cross-run growth tracking.

Core features

• Dual discovery modes — keywords (yt-dlp ytsearch powered) and urls (direct channel or video links), usable together in one run
• Full channel profile fields — channelName, userName, channelId, canonicalChannelUrl, description, location, links, joinedDateIso
• Numeric subscriber parsing — subscriberCountInt converts YouTube's own rounded display text (e.g. "4.77M subscribers") into an integer; because YouTube itself only shows a rounded figure, this is an approximation on large channels, not an exact per-subscriber count, and returns null rather than a faked 0 when the text can't be parsed
• Cross-run growth deltas — subscriberDelta, subscriberDeltaPct, growthRatePerDay, viewsDelta, videosDelta, computed against a persistent named key-value store snapshot
• Baseline-aware, never fabricated — isFirstSnapshot is true and every delta is null on a channel's first run; there is no history to synthesize
• Alert filtering — minSubscriberGrowth and onlyChanged suppress unchanged rows from the output (the snapshot is still saved either way)
• Join-date filtering — fromDate/toDate keep only channels that joined YouTube within a range
• Historical trail — up to maxHistory past snapshot points are mirrored in the history field on every channel row

How does YouTube Channel Finder With Subscriber Counts work inside AI coding agents?

Register the Actor with Apify's MCP Server:

npx -y @apify/actors-mcp-server --actors Scrapio/youtube-channel-finder-with-subscriber-counts

Once registered, an agent running in Claude Desktop, Claude Code, Cursor, or another MCP-compatible client can call the Actor mid-task — for example, "find tech-review channels that gained more than 500 subscribers since last week" — without leaving the IDE or hand-writing a scraping script.

YouTube Channel Finder With Subscriber Counts within the Scrapio data stack

YouTube Channel Finder With Subscriber Counts covers channel profile data and cross-run subscriber/view/video growth. For full comment threads with expanded reply chains, use YouTube Comments Scraper With Reply Thread Expansion. For video-level retention heatmaps, chapters, and comment engagement analytics, use YouTube Scraper With Comment & Engagement Analytics. For transcripts paired with view/like analytics, use YouTube Transcript Scraper With View & Like Analytics. Together these four cover channels, comments, video engagement, and transcripts across the platform.

Why do developers and data teams scrape YouTube?

YouTube channel and creator data feeds influencer marketing, competitive intelligence, AI pipelines, and academic research. Each audience below reads different fields from the same channel row — subscriber counts and growth deltas matter to a brand team, while bio and link fields matter to an AI pipeline.

🏢 Creator agencies, marketing teams and brand partnership sourcing

Talent agencies and brand marketing teams use keywords to discover channels in a niche (e.g. "fitness workout", "tech reviews"), then track subscriberCountInt, subscriberDelta, and growthRatePerDay for every candidate creator before a sponsorship offer goes out. A channel gaining subscribers faster than its category peers gets flagged as a rising partner; location and description help match creators to a campaign's target market. Because growth is measured against a persisted snapshot rather than a single vanity number, agencies can tell a channel that is actually accelerating apart from one that just has a large historical subscriber base. Output rows land directly in a dataset a lead-scoring spreadsheet or CRM import can consume without any HTML parsing.

📊 AI training data and RAG indexing

The description field — a channel's own bio text — and links (external site/social references) are the highest-information text fields for RAG indexing: they describe what a channel is about in the creator's own words, useful when an agent needs to identify or summarize a creator. For training data, subscriberCountInt, channel_views, videos_uploaded, and the growth-delta fields (subscriberDelta, viewsDelta, videosDelta, growthRatePerDay) are consistently structured numeric fields across every record, suited to a growth-prediction or creator-ranking model. Two concrete uses: (1) RAG enrichment — index description and channelName so an agent answering "who covers X topic on YouTube" can cite real channels; (2) training data — the history array gives a small time-series per channel for models learning growth patterns instead of a single static snapshot.

📱 Competitive and market intelligence

Track a named list of competitor channels via urls on a recurring schedule and watch subscriberDelta, viewsDelta, and videosDelta to see which competitor is publishing more (videosDelta) or growing faster (growthRatePerDay) than your own channel. Because deltas are computed against a persisted per-channel snapshot rather than a fresh scrape each time, a dashboard can show real week-over-week movement instead of just a current subscriber count. minSubscriberGrowth filters the output down to channels that moved meaningfully, so a market-intelligence report only surfaces channels worth a human's attention.

🔬 Research and academic use

Academic researchers studying creator economies, platform growth dynamics, or content-category trends can use keywords to sample channels within a niche and fromDate/toDate to constrain the sample to channels that joined YouTube within a specific period. Because every field is scraped from YouTube's own public /about page with no login, the dataset reflects only publicly accessible data. Re-running on a schedule builds a longitudinal growth dataset per channel without manual tracking.

🎥 Product and SaaS development

Teams building a creator-discovery tool, an influencer-rate calculator, or a growth-monitoring dashboard can run this Actor on a schedule as the data layer behind the product, using a distinct growthStoreName per customer or workspace to keep each user's tracked channel list independent. The Actor's typed JSON output — including subscriberDelta and growthRatePerDay — pipes directly into a product's own database or charting layer without a custom scraper to build or maintain.

🍚 Input Parameters

YouTube Channel Finder With Subscriber Counts accepts 13 parameters, all optional — running it with defaults searches for "python" channels (the schema's own prefill) and returns a baseline snapshot for each. The full parameter set, in schema order:

Parameter	Required	Type	Description	Example Value
keywords	No	array	Search terms to discover YouTube channels. One keyword per line. Combine with channelCount to control how many channels are fetched per term.	["cooking tutorials", "tech reviews"]
urls	No	array	Track specific channels directly by URL (channel or video URLs) instead of, or in addition to, keyword search.	["https://www.youtube.com/@apify"]
channelCount	No	integer	Maximum number of channels to extract per search keyword (1-50, capped at 50 regardless of value entered — matches the Actor's real per-keyword limit). Default 10.	15
searchRegion	No	string	YouTube search region (country code). Affects which channels appear in search results. Default "US".	"GB"
language	No	string	Interface and result language code. Default "en".	"es"
fromDate	No	string	Only include channels that joined on or after this date (YYYY-MM-DD). Leave empty for no filter.	"2015-01-01"
toDate	No	string	Only include channels that joined on or before this date (YYYY-MM-DD). Leave empty for no filter.	"2023-12-31"
growthStoreName	No	string	Name of the persistent named key-value store that holds each channel's last snapshot between runs. Keep it identical across runs to accumulate real growth. Default "youtube-channel-growth-watchlist".	"my-youtube-watchlist"
minSubscriberGrowth	No	integer	Only emit a channel whose absolute subscriber change since the last snapshot is at least this many subscribers. 0 = emit all. Ignored on baseline runs. Default 0.	100
onlyChanged	No	boolean	When true, skip channels whose subscribers, views, and videos are all unchanged since the last snapshot. Baseline runs always emit. Default false.	true
previousChannelDatasetId	No	string	Optional dataset ID of a prior run's output; when a channel appears in it, deltas are computed against that dataset instead of the named store.	""
maxHistory	No	integer	How many past snapshot points to retain per channel in the store and mirror in the history field. Default 30.	30
proxyConfiguration	No	object	Optional Apify proxy. Runs without a proxy by default; auto-escalates to Residential proxy if the chosen proxy is blocked.	{"useApifyProxy": false}

Example input

{
  "keywords": ["cooking tutorials"],
  "urls": ["https://www.youtube.com/@mkbhd"],
  "channelCount": 15,
  "searchRegion": "US",
  "language": "en",
  "fromDate": "2015-01-01",
  "toDate": "",
  "growthStoreName": "my-youtube-watchlist",
  "minSubscriberGrowth": 100,
  "onlyChanged": true,
  "previousChannelDatasetId": "",
  "maxHistory": 30,
  "proxyConfiguration": { "useApifyProxy": false }
}

Supported URL types and input formats

The urls field accepts direct channel and video links; the Actor resolves a video URL to the channel that owns it before extracting profile data:

• Channel handle URL — https://www.youtube.com/@mkbhd
• Legacy channel-ID URL — https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ
• Video URL (resolves to its owning channel) — https://www.youtube.com/watch?v=dQw4w9WgXcQ

For discovery instead of direct tracking, keywords takes plain search terms ("python", "cooking tutorials") and runs a ytsearch query per term — no URL needed at all.

📦 Output Format

Every run returns typed, normalized JSON with a consistent schema — the same keys appear on every non-error row. This Actor bills on Apify's Pay-Per-Event model: each dataset row pushed charges one row_result event, including baseline rows and error rows. Rows suppressed by minSubscriberGrowth or onlyChanged filtering are never pushed to the dataset and are therefore never charged.

Output for channels

Full row for a channel on its second (diffed) run — 27 fields, all real keys from the source:

{
  "keyword": "python tutorials",
  "channelName": "Corey Schafer",
  "userName": "@coreyms",
  "channelId": "UCCezIgC97PvUuR4_gbFUs5g",
  "canonicalChannelUrl": "https://www.youtube.com/@coreyms",
  "subscriberCount": "1.24M subscribers",
  "subscriberCountInt": 1240000,
  "description": "Programming tutorials and reviews, focusing primarily on Python.",
  "location": "United States",
  "links": [
    { "title": "Twitter", "url": "https://twitter.com/coreymschafer" }
  ],
  "joined_date": "Joined Aug 31, 2011",
  "joinedDateIso": "2011-08-31",
  "channel_views": 98450213,
  "videos_uploaded": 216,
  "isFirstSnapshot": false,
  "previousSnapshotAt": "2026-07-18T09:00:00Z",
  "snapshotCount": 3,
  "subscriberDelta": 1500,
  "subscriberDeltaPct": 0.1213,
  "growthRatePerDay": 214.29,
  "viewsDelta": 38210,
  "videosDelta": 1,
  "history": [
    {
      "subscriberCountInt": 1238500,
      "channel_views": 98412003,
      "videos_uploaded": 215,
      "runAt": "2026-07-18T09:00:00Z"
    }
  ],
  "growthStoreName": "my-youtube-watchlist",
  "url": "https://www.youtube.com/@coreyms",
  "scrapedAt": "2026-07-25T09:05:00Z",
  "error": null
}

On a channel's first run, subscriberDelta, subscriberDeltaPct, growthRatePerDay, viewsDelta, videosDelta, and previousSnapshotAt are all null, and isFirstSnapshot is true — that run establishes the baseline the next run diffs against.

Output for growth history points

Each entry in a channel row's history array is a structurally distinct, smaller record — a past snapshot point, oldest logic aside:

[
  {
    "subscriberCountInt": 1238500,
    "channel_views": 98412003,
    "videos_uploaded": 215,
    "runAt": "2026-07-18T09:00:00Z"
  },
  {
    "subscriberCountInt": 1237100,
    "channel_views": 98390550,
    "videos_uploaded": 215,
    "runAt": "2026-07-11T09:00:00Z"
  }
]

Schema stability and export options

Field names stay stable across runs because they are Actor-computed keys, not raw HTML tag names lifted from YouTube's front end — a YouTube redesign changes how the Actor parses the page internally, not the JSON keys it emits. The default dataset table view surfaces 22 of the 27 fields (it omits description, links, joined_date, history, and growthStoreName from the table but not from the underlying data); open the dataset as JSON, CSV, Excel, or XML — all standard Apify dataset export formats — to get every field, or pull rows directly via the Apify API/SDKs.

💡 YouTube Channel Finder With Subscriber Counts Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new creator enters your pipeline — a lead form, a CRM record, or an inbound partnership request. Feed the creator's channel handle into urls, run the Actor, and append the returned subscriberCountInt, channel_views, description, and links fields onto the lead record in your CRM or database. Because these fields land as typed JSON, no parsing step sits between the Actor and your enrichment write-back — the run output maps directly onto your record's fields. Since this is likely the first time the Actor has seen that channel, expect isFirstSnapshot: true and null deltas on this initial call; the growth fields populate once you re-run the same channel later.

🎯 Strategy 2: Scheduled monitoring and alerting

Put the same urls list and the same growthStoreName on an Apify Schedule (daily or weekly). Each scheduled run diffs against the previous snapshot and emits subscriberDelta, viewsDelta, and videosDelta. Set minSubscriberGrowth to a meaningful threshold, or onlyChanged to true, so the output dataset only contains channels that actually moved — feed that filtered dataset into a Slack/email alert rather than re-checking every channel manually. Keeping growthStoreName fixed is what makes this work: a different name on any run starts an independent, fresh baseline instead of continuing the watchlist's history.

🎯 Strategy 3: Bulk dataset build

For a research or benchmark dataset, split a large channel/keyword list across multiple Actor runs rather than expecting a single run to parallelize internally — channels are processed sequentially within one run, not concurrently. Kick off the runs via the Apify API, then aggregate each run's dataset into one CSV or database table using the shared channelId as the join key across runs. If the goal is a one-off snapshot rather than growth over time, the delta fields can simply be ignored — every row still carries the full channel profile (description, location, links, subscriberCountInt) regardless of whether a prior snapshot exists.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Enriching individual creators as they enter a pipeline	One run per creator, triggered on demand	JSON row appended to a CRM/database record
Scheduled monitoring	Ongoing growth tracking and alerting on a watchlist	Recurring run on an Apify Schedule, same growthStoreName	Filtered dataset (movers only) feeding an alert
Bulk dataset build	Research or benchmark datasets across many channels	Multiple parallel Actor runs, each processing its input sequentially	Aggregated CSV or database table

🌴 Related YouTube Scrapers & Tools

Scraper Name	What it extracts
YouTube Comments Scraper With Reply Thread Expansion	Full video comment and reply threads, including replies hidden behind "more replies"
YouTube Scraper With Comment & Engagement Analytics	Videos/Shorts/streams with retention heatmap, chapters, comments, and derived engagement rate
YouTube Transcript Scraper With View & Like Analytics	Video transcripts paired with real view/like metadata and engagement analytics
Instagram Followers Count: Multiple Accounts Follower Counts	Cross-run Instagram profile follower/following/post growth tracking (same snapshot-diff design)
Twitter Profile Scraper: Sentiment Analyzer	Twitter/X profile tweets enriched with AI sentiment and topic classification
LinkedIn Profile Scraper By Similar Profile Finder	LinkedIn profile network expansion via "People also viewed"
TikTok Trending Videos Insights & Author Engagement	TikTok ad videos enriched with real organic engagement and creator follower counts

How to integrate YouTube Channel Finder With Subscriber Counts with your stack

YouTube Channel Finder With Subscriber Counts works with any language or tool that can make an HTTP request — it runs on the Apify platform and is callable through the Apify API or the official Apify SDKs.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

channel_urls = [
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium",
]

run_input = {
    "urls": channel_urls,
    "growthStoreName": "my-youtube-watchlist",
    "onlyChanged": False,
}

run = client.actor("Scrapio/youtube-channel-finder-with-subscriber-counts").call(run_input=run_input)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("channel_growth.csv", "w", newline="", encoding="utf-8") as f:
    fieldnames = ["channelName", "subscriberCountInt", "subscriberDelta", "growthRatePerDay", "isFirstSnapshot", "scrapedAt"]
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    for row in rows:
        writer.writerow({k: row.get(k) for k in fieldnames})

print(f"Saved {len(rows)} channel rows to channel_growth.csv")

Node.js

import { ApifyClient } from 'apify-client';
import fs from 'fs';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const run = await client.actor('Scrapio/youtube-channel-finder-with-subscriber-counts').call({
    urls: ['https://www.youtube.com/@mkbhd', 'https://www.youtube.com/@veritasium'],
    growthStoreName: 'my-youtube-watchlist',
    onlyChanged: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

fs.writeFileSync('channel_growth.json', JSON.stringify(items, null, 2));
console.log(`Saved ${items.length} channel rows to channel_growth.json`);

MCP for AI agents

Register with Apify's MCP Server — npx -y @apify/actors-mcp-server --actors Scrapio/youtube-channel-finder-with-subscriber-counts — and an MCP-compatible client (Claude Desktop, Claude Code, Cursor) can call the Actor directly: "check @mkbhd's subscriber growth since last week" resolves to a real Actor call, returning typed JSON straight into the agent's context.

Async and scheduled pipelines

For fire-and-forget large batches, start the run asynchronously via the Apify API and poll the run status or dataset item count instead of blocking on a synchronous call. For recurring monitoring, use an Apify Schedule to trigger the Actor automatically with a fixed growthStoreName, and configure an Apify webhook on run completion if you want an event pushed to your own system instead of polling.

🎯 Who Needs YouTube Channel Finder With Subscriber Counts? (Use Cases & Industries)

🏢 Creator agencies and marketing teams

A talent manager monitors subscriberDelta and growthRatePerDay for a shortlist of prospective creator partners tracked via urls, so an offer goes to a creator who is genuinely accelerating rather than one that is just currently large.

📊 AI and data teams building RAG and training pipelines

An ML engineer indexes description and channelName for retrieval, and trains a creator-growth model on subscriberCountInt, growthRatePerDay, and the history time-series instead of a single static number.

📱 Competitive intelligence analysts

An analyst schedules urls runs against a fixed list of competitor channels and reports weekly on videosDelta and growthRatePerDay — who is publishing more, and who is growing faster.

🔬 Researchers

Academic researchers sample channels by keywords and fromDate/toDate to build a longitudinal, public-data-only dataset of creator growth for platform or creator-economy studies.

🎥 Product and SaaS builders

A SaaS team ships a creator-monitoring feature by running this Actor on a schedule per customer workspace, using a distinct growthStoreName per customer so tracked channel lists stay independent.

Is it legal to scrape YouTube?

Yes — YouTube Channel Finder With Subscriber Counts only reads data YouTube already displays publicly on a channel's own /about page and in public search results; no login, cookie, or authenticated session is used to reach it.

In the United States, scraping publicly accessible web data is generally lawful: hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), held that scraping data a website makes publicly available does not violate the Computer Fraud and Abuse Act. That precedent concerns unauthorized-access exposure, not a platform's own Terms of Service — violating YouTube's ToS is a contract matter between an account holder and the platform, a civil risk rather than a criminal one, and it attaches to whoever runs the scrape, not to the underlying public data itself.

Channel data returned here — a channel's name, bio, location, and public link list — is data creators chose to publish on their own channel page; the Actor does not access private, login-gated, or authenticated data. Storage and downstream use of any personal data among those fields is your responsibility as the person running the Actor — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does YouTube Channel Finder With Subscriber Counts work without a YouTube account?

Yes. It needs no YouTube login, cookie, or API key — channel discovery uses yt-dlp's keyword search, and channel data comes from a keyless HTTP GET of the channel's public /about page.

How does it handle YouTube's anti-scraping measures?

By default it makes requests without a proxy. When a request looks blocked (a 403, 429, CAPTCHA, or "forbidden"/"blocked"/"access denied" response), it automatically switches to Apify's Residential proxy for the rest of the run and retries with jittered exponential backoff, up to 3 attempts per channel or keyword search.

Can I run it at scale without getting blocked?

There's no published uptime or success-rate figure. Internally, channels are processed sequentially within a single run rather than in parallel batches, so a very large keyword/URL list takes proportionally longer — for high-volume scraping, split the input across multiple Actor runs instead of expecting one run to parallelize internally. Enabling Apify Proxy (with automatic Residential escalation on a detected block) is the documented way to reduce blocking.

How fresh is the data it returns?

Every run performs a live fetch — channel numbers reflect the moment the Actor ran, not a cached copy. Growth fields compare that live fetch against whatever snapshot was saved on a previous run, which could be minutes, days, or weeks old depending on how often you re-run it.

Which YouTube fields work best for AI training and RAG indexing?

For RAG: description and links, the channel's own free-text summary and cited external references. For training data: subscriberCountInt, channel_views, videos_uploaded, and the delta/history fields, which are consistently typed numeric values across every record and require no normalization before use.

What personal data does this Actor return, and who is responsible for its use?

Channel rows can include a creator's display name, self-declared location (country only), and bio/links — data the channel owner published publicly on YouTube. The Actor does not access email addresses, private messages, or any login-gated field (YouTube's Business-email button is Google-auth-gated and is deliberately dropped from this Actor's output rather than shipped as a permanently-null field). Because a channel name can identify an individual creator, especially on a small or personal channel, lawful basis for storing and using that data sits with you, the person running the Actor.

Why is subscriberDelta null the first time I run it on a channel?

Because there's nothing to compare against yet. Apify Actor runs are stateless, so the first run for any channel is always a baseline: it saves a snapshot to the named key-value store and reports isFirstSnapshot: true with every delta field null. Re-run the Actor later — on the same growthStoreName — to see real subscriberDelta, viewsDelta, and videosDelta values.

Why does channelCount cap at 50 even if I enter a higher number?

50 is the Actor's real per-keyword extraction limit — the input schema's maximum now matches that clamp exactly. An earlier version of the schema allowed values up to 5,000 with no effect above 50; that mismatch has been fixed so the number you set matches actual behavior.

Does it work with Claude, ChatGPT, and other AI agent tools?

Yes. It's registrable through Apify's MCP Server (npx -y @apify/actors-mcp-server --actors Scrapio/youtube-channel-finder-with-subscriber-counts) for MCP-compatible clients like Claude Desktop or Claude Code, and callable as a standard Actor via the Apify API by any agent framework. Every response is typed JSON — no HTML parsing required before it enters an LLM's context window.

How do I keep tracking the same channel's growth across runs?

Keep growthStoreName identical across every run you want to accumulate history for, and prefer urls (a stable channel handle or URL) over keywords for channels you're actively monitoring — a keyword search can surface a channel via a slightly different URL form next time, though the Actor also matches on the stable channelId internally where it's available.

ℹ️ Disclaimer

YouTube Channel Finder With Subscriber Counts extracts only publicly available data from YouTube's own public channel pages and search results. This tool is intended for lawful use cases only. Users are responsible for complying with YouTube's Terms of Service and applicable data protection laws in their jurisdiction.