# Supadata Alternative für YouTube Daten

Vergleichen Sie YouTube Transkript- und Metadatenkosten, native Untertitelfunktionen und Agentenzugriff. Migrieren Sie von Supadata mit ausführbaren Beispielen Python und Bash.

Supadata Fakten überprüft 2026-11-10. FlashData Preise und Probepauschalen entnehmen Sie bitte den aktuellen öffentlichen Katalogen.

- [Funktionen](#features)
- [Kosten vergleichen](#costs)
- [Ein Transkript migrieren](#migration)
- [Metadaten und Massendaten](#workflows)
- [Für KI-Agenten](#agents)
- [FAQ](#faq)

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

Für Apps und Agenten, die vorhandene YouTube Untertitel und Metadaten sammeln.

### Halten Sie den bezahlten Abruf im Wert von YouTube wirtschaftlich

| Funktion | FlashData | Supadata |
| --- | --- | --- |
| Kostenpflichtige Nutzung ohne Abonnement | Ja — Pay-as-you-go-Gutschriften; Einkäufe ab $10 | Bezahlte Pläne — Basic: $60/Jahr · Pro: $17/Monat |
| Natives Transkript oder Metadaten · Preis pro 1,000 | $0.50 — Bezahlung nach Bedarf · keine monatliche Gebühr | $5.67 auf Pro — $17 / 3,000 included credits; full allowance verwendet |
| Batch ohne Monatsplan | Bis zu 100 Abfragen/Batch — Pay-as-you-go-Eigentümerschlüssel; Das Testlimit ist separat | Pro und höher — Video und Transkript batch Endpunkte |

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

| Funktion | FlashData | Supadata |
| --- | --- | --- |
| Finden Sie Videos nach Themen | Ja — Stichwortsuche mit Datum, Dauer, Typ und Sortierfiltern | Ja — Video-, Kanal- und Playlist-Suche mit Filtern |
| Aktualisieren Sie Videometadaten, ohne Untertitel abzurufen | Ja — Titel, Kanal, Dauer, Miniaturansichten und Anzahl der Interaktionen | Ja — Separater Metadaten-Endpunkt mit Autoren-, Medien- und Statistikfeldern |
| Untertitelsprachen in Videometadaten | Ja — hasTranscripts und transcriptLanguages | In der Transkriptantwort — availableLangs; separates Metadatenschema |

### Halten Sie Transkripte für Zitate und Analysen nützlich

| Funktion | FlashData | Supadata |
| --- | --- | --- |
| Text mit Zeitstempel für Quellenzitate | JSON Segmente in Sekunden — Text mit Start- und Endzeiten | JSON Blöcke in Millisekunden — Text mit Versatz und Dauer |
| Volltext und Zeitstempel derselben Antwort | Ja — fullText und Segmente werden zusammen zurückgegeben | Wählen Sie Text oder Blöcke — text=true gibt eine Zeichenfolge zurück; andernfalls verbinden Sie die Blöcke in Ihrer App |
| Mehrere vorhandene Untertitelsprachen in einer Anfrage | Bis zu 10 Sprachen — Tracks und Fehler pro Sprache | Eine bevorzugte Sprache — lang-Parameter am Transkript-Endpunkt |
| Wählen Sie vom Uploader bereitgestellte oder von YouTube generierte Untertitel aus | Ja — Explizit params.auto=false oder true | Kein Ursprungsselektor dokumentiert — Der Modus wählt nativen Abruf gegenüber KI-Generierung |
| Behandeln Sie nicht verfügbare Untertitel explizit | Nur vorhandene Tracks — Spracharrays geben Spuren und Fehler zurück; keine neue Transkription | Wählen Sie natives oder KI-Fallback — mode=auto kann Speech-to-Text generieren; Native beschränkt den Abruf auf vorhandene Untertitel |

### Wechseln Sie von einer Anfrage zu einem wiederholbaren Workflow

| Funktion | FlashData | Supadata |
| --- | --- | --- |
| Interaktive und Hintergrundanfragen | Echtzeit oder async — Wählen Sie den Ausführungsmodus und speichern Sie den Job ID | Ergebnis- oder Transkriptauftrag — HTTP 200 gibt Daten zurück; HTTP 202 gibt einen Job zurück ID |
| Verarbeiten Sie eine vorbereitete Liste von Videos | Batch-Konsole API oder Bulk Jobs — Laden Sie eine ID-Datei hoch; Behalten Sie die Manifest- und Ergebnisteile bei | Asynchron batch API · Pro+ — Akzeptiert Videolisten, Playlists oder Kanäle |
| Sammeln Sie eine ganze Playlist oder einen ganzen Kanal | Anstößiges Video IDs bereitstellen — Bereiten Sie die Liste vor der Stapel- oder Massenverarbeitung vor | Wiedergabeliste oder Kanal batch-Eingabe — Regular videos; excludes Shorts and live Videos |
| Ausgabe für Anwendungen und LLMs | JSON, Klartext oder Markdown — Wählen Sie das Antwort- und Inhaltsformat | JSON mit Text oder Chunks — Verwenden Sie den Inhalt des Transkripts in Ihrer Bewerbung oder Eingabeaufforderung |
| Sprach-SDKs | Python, TypeScript und Los | Python und JavaScript / TypeScript |
| MCP Zugriff für einen Agent-Host | Ja — Fernbedienung MCP mit OAuth oder einer API-Taste | Ja — MCP-Server mit Supadata-Anmeldeinformationen |
| Programmatische Testversion vor der Eigentümeranmeldung | Ja — Bis zu 100 native Transkriptionsanfragen · 72 Stunden | Zuerst den Kontoschlüssel API eingeben — 100 kostenlose Credits jeden Monat nach der Anmeldung |

Supadata unterstützt KI-generierte Transkription und mehrere soziale Plattformen. Die Beschriftungsendpunkte von FlashData rufen vorhandene YouTube-Tracks ab. Beide Dienste bieten MCP und SDKs.

### Halten Sie einen kleinen Forschungsaufwand erschwinglich

Bezahlen Sie für die YouTube Datenanfragen, die Sie nutzen. Fügen Sie später ein Abonnement hinzu, wenn der günstigere Preis und das enthaltene Guthaben zu Ihrem Volumen passen.

[Bewerten Sie Ihren Arbeitsaufwand](#costs)

### Halten Sie die Quelle der Bildunterschrift explizit

Wählen Sie YouTube-generierte oder vom Uploader bereitgestellte Untertitel aus, behalten Sie die zurückgegebene Sprache bei und behalten Sie Zeitstempel für Zitate bei. Fordern Sie vorhandene Titel in mehreren Sprachen an, ohne neue Sprachausgabe zu erstellen.

[Ordnen Sie Ihren Transkriptleser zu](#migration)

### Wachsen Sie von einem Video zu einer Pipeline

Verwenden Sie die gleiche Anforderungsform für die Arbeiten realtime, async und batch. Fügen Sie Google Search zum Recherche-Workflow hinzu, indem Sie dasselbe Konto und denselben Kontostand verwenden.

[Bauen Sie den nächsten Schritt](#workflows)

<a id="costs"></a>
## Preis für den kompletten Video-Workflow

USD. Ein muttersprachliches Transkript in einer Sprache oder eine Metadatensuche ist eine Anfrage und ein Supadata-Credit. Metadaten plus ein natives Transkript sind zwei Anfragen pro Video. FlashData nutzt seinen Live-Datenkatalog YouTube und wendet den enthaltenen Kreditwert vor der weiteren Nutzung an. Der angezeigte Einheitssatz ist ein Nutzungssatz; Supadata ist die Plangebühr dividiert durch die volle monatliche Vergütung. Basic ist nur jährlich: $60 im Voraus bezahlt, angezeigt als $5/Monat entsprechend mit 300 Credits jeden Monat, nicht 3,600 sofort verfügbar. Andere Supadata-Pläne verwenden monatliche Listenpreise. Das automatische Aufladen ist in dieser Schätzung deaktiviert, bis es ausgewählt wird. Bei Auswahl decken die kleinsten gesamten veröffentlichten Pakete den Fehlbetrag. Der tatsächliche Zeitpunkt des automatischen Aufladens kann früher liegen. Bei Kaufbeträgen wird kein Startguthaben vorausgesetzt. FlashData Aufladungen beginnen bei $10; Bei einem Kauf bleiben möglicherweise Mittel für später übrig. Supadata Monatliche Guthaben können nicht verlängert werden. Testguthaben, Steuern, sonstige API-Nutzung, jährliche Rabatte auf andere Pläne, KI-Generierung und Übersetzung sind ausgeschlossen. Bei null Anfragen bleibt die Gebühr des ausgewählten Plans bestehen und der effektive Tarif ist nicht definiert.

### FlashData YouTube Datenpläne

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

[Volle YouTube Datenpreise](https://flashdata.dev/de/pricing/youtube-data)

### Supadata veröffentlichte Pläne

| Supadata Plan | Planen Sie die Zahlung | Credits / Monat | Pro 1,000 bei vollem Freibetrag | Auto-Recharge-Paket |
| --- | --- | --- | --- | --- |
| Kostenlos | $0.00 / Monat | 100 | $0.00 | Nicht verfügbar |
| Basic · annual only | $60.00 / Jahr ($5.00 / Monatsäquivalent) | 300 | $16.67 | $10.00 / 1,000 Credits |
| Pro · monthly | $17.00 / Monat | 3,000 | $5.67 | $10.00 / 1,000 Credits |
| Mega · monthly | $47.00 / Monat | 30,000 | $1.57 | $10.00 / 5,000 Credits |
| Giga · monthly | $297.00 / Monat | 300,000 | $0.99 | $20.00 / 20,000 Credits |
| Supa · monthly | $897.00 / Monat | 1,000,000 | $0.90 | $20.00 / 20,000 Credits |

### Beispiel: Metadaten plus ein natives Transkript für jedes Video

FlashData Pay-as-you-go im Vergleich zu Supadata Mega monatlich, inklusive automatischer Aufladung. Dies ist ein expliziter Planvergleich; Wählen Sie andere Pläne unabhängig im HTML-Rechner aus.

| Videos/Monat | Datenanfragen | FlashData modellierte Nutzung | Supadata Mega + ganze Aufladepakete | Aufladepakete |
| --- | --- | --- | --- | --- |
| 100 | 200 | $0.10 | $47.00 | 0 |
| 1,000 | 2,000 | $1.00 | $47.00 | 0 |
| 10,000 | 20,000 | $10.00 | $47.00 | 0 |
| 100,000 | 200,000 | $100.00 | $387.00 | 34 |

### Kostenloser Zugang und KI-Generierung

Supadata Kostenlose Aufladungen 100 Credits monatlich. Für das native Transkript wird ein Credit benötigt; Die KI-Generierung verbraucht zwei Credits pro Minute. Für ein 30-Minuten-generiertes Transkript werden daher 60 Credits benötigt. Der standardmäßige automatische Modus kann die Generierung auslösen; mode=native vermeidet diesen Fallback. Generierung, Übersetzung und erweiterte Suche sind von diesem Vergleich ausgeschlossen.

Berechtigte verifizierte FlashData-Anmeldungen können eine anfängliche Vergütung von bis zu 4,000 Standard-YouTube-Datenanfragen erhalten. Es handelt sich nicht um ein monatliches kostenloses Kontingent.

<a id="migration"></a>
## Migrieren Sie einen nativen Transkript-Reader

| Veränderung | Supadata | FlashData | Was zu tun ist |
| --- | --- | --- | --- |
| Anfrage | GET /v1/transcript mit URL, Sprache, Text und Modus | POST /v1/queries/realtime mit Quelle, video_id und Parametern | Extrahieren Sie das 11-Zeichen YouTube ID. Ein Supadata-Schlüssel führt keine Authentifizierung bei FlashData durch. |
| Authentifizierung | x-api-key: Ihr Supadata-Schlüssel | X-API-Key: Ihre FlashData-Taste | Erstellen oder verwenden Sie einen Berechtigungsnachweis mit der Berechtigung youtube_transcript wieder. Bei Header-Namen wird die Groß-/Kleinschreibung nicht beachtet. Die Anmeldeinformationen ändern sich. |
| Nativ versus generiert | mode=native ruft vorhandene Untertitel ab; Auto kann auf KI zurückgreifen; Generate verwendet immer KI | youtube_transcript liest vorhandene YouTube-Untertitel | Verschieben Sie zuerst den nativen Abruf. Behalten Sie einen separaten Sprache-zu-Text-Schritt für Videos bei, die eine neue Transkription benötigen. |
| Herkunft der Bildunterschrift | Der Modus wählt den Abruf gegenüber der Generierung aus | params.auto=true wählt YouTube-generierte Untertitel aus; false wählt vom Uploader bereitgestellte Untertitel aus | Diese automatischen Einstellungen sind nicht gleichwertig. FlashData Auto startet nie die Sprachausgabe. |
| Sprache | lang wird bevorzugt; Nicht verfügbare Sprachen können auf die erste verfügbare Sprache zurückgreifen | params.language ist explizit; auto=true probiert die Variante -orig und dann den angeforderten Code aus | Markieren Sie languageCode und requestedLanguageCode. FlashData wählt nicht stillschweigend eine andere Sprache oder den Ursprung der Beschriftung. |
| Segmente | content[]: Text, Offset und Dauer in Millisekunden | results[0].segments[]: Text, Start und Ende in Sekunden | offset = runde(start × 1000); Dauer = Runde((Ende − Anfang) × 1000). Behalten Sie Überlappungen bei, anstatt Hinweise zu verschieben. |
| Klartext | text=true gibt Inhalt als String zurück | Ergebnisse[0].fullText | Lesen Sie fullText zur Zusammenfassung und behalten Sie die Segmente für Zeitstempelzitate bei. |
| Sprachentdeckung | availableLangs in der Transkriptantwort | transcriptLanguages in youtube_metadata | Rufen Sie Metadaten ab, wenn Ihre App die vollständige Sprachliste benötigt. Erfinden Sie availableLangs nicht aus einem zurückgegebenen Track. |
| Fertigstellung | HTTP 200 Ergebnis oder HTTP 202 + jobId | Echtzeitstatus=done; async Einreichungen zurück FlashData Job IDs | Behandeln Sie die Status jedes Anbieters separat. Beenden Sie dort vorhandene Supadata Jobs, bevor Sie neue Jobs migrieren. |

### 1. Zugriff einrichten

Erstellen oder verwenden Sie einen FlashData-Schlüssel mit der youtube_transcript-Berechtigung in [API Schlüssel](https://flashdata.dev/app/api-keys) wieder. Fügen Sie youtube_metadata für die optionale Metadatenaufgabe hinzu. Markieren Sie [verfügbare Credits](https://flashdata.dev/app/billing) oder verwenden Sie [Testzugang für berechtigte Agenten](#agents). Bewahren Sie Schlüssel in einer Umgebung oder einem geheimen Geschäft auf.

Supadata native Anfrage wird ersetzt:

```bash
# Existing Supadata call: use your saved SUPADATA_API_KEY.
curl --get --fail-with-body --silent --show-error \
  'https://api.supadata.ai/v1/transcript' \
  --header "x-api-key: $SUPADATA_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'lang=en' --data-urlencode 'text=false' \
  --data-urlencode 'mode=native'
```

FlashData Ersatzkörper JSON für POST /v1/queries/realtime:

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

### 2. Speichern Sie das Skript und führen Sie es dann aus

Wählen Sie Python oder Bash. Jeder neue Ausgabeordner sendet eine Anfrage; Durch die Wiederverwendung eines Ordners wird die gespeicherte Ausgabe ohne einen weiteren API-Aufruf gelesen. Die Versionen teilen sich das gespeicherte Dateiformat. Wählen Sie ein Video mit der gewünschten Untertitelspur aus.

#### Python

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 youtube-migrate.py, bevor du es ausführst.

```python
import argparse
import getpass
import json
import math
import os
import re
from pathlib import Path

import requests

parser = argparse.ArgumentParser()
parser.add_argument("operation", choices=["transcript", "metadata"])
parser.add_argument("video_id")
parser.add_argument("folder", type=Path)
parser.add_argument("--language", default="en")
parser.add_argument("--origin", choices=["auto", "manual"], default="auto")
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")
source = "youtube_" + args.operation
params = ({"language": args.language, "auto": args.origin == "auto"}
          if args.operation == "transcript"
          else {"include_formats": False, "include_chapters": True})
body = {"source": source, "video_id": args.video_id, "params": params}
out = args.folder
if not out.exists():
    key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
    if not key.strip():
        raise SystemExit("An API key is required")
    out.mkdir(parents=True)
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime", json=body,
            headers={"X-API-Key": key, "Accept": "application/json"},
            timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit("Outcome unknown. Keep this folder and check History before retrying.")
    (out / "response.json").write_bytes(response.content)
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""), encoding="utf-8")
else:
    print("Reading saved output; no API call.")

try:
    saved_request = json.loads((out / "request.json").read_text(encoding="utf-8"))
    status = (out / "http-status.txt").read_text(encoding="utf-8").strip()
except (OSError, ValueError):
    raise SystemExit("Incomplete attempt. Inspect this folder and History before retrying.")
if saved_request != body:
    raise SystemExit("This folder belongs to a different request. Use a new folder.")
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect response.json and retry-after.txt")
data = json.loads((out / "response.json").read_text(encoding="utf-8"))
if not isinstance(data, dict) or data.get("status") != "done" or data.get("source") != source:
    raise SystemExit("Request did not complete successfully; inspect response.json")
results = data.get("results")
if not isinstance(results, list) or len(results) != 1 or not isinstance(results[0], dict):
    raise SystemExit("Expected one result; inspect response.json")
item = results[0]
if item.get("videoId") != args.video_id:
    raise SystemExit("Returned video does not match the request")
if args.operation == "transcript":
    allowed = {args.language}
    if args.origin == "auto" and not args.language.endswith("-orig"):
        allowed.add(args.language + "-orig")
    if item.get("languageCode") not in allowed or item.get("isAutoGenerated") is not params["auto"]:
        raise SystemExit("Returned caption language or origin does not match")
    if not isinstance(item.get("segments"), list):
        raise SystemExit("Expected caption segments")
    content = []
    for cue in item["segments"]:
        if not isinstance(cue, dict):
            raise SystemExit("Invalid caption segment")
        start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
        if (type(start) not in (int, float) or type(end) not in (int, float)
                or not math.isfinite(start) or not math.isfinite(end)
                or start < 0 or end < start or not isinstance(text, str)):
            raise SystemExit("Invalid caption segment")
        content.append({"text": text, "offset": round(start * 1000),
                        "duration": round((end - start) * 1000)})
    normalized = {"content": content, "lang": item["languageCode"].removesuffix("-orig")}
else:
    normalized = {name: item.get(name) for name in (
        "videoId", "title", "channel", "duration", "viewCount", "likeCount",
        "commentCount", "hasTranscripts", "transcriptLanguages", "chapters")}
(out / "normalized.json").write_text(
    json.dumps(normalized, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/normalized.json; actual usage: {json.dumps(data.get('usage'))}")

```

Führen Sie von diesem Arbeitsordner aus Folgendes aus:

```bash
python youtube-migrate.py transcript FUfGcZ092b0 transcript-001
```

Dadurch werden YouTube-generierte englische Untertitel ausgewählt. Fügen Sie --origin Handbuch für einen vom Uploader bereitgestellten Titel oder --language CODE hinzu, um eine Sprache auszuwählen.

Optionale separate Metadatenanfrage:

```bash
python youtube-migrate.py metadata FUfGcZ092b0 metadata-001
```

#### Bash

Erfordert Bash, cURL 7.76+ und jq 1.6+. Speichern Sie dieses vollständige Skript als youtube-migrate.sh in Ihrem Arbeitsordner, bevor Sie es mit running ausführen:

```bash
#!/usr/bin/env bash
set -euo pipefail
operation="${1:?Use: transcript|metadata VIDEO_ID OUTPUT_FOLDER [LANGUAGE] [auto|manual]}"
video_id="${2:?Set VIDEO_ID}"
out="${3:?Set OUTPUT_FOLDER}"
language="${4:-en}"
origin="${5:-auto}"
[[ "$operation" == transcript || "$operation" == metadata ]] || exit 1
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || exit 1
[[ "$origin" == auto || "$origin" == manual ]] || exit 1
body=$(jq -n --arg source "youtube_$operation" --arg id "$video_id" \
  --arg language "$language" --arg origin "$origin" '
  {source: $source, video_id: $id, params:
    (if $source == "youtube_transcript" then {language: $language, auto: ($origin == "auto")}
     else {include_formats: false, include_chapters: true} end)}')
if [[ ! -e "$out" ]]; 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}"
  mkdir -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep the output folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved HTTP status, response and Retry-After header.\n' >&2; exit 1;
}
normalized=$(jq -e --argjson request "$body" '
  if .source != $request.source or .status != "done" then error("Request 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 != $request.video_id then error("Wrong video") else . end
  | if $request.source == "youtube_metadata" then
      {videoId, title, channel, duration, viewCount, likeCount, commentCount,
       hasTranscripts, transcriptLanguages, chapters}
    else
      if (.languageCode != $request.params.language and
          ($request.params.auto != true or ($request.params.language | endswith("-orig")) or
           .languageCode != ($request.params.language + "-orig"))) or
          .isAutoGenerated != $request.params.auto then error("Wrong language or origin") else . end
      | {lang: (.languageCode | sub("-orig$"; "")), content: [.segments[] |
          if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
          then error("Invalid caption segment")
          elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
          then error("Invalid caption timing")
          else {text, offset: (.start * 1000 | round), duration: ((.end - .start) * 1000 | round)} end]}
    end' "$out/response.json")
printf '%s\n' "$normalized" > "$out/normalized.json"
printf 'Saved %s/normalized.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

Führen Sie von diesem Arbeitsordner aus Folgendes aus:

```bash
bash youtube-migrate.sh transcript FUfGcZ092b0 transcript-001
```

Optionale Argumente nach dem Ordner sind Sprache und Herkunft; Beispielsweise wählt „En Manual“ vom Uploader bereitgestellte englische Untertitel aus.

Optionale separate Metadatenanfrage:

```bash
bash youtube-migrate.sh metadata FUfGcZ092b0 metadata-001
```

Für einen vorübergehenden Testzugriff führen Sie die Anforderungen nacheinander im Abstand von mindestens einer Sekunde aus.

### 3. Lesen Sie die Ausgabe

response.json bewahrt das Rohergebnis und die Verwendung. normalized.json wandelt Transkriptsegmentsekunden in Offset/duration Millisekunden um. Dies ist ein Segmentadapter, keine vollständige Supadata-kompatible Antwort: availableLangs ist nicht fabriziert. Bei der Metadatenausgabe bleiben nullfähige Werte erhalten. Fehlgeschlagene oder unterbrochene Anfragen behalten ihre Beweise und werden eingestellt.

Beispielhaft normalized.json:

```json
{
  "content": [
    {
      "text": "Example caption text.",
      "offset": 1250,
      "duration": 2250
    }
  ],
  "lang": "en"
}
```

[Transkriptschema](https://flashdata.dev/de/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## Metadaten und Massenworkflows

| Daten | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Videoidentität | id | Ergebnisse[0].videoId |
| Titel und Beschreibung | Titel, Beschreibung | Ergebnisse[0].Titel, Ergebnisse[0].Beschreibung |
| Kanal | author.displayName; additionalData.channelId | Ergebnisse[0].channel; Ergebnisse[0].channelId |
| Engagement | stats.views, stats.likes, stats.comments | Ergebnisse[0].viewCount, likeCount, commentCount |
| Dauer | media.duration (Sekunden) | Ergebnisse[0].Dauer (Sekunden) |
| Miniaturansicht | media.thumbnailUrl | Ergebnisse[0].thumbnails[]; Wählen Sie die Größe, die Ihre App benötigt |
| Erscheinungsdatum | createdAt | Ergebnisse[0].uploadDate; Normalisieren Sie das Format in Ihrer App |
| Untertitelerkennung | Lesen Sie availableLangs aus einer Transkriptantwort | Ergebnisse[0].hasTranscripts und transcriptLanguages |

### Mehrere vorhandene Sprachen in einer Anfrage

Senden Sie ein Spracharray, um Spuren und Fehler zu empfangen, auch für ein Array, das eine Sprache enthält. Überprüfen Sie Fehler, auch wenn der Status done ist. Hierbei handelt es sich um vorhandene Titel, nicht um übersetzte oder generierte Untertitel.

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

### Bereichern Sie eine Forschungsbibliothek

Rufen Sie einmal die Metadaten ab, speichern Sie das Video ID und die verfügbaren Untertitelsprachen und rufen Sie dann den benötigten Titel ab. Behalten Sie nullbare Engagement-Zählungen bei null, anstatt sie in Null umzuwandeln.

[YouTube Best Practices für Daten](https://flashdata.dev/de/docs/guides/youtube-data-guide/reference.md)

### Verarbeiten Sie eine Liste mit Videos IDs

Erweitern Sie Ihre Eingabe in ein explizites Video IDs und verwenden Sie dann Batch oder eine Massendatei. FlashData akzeptiert kein Supadata playlistId als Drop-in-batch-Eingabe. Speichern Sie den Status und die Ausgabe pro Element, bevor Sie failed Elemente erneut versuchen.

[Referenz zur Massenverarbeitung](https://flashdata.dev/de/docs/reference/bulk-processing/reference.md)

### Führen Sie die Recherche nach einem Zeitplan durch

Behalten Sie die Anmeldeinformationen des Besitzers bei, überprüfen Sie completed-Videos und lesen Sie die gespeicherte Ausgabe beim Neustart. Stopp wegen entzogenem Zugriff oder unzureichendem Guthaben; Erstellen Sie keinen weiteren Versuch, um einen geplanten Auftrag fortzusetzen.

[Wiederkehrende Agentenaufgaben](https://flashdata.dev/de/docs/guides/recurring-tasks/reference.md)

### Production Migrationsentscheidungen

- Playlist/channel-Eingaben in explizites Video IDs vor FlashData auflösen. Stapel- oder Massendateiverarbeitung; Supadata playlistId ist keine Drop-In-Eingabe.
- Die Supadata-Suche kostet ein Guthaben pro 20-Ergebnisseite, oder ceil(limit/20) mit Limit. FlashData Standard YouTube Die Suche unterstützt bis zu 20 Ergebnisse; Für die erweiterte Suche gilt ein separater Tarif. Ordnen Sie Filter zu und übertragen Sie keine Seitentokens.
- Supadata dokumentiert ein einstündiges completed Transkript-Job-Ergebnisfenster. Löschen Sie dort vorhandene Jobs und speichern Sie die Ergebnisse, bevor Sie neue Jobs migrieren. Halten Sie den anbieterspezifischen Job IDs getrennt.
- Behalten Sie plattformübergreifende Medien, KI-Extraktion, Übersetzung und Audiotranskription auf ihren bestehenden Pfaden bei, sofern kein gleichwertiger Workflow implementiert wurde.

<a id="agents"></a>
## Testversion, Inanspruchnahme und wiederkehrende Nutzung des Agenten

Berechtigte Agenten können mit 1 Credit(s) beginnen, bis zu 100 native Transkriptionsanfragen für 72 Stunden. Metadaten und Transkripte teilen sich diesen Freibetrag.

1. Verwenden Sie zunächst den vorhandenen Zugriff wieder. Andernfalls starten Sie eine berechtigte Testversion nur mit den erforderlichen Berechtigungen.
2. Geben Sie ein nützliches Ergebnis zurück, speichern Sie die Rohausgabe und -nutzung und behalten Sie das gleiche Profil und Statusverzeichnis bei.
3. Der Eigentümer meldet sich an oder registriert sich, überprüft die E-Mail-Adresse und genehmigt die Inanspruchnahme, den Umfang und den Zugriff auf das gemeinsame Guthaben.
4. Verwenden Sie die Anmeldeinformationen des Besitzers für wiederkehrende Aufgaben wieder. Nicht genutzte Testguthaben werden nicht übertragen. Stopp nach Widerruf oder unzureichendem Guthaben; Erstellen Sie niemals einen weiteren Versuch, um fortzufahren.

```text
Migrate the native YouTube transcript part of this project from Supadata to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_transcript/reference.md.
Reuse a saved FlashData credential before requesting an eligible temporary trial.
Use youtube_transcript permission and one explicit video ID, language and caption origin.
Do not map Supadata mode=auto to FlashData auto=true: the latter selects existing YouTube-generated captions.
Save the raw response and actual usage. Convert segment seconds to milliseconds if my reader expects offset/duration.
Do not fabricate captions or available languages. Report missing tracks and keep AI generation separate.
Ask the owner to claim access before recurring use. Store credentials outside chat and source control.
Reuse saved outputs on restart and stop after revocation; never create repeated trials to keep running.
```

[Prozess und Anspruch](https://flashdata.dev/de/docs/guides/agent-onboarding/reference.md) · [Eigenständig CLI](https://flashdata.dev/de/docs/guides/flashdata-cli/reference.md) · [MCP Verbindung](https://flashdata.dev/de/docs/integrations/mcp-clients/reference.md)

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

### Kann FlashData die KI-Transkription von Supadata ersetzen?

Die Transkript- und Untertitelquellen von FlashData rufen Untertitel ab, die bereits auf YouTube vorhanden sind. Sie transkribieren keine Audiodaten, übersetzen keinen Text und führen keine visuelle Analyse durch. Verschieben Sie den nativen YouTube-Abruf nach FlashData; Behalten Sie einen separaten Dienst für Sprache-zu-Text, plattformübergreifendes Video oder KI-Extraktion bei, wenn Ihre Anwendung dies benötigt.

### Was kauft eine Anfrage?

Der Rechner deckt ein vorhandenes Transkript in einer Sprache oder eine Video-Metadatensuche ab. Beim Abrufen beider werden zwei Anfragen pro Video benötigt. Supadata rechnet jeden dieser Vorgänge mit einem Guthaben ab. FlashData verwendet die Datenrate YouTube des ausgewählten Plans. Erweiterte Suche, KI-Transkription, Übersetzung und Medienbereitstellung liegen außerhalb dieser Schätzung.

### Ist FlashData immer günstiger?

Vergleichen Sie Ihren tatsächlichen Arbeitsaufwand und ausgewählte Pläne. Supadata beinhaltet 100 Credits jeden Monat kostenlos. Die Testversion von FlashData für Zeitarbeitskräfte ist begrenzt und läuft ab; Es handelt sich nicht um ein monatliches kostenloses Kontingent. Bei geringem Volumen kann ein kostenloser Zuschuss die gesamte Aufgabe abdecken. Bezahlte Tarifgebühren, Aufladepakete und ungenutztes Guthaben wirken sich auf den von Ihnen gezahlten Betrag aus.

### Unterstützt Supadata bereits MCP und SDKs?

Ja. Beide Dienste unterstützen MCP- und Python/JavaScript-Integrationen. FlashData bietet außerdem ein Go SDK, ein eigenständiges CLI und eine temporäre Agent-Testversion, die für wiederkehrenden Zugriff beansprucht werden kann. Wählen Sie die Schnittstelle, die Ihr Host unterstützt; MCP allein ist kein Grund für einen Wechsel.

### Was passiert, wenn eine Untertitelspur fehlt?

Behandeln Sie es als Datenlücke. FlashData wechselt nicht zwischen vom Uploader bereitgestellten und von YouTube generierten Untertiteln und synthetisiert kein Transkript. Überprüfen Sie bei einem Spracharray Fehler, auch wenn die Anforderung done ist. Supadata kann ein Transkript im automatischen Modus generieren, während der native Modus HTTP 206 für ein nicht verfügbares Transkript zurückgeben kann; In der Dokumentation wird diese Antwort mit einer Gutschrift berechnet.

### Kann ich die bestehende Antwortform der Anwendung beibehalten?

Behalten Sie Ihren eigenen Adapter. Das Beispiel konvertiert FlashData-Segmente in Inhaltseinträge mit Offset und Dauer in Millisekunden, erhebt jedoch keinen Anspruch auf eine vollständige Supadata-kompatible Antwort. Lesen Sie die FlashData-Metadaten, wenn Sie verfügbare Sprachen benötigen, und migrieren Sie Jobstatus, Fehler- und Nutzungsbehandlung explizit.

[Holen Sie sich einen API-Schlüssel](https://flashdata.dev/signup)
