How to Scrape a YouTube Channel's Full Video Catalog in 2026

If you want a channel’s entire upload history — not the 50 most recent videos the public API hands you per page, but the full back catalog with real view counts — you quickly run into YouTube’s two unhelpful options: the Data API v3 (quota-capped, key-gated, and oddly incomplete) or scraping the channel page yourself (which fights you with infinite scroll and obfuscated data structures). This guide covers what’s actually extractable from a channel in 2026, how YouTube exposes that data internally, and how to pull a complete catalog without burning quota or maintaining a browser farm.

What’s worth extracting

A channel’s video grid is a goldmine once you can read it cleanly. Per video, the useful fields are:

• Identity — video title, video ID, watch URL, and a Shorts indicator so you can separate long-form from Shorts.
• Performance — view count parsed to a real integer (not “1.2M” as a string), duration formatted and in seconds.
• Recency — relative publish time (“3 weeks ago”) so you can reconstruct posting cadence.
• Media — thumbnail URL for the grid card.

Attached to every row, you also get channel-level metadata: subscriber count, total video count, channel description, the @handle and the channel ID. That denormalization matters — when you dump 2,000 videos to a CSV, each row already knows which channel it came from and how big that channel is.

The full record is roughly 12–16 fields per video. For most jobs — competitor benchmarking, cadence analysis, dataset building — that’s everything you need without ever touching a single watch page.

How the data is exposed (InnerTube, no login)

YouTube’s website doesn’t render the video grid from clean HTML. It hydrates from an internal data layer — the same InnerTube structures the front-end JavaScript consumes. The channel scraper resolves your input (a @handle, a channel URL, or a raw channel ID) to the internal browse ID, then reads those structures directly.

A few realities that shape how this works in practice:

• No login, no API key. The actor fetches a fresh access key per run the same way an anonymous browser does. There’s no OAuth, no quota ceiling to hit.
• The grid is paginated with continuation tokens. The first response gives you ~30 videos plus a token; the actor auto-paginates that token until it reaches the end of the catalog — hundreds or thousands of videos.
• The video card format changed. YouTube migrated to the lockupViewModel format, which broke a lot of older scrapers. A maintained actor parses the current shape; a stale one returns empty rows.

This is the difference between the Data API and reading InnerTube: the API caps you at 10,000 quota units/day (a few hundred videos with stats) and silently omits some uploads. Reading the channel the way the website does has no such cap.

▶ Run the YouTube Channel Scraper — feed it a @handle, URL or channel ID and get the full video catalog with view counts, durations and dates. No login, no API key, auto-paginated to the end of the grid.

Schema design for downstream use

When you export the catalog, normalize it for the queries you’ll actually run. A clean per-video row looks like:

{
  "channel_id": "UCxxxxxxxxxxxxxxxxxxxxxx",
  "channel_handle": "@somecreator",
  "channel_subscribers": 482000,
  "channel_total_videos": 1043,
  "video_id": "dQw4w9WgXcQ",
  "title": "How I Edit My Videos in 2026",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "views": 184213,
  "duration_seconds": 742,
  "duration_text": "12:22",
  "published_text": "3 weeks ago",
  "is_short": false,
  "thumbnail_url": "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg",
  "scraped_at": "2026-05-20T09:00:00Z"
}

Schema choices worth making early:

• Keep views as an integer. The grid shows “184K”; store the parsed number so you can sum, sort and average without re-parsing.
• Store is_short separately. Shorts and long-form have wildly different view economics; conflating them ruins any average.
• Persist scraped_at. A channel’s catalog is a moving target — view counts climb daily. You need to know when the snapshot was valid.
• The relative published_text is approximate. If you need exact dates, pair this actor with a video-details pass (see the video-details guide) — the grid only exposes “3 weeks ago,” not an ISO timestamp.

Typical use cases

What people actually do with a full channel catalog:

• Competitor analysis — pull a rival channel’s entire upload history with views and dates to benchmark output and what’s working.
• Influencer vetting — assess catalog depth, average views and posting cadence before a partnership. (For contact details and engagement scoring, the influencer-discovery actor is the better fit.)
• Content and video SEO research — analyze title patterns, duration distributions and view spread across a niche.
• New-upload monitoring — schedule the actor on a set of channels to detect fresh uploads on a daily cadence.
• Dataset building — assemble complete catalogs to feed analytics, recommendation systems or AI pipelines.
• Pipeline enrichment — harvest video IDs here, then fan them out to the comments or video-details actors downstream.

The common thread: the value is in completeness. A partial recent-uploads list misleads; a full catalog with real view counts is analyzable infrastructure.

Cost math for the managed approach

Pricing is pay-per-event with a tiny per-run start fee and no per-result charge — you pay essentially for the runs, not the rows. Pulling a 2,000-video catalog costs a fraction of a cent in start fees plus the modest compute to paginate the grid. Monitor 100 channels daily and you’re still in low single-digit dollars per month territory, dominated by compute rather than per-row billing.

Compared to running your own stack, you skip:

• Data API quota juggling — no 10,000-unit/day ceiling, no key rotation across projects.
• A headless browser farm — InnerTube reads don’t need Playwright, so no Chrome RAM tax.
• Maintenance — every time YouTube reshapes its internal card format (the lockupViewModel migration is the recent example), the actor’s maintainer absorbs the fix, not you.

Common pitfalls

A few things to know before you wire a channel pipeline into production:

• Handles aren’t stable forever. Creators occasionally change their @handle; the channel ID never moves. Store and join on the ID.
• “Videos” tab vs. everything. Shorts and live streams live in the catalog too — decide whether you want them mixed or filtered, and use the is_short flag accordingly.
• Relative timestamps drift. “3 weeks ago” computed today and re-run next month won’t line up. Anchor on scraped_at or hydrate exact dates separately.
• Very large catalogs take longer. A 5,000-video channel means many continuation pages; budget run time accordingly and let the built-in retry logic reach the end.
• View counts on the grid are rounded. They’re fine for ranking and trend work; for exact integers on specific videos, hydrate those IDs through the video-details actor.

Wrapping up

If you need a one-off look at a single channel, the public page and a lot of patience will eventually get you there. If you need complete catalogs across many channels — refreshed, parsed to integers, and resilient to YouTube’s format churn — let a maintained actor read InnerTube for you and hand back clean rows.

▶ Open the YouTube Channel Scraper on Apify — bulk channel lists, full back catalogs, exports to JSON, CSV or Excel. Start with Apify’s free monthly credit.