Skip to content
EN
Get API key

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-by-feature comparison: FlashData and Bright Data YouTube
FeatureFlashDataBright 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 subscriptionYesYes
Find videos and build a research library
Discover videos by keywordYesSearch with date, duration, type and sorting filtersYesKeyword and search-filter discovery modes
Metadata for a known videoYesTitle, channel, duration, thumbnails and engagement countsYesVideo records with identity, channel and engagement fields
Chapter markers for navigationYesinclude_chapters; chapter times in secondsYesChapter titles, previews and start times in milliseconds
Discover available caption languagesLanguage list in metadataTrack list in the video recordIncludes language and automatic-caption information
Make captions usable as evidence
Request captions without refreshing metadataDedicated transcript sourceOne standard request per videoCaption fields in the video recordYouTube Videos scraper
Request multiple caption languagesUp to 10 explicit languagesTracks plus per-language errorsOne selected languageSelect the language when collecting the video record
Select uploader or automatic caption originYesparams.auto selects one origin without cross-origin fallbackOrigin shown in track metadataNo origin-selection input listed for the reviewed Videos scraper
Full text and timestamped citationsFull text + timed segmentsStart/end times in secondsFull text + timed segmentsSegment start, end and duration in milliseconds
Run collection in your application or agent
Interactive and background collectionRealtime or asyncChoose the mode; save the job ID for background workSync scrape or async triggerSync work exceeding one minute continues as a snapshot
Process a large prepared listBulk Jobs with a video-ID fileConsole or API; progress, manifest and result partsAsync input batchesTrigger a collection and retrieve or deliver its snapshot
Output for applications and LLMsJSON, plain text or MarkdownSnapshot export formatsJSON, NDJSON and CSV
Preserve completed results for later analysisSave results or use bulk storageKeep raw data and manifests in your own storageSnapshots and storage deliverySnapshots retained for 30 days
Standalone terminal clientNative CLILinux, macOS and Windows; no Node/Python runtimeNode.js CLInpm-installed bdata command
MCP, skills and SDK accessYesYes

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

YouTube Scraper API plans
Bright Data YouTube offerMonthly feeIncluded recordsPaid rate / 1,000 records
Eligible free pool$0Up to 5,000/month shared across eligible productsWithin allowance
Pay as you go$0.00No paid-plan allowance$1.50
Scale · $499/month$499.00384,000$1.30 additional
EnterpriseCustomCustomCustom

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 YouTube Data plans
FlashData planPer 1,000 requestsMonthly feeIncluded requests / month
Pay As You Go$0.50$0.000
Micro$0.40$49.00125,000
Starter$0.35$199.00571,428
Pro$0.30$499.001,666,666
Scale$0.25$999.004,000,000
Business$0.20$1,999.0010,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.

YouTube collection limits
ConcernFlashDataBright Data Scraper API
What consumes the allowance?Each source query; metadata and captions are separateSuccessfully delivered records; one discovery input can return many
One interactive requestPOST /v1/queries/realtime; choose async for background workPOST /datasets/v3/scrape; after 1 minute, HTTP 202 returns a snapshot ID and the job continues
Larger inputsBatch size depends on plan; use Bulk processing for a file of IDsAsync /trigger accepts up to 1 GB of input; minimum input count depends on scraper
Running workAccount concurrency depends on the selected plan, shown below5,000 active jobs/snapshots; exceeding the limit returns 429
BackoffHonor Retry-After; temporary agent trials allow one request per secondHonor Retry-After; 25 HTTP 429 responses per IP in 5 minutes can trigger a 1-hour API block
Saved resultsDownload and keep the JSON in your own task storageSnapshots retained for 30 days; download requests support up to 5 GB, with part-based retrieval for larger results

FlashData account limits by plan

Current FlashData plan limits
PlanConcurrent queriesQueries per Batch request
Pay As You Go25100
Micro50100
Starter100200
Pro200300
Scale300400
Business400500

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.

Bright Data · existing submission
# 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"}]}'
FlashData · POST /v1/queries
{
  "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.

migrate-video.py
# 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/.

Submit once, then collect
python migrate-video.py FUfGcZ092b0 video-001

If 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.

Metadata fields →
Illustrative video-records.json
[
  {
    "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"
    ]
  }
]
Bright Data to FlashData migration map
ConcernExisting integrationFlashData change
Scraper selectiondataset_id=gd_lk56epmy2i5g7lzu0ksource=youtube_metadata; captions use youtube_transcript separately
InputA watch URL in the input arrayAn 11-character video_id
AuthenticationAuthorization: BearerX-API-Key with the requested source permission
SubmitPOST /datasets/v3/trigger → snapshot_idPOST /v1/queries → id; save the receipt
TrackSnapshot progress → readyGET /v2/jobs/{id} → job.status=completed
RetrieveDownload a snapshot as JSON, NDJSON or CSVGET /v2/jobs/{id}/results → signed storage URL; fetch without the API key
Video fieldsvideo_id, title, description, views, likes, num_comments, video_lengthvideoId, title, description, viewCount, likeCount, commentCount, duration (seconds)
Channel and dateyoutuber is a handle; date_posted is a dateKeep channelName, channelId and uploadDateRaw; do not rename a display name to a handle
TranscriptMay be included as transcript and formatted_transcript in the video recordSeparate track request; fullText and segments use seconds. Map timestamps if the existing parser expects milliseconds
Direct media URLvideo_url is a streaming URLUse 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.

English, YouTube-generated caption track
{
  "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.

Runnable timestamped captions recipe →
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.
Errors and status codes →

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.

  1. Discover and shortlist.

    Use search to choose useful videos. Count returned records separately from discovery requests.

  2. Fetch and verify.

    Check one video’s metadata and caption track. Save raw output and test the parser.

  3. Claim continued access.

    The owner completes signup or sign-in and approves permissions and shared-balance access. Unused temporary credits do not transfer.

  4. Schedule and reuse.

    Keep credentials and run folders across processes. Reuse saved results and stop on revocation or depleted balance.

Give this task to your agent
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.