YouTube Data API comparison
Bright Data Alternative for YouTube Data
Build video research around source requests.
Bring YouTube metadata and captions into your app or agent with FlashData. Compare the cost of a complete video task, then migrate your snapshot workflow to saved, resumable jobs.
Read as Markdown · Comparing Google Search? See the SERP comparison →
01 · Video research, on your terms
Feature-by-feature comparison
Compare a useful video task, from metadata to caption analysis.
| Feature | FlashData | Bright Data YouTube |
|---|---|---|
| Lower paid costs for focused video lookups | ||
| Paid metadata lookup · 1,000 videos | $0.501,000 source requests · PAYG | $1.501,000 delivered video records · PAYG |
| Metadata + existing captions · 1,000 videos | $1.002,000 source requests · PAYG | $1.501,000 video records when caption fields are included |
| Entry monthly plan | $49.00Micro/month; shared usage balance included | $499Scale/month · 384,000 records included |
| Pay as you go without a monthly subscription | Yes | Yes |
| Find videos and build a research library | ||
| Discover videos by keyword | YesSearch with date, duration, type and sorting filters | YesKeyword and search-filter discovery modes |
| Metadata for a known video | YesTitle, channel, duration, thumbnails and engagement counts | YesVideo records with identity, channel and engagement fields |
| Chapter markers for navigation | Yesinclude_chapters; chapter times in seconds | YesChapter titles, previews and start times in milliseconds |
| Discover available caption languages | Language list in metadata | Track list in the video recordIncludes language and automatic-caption information |
| Make captions usable as evidence | ||
| Request captions without refreshing metadata | Dedicated transcript sourceOne standard request per video | Caption fields in the video recordYouTube Videos scraper |
| Request multiple caption languages | Up to 10 explicit languagesTracks plus per-language errors | One selected languageSelect the language when collecting the video record |
| Select uploader or automatic caption origin | Yesparams.auto selects one origin without cross-origin fallback | Origin shown in track metadataNo origin-selection input listed for the reviewed Videos scraper |
| Full text and timestamped citations | Full text + timed segmentsStart/end times in seconds | Full text + timed segmentsSegment start, end and duration in milliseconds |
| Run collection in your application or agent | ||
| Interactive and background collection | Realtime or asyncChoose the mode; save the job ID for background work | Sync scrape or async triggerSync work exceeding one minute continues as a snapshot |
| Process a large prepared list | Bulk Jobs with a video-ID fileConsole or API; progress, manifest and result parts | Async input batchesTrigger a collection and retrieve or deliver its snapshot |
| Output for applications and LLMs | JSON, plain text or Markdown | Snapshot export formatsJSON, NDJSON and CSV |
| Preserve completed results for later analysis | Save results or use bulk storageKeep raw data and manifests in your own storage | Snapshots and storage deliverySnapshots retained for 30 days |
| Standalone terminal client | Native CLILinux, macOS and Windows; no Node/Python runtime | Node.js CLInpm-installed bdata command |
| MCP, skills and SDK access | Yes | Yes |
Paid rates above exclude free allowances. Both provide async jobs, bulk collection and agent tools. Bright Data also offers comment scrapers, broader social coverage and delivery integrations; move the workflows your app needs.
Pay for the fields your task needs
Fetch metadata for your shortlist. Request captions only for videos you will analyze. A metadata refresh does not need to repeat the transcript step.
Choose the caption track explicitly
Request a language and select uploader-provided or YouTube-generated captions. Keep language errors visible instead of silently changing the research input.
Keep the job across agent sessions
Save the accepted job ID before polling. A later process resumes the same job and reuses the downloaded result without submitting another query.
02 · Records are not requests
Compare the cost of the complete video task.
Bright Data’s video record can include metadata and caption fields. FlashData retrieves them through separate sources. Choose your workload and plan on each side; the calculator counts both FlashData requests when you need both.
One Bright Data video record; one FlashData source request.
0 compares paid usage. Enter up to 5,000 only if still available in your shared free pool.
FlashData
$5.00modeled monthly bill
- Rate / 1,000 source requests
- $0.50
- Usage rate / 1,000 complete video tasks
- $0.50
- Monthly fee
- $0.00
- Included standard requests
- 0
- Requests in this workload
- 10,000
- Usage above included balance
- $5.00
From zero balance: $10.00 in plan fees and credit purchases. Unspent top-up credit stays available.
Bright Data · YouTube
$15.00modeled monthly bill
- Rate / 1,000 paid records
- $1.50
- Usage rate / 1,000 complete video tasks
- $1.50
- Monthly fee
- $0.00
- Included paid-plan records
- 0
- Records in this workload
- 10,000
- Free records applied
- 0
- Additional paid records
- 10,000
Each returned video is one record in this model. Discovery and comments can produce more records per input.
How the estimate works
USD for one month of successful video lookups. One returned Bright Data video record can contain metadata and existing captions; the combined FlashData task uses two source requests. Discovery, comments, AI transcription, Extended Search and media downloads are excluded. Enter only Bright Data free credits still available for these records; the 5,000-credit pool is shared, and recurring free credits do not stack with Scale. FlashData prices come from its current public catalog; the entire selected plan balance is allocated here before additional usage. FlashData starting balances and signup/agent trials are excluded. The modeled bill measures usage plus any monthly fee, not a new wallet purchase: FlashData top-ups start at $10. No taxes, deposit-match promotions, custom rates or annual discounts are included.
Bright Data YouTube pricing
| Bright Data YouTube offer | Monthly fee | Included records | Paid rate / 1,000 records |
|---|---|---|---|
| Eligible free pool | $0 | Up to 5,000/month shared across eligible products | Within allowance |
| Pay as you go | $0.00 | No paid-plan allowance | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Enterprise | Custom | Custom | Custom |
Reviewed 2026-11-10. Scale’s included allowance is 384,000 records; $1.30 is its additional-record rate. Enterprise terms and promotional deposit matching are not modeled.
All FlashData YouTube Data plans
| FlashData plan | Per 1,000 requests | Monthly fee | Included requests / month |
|---|---|---|---|
| Pay As You Go | $0.50 | $0.00 | 0 |
| Micro | $0.40 | $49.00 | 125,000 |
| Starter | $0.35 | $199.00 | 571,428 |
| Pro | $0.30 | $499.00 | 1,666,666 |
| Scale | $0.25 | $999.00 | 4,000,000 |
| Business | $0.20 | $1,999.00 | 10,000,000 |
Included-request counts allocate the full shared plan balance to standard YouTube Data. Extended Search and Download have separate rates.
Full YouTube Data pricing →FlashData starting access
Eligible verified signups can receive an initial allowance of up to 4,000 standard YouTube Data requests. This is an initial balance, not a recurring monthly quota.
Separate agent trial and claiming →Bright Data monthly free pool
Eligible accounts receive 5,000 credits each month, shared across eligible products. One YouTube record consumes one credit. Unused free credits do not roll over; recurring free credits stop on pre-commit plans.
03 · Plan the queue, not just the bill
Allowances, batch sizes and running jobs.
A monthly record allowance, an input-size limit and a running-job cap measure different things. Size each part of your pipeline separately.
| Concern | FlashData | Bright Data Scraper API |
|---|---|---|
| What consumes the allowance? | Each source query; metadata and captions are separate | Successfully delivered records; one discovery input can return many |
| One interactive request | POST /v1/queries/realtime; choose async for background work | POST /datasets/v3/scrape; after 1 minute, HTTP 202 returns a snapshot ID and the job continues |
| Larger inputs | Batch size depends on plan; use Bulk processing for a file of IDs | Async /trigger accepts up to 1 GB of input; minimum input count depends on scraper |
| Running work | Account concurrency depends on the selected plan, shown below | 5,000 active jobs/snapshots; exceeding the limit returns 429 |
| Backoff | Honor Retry-After; temporary agent trials allow one request per second | Honor Retry-After; 25 HTTP 429 responses per IP in 5 minutes can trigger a 1-hour API block |
| Saved results | Download and keep the JSON in your own task storage | Snapshots retained for 30 days; download requests support up to 5 GB, with part-based retrieval for larger results |
FlashData account limits by plan
| Plan | Concurrent queries | Queries per Batch request |
|---|---|---|
| Pay As You Go | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |
These are concurrency and submission limits, not requests per second. Credits still apply to each query.
04 · Preserve the job and the parser
From a Bright Data snapshot to a FlashData job.
Start with one known video. Keep existing snapshots and their identifiers separate from the new job receipts.
1 Prepare access and map the request
Create or reuse a key with youtube_metadata permission in API Keys. Check available credits. Store the key as FLASHDATA_API_KEY in your secret store, or enter it in the script’s hidden prompt.
# Existing Bright Data job submission, for migration reference.
curl --fail-with-body --silent --show-error --max-time 120 \
--request POST \
'https://api.brightdata.com/datasets/v3/trigger?dataset_id=gd_lk56epmy2i5g7lzu0k&format=json' \
--header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
--header 'Content-Type: application/json' \
--data '{"input":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}]}'{
"source": "youtube_metadata",
"video_id": "FUfGcZ092b0",
"params": {
"include_formats": false,
"include_chapters": true
}
}2 Save the script, then run it
Use Python 3.10+ and install python -m pip install requests. Save the complete script below as migrate-video.py in a new working folder. It reads FLASHDATA_API_KEY from the environment or a hidden prompt.
# Save as migrate-video.py in your working folder.
import argparse
import getpass
import json
import os
import re
import time
from pathlib import Path
from urllib.parse import urlsplit
import requests
parser = argparse.ArgumentParser()
parser.add_argument("video_id")
parser.add_argument("folder", help="A new folder name, such as video-001")
args = parser.parse_args()
if not re.fullmatch(r"[A-Za-z0-9_-]{11}", args.video_id):
raise SystemExit("Use an 11-character YouTube video ID")
if not re.fullmatch(r"[A-Za-z0-9_-]+", args.folder):
raise SystemExit("Use a simple output folder name")
os.umask(0o077)
out = Path(args.folder)
body = {"source": "youtube_metadata", "video_id": args.video_id,
"params": {"include_formats": False, "include_chapters": True}}
key = None
def read(name):
return json.loads((out / name).read_text(encoding="utf-8"))
def call(method, url, name, payload=None, authenticated=True):
global key
headers = {"Accept": "application/json"}
if authenticated:
if key is None:
key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
if not key.strip():
raise SystemExit("An API key is required")
headers["X-API-Key"] = key
try:
response = requests.request(method, url, json=payload, headers=headers,
timeout=(10, 120), allow_redirects=False)
except requests.RequestException:
raise SystemExit("Network outcome unknown. Keep this folder and check History; do not resubmit.")
(out / name).write_bytes(response.content)
(out / (name + ".http")).write_text(str(response.status_code))
(out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""))
return response
if not out.exists():
out.mkdir()
(out / "request.json").write_text(json.dumps(body), encoding="utf-8")
submitted = call("POST", "https://data.flashdata.dev/v1/queries", "submission.json", body)
if submitted.status_code not in (200, 201, 202):
raise SystemExit(f"HTTP {submitted.status_code}. Inspect submission.json and retry-after.txt.")
else:
try:
if read("request.json") != body:
raise SystemExit("This folder belongs to another request. Use a new folder.")
except (OSError, ValueError):
raise SystemExit("Incomplete attempt. Check the folder and History before resubmitting.")
try:
receipt = read("submission.json")
job_id = receipt["id"]
status = (out / "submission.json.http").read_text().strip()
if status not in ("200", "201", "202") or receipt["source"] != body["source"] or not re.fullmatch(r"[A-Za-z0-9_-]+", job_id):
raise ValueError()
except (OSError, ValueError, KeyError, TypeError):
raise SystemExit("No valid saved receipt. Check History; this script will not submit again.")
if not (out / "result.json").exists():
url = "https://api.flashdata.dev/v2/jobs/" + job_id
for attempt in range(12):
response = call("GET", url, "job.json")
if response.status_code != 200:
raise SystemExit(f"HTTP {response.status_code}. Resolve the error; then resume this folder.")
job = response.json()["job"]
if job["id"] != job_id or job["source"] != body["source"]:
raise SystemExit("Job does not match the saved receipt")
if job["status"] == "completed":
break
if job["status"] not in ("pending", "processing"):
raise SystemExit("Job " + job["status"] + ". Inspect job.json; do not resubmit.")
delay = response.headers.get("Retry-After", "5")
if attempt == 11 or not delay.isdigit() or int(delay) > 60:
raise SystemExit("Still running. Wait for Retry-After, then run the same command to resume.")
time.sleep(max(1, int(delay)))
result = call("GET", url + "/results", "result.pending.json")
if result.status_code == 302:
location = result.headers.get("Location", "")
parsed = urlsplit(location)
if parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password:
raise SystemExit("Expected an HTTPS storage URL")
# Separate request: the API key is never sent to storage.
result = call("GET", location, "result.pending.json", authenticated=False)
if result.status_code != 200:
raise SystemExit(f"HTTP {result.status_code}. Resolve the error, then resume this folder.")
data = result.json()
else:
print("Reading saved result; no API call.")
data = read("result.json")
if not isinstance(data, dict) or data.get("source") != body["source"] or data.get("status") != "done":
raise SystemExit("Result did not complete successfully")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict) or items[0].get("videoId") != args.video_id:
raise SystemExit("Expected the requested video in results")
item = items[0]
mapped = [{"video_id": item["videoId"], "url": "https://www.youtube.com/watch?v=" + item["videoId"],
"title": item.get("title"), "description": item.get("description"),
"views": item.get("viewCount"), "likes": item.get("likeCount"),
"num_comments": item.get("commentCount"), "video_length": item.get("duration"),
"channelName": item.get("channel"), "channelId": item.get("channelId"),
"uploadDateRaw": item.get("uploadDate"), "captionLanguages": item.get("transcriptLanguages")}]
if not (out / "result.json").exists():
(out / "result.pending.json").replace(out / "result.json")
(out / "video-records.json").write_text(json.dumps(mapped, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Saved {out}/video-records.json; actual usage: {json.dumps(data.get('usage'))}")
From that folder, run one metadata task. The script saves its receipt before polling and writes its files inside video-001/.
python migrate-video.py FUfGcZ092b0 video-001If it is still running, repeat the same command to resume. A completed run reuses result.json without an API call. For an intentional refresh, use a new folder after checking the previous attempt.
3 Verify the video record and actual usage
video-001/video-records.json keeps familiar video field names. result.json preserves the full response and usage; submission.json preserves the job ID.
Missing metrics remain null. The adapter uses channelName and uploadDateRaw instead of pretending a channel display name is a handle or an unparsed date has already been normalized. It does not create transcript or media fields.
[
{
"video_id": "FUfGcZ092b0",
"url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
"title": "Example video",
"description": "Example description",
"views": 1200,
"likes": null,
"num_comments": null,
"video_length": 197,
"channelName": "Example channel",
"channelId": "UC_EXAMPLE",
"uploadDateRaw": "2025-01-15",
"captionLanguages": [
"en",
"es"
]
}
]| Concern | Existing integration | FlashData change |
|---|---|---|
| Scraper selection | dataset_id=gd_lk56epmy2i5g7lzu0k | source=youtube_metadata; captions use youtube_transcript separately |
| Input | A watch URL in the input array | An 11-character video_id |
| Authentication | Authorization: Bearer | X-API-Key with the requested source permission |
| Submit | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → id; save the receipt |
| Track | Snapshot progress → ready | GET /v2/jobs/{id} → job.status=completed |
| Retrieve | Download a snapshot as JSON, NDJSON or CSV | GET /v2/jobs/{id}/results → signed storage URL; fetch without the API key |
| Video fields | video_id, title, description, views, likes, num_comments, video_length | videoId, title, description, viewCount, likeCount, commentCount, duration (seconds) |
| Channel and date | youtuber is a handle; date_posted is a date | Keep channelName, channelId and uploadDateRaw; do not rename a display name to a handle |
| Transcript | May be included as transcript and formatted_transcript in the video record | Separate track request; fullText and segments use seconds. Map timestamps if the existing parser expects milliseconds |
| Direct media URL | video_url is a streaming URL | Use the separate YouTube Download workflow for delivery to your storage |
Add captions only when your task needs them
Grant youtube_transcript permission and submit this body to POST https://data.flashdata.dev/v1/queries with X-API-Key. Save its own job ID and retrieve it separately. This adds one standard request per video.
{
"source": "youtube_transcript",
"video_id": "FUfGcZ092b0",
"params": {
"language": "en",
"auto": true
}
}auto=false selects uploader-provided captions. Read fullText and segments, preserving language and origin. Bright Data’s formatted transcript schema uses milliseconds; FlashData segment times use seconds. Multiply by 1,000 when your existing parser expects milliseconds.
Resume and recover without duplicate submissions
- Pending / processing: resume from the saved job ID. The examples honor numeric Retry-After and stop after bounded polling.
- 401 / 403: resolve key or source permissions; stop recurring work when revoked.
- 402: restore the owner’s available balance before continuing.
- 429: stop sending and follow Retry-After. The scripts do not automatically retry rejected submissions.
- Timeout before a receipt: inspect History before creating a new folder. A transport timeout does not prove the job was rejected.
05 · A persistent research workflow
One connection, reusable tasks.
Eligible agents can start with 1 credit (up to 100 standard YouTube Data requests) for 72 hours. Reuse existing credentials before starting a new trial. Metadata and captions share the trial balance.
- Discover and shortlist.
Use search to choose useful videos. Count returned records separately from discovery requests.
- Fetch and verify.
Check one video’s metadata and caption track. Save raw output and test the parser.
- Claim continued access.
The owner completes signup or sign-in and approves permissions and shared-balance access. Unused temporary credits do not transfer.
- Schedule and reuse.
Keep credentials and run folders across processes. Reuse saved results and stop on revocation or depleted balance.
Migrate one Bright Data YouTube video lookup to FlashData.
Read https://flashdata.dev/auth.md and reuse saved access first.
Inspect the current video-record parser and list its required fields.
Fetch metadata for one known video. Request captions separately only if needed.
Keep channel handles, dates, caption origin and timestamp units explicit.
Save the submission receipt, job ID, raw JSON and normalized output.
Resume accepted work; do not submit again after a timeout or agent restart.
Verify the output before scheduling. Have the owner claim access and approve
the required permissions and shared balance for continued use.
Keep keys in the host's secret store. Stop on revoked access or insufficient balance.06 · Before moving traffic
Migration questions
Is this the Bright Data Google Search comparison?
This page covers the YouTube Scraper API. Google Search uses Bright Data’s SERP product, with different pricing units and request configuration. The Google Search comparison has its own page.
Does Bright Data charge twice for metadata and a transcript?
Its YouTube video schema includes metadata and caption fields in the returned video record. Do not automatically count two records. FlashData uses separate metadata and transcript queries; the combined workload in the calculator counts two FlashData requests per video. A caption field may be unavailable for a particular video.
Which provider has the larger free allowance?
Bright Data offers eligible accounts 5,000 shared credits every month. FlashData’s eligible signup allowance is an initial balance, and its temporary agent trial is separate. These offers have different renewal rules. Use the remaining free-record input to model Bright Data PAYG accurately.
Can I replace every Bright Data scraper?
Move the supported YouTube metadata, search, channel and caption workflows you need. Keep comment collection, other social platforms, managed datasets and existing storage-delivery integrations where your application still depends on them.
Do both providers support AI agents?
Yes. Both offer MCP, a CLI and agent skills. FlashData’s standalone CLI, source permissions and shared Google/YouTube balance are useful for a focused research workflow. Reuse saved access and ask the owner to approve continued account access before scheduling recurring work.
Can I reuse a snapshot ID after migrating?
No. Save the Bright Data snapshot and the new FlashData job ID as separate identifiers. The example reuses only its saved FlashData receipt and checks that the returned video matches the requested ID.
Start with one video
Build your next video research task.
Save the job, verify the fields and reuse the result.