YouTube channel scraper API

Social & communities · v1.1.0 · youtube_channel

$0.0008 / video

$0.80 / 1K · pay per delivered video

A YouTube channel scraper API: pass a handle, a channel id or a URL and get the channel's uploads — title, video id, views, publish age, duration and thumbnail — with the channel's own name, subscriber count and video total stamped on every row.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0008 per delivered video · $2 free every month · Failed runs never billed

What it does

What a YouTube channel scraper API does

Monitoring a creator means reading the uploads tab, not the search page. That tab has already migrated to YouTube's newer card format, where the old video renderer object simply does not exist — which is why search-based scrapers return zero rows on a channel page that visibly has thirty videos.

This collector reads the new format directly, expands abbreviated counts (15.1M subscribers becomes a number) and covers the videos, shorts and streams tabs.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`channel`	string	yes	Handle (@NASA), channel id (UC…) or channel URL.
`tab`	string	no	Which uploads tab to read. One of: `videos`, `shorts`, `streams`.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many videos to deliver at most (1–150). You pay only for delivered videos.

Outputs — 23 fields, one row per video

What one video looks like

Every delivered video carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position on the tab.
`channel`	string · nullable	Channel name.
`channel_id`	string · nullable	Channel id (UC…).
`channel_url`	string · nullable	Canonical channel URL.
`channel_description`	string · nullable	Channel description (trimmed).
`channel_subscribers`	integer · nullable	Subscribers (15.1M → 15100000).
`channel_videos`	integer · nullable	Total videos on the channel.
`video_id`	string	Video id.
`title`	string	Video title.
`url`	string	Watch URL.
`views`	string · nullable	Views as shown.
`views_value`	integer · nullable	Views as a number.
`published`	string · nullable	Publish age.
`duration`	string · nullable	Duration (m:ss).
`live`	boolean	True for live/premiere items.
`thumbnail`	string · nullable	Thumbnail URL.
`channel_handle`	string · nullable	Channel handle (@NASA).
`channel_avatar`	string · nullable	Channel avatar URL.
`channel_keywords`	string · nullable	Channel keywords.
`published_label`	string · nullable	Publish age spelled out (3 days ago).
`duration_seconds`	integer · nullable	Duration in seconds.
`upcoming`	boolean	Scheduled stream or premiere that has not started.
`is_short`	boolean	True for rows from the shorts tab.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/youtube_channel/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/youtube_channel/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"channel":"@NASA","tab":"videos","max_results":30}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/youtube_channel/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "channel": "@NASA",
        "tab": "videos",
        "max_results": 30
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/youtube_channel/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"channel":"@NASA","tab":"videos","max_results":30}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the youtube_channel collector with channel="@NASA" and tab="videos"

Example response

POST /v1/scraper/collectors/youtube_channel/run

$ curl $QD/youtube_channel/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"channel": "@NASA", "tab": "videos", "max_results": 30}'
{ "status": "done", "count": 30,
  "results": [
    {
      "channel": "…",
      "channel_id": "…",
      "channel_url": "…",
      "channel_description": "…" } ],
  "cost": 0.024 }
# 30 videos × $0.0008 · nothing delivered, nothing charged

Try it

YouTube channel, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

YouTube channel scraper API: from channel and tab, QuanticData reads the YouTube channel and returns one row per video with title, channel and views, at $0.0008 per delivered video. — You send channel and tab; the run goes out through a residential exit and comes back as videos with rank, channel and channel_id — 23 fields on every row — and you are billed $0.0008 for each video actually delivered, nothing for a run that delivers none.

$0.0008 / video2,500 videos on the free $2 every month

Semantic inputchannel, tab, country — no URL lists

Up to 150videos per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

YouTube channel scraper API pricing

$0.0008 per delivered video. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,500 videos before you spend anything.

$0.0008per delivered video$0.8 per 1,000 delivered videos

2,500 videoson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the YouTube channel scraper API

Three shapes of work this endpoint was designed around.

Competitor content audit

Pull a rival channel's recent uploads with views and duration in one call.

Influencer vetting

Check publishing cadence and view distribution before a partnership.

Content datasets

Collect a channel corpus for topic modelling or transcription pipelines.

YouTube channel scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Card format	Search parser returns zero rows here	Reads the current uploads format
Channel stats	A second call	On every row

What people search for

Live autocomplete demand around YouTube channel, pulled with our own Keyword ideas collector.

Three calls, or one row shape

Reading a channel through the Data API means resolving the handle, fetching the uploads playlist, then making a separate statistics call because playlist items do not carry view counts. Three resources, three responses to join, and a quota bill that returns once you do it across a few hundred channels.

The other gap is structural: the Data API does not model shorts and streams as distinct catalogues, so separating a creator's short-form output from their long-form means inferring it from duration. Here it is an input, and channel-level stats are stamped onto every video row so one flat table answers both the channel and the video question without a join.

Limits, tabs and the legal bit

Up to 150 videos per run. Pick the tab deliberately — averaging shorts and long-form together misrepresents any channel that posts both. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. YouTube's terms restrict automated access. Creator names and channel descriptions can be personal data. None of this is legal advice — get some for your actual use case.

YouTube channel scraper API: the POST to the youtube_channel collector, 30 videos delivered and the bill, 30 × $0.0008 = $0.024 in usage.cost_usd; zero videos would cost $0. — The same call you would paste into a terminal: a Bearer key, channel, tab and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many videos arrived and usage.cost_usd is $0.024, which is 30 × $0.0008. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the YouTube channel scraper API.

Something else? Ask us

Can I read shorts or live streams?

Yes — tab accepts videos, shorts and streams.

How far back does it go?

Up to 150 per run, newest first: the run follows the tab's own paging until it reaches max_results.

Is there a free YouTube channel scraper API?

Every account gets $2 of credit every month with no card, which is about 2,500 delivered videos on this endpoint at $0.0008 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0008. A run capped at 150 videos — the maximum for this collector — costs $0.12 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Why are channel stats repeated on every row?

So the output stays one flat table. Subscriber and video totals on each row mean per-video performance relative to audience size is a single expression, with no join and no second call — which is what makes the output usable directly as a dataset.

Run the YouTube channel scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (YouTube channel) turn into clean JSON with the fields title, channel and views; 23 fields on every row.