# Bright Data Alternative für YouTube Daten

Vergleichen Sie FlashData YouTube-Anfragen mit Bright Data Scraper-Datensätzen: bezahlte Tarife, monatliche Zulagen, Joblimits und Python/Bash Migration von Snapshots zu gespeicherten Jobs.

Bauen Sie Videorecherchen rund um Quellenanfragen auf. Vergleichen Sie die gesamte Aufgabe und verschieben Sie dann einen Snapshot-Workflow zu gespeicherten, fortsetzbaren Jobs.

Dies ist der YouTube-Vergleich. [Bright Data Alternative für Google Suche](https://flashdata.dev/de/compare/brightdata/reference.md) ist eine separate Seite.

Bright Data Fakten überprüft 2026-11-10. FlashData-Preise und -Zulagen verwenden ihre aktuellen öffentlichen Kataloge.

- [Funktionen](#features)
- [Preise](#pricing)
- [Quoten und Limits](#limits)
- [Einen Job migrieren](#migration)
- [Agenten-Workflows](#agents)
- [FAQ](#faq)

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

### Niedrigere bezahlte Kosten für gezielte Videosuche

| Funktion | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Kostenpflichtige Metadatensuche · 1,000 Videos | $0.50 — 1,000 Quellanfragen · PAYG | $1.50 — 1,000 gelieferte Videoaufzeichnungen · PAYG |
| Metadaten + vorhandene Untertitel · 1,000 Videos | $1.00 — 2,000 Quellanfragen · PAYG | $1.50 — 1,000 Videoaufzeichnungen, wenn Untertitelfelder enthalten sind |
| Einstiegsmonatsplan | $49.00 — Micro/Monat; geteilte Nutzungsbilanz inklusive | $499 — Scale/Monat · 384,000-Datensätze enthalten |
| Zahlen Sie nach Bedarf, ohne ein monatliches Abonnement | Ja | Ja |

### Finden Sie Videos und bauen Sie eine Forschungsbibliothek auf

| Funktion | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Entdecken Sie Videos nach Schlüsselwörtern | Ja — Suchen Sie mit Datums-, Dauer-, Typ- und Sortierfiltern | Ja — Schlüsselwort- und Suchfilter-Erkennungsmodi |
| Metadaten für ein bekanntes Video | Ja — Titel, Kanal, Dauer, Miniaturansichten und Anzahl der Interaktionen | Ja — Videoaufzeichnungen mit Identitäts-, Kanal- und Engagementfeldern |
| Kapitelmarkierungen zur Navigation | Ja — include_chapters; Kapitelzeiten in Sekunden | Ja — Kapiteltitel, Vorschauen und Startzeiten in Millisekunden |
| Entdecken Sie die verfügbaren Untertitelsprachen | Sprachliste in Metadaten | Titelliste in der Videoaufzeichnung — Enthält Informationen zur Sprache und automatischen Untertiteln |

### Bildunterschriften als Beweismittel nutzbar machen

| Funktion | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Untertitel anfordern, ohne Metadaten zu aktualisieren | Dedizierte Transkriptquelle — Eine Standardanfrage pro Video | Beschriftungsfelder im Videodatensatz — YouTube Video-Scraper |
| Fordern Sie mehrere Untertitelsprachen an | Bis zu 10 explizite Sprachen — Tracks plus Fehler pro Sprache | Eine ausgewählte Sprache — Wählen Sie die Sprache aus, wenn Sie die Videoaufzeichnung erfassen |
| Wählen Sie den Uploader oder den automatischen Untertitelursprung aus | Ja — params.auto wählt einen Ursprung ohne ursprungsübergreifenden Fallback aus | Der Ursprung wird in den Track-Metadaten angezeigt — Für den überprüften Video-Scraper ist keine Eingabe zur Ursprungsauswahl aufgeführt |
| Zitierungen im Volltext und mit Zeitstempel | Volltext + zeitgesteuerte Segmente — Start/end Zeiten in Sekunden | Volltext + zeitgesteuerte Segmente — Segmentanfang, -ende und -dauer in Millisekunden |

### Führen Sie die Sammlung in Ihrer Anwendung oder Ihrem Agenten aus

| Funktion | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Interaktive und Hintergrundsammlung | Echtzeit oder async — Wählen Sie den Modus; Speichern Sie den Job ID für die Hintergrundarbeit | Sync-Scrape oder async-Trigger — Synchronisierungsarbeiten, die länger als eine Minute dauern, werden als Snapshot fortgesetzt |
| Verarbeiten Sie eine große vorbereitete Liste | Bulk Jobs mit einer Video-ID-Datei — Konsole oder API; Fortschritts-, Manifest- und Ergebnisteile | Asynchrone Eingabebatches — Lösen Sie eine Sammlung aus und rufen Sie den Snapshot ab oder stellen Sie ihn bereit |
| Ausgabe für Anwendungen und LLMs | JSON, Klartext oder Markdown | Snapshot-Exportformate — JSON, NDJSON und CSV |
| Bewahren Sie completed Ergebnisse für eine spätere Analyse auf | Ergebnisse speichern oder Massenspeicher verwenden — Bewahren Sie Rohdaten und Manifeste in Ihrem eigenen Speicher auf | Snapshots und Speicherbereitstellung — Snapshots werden 30 Tage lang aufbewahrt |
| Eigenständiger Terminal-Client | Einheimisch CLI — Linux, macOS und Windows; keine Node/Python Laufzeit | Node.js CLI — npm-installierter bdata-Befehl |
| MCP, Fähigkeiten und SDK Zugang | Ja | Ja |

Bezahlte Tarife schließen kostenlose Zulagen aus. Beide bieten async Jobs, Massenerfassung und Agententools. Behalten Sie die Sammlung von Kommentaren, andere soziale Plattformen, verwaltete Datensätze und bestehende Integrationen zur Speicherbereitstellung bei Bedarf bei.

### Bezahlen Sie für die Felder, die Ihre Aufgabe benötigt

Rufen Sie Metadaten für Ihre Auswahlliste ab. Fordern Sie Untertitel nur für Videos an, die Sie analysieren möchten. Bei einer Metadatenaktualisierung muss der Transkriptschritt nicht wiederholt werden.

### Wählen Sie die Untertitelspur explizit aus

Fordern Sie eine Sprache an und wählen Sie vom Uploader bereitgestellte oder von YouTube generierte Untertitel aus. Halten Sie Sprachfehler sichtbar, anstatt den Forschungsinput stillschweigend zu ändern.

### Behalten Sie den Job über Agentensitzungen hinweg bei

Speichern Sie den angenommenen Job ID vor der Abfrage. Ein späterer Prozess nimmt denselben Job wieder auf und verwendet das heruntergeladene Ergebnis erneut, ohne eine weitere Abfrage zu senden.

<a id="pricing"></a>
## Vergleichen Sie die komplette Videoaufgabe

Die Videoaufzeichnung von Bright Data kann Metadaten und Untertitel enthalten. FlashData verwendet eine Metadatenanforderung und eine separate Untertitelanforderung. Eine Discovery-Eingabe kann viele abrechenbare Datensätze zurückgeben; Dieser Rechner deckt nur bekannte Videosuchen ab.

| Bright Data YouTube Angebot | Monatliche Gebühr | Enthaltene Datensätze | Bezahlter Tarif / 1,000 Datensätze |
| --- | --- | --- | --- |
| Berechtigter kostenloser Pool | $0 | Bis zu 5,000/Monat werden auf alle berechtigten Produkte verteilt | Innerhalb des zulässigen Rahmens |
| Nutzungsabhängige Abrechnung | $0.00 | Keine bezahlte Planzulage | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Unternehmen | Benutzerdefiniert | Benutzerdefiniert | Benutzerdefiniert |

Scale umfasst 384,000 Datensätze für $499/Monat; Zusätzliche Datensätze kosten $1.30 pro 1,000. Benutzerdefinierte Enterprise- und Promotion-Einzahlungsabgleiche werden nicht modelliert.

| FlashData Plan | Pro 1,000 Anfragen | Monatliche Gebühr | Enthaltene Anfragen pro Monat |
| --- | --- | --- | --- |
| Nutzungsabhängige Abrechnung | $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 |

Die Anzahl der eingeschlossenen Anfragen weist den gesamten gemeinsamen Plansaldo den Standarddaten von YouTube zu. Für die erweiterte Suche und den Download gelten separate Tarife. [Vollpreis](https://flashdata.dev/de/pricing/youtube-data).

### 10,000 Videos: Pay-as-you-go auf beiden Seiten

| Aufgabe | FlashData Anfragen | FlashData modellierte Rechnung | Bright Data kostenlose Datensätze angewendet | Bright Data modellierte Rechnung |
| --- | --- | --- | --- | --- |
| Video-Metadaten | 10,000 | $5.00 | 0 | $15.00 |
| Video-Metadaten | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadaten + vorhandene Untertitel | 20,000 | $10.00 | 0 | $15.00 |
| Metadaten + vorhandene Untertitel | 20,000 | $10.00 | 5,000 | $7.50 |

USD für einen Monat erfolgreicher Videosuche. Ein zurückgegebener Bright Data-Videodatensatz kann Metadaten und vorhandene Untertitel enthalten; Die kombinierte FlashData-Aufgabe verwendet zwei Quellanforderungen. Ausgenommen sind Discovery, Kommentare, AI-Transkription, erweiterte Suche und Mediendownloads. Geben Sie nur Bright Data kostenlose Credits ein, die für diese Datensätze noch verfügbar sind; Der 5,000-Credit-Pool wird geteilt und wiederkehrende Gratis-Credits sind nicht mit Scale kumulierbar. FlashData Die Preise stammen aus dem aktuellen öffentlichen Katalog; Hier wird der gesamte ausgewählte Plansaldo vor der weiteren Nutzung zugewiesen. FlashData Startguthaben und Anmeldung/agent Testversionen sind ausgeschlossen. Die modellierte Rechnung misst die Nutzung zuzüglich etwaiger monatlicher Gebühren, nicht den Kauf einer neuen Geldbörse: FlashData Aufladungen beginnen bei $10. Es sind keine Steuern, Einzahlungsboni, Sondertarife oder Jahresrabatte enthalten.

### Startangebote

Berechtigte FlashData-Anmeldungen können eine anfängliche Berechtigung von bis zu 4,000 Standard YouTube Datenanforderungen erhalten. Dies ist ein Anfangssaldo, kein wiederkehrendes monatliches Kontingent.

Berechtigte Bright Data-Konten erhalten 5,000 kostenlose Credits pro Monat, die auf alle berechtigten Produkte verteilt werden, einschließlich Scraper API. Ein gelieferter YouTube-Datensatz verbraucht ein Guthaben. Ungenutzte Gratisguthaben werden nicht übertragen; Pre-Commit-Konten erhalten keine wiederkehrenden kostenlosen Gutschriften. Stapeln Sie den monatlichen kostenlosen Pool nicht mit Scale.

<a id="limits"></a>
## Zulagen, batch Größen und running Jobs

| Sorge | FlashData | Bright Data Schaber API |
| --- | --- | --- |
| Was verbraucht den Zuschuss? | Jede Quellabfrage; Metadaten und Beschriftungen sind getrennt | Erfolgreich zugestellte Datensätze; Eine Discovery-Eingabe kann viele zurückgeben |
| Eine interaktive Anfrage | POST /v1/queries/realtime; Wählen Sie async für die Hintergrundarbeit | POST /datasets/v3/scrape; Nach 1 Minute gibt HTTP 202 einen Schnappschuss ID zurück und der Job wird fortgesetzt |
| Größere Eingänge | Die Chargengröße hängt vom Plan ab; Verwenden Sie die Massenverarbeitung für eine Datei mit IDs | Async /trigger akzeptiert bis zu 1 GB an Eingaben; Die Mindesteingabeanzahl hängt vom Schaber ab |
| Laufende Arbeit | Die Kontogleichzeitigkeit hängt vom ausgewählten Plan ab (siehe unten). | 5,000 aktive Jobs/snapshots; Bei Überschreitung des Grenzwerts wird 429 zurückgegeben. |
| Zurück | Ehre Retry-After; Temporäre Agent-Tests erlauben eine Anfrage pro Sekunde | Ehre Retry-After; 25 HTTP 429 Antworten pro IP in 5 Minuten können eine 1-stündige API-Blockierung auslösen |
| Gespeicherte Ergebnisse | Laden Sie die JSON herunter und bewahren Sie sie in Ihrem eigenen Aufgabenspeicher auf | Snapshots werden 30 Tage lang aufbewahrt; Download-Anfragen unterstützen bis zu 5 GB, mit teilbasiertem Abruf für größere Ergebnisse |

| FlashData Plan | Gleichzeitige Abfragen | Abfragen pro Batch-Anfrage |
| --- | --- | --- |
| Nutzungsabhängige Abrechnung | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

Bei der Parallelität handelt es sich nicht um Anfragen pro Sekunde. Credits gelten weiterhin für jede Abfrage. [Echtzeit und async](https://flashdata.dev/de/docs/reference/realtime-and-async/reference.md) · [Batch und Bulk](https://flashdata.dev/de/docs/reference/batch-and-bulk/reference.md) · [Referenz zur Massenverarbeitung](https://flashdata.dev/de/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## Vom Schnappschuss bis zum gespeicherten Job

### 1. Bereiten Sie den Zugang vor und ordnen Sie die Anfrage zu

Erstellen oder verwenden Sie einen Schlüssel mit der Berechtigung youtube_metadata wieder. [API Schlüssel](https://flashdata.dev/app/api-keys) · [Verfügbare Credits](https://flashdata.dev/app/billing). Speichern Sie FLASHDATA_API_KEY in einem geheimen Speicher oder geben Sie es in die versteckte Eingabeaufforderung des Skripts ein.

Vorhandene Bright Data-Einreichung als Migrationsreferenz:

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

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

### 2. Speichern Sie das Skript vor running

Python 3.10+ erforderlich. Installiere die Abhängigkeit mit python -m pip install requests. Speichere das vollständige Skript unten in einem neuen Arbeitsordner als migrate-video.py, bevor du es ausführst.

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

```

Aus demselben Ordner ausführen:

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

Alternativ können Sie Bash, cURL 7.76+ und jq 1.6+ verwenden. Speichern Sie das vollständige Skript unten als migrate-video.sh in einem neuen Arbeitsordner.

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

```

Aus demselben Ordner ausführen:

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

Wenn immer noch running angezeigt wird, wiederholen Sie denselben Befehl, um den gespeicherten Job fortzusetzen. Abgeschlossene Läufe können result.json ohne API-Aufruf wiederverwenden. Ein neuer Ordner sendet eine neue Anfrage. Überprüfen Sie den Verlauf, bevor Sie eine unsichere Übermittlung erneut versuchen. Halten Sie Schlüssel aus dem Chat fern und leiten Sie sie niemals an den signierten Speicher weiter URLs.

### 3. Lesen Sie den zugeordneten Datensatz

video-001/video-records.json behält gängige Videofeldnamen bei; result.json speichert Rohdaten und -nutzung. Fehlende Metriken bleiben null. channelName ist ein Anzeigename, kein Handle; uploadDateRaw kein normalisiertes Datum. Transkript- und Medienfelder sind nicht fabriziert.

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

| Sorge | Bestehende Integration | FlashData ändern |
| --- | --- | --- |
| Schaberauswahl | dataset_id=gd_lk56epmy2i5g7lzu0k | Quelle=youtube_metadata; Untertitel verwenden youtube_transcript separat |
| Eingabe | Eine Uhr URL im Eingabearray | Ein 11-Zeichen video_id |
| Authentifizierung | Autorisierung: Inhaber | X-API-Key mit der angeforderten Quellberechtigung |
| Senden | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → ID; Bewahren Sie die Quittung auf |
| Verfolgen | Snapshot-Fortschritt → ready | GET /v2/jobs/{id} → job.status=completed |
| Abrufen | Laden Sie einen Schnappschuss als JSON, NDJSON oder CSV herunter. | GET /v2/jobs/{id}/results → signierter Speicher URL; ohne die Taste API abrufen |
| Videofelder | video_id, title, description, views, likes, num_comments, video_length | videoId, Titel, Beschreibung, viewCount, likeCount, commentCount, Dauer (Sekunden) |
| Kanal und Datum | youtuber ist ein Handle; date_posted ist ein Datum | Behalten Sie channelName, channelId und uploadDateRaw; Benennen Sie einen Anzeigenamen nicht in ein Handle um |
| Transkript | Kann als Transkript und formatted_transcript in die Videoaufzeichnung eingefügt werden | Separate Titelanforderung; fullText und Segmente verwenden Sekunden. Ordnen Sie Zeitstempel zu, wenn der vorhandene Parser Millisekunden erwartet |
| Direktmedien URL | video_url ist ein Streaming URL | Verwenden Sie den separaten YouTube Download-Workflow für die Lieferung an Ihren Speicher |

### Optionale Bildunterschriften

Erteilen Sie die youtube_transcript-Berechtigung. Senden Sie diesen Körper an POST https://data.flashdata.dev/v1/queries mit X-API-Key und speichern Sie seinen eigenen Job ID. Dadurch wird pro Video eine Standardanfrage hinzugefügt:

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

auto=false wählt vom Uploader bereitgestellte Untertitel aus. Sprache und Herkunft bewahren. Bright Data formatierte Transkriptzeiten verwenden Millisekunden; FlashData Segmente verwenden Sekunden. Mit 1,000 multiplizieren, um einen Parser zu erhalten, der Millisekunden erwartet. [Ausführbares Rezept für Untertitel mit Zeitstempel](https://flashdata.dev/de/docs/guides/timestamped-captions-recipe/reference.md).

### Erholung

- Pending/processing: nimmt das gespeicherte ID wieder auf. Polling ist begrenzt und ehrt numerische Retry-After.
- 401/403: Authentifizierung oder Berechtigung auflösen; Widerruf beenden.
- 402: Stellen Sie das verfügbare Besitzerguthaben wieder her, bevor Sie fortfahren.
- 429: Senden beenden und Retry-After respektieren; Übermittlungen werden nicht automatisch wiederholt.
- Zeitüberschreitung ohne Quittung: Überprüfen Sie den Verlauf, bevor Sie einen weiteren Ordner erstellen.

[Fehler und Statuscodes](https://flashdata.dev/de/docs/errors/reference.md).

<a id="agents"></a>
## Eine Verbindung, wiederverwendbare Aufgaben

Berechtigte Agenten können mit 1-Gutschrift (bis zu 100 Standard YouTube Datenanforderungen) für 72 Stunden beginnen. Reuse hat den Zugriff zuerst gespeichert; Metadaten und Beschriftungen teilen sich die Berechtigung.

1. Entdecken Sie Videos und eine Auswahlliste, bevor Sie sie bereichern.
2. Rufen Sie ein Video ab, überprüfen Sie die Felder und die Untertitelauswahl und speichern Sie die Rohausgabe.
3. Bitten Sie den Eigentümer, die Anmeldung/sign-in abzuschließen und die Bereiche und den gemeinsamen Kontostand zu genehmigen. Nicht genutzte temporäre Guthaben werden nicht übertragen.
4. Behalten Sie Anmeldeinformationen bei und führen Sie Ordner bei wiederkehrenden Aufgaben aus. Ergebnisse wiederverwenden und bei Widerruf oder aufgebrauchtem Guthaben stoppen.

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

[Prozess und Anspruch](https://flashdata.dev/de/docs/guides/agent-onboarding/reference.md) · [Wiederkehrende Aufgaben](https://flashdata.dev/de/docs/guides/recurring-tasks/reference.md) · [Ergebnisse speichern](https://flashdata.dev/de/docs/guides/save-results/reference.md).

<a id="faq"></a>
## Migrationsfragen

### Ist das der Suchvergleich Bright Data Google?

Diese Seite behandelt den YouTube Schaber API. Google Die Suche verwendet das SERP-Produkt von Bright Data mit unterschiedlichen Preiseinheiten und Anfragekonfigurationen. Der Suchvergleich Google hat eine eigene Seite.

### Erhebt Bright Data doppelte Gebühren für Metadaten und ein Transkript?

Sein YouTube-Videoschema enthält Metadaten und Beschriftungsfelder im zurückgegebenen Videodatensatz. Zählen Sie nicht automatisch zwei Datensätze. FlashData verwendet separate Metadaten- und Transkriptabfragen; Der kombinierte Arbeitsaufwand im Rechner zählt zwei FlashData Anfragen pro Video. Für ein bestimmtes Video ist möglicherweise kein Untertitelfeld verfügbar.

### Welcher Anbieter hat das größere Freikontingent?

Bright Data bietet berechtigte Konten 5,000 jeden Monat geteilte Credits. Die berechtigte Anmeldevergütung von FlashData ist ein Anfangssaldo, und die Testversion für Zeitarbeitskräfte ist separat. Für diese Angebote gelten unterschiedliche Verlängerungsregeln. Verwenden Sie die verbleibende freie Aufzeichnungseingabe, um Bright Data PAYG genau zu modellieren.

### Kann ich jeden Bright Data Schaber ersetzen?

Verschieben Sie die unterstützten YouTube Metadaten-, Such-, Kanal- und Untertitel-Workflows, die Sie benötigen. Behalten Sie das Sammeln von Kommentaren, andere soziale Plattformen, verwaltete Datensätze und bestehende Integrationen zur Speicherbereitstellung dort bei, wo Ihre Anwendung noch darauf angewiesen ist.

### Unterstützen beide Anbieter KI-Agenten?

Ja. Beide bieten MCP, ein CLI und Agentenfähigkeiten. Das eigenständige CLI, die Quellberechtigungen und das gemeinsame Google/YouTube-Gleichgewicht von FlashData sind für einen fokussierten Recherche-Workflow nützlich. Verwenden Sie den gespeicherten Zugriff erneut und bitten Sie den Eigentümer, den weiteren Kontozugriff zu genehmigen, bevor Sie wiederkehrende Arbeiten planen.

### Kann ich einen Snapshot ID nach der Migration wiederverwenden?

Nein. Speichern Sie den Bright Data-Snapshot und den neuen FlashData-Job ID als separate Kennungen. Das Beispiel verwendet nur den gespeicherten FlashData-Beleg wieder und prüft, ob das zurückgegebene Video mit dem angeforderten ID übereinstimmt.

[Holen Sie sich einen API-Schlüssel](https://flashdata.dev/signup) · [Google Suchvergleich](https://flashdata.dev/de/compare/brightdata/reference.md).
