# Bright Data Alternatief voor YouTube Gegevens

Vergelijk FlashData YouTube verzoeken met Bright Data scraperrecords: betaalde tarieven, maandelijkse vergoedingen, taaklimieten en Python/Bash migratie van snapshots naar opgeslagen banen.

Bouw videoonderzoek rond bronverzoeken. Vergelijk de hele taak en verplaats vervolgens een momentopnameworkflow naar opgeslagen, hervatbare taken.

Dit is de YouTube-vergelijking. [Bright Data Alternatief voor Google Zoeken](https://flashdata.dev/nl/compare/brightdata/reference.md) is een aparte pagina.

Bright Data feiten herzien 2026-11-10. FlashData tarieven en emissierechten gebruiken de huidige openbare catalogi.

- [Kenmerken](#features)
- [Prijzen](#pricing)
- [Quota en limieten](#limits)
- [Een baan migreren](#migration)
- [Agentworkflows](#agents)
- [Veelgestelde vragen](#faq)

<a id="features"></a>
## Functievergelijking

### Lagere betaalde kosten voor gerichte videozoekopdrachten

| Functie | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Betaalde metadata opzoeken · 1,000 video's | $0.50 — 1,000 bronverzoeken · PAYG | $1.50 — 1,000 geleverde video-opnamen · PAYG |
| Metadata + bestaande ondertiteling · 1,000 video's | $1.00 — 2,000 bronverzoeken · PAYG | $1.50 — 1,000 video-opnamen wanneer ondertitelingsvelden zijn opgenomen |
| Instap maandabonnement | $49.00 — Micro/maand; gedeelde verbruiksbalans inbegrepen | $499 — Scale/maand · 384,000 records inbegrepen |
| Pay as you go zonder maandelijks abonnement | Ja | Ja |

### Zoek video's en bouw een onderzoeksbibliotheek

| Functie | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Ontdek video's op trefwoord | Ja — Zoeken met datum, duur, type en sorteerfilters | Ja — Ontdekkingsmodi voor trefwoorden en zoekfilters |
| Metagegevens voor een bekende video | Ja — Titel, kanaal, duur, thumbnails en betrokkenheidsaantallen | Ja — Videorecords met velden voor identiteit, kanaal en betrokkenheid |
| Hoofdstukmarkeringen voor navigatie | Ja — include_chapters; hoofdstuktijden in seconden | Ja — Hoofdstuktitels, previews en starttijden in milliseconden |
| Ontdek beschikbare ondertitelingstalen | Taallijst in metadata | Tracklijst in de video-opname — Inclusief informatie over taal en automatische ondertiteling |

### Maak bijschriften bruikbaar als bewijsmateriaal

| Functie | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Vraag ondertiteling aan zonder de metadata te vernieuwen | Speciale transcriptiebron — Eén standaardverzoek per video | Bijschriftvelden in de video-opname — YouTube Videoschraper |
| Vraag meerdere ondertitelingstalen aan | Maximaal 10 expliciete talen — Tracks plus fouten per taal | Eén geselecteerde taal — Selecteer de taal bij het ophalen van de video-opname |
| Selecteer de oorsprong van de uploader of de automatische ondertiteling | Ja — params.auto selecteert één oorsprong zonder terugval tussen verschillende oorsprongen | Herkomst weergegeven in trackmetadata — Er is geen invoer voor herkomstselectie vermeld voor de beoordeelde videoschraper |
| Volledige tekst en citaten met tijdstempel | Volledige tekst + getimede segmenten — Start/end keer in seconden | Volledige tekst + getimede segmenten — Begin, einde en duur van segmenten in milliseconden |

### Voer een verzameling uit in uw toepassing of agent

| Functie | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Interactieve en achtergrondcollectie | Realtime of async — Kies de modus; sla de taak ID op voor achtergrondwerk | Synchroniseer scrape of async trigger — Synchronisatiewerkzaamheden die langer dan een minuut duren, worden voortgezet als een momentopname |
| Verwerk een grote voorbereide lijst | Bulk Jobs met een video-ID bestand — Console of API; voortgangs-, manifest- en resultaatdelen | Asynchrone invoerbatches — Activeer een verzameling en haal de momentopname ervan op of lever deze af |
| Uitvoer voor applicaties en LLM's | JSON, platte tekst of Markdown | Exportformaten voor momentopnamen — JSON, NDJSON en CSV |
| Bewaar completed resultaten voor latere analyse | Bewaar resultaten of gebruik bulkopslag — Bewaar onbewerkte gegevens en manifesten in uw eigen opslag | Snapshots en opslaglevering — Momentopnamen worden 30 dagen bewaard |
| Zelfstandige terminalclient | Native CLI — Linux, macOS en Windows; geen Node/Python runtime | Node.js CLI — npm-geïnstalleerde bdata-opdracht |
| MCP, vaardigheden en SDK toegang | Ja | Ja |

Betaalde tarieven zijn exclusief gratis emissierechten. Beide bieden async banen, bulkinzameling en agenttools. Houd het verzamelen van reacties, andere sociale platforms, beheerde datasets en bestaande opslagleveringsintegraties waar nodig.

### Betaal voor de velden die uw taak nodig heeft

Haal metadata op voor uw shortlist. Vraag alleen ondertiteling aan voor video's die je gaat analyseren. Bij het vernieuwen van metagegevens hoeft de transcriptiestap niet te worden herhaald.

### Kies expliciet het ondertitelingsspoor

Vraag een taal aan en selecteer door de uploader geleverde of door YouTube gegenereerde ondertiteling. Houd taalfouten zichtbaar in plaats van de onderzoeksinput stilletjes te veranderen.

### Behoud de taak tijdens agentsessies

Sla de geaccepteerde taak op ID voordat u gaat pollen. Een later proces hervat dezelfde taak en gebruikt het gedownloade resultaat opnieuw zonder een nieuwe zoekopdracht in te dienen.

<a id="pricing"></a>
## Vergelijk de volledige videotaak

De video-opname van Bright Data kan metagegevens en bijschriften bevatten. FlashData gebruikt één metadataverzoek en een afzonderlijk ondertitelingsverzoek. Eén ontdekkingsinvoer kan veel factureerbare records opleveren; deze rekenmachine dekt alleen bekende video-lookups.

| Bright Data YouTube aanbieding | Maandelijkse kosten | Inbegrepen records | Betaald tarief / 1,000 records |
| --- | --- | --- | --- |
| In aanmerking komend gratis zwembad | $0 | Maximaal 5,000/maand gedeeld door in aanmerking komende producten | Binnen uitkering |
| Betalen naar gebruik | $0.00 | Geen betaalde abonnementsvergoeding | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Onderneming | Aangepast | Aangepast | Aangepast |

Scale bevat 384,000 records voor $499/maand; extra records kosten $1.30 per 1,000. Aangepaste Enterprise- en promotionele stortingsmatching zijn niet gemodelleerd.

| FlashData plan | Per 1,000 verzoeken | Maandelijkse kosten | Inbegrepen verzoeken per maand |
| --- | --- | --- | --- |
| Betalen naar gebruik | $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 |

Het aantal opgenomen aanvragen wijst het volledige gedeelde abonnementssaldo toe aan standaard YouTube gegevens. Uitgebreid zoeken en downloaden hebben aparte tarieven. [Volledige prijzen](https://flashdata.dev/nl/pricing/youtube-data).

### 10,000 video's: betaal aan beide kanten

| Taak | FlashData verzoeken | FlashData gemodelleerd wetsvoorstel | Bright Data gratis records toegepast | Bright Data gemodelleerd wetsvoorstel |
| --- | --- | --- | --- | --- |
| Metagegevens van video's | 10,000 | $5.00 | 0 | $15.00 |
| Metagegevens van video's | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadata + bestaande bijschriften | 20,000 | $10.00 | 0 | $15.00 |
| Metadata + bestaande bijschriften | 20,000 | $10.00 | 5,000 | $7.50 |

USD voor één maand succesvol video-opzoeken. Eén geretourneerde video-opname Bright Data kan metagegevens en bestaande bijschriften bevatten; de gecombineerde taak FlashData gebruikt twee bronverzoeken. Ontdekking, commentaar, AI-transcriptie, Uitgebreid zoeken en mediadownloads zijn uitgesloten. Voer alleen Bright Data gratis credits in die nog beschikbaar zijn voor deze records; de 5,000-creditpool wordt gedeeld, en terugkerende gratis credits worden niet gestapeld met Scale. FlashData prijzen zijn afkomstig uit de huidige openbare catalogus; het volledige geselecteerde abonnementssaldo wordt hier toegewezen vóór extra gebruik. FlashData startsaldo's en aanmeldingsproeven/agent zijn uitgesloten. De gemodelleerde factuur meet het gebruik plus eventuele maandelijkse kosten, niet de aankoop van een nieuwe portemonnee: FlashData opwaarderingen beginnen bij $10. Er zijn geen belastingen, stortingspromoties, aangepaste tarieven of jaarlijkse kortingen inbegrepen.

### Startaanbiedingen

In aanmerking komende geverifieerde FlashData-aanmeldingen kunnen een initiële vergoeding ontvangen van maximaal 4,000 standaard YouTube Dataverzoeken. Dit is een aanvankelijk saldo, geen terugkerend maandelijks quotum.

In aanmerking komende Bright Data accounts ontvangen 5,000 gratis credits per maand, verdeeld over in aanmerking komende producten, waaronder Scraper API. Eén afgeleverd YouTube-record verbruikt één credit. Ongebruikte gratis credits worden niet overgedragen; Pre-commit-accounts ontvangen geen terugkerende gratis credits. Stapel de maandelijkse gratis pool niet met Scale.

<a id="limits"></a>
## Toeslagen, batch maten en running banen

| Bezorgdheid | FlashData | Bright Data Schraper API |
| --- | --- | --- |
| Wat kost de uitkering? | Elke bronquery; metadata en bijschriften zijn gescheiden | Records succesvol afgeleverd; één ontdekkingsinvoer kan er veel opleveren |
| Eén interactief verzoek | POST /v1/queries/realtime; kies async voor achtergrondwerk | POST /datasets/v3/scrape; na 1 minuut retourneert HTTP 202 een momentopname ID en gaat de taak verder |
| Grotere ingangen | Batchgrootte is afhankelijk van plan; gebruik bulkverwerking voor een bestand van IDs | Asynchrone /trigger accepteert maximaal 1 GB aan invoer; Het minimale invoeraantal is afhankelijk van de schraper |
| Lopend werk | De gelijktijdigheid van accounts is afhankelijk van het geselecteerde abonnement, zoals hieronder weergegeven | 5,000 actieve banen/snapshots; het overschrijden van de limiet retourneert 429 |
| Terugtrekken | Eer Retry-After; Proeven met tijdelijke agenten staan één verzoek per seconde toe | Eer Retry-After; 25 HTTP 429 reacties per IP in 5 minuten kunnen een blok van 1 uur API activeren |
| Opgeslagen resultaten | Download en bewaar de JSON in uw eigen taakopslag | Momentopnamen worden 30 dagen bewaard; downloadverzoeken ondersteunen tot 5 GB, met op onderdelen gebaseerd ophalen voor grotere resultaten |

| FlashData plan | Gelijktijdige zoekopdrachten | Query's per batchverzoek |
| --- | --- | --- |
| Betalen naar gebruik | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

Gelijktijdigheid is geen verzoek per seconde. Er zijn nog steeds credits van toepassing op elke zoekopdracht. [Realtime en async](https://flashdata.dev/nl/docs/reference/realtime-and-async/reference.md) · [Partij en bulk](https://flashdata.dev/nl/docs/reference/batch-and-bulk/reference.md) · [Referentie voor bulkverwerking](https://flashdata.dev/nl/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## Van een momentopname tot een opgeslagen opdracht

### 1. Toegang voorbereiden en de aanvraag in kaart brengen

Maak of hergebruik een sleutel met toestemming youtube_metadata. [API Toetsen](https://flashdata.dev/app/api-keys) · [Beschikbare kredieten](https://flashdata.dev/app/billing). Bewaar FLASHDATA_API_KEY in een geheime opslag of voer het in de verborgen prompt van het script in.

Bestaande Bright Data indiening, ter referentie voor de migratie:

```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 met X-API-Key:

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

### 2. Sla het script op vóór running het

Python 3.10+ vereist. Installeer de afhankelijkheid met python -m pip install requests. Sla het volledige onderstaande script in een nieuwe werkmap op als migrate-video.py voordat je het uitvoert.

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

```

Uitvoeren vanuit dezelfde map:

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

U kunt ook Bash, cURL 7.76+ en jq 1.6+ gebruiken. Sla het volledige script hieronder op als migrate-video.sh in een nieuwe werkmap.

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

```

Uitvoeren vanuit dezelfde map:

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

Indien nog steeds running, herhaal dan dezelfde opdracht om de opgeslagen taak te hervatten. Voltooide uitvoeringen hergebruiken result.json zonder een API-aanroep. Een nieuwe map dient een nieuw verzoek in; Controleer de Geschiedenis voordat u een onzekere inzending opnieuw probeert. Houd sleutels buiten de chat en stuur ze nooit door naar ondertekende opslag URLs.

### 3. Lees het in kaart gebrachte record

video-001/video-records.json behoudt gemeenschappelijke videoveldnamen; result.json bewaart ruwe gegevens en gebruik. Ontbrekende metrics blijven null. channelName is een displaynaam, geen handvat; uploadDateRaw wordt niet genormaliseerd. Transcript- en mediavelden zijn niet verzonnen.

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

| Bezorgdheid | Bestaande integratie | FlashData wijzigen |
| --- | --- | --- |
| Schraper selectie | dataset_id=gd_lk56epmy2i5g7lzu0k | bron=youtube_metadata; bijschriften gebruiken afzonderlijk youtube_transcript |
| Invoer | Een horloge URL in de invoerarray | Een 11-teken video_id |
| Authenticatie | Machtiging: Aan toonder | X-API-Key met de gevraagde brontoestemming |
| Verzenden | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → ID; bewaar de bon |
| Volg | Momentopname voortgang → ready | GET /v2/jobs/{id} → job.status=completed |
| Ophalen | Download een momentopname als JSON, NDJSON of CSV | GET /v2/jobs/{id}/results → ondertekende opslag URL; ophalen zonder de sleutel API |
| Videovelden | video_id, title, description, views, likes, num_comments, video_length | videoId, titel, beschrijving, viewCount, likeCount, commentCount, duur (seconden) |
| Kanaal en datum | youtuber is een handvat; date_posted is een datum | Behoud channelName, channelId en uploadDateRaw; hernoem een weergavenaam niet naar een handle |
| Afschrift | Kan als transcript en formatted_transcript in de video-opname worden opgenomen | Apart trackverzoek; fullText en segmenten gebruiken seconden. Wijs tijdstempels toe als de bestaande parser milliseconden verwacht |
| Directe media URL | video_url is een streaming-URL | Gebruik de aparte YouTube Downloadworkflow voor bezorging in uw opslag |

### Optionele bijschriften

Verleen youtube_transcript toestemming. Verzend dit lichaam naar POST https://data.flashdata.dev/v1/queries met X-API-Key en sla zijn eigen taak op ID. Dit voegt één standaardverzoek per video toe:

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

auto=false selecteert door de uploader geleverde ondertiteling. Behoud taal en herkomst. Bright Data geformatteerde transcriptietijden gebruiken milliseconden; FlashData segmenten gebruiken seconden. Vermenigvuldig met 1,000 voor een parser die milliseconden verwacht. [Uitvoerbaar recept voor bijschriften met tijdstempel](https://flashdata.dev/nl/docs/guides/timestamped-captions-recipe/reference.md).

### Herstel

- In afwachting /processing: hervat de opgeslagen ID. Polling is begrensd en eert numeriek Retry-After.
- 401/403: authenticatie of toestemming oplossen; stoppen bij intrekking.
- 402: herstel het beschikbare eigenaarssaldo voordat u doorgaat.
- 429: stop met verzenden en eer Retry-After; inzendingen niet automatisch opnieuw proberen.
- Time-out zonder ontvangstbewijs: controleer de geschiedenis voordat u een nieuwe map maakt.

[Fouten en statuscodes](https://flashdata.dev/nl/docs/errors/reference.md).

<a id="agents"></a>
## Eén verbinding, herbruikbare taken

In aanmerking komende agenten kunnen beginnen met 1-krediet (tot 100 standaard YouTube Dataverzoeken) voor 72 uren. Hergebruik opgeslagen toegang eerst; metadata en bijschriften delen de vergoeding.

1. Ontdek video's en shortlist voordat u deze verrijkt.
2. Haal één video op, verifieer de selectie van velden en bijschriften en sla de onbewerkte uitvoer op.
3. Laat de eigenaar de aanmelding/sign-in voltooien en de scopes en het gedeelde saldo goedkeuren. Ongebruikte tijdelijke tegoeden worden niet overgedragen.
4. Bewaar inloggegevens en voer mappen uit voor terugkerende taken. Hergebruik resultaten en stop bij intrekking of uitgeput saldo.

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

[Proberen en claimen](https://flashdata.dev/nl/docs/guides/agent-onboarding/reference.md) · [Terugkerende taken](https://flashdata.dev/nl/docs/guides/recurring-tasks/reference.md) · [Resultaten opslaan](https://flashdata.dev/nl/docs/guides/save-results/reference.md).

<a id="faq"></a>
## Migratie vragen

### Is dit de Bright Data Google Zoekvergelijking?

Deze pagina behandelt de YouTube Schraper API. Google Zoeken gebruikt het SERP-product van Bright Data, met verschillende prijseenheden en verzoekconfiguratie. De Google Zoekvergelijking heeft een eigen pagina.

### Brengt Bright Data tweemaal kosten in rekening voor metadata en een transcriptie?

Het videoschema YouTube bevat metagegevens en ondertitelingsvelden in de geretourneerde videorecord. Tel niet automatisch twee records. FlashData gebruikt afzonderlijke metadata- en transcriptquery's; de gecombineerde werklast in de rekenmachine telt twee FlashData verzoeken per video. Het is mogelijk dat een ondertitelingsveld niet beschikbaar is voor een bepaalde video.

### Welke aanbieder heeft de grootste gratis vergoeding?

Bright Data biedt elke maand in aanmerking komende accounts 5,000 gedeelde credits. De in aanmerking komende aanmeldingsvergoeding van FlashData is een initieel saldo, en de proefperiode voor een tijdelijke agent is afzonderlijk. Deze aanbiedingen hebben verschillende verlengingsregels. Gebruik de resterende vrije invoer om Bright Data PAYG nauwkeurig te modelleren.

### Kan ik elke Bright Data schraper vervangen?

Verplaats de ondersteunde YouTube metadata-, zoek-, kanaal- en ondertitelworkflows die u nodig hebt. Bewaar het verzamelen van reacties, andere sociale platforms, beheerde datasets en bestaande integraties voor opslaglevering waar uw applicatie er nog steeds van afhankelijk is.

### Ondersteunen beide providers AI-agents?

Ja. Beide bieden MCP, een CLI en agentvaardigheden. De zelfstandige CLI, bronrechten en het gedeelde Google/YouTube-saldo van FlashData zijn nuttig voor een gerichte onderzoeksworkflow. Hergebruik opgeslagen toegang en vraag de eigenaar om voortgezette accounttoegang goed te keuren voordat u terugkerend werk plant.

### Kan ik een momentopname ID opnieuw gebruiken na de migratie?

Nee. Sla de momentopname Bright Data en de nieuwe taak FlashData ID op als afzonderlijke ID's. In het voorbeeld wordt alleen het opgeslagen ontvangstbewijs FlashData hergebruikt en wordt gecontroleerd of de geretourneerde video overeenkomt met de gevraagde ID.

[Verkrijg een sleutel API](https://flashdata.dev/signup) · [Google Zoekvergelijking](https://flashdata.dev/nl/compare/brightdata/reference.md).
