# Bright Data Alternative for YouTube Data

Compare FlashData YouTube requests with Bright Data scraper records: paid rates, monthly allowances, job limits and Python/Bash migration from snapshots to saved jobs.

Build video research around source requests. Compare the whole task, then move a snapshot workflow to saved, resumable jobs.

This is the YouTube comparison. [Bright Data Alternative for Google Search](https://flashdata.dev/compare/brightdata/reference.md) is a separate page.

Bright Data facts reviewed 2026-11-10. FlashData rates and allowances use its current public catalogs.

- [Features](#features)
- [Pricing](#pricing)
- [Quotas & limits](#limits)
- [Migrate a job](#migration)
- [Agent workflows](#agents)
- [FAQ](#faq)

<a id="features"></a>
## Feature-by-feature comparison

### Lower paid costs for focused video lookups

| Feature | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Paid metadata lookup · 1,000 videos | $0.50 — 1,000 source requests · PAYG | $1.50 — 1,000 delivered video records · PAYG |
| Metadata + existing captions · 1,000 videos | $1.00 — 2,000 source requests · PAYG | $1.50 — 1,000 video records when caption fields are included |
| Entry monthly plan | $49.00 — Micro/month; shared usage balance included | $499 — Scale/month · 384,000 records included |
| Pay as you go without a monthly subscription | Yes | Yes |

### Find videos and build a research library

| Feature | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Discover videos by keyword | Yes — Search with date, duration, type and sorting filters | Yes — Keyword and search-filter discovery modes |
| Metadata for a known video | Yes — Title, channel, duration, thumbnails and engagement counts | Yes — Video records with identity, channel and engagement fields |
| Chapter markers for navigation | Yes — include_chapters; chapter times in seconds | Yes — Chapter titles, previews and start times in milliseconds |
| Discover available caption languages | Language list in metadata | Track list in the video record — Includes language and automatic-caption information |

### Make captions usable as evidence

| Feature | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Request captions without refreshing metadata | Dedicated transcript source — One standard request per video | Caption fields in the video record — YouTube Videos scraper |
| Request multiple caption languages | Up to 10 explicit languages — Tracks plus per-language errors | One selected language — Select the language when collecting the video record |
| Select uploader or automatic caption origin | Yes — params.auto selects one origin without cross-origin fallback | Origin shown in track metadata — No origin-selection input listed for the reviewed Videos scraper |
| Full text and timestamped citations | Full text + timed segments — Start/end times in seconds | Full text + timed segments — Segment start, end and duration in milliseconds |

### Run collection in your application or agent

| Feature | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Interactive and background collection | Realtime or async — Choose the mode; save the job ID for background work | Sync scrape or async trigger — Sync work exceeding one minute continues as a snapshot |
| Process a large prepared list | Bulk Jobs with a video-ID file — Console or API; progress, manifest and result parts | Async input batches — Trigger a collection and retrieve or deliver its snapshot |
| Output for applications and LLMs | JSON, plain text or Markdown | Snapshot export formats — JSON, NDJSON and CSV |
| Preserve completed results for later analysis | Save results or use bulk storage — Keep raw data and manifests in your own storage | Snapshots and storage delivery — Snapshots retained for 30 days |
| Standalone terminal client | Native CLI — Linux, macOS and Windows; no Node/Python runtime | Node.js CLI — npm-installed bdata command |
| MCP, skills and SDK access | Yes | Yes |

Paid rates exclude free allowances. Both offer async jobs, bulk collection and agent tools. Keep comment collection, other social platforms, managed datasets and existing storage-delivery integrations where needed.

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

<a id="pricing"></a>
## Compare the complete video task

Bright Data's video record can include metadata and captions. FlashData uses one metadata request and a separate caption request. One discovery input may return many billable records; this calculator covers known-video lookups only.

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

Scale includes 384,000 records for $499/month; additional records cost $1.30 per 1,000. Custom Enterprise and promotional deposit matching are not modeled.

| 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 pricing](https://flashdata.dev/pricing/youtube-data).

### 10,000 videos: pay as you go on both sides

| Task | FlashData requests | FlashData modeled bill | Bright Data free records applied | Bright Data modeled bill |
| --- | --- | --- | --- | --- |
| Video metadata | 10,000 | $5.00 | 0 | $15.00 |
| Video metadata | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadata + existing captions | 20,000 | $10.00 | 0 | $15.00 |
| Metadata + existing captions | 20,000 | $10.00 | 5,000 | $7.50 |

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.

### Starting offers

Eligible verified FlashData 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.

Eligible Bright Data accounts receive 5,000 free credits per month shared across eligible products, including Scraper API. One delivered YouTube record consumes one credit. Unused free credits do not roll over; pre-commit accounts do not receive recurring free credits. Do not stack the monthly free pool with Scale.

<a id="limits"></a>
## Allowances, batch sizes and running jobs

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

Concurrency is not requests per second. Credits still apply to each query. [Realtime and async](https://flashdata.dev/docs/reference/realtime-and-async/reference.md) · [Batch and bulk](https://flashdata.dev/docs/reference/batch-and-bulk/reference.md) · [Bulk processing reference](https://flashdata.dev/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## From a snapshot to a saved job

### 1. Prepare access and map the request

Create or reuse a key with youtube_metadata permission. [API Keys](https://flashdata.dev/app/api-keys) · [Available credits](https://flashdata.dev/app/billing). Store FLASHDATA_API_KEY in a secret store or enter it in the script's hidden prompt.

Existing Bright Data submission, for migration reference:

```bash
# 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 https://data.flashdata.dev/v1/queries with X-API-Key:

```json
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_formats": false,
    "include_chapters": true
  }
}
```

### 2. Save the script before running it

Python 3.10+: install python -m pip install requests. Save the complete script below as migrate-video.py in a new working folder.

```python
# 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'))}")

```

Run from the same folder:

```bash
python migrate-video.py FUfGcZ092b0 video-001
```

Alternatively, use Bash, cURL 7.76+ and jq 1.6+. Save the complete script below as migrate-video.sh in a new working folder.

```bash
#!/usr/bin/env bash
# Save as migrate-video.sh in your working folder.
set -euo pipefail
umask 077
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Use a folder name such as video-001}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ && "$out" =~ ^[A-Za-z0-9_-]+$ ]] || exit 2
body=$(jq -n --arg id "$video_id" '{source:"youtube_metadata", video_id:$id,
  params:{include_formats:false, include_chapters:true}}')
call() {
  local method="$1" url="$2" name="$3" authenticated="$4" payload="${5:-}"
  local -a options=(--silent --show-error --compressed --proto '=https'
    --connect-timeout 10 --max-time 120 --request "$method"
    --header 'Accept: application/json' --output "$out/$name"
    --dump-header "$out/$name.headers" --write-out '%{http_code}')
  if [[ "$authenticated" == yes ]]; then
    if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
      read -r -s -p 'FlashData API key: ' FLASHDATA_API_KEY; printf '\n'
    fi
    : "${FLASHDATA_API_KEY:?An API key is required}"
    options+=(--header "X-API-Key: $FLASHDATA_API_KEY")
  fi
  if [[ -n "$payload" ]]; then options+=(--header 'Content-Type: application/json' --data-binary "$payload"); fi
  curl "${options[@]}" "$url" > "$out/$name.http" || {
    echo 'Network outcome unknown. Keep this folder and check History; do not resubmit.' >&2; exit 1;
  }
  status=$(cat "$out/$name.http")
}
if [[ ! -e "$out" ]]; then
  mkdir -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  call POST 'https://data.flashdata.dev/v1/queries' submission.json yes "@$out/request.json"
  [[ "$status" =~ ^20[012]$ ]] || { echo "HTTP $status. Inspect submission.json and its headers." >&2; exit 1; }
else
  jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null || {
    echo 'Incomplete or different request. Check this folder and History.' >&2; exit 1;
  }
fi
[[ "$(cat "$out/submission.json.http")" =~ ^20[012]$ ]] || exit 1
id=$(jq -er 'select(.source == "youtube_metadata") | .id | select(type == "string" and test("^[A-Za-z0-9_-]+$"))' "$out/submission.json")
if [[ ! -f "$out/result.json" ]]; then
  url="https://api.flashdata.dev/v2/jobs/$id"
  for attempt in {1..12}; do
    call GET "$url" job.json yes
    [[ "$status" == 200 ]] || { echo "HTTP $status. Inspect job.json and its headers; resume after resolving." >&2; exit 1; }
    state=$(jq -er --arg id "$id" 'select(.job.id == $id and .job.source == "youtube_metadata") | .job.status' "$out/job.json")
    [[ "$state" == completed ]] && break
    [[ "$state" == pending || "$state" == processing ]] || { echo "Job $state. Do not resubmit." >&2; exit 1; }
    delay=$(awk 'tolower($1)=="retry-after:" {sub(/\r$/, "", $2); print $2}' "$out/job.json.headers")
    delay="${delay:-5}"
    [[ "$attempt" -lt 12 && "$delay" =~ ^[0-9]+$ && "$delay" -le 60 ]] || {
      echo 'Still running. Wait for Retry-After, then run the same command to resume.' >&2; exit 1;
    }
    [[ "$delay" -gt 0 ]] || delay=1
    sleep "$delay"
  done
  call GET "$url/results" result.pending.json yes
  if [[ "$status" == 302 ]]; then
    location=$(awk 'tolower($1)=="location:" {sub(/\r$/, "", $2); print $2}' "$out/result.pending.json.headers")
    [[ "$location" =~ ^https://[^/@[:space:]]+(/|$) ]] || { echo 'Expected HTTPS storage URL.' >&2; exit 1; }
    # Separate request, without the API key. Do not add -L to an authenticated request.
    call GET "$location" result.pending.json no
  fi
  [[ "$status" == 200 ]] || { echo "HTTP $status. Resolve it, then resume this folder." >&2; exit 1; }
  result="$out/result.pending.json"
else
  echo 'Reading saved result; no API call.'
  result="$out/result.json"
fi
mapped=$(jq -e --arg id "$video_id" '
  if .source != "youtube_metadata" or .status != "done" then error("Result not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $id then error("Wrong video") else . end
  | [{video_id:.videoId, url:("https://www.youtube.com/watch?v=" + .videoId), title, description,
      views:.viewCount, likes:.likeCount, num_comments:.commentCount, video_length:.duration,
      channelName:.channel, channelId, uploadDateRaw:.uploadDate, captionLanguages:.transcriptLanguages}]' "$result")
[[ "$result" == "$out/result.json" ]] || mv -- "$result" "$out/result.json"
printf '%s\n' "$mapped" > "$out/video-records.json"
printf 'Saved %s/video-records.json; actual usage: ' "$out"
jq -c '.usage' "$out/result.json"

```

Run from the same folder:

```bash
bash migrate-video.sh FUfGcZ092b0 video-001
```

If still running, repeat the same command to resume the saved job. Completed runs reuse result.json without an API call. A new folder submits a new request; check History before retrying an uncertain submission. Keep keys out of chat and never forward them to signed storage URLs.

### 3. Read the mapped record

video-001/video-records.json preserves common video field names; result.json retains raw data and usage. Missing metrics remain null. channelName is a display name, not a handle; uploadDateRaw is not a normalized date. Transcript and media fields are not fabricated.

```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"
    ]
  }
]
```

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

### Optional captions

Grant youtube_transcript permission. Submit this body to POST https://data.flashdata.dev/v1/queries with X-API-Key and save its own job ID. This adds one standard request per video:

```json
{
  "source": "youtube_transcript",
  "video_id": "FUfGcZ092b0",
  "params": {
    "language": "en",
    "auto": true
  }
}
```

auto=false selects uploader-provided captions. Preserve language and origin. Bright Data formatted transcript times use milliseconds; FlashData segments use seconds. Multiply by 1,000 for a parser expecting milliseconds. [Runnable timestamped captions recipe](https://flashdata.dev/docs/guides/timestamped-captions-recipe/reference.md).

### Recovery

- Pending/processing: resume the saved ID. Polling is bounded and honors numeric Retry-After.
- 401/403: resolve authentication or permission; stop on revocation.
- 402: restore available owner balance before continuing.
- 429: stop sending and honor Retry-After; do not automatically retry submissions.
- Timeout without a receipt: inspect History before creating another folder.

[Errors and status codes](https://flashdata.dev/docs/errors/reference.md).

<a id="agents"></a>
## One connection, reusable tasks

Eligible agents can start with 1 credit (up to 100 standard YouTube Data requests) for 72 hours. Reuse saved access first; metadata and captions share the allowance.

1. Discover videos and shortlist before enriching.
2. Fetch one video, verify fields and caption selection, and save raw output.
3. Have the owner complete signup/sign-in and approve scopes and shared balance. Unused temporary credits do not transfer.
4. Keep credentials and run folders across recurring tasks. Reuse results and stop on revocation or depleted balance.

```text
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.
```

[Trial and claiming](https://flashdata.dev/docs/guides/agent-onboarding/reference.md) · [Recurring tasks](https://flashdata.dev/docs/guides/recurring-tasks/reference.md) · [Save results](https://flashdata.dev/docs/guides/save-results/reference.md).

<a id="faq"></a>
## 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.

[Get an API key](https://flashdata.dev/signup) · [Google Search comparison](https://flashdata.dev/compare/brightdata/reference.md).
