# YouTube scraper API — $0.0008 per video

> YouTube scraper API: YouTube search results without the Data API — views, channel. $0.0008 per delivered video, nothing delivered means nothing charged.

[Home](https://quanticdata.io/)/[Collectors](https://quanticdata.io/collectors/)/*YouTube scraper API*

# YouTube scraper API

A YouTube scraper API with no Data API key and no quota: search YouTube and get id, title, channel and channel URL, view count as text and as a number, publish age, duration, description snippet, badges and thumbnail.

[Get my free API key](https://app.quanticdata.io/register) [See the request](/collectors/youtube-scraper-api/#integration)

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

POST /v1/scraper/collectors/youtube_search/run

```
$ curl $QD/youtube_search/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "residential proxies explained", "country": "us", "max_results": 20}'
{ "status": "done", "count": 20,
  "results": [
    {
      "video_id": "…",
      "title": "…",
      "url": "…",
      "channel": "…" } ],
  "cost": 0.016 }
# 20 videos × $0.0008 · nothing delivered, nothing charged
```

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

**Semantic input**query, sort, country — no URL lists

**Up to 40**videos per run, pagination handled for you

**No browser**read over HTTP/TLS — cheaper and faster than rendering

On this page: [What it is](/collectors/youtube-scraper-api/#what) [Output fields](/collectors/youtube-scraper-api/#output) [Inputs](/collectors/youtube-scraper-api/#input) [Pricing](/collectors/youtube-scraper-api/#pricing) [Integration](/collectors/youtube-scraper-api/#integration) [Use cases](/collectors/youtube-scraper-api/#use-cases) [Versus the alternatives](/collectors/youtube-scraper-api/#compare) [FAQ](/collectors/youtube-scraper-api/#faq)

## What a YouTube scraper API does

The official Data API is fine until the quota runs out, and it costs units for exactly the queries a research workload repeats. The results page, meanwhile, ships its entire model in the page — so a single request returns the same fields the interface renders, with no key to manage and no daily budget to ration.

View counts come back twice: as YouTube prints them and as an integer you can sort on. Live streams are the exception the collector refuses to fudge — "1.2K watching" is a concurrent viewer count, not a view total, so the numeric field stays null instead of quietly under-reporting.

Input is meaning, not a URL *query* *sort* *country* *lang* *max_results*

## 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. |
| `video_id` | string | YouTube video id. |
| `title` | string | Video title. |
| `url` | string | Watch URL. |
| `channel` | string · nullable | Channel name. |
| `channel_url` | string · nullable | Channel URL. |
| `views` | string · nullable | View count as shown. |
| `views_value` | integer · nullable | View count as a number (null for live viewer counts). |
| `published` | string · nullable | Publish age ("6 months ago"). |
| `duration` | string · nullable | Duration (m:ss). |
| `live` | boolean | True for live streams. |
| `description` | string · nullable | Description snippet. |
| `thumbnail` | string · nullable | Thumbnail URL. |
| `badges` | string[] | Badges (4K, CC, New…). |

## Inputs

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

| Input | Type | Required | What it does |
| --- | --- | --- | --- |
| `query` | string | yes | What to search on YouTube. |
| `sort` | string | no | Result order. One of: `relevance`, `upload_date`, `view_count`, `rating`. |
| `country` | string | no | ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool. |
| `lang` | string | no | Interface language (hl), e.g. en, it, de. |
| `max_results` | integer | no | How many videos to deliver at most (1–40). You pay only for delivered videos. |

Pricing

## YouTube 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.0008**per delivered video*$0.8 per 1,000 delivered videos*

**2,500 videos**on the free allowance*$2 every month, no card*

**Zero rows**zero charge*blocks, captchas and retries are on us*

**−30%**on volume tiers*the 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

Most popular

### 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](https://quanticdata.io/web-data-api-for-ai/). Prices are launch pricing read live from the billing config — `GET /v1/scraper/collectors` returns the price your key actually pays.

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_search/run`.

```
curl -X POST https://api.quanticdata.io/v1/scraper/collectors/youtube_search/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"residential proxies explained","country":"us","max_results":20}'
```

```
import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/youtube_search/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "query": "residential proxies explained",
        "country": "us",
        "max_results": 20
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)
```

```
const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/youtube_search/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"residential proxies explained","country":"us","max_results":20}),
  },
);
const { payload } = await res.json();
console.table(payload.results);
```

```
claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, in the chat:
> run the youtube_search collector with query="residential proxies explained" and country="us"
```

## What people build with the YouTube scraper API

Three shapes of work this endpoint was designed around.

### Topic research

See which videos and channels own a query before you script your own.

### Creator discovery

Collect channels ranking for your niche with view counts attached.

### Trend tracking

Sort by upload date to watch a topic's newest coverage.

## YouTube scraper API versus rolling your own

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

|  | DIY scraper | This collector |
| --- | --- | --- |
| Quota | Units per call, daily ceiling | None — pay per delivered video |
| Key management | Google Cloud project required | Your existing API key |
| Live streams | Viewer count reported as views | Left null: it is not a view total |

## Quota is the whole story

A search against YouTube's Data API costs 100 quota units and a default project gets 10,000 a day — one hundred searches, for everything the project does. Simple metadata reads cost one unit, which is why quota rarely bites until the moment you start searching, and why continuous topic monitoring turns into a quota-increase application rather than a dataset.

For anything that feeds a model or a dashboard, the second difference matters as much: the Data API returns YouTube's API ranking, while the results page returns what a viewer in that country was actually shown. Only one of those is a measurement of the surface.

## Limits, coverage and the legal bit

One results page per run — roughly 20 videos, up to 40. Everything past that sits behind a continuation token, so coverage comes from more queries rather than deeper paging. Design the pipeline around breadth. 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.

Views arrive twice, as YouTube's display string and as an integer, and `published` is a relative age rather than a timestamp because that is what the page publishes. Resolve it against the collection time consistently or a time series will drift.

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. Metadata and links only — no media is fetched, and video content belongs to its creators. None of this is legal advice — get some for your actual use case.

## FAQ

Questions we get about the YouTube scraper API.

[Something else? Ask us →](mailto:hello@quanticdata.io)

### Do I need a YouTube Data API key?

No. The collector reads the public results page, so there is no Google Cloud project, no quota and no per-call unit accounting.

### How many videos per run?

Up to 40, from the first results page. Deeper paging sits behind a continuation token that this collector does not follow — the run tells you how many it found rather than looking silently truncated.

### Can I sort by upload date?

Yes: `sort` accepts relevance, upload_date, view_count and rating.

### Is there a free YouTube 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 40 videos — the maximum for this collector — costs $0.032 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.

### Do I need a Data API key?

No. Your QuanticData key is the only credential — no Google Cloud project, no OAuth and no quota application. That is the practical reason most people arrive at this endpoint.

### Why only about 20 results per run?

Because YouTube puts everything past the first results page behind a continuation token. Rather than pretending to paginate it, the collector covers one page honestly and the pattern for breadth is more queries — which is also cheaper.

## Run the YouTube scraper API now

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

[Get my free API key](https://app.quanticdata.io/register)

Related: [All 32 collectors](https://quanticdata.io/collectors/) [YouTube channel scraper API](https://quanticdata.io/collectors/youtube-channel-scraper-api/) [TikTok scraper API](https://quanticdata.io/collectors/tiktok-scraper-api/) [Video search API](https://quanticdata.io/collectors/search-videos-api/) [Documentation](https://quanticdata.io/docs/)

---

Source: https://quanticdata.io/collectors/youtube-scraper-api/ · Site index for AI: https://quanticdata.io/llms.txt