# ScrapeCreators Alternative für YouTube Daten

Vergleichen Sie YouTube Metadaten- und Untertitelkosten, Prepaid-Pakete und Cache-Hits. Migrieren Sie zu FlashData mit ausführbaren Python- und Bash-Feldadaptern für Apps und Agents.

Neue Videodaten. Eine geringere Anfangsausgabe. Verschieben Sie YouTube-Metadaten und Untertitelaufrufe, während Sie den Rest Ihrer Social-Data-Integration beibehalten.

ScrapeCreators Fakten überprüft 2026-11-10. FlashData Preise und Probezulagen stammen aus seinen aktuellen öffentlichen Katalogen.

- [Funktionen](#features)
- [Preise und Cache](#costs)
- [Eine Anfrage migrieren](#migration)
- [Forschungsworkflow](#workflow)
- [Für KI-Agenten](#agents)
- [FAQ](#faq)

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

### Senken Sie die Kosten für neue YouTube Daten

| Funktion | FlashData | ScrapeCreators |
| --- | --- | --- |
| Kostenpflichtiger Eintrittspreis / 1,000 Metadaten- oder Untertitelaufrufe | $0.50 — Pay-as-you-go-Nutzung | $1.88 — Freelance · neue One-Credit-Anrufe |
| Niedrigster aufgeführter Einheitspreis / 1,000 Anrufe | $0.20 — Optionaler Monatsplan; Die Gebühr gilt weiterhin | $0.994 — Business · $497 Prepaid-Paket; kundenspezifisches Unternehmen ausgeschlossen |
| Erster bezahlter Kreditkauf | Von $10 | $47 — 25,000-Credit Freelance-Paket |
| Zahlen Sie nach Bedarf ohne monatliche Gebühr | Ja | Ja |

### Finden Sie Videos und aktualisieren Sie die Fakten, die Sie benötigen

| Funktion | FlashData | ScrapeCreators |
| --- | --- | --- |
| Finden Sie Videos anhand von Schlüsselwörtern und Filtern | Ja — Datums-, Dauer-, Typ- und Sortierfilter | Ja — Suchfilter und Fortsetzungstoken-Paginierung |
| Metadaten für ein bekanntes Video | Ja — Titel, Kanal, Dauer, Miniaturansichten und Anzahl der Interaktionen | Ja — Video/Short Details Endpunkt |
| Kapitelmarkierungen zur Navigation | Ja — include_chapters; Titel mit Startzeit/end, sofern vorhanden | Ja — Kapitel in der Videoantwort, sofern vorhanden |
| Entdecken Sie verfügbare Untertiteltitel | Liste der Metadatensprachen — hasTranscripts und transcriptLanguages | Metadaten captionTracks — Sprachcodes und Titeldetails |

### Sorgen Sie dafür, dass die Auswahl der Bildunterschrift und die Belege eindeutig sind

| Funktion | FlashData | ScrapeCreators |
| --- | --- | --- |
| Text und Zeitstempel derselben Antwort | Volltext + zeitgesteuerte Segmente — Start/end Zeiten in Sekunden | Volltext + zeitgesteuerte Segmente — startMs/endMs als Millisekunden-Strings |
| Mehrere Untertitelsprachen in einer Anfrage | Bis zu 10 Sprachen — Vorhandene Titel plus sprachspezifische Fehler | Eine ausgewählte Sprache — Sprache oder original_audio Auswahl pro Transkriptaufruf |
| Wählen Sie den Ursprung der Beschriftung explizit aus | Uploader oder YouTube-generiert — params.auto wählt einen Ursprung aus | Auswahl von Sprache und gesprochenem Audio — original_audio ist kein Untertitel-Ursprungsschalter |
| Behandlung fehlender Untertitel | Vorhandene Titel und explizite Fehler — Spracharrays bewahren erfolgreiche Titel und melden fehlende Auswahlen | Null-Transkriptfelder — Das Fehlen angeforderter Titel kostet keine Credits; keine YouTube AI-Transkription |
| Wählen Sie aus, wie alt die wiederverwendeten Daten sein dürfen | Cache-Richtlinie in Ihrer Anwendung — Sparen Sie Abrufzeiten und entscheiden Sie, wann Sie erneut abholen möchten | cache_max_age — 1–30-Tagesoptionen; Cache-Treffer kosten null Credits und enthüllen cached_at |

### Führen Sie einen wiederholbaren Datenworkflow aus

| Funktion | FlashData | ScrapeCreators |
| --- | --- | --- |
| Verarbeiten Sie eine gespeicherte Videodatei IDs | Verwaltete Massenaufträge — Senden Sie die Datei, verfolgen Sie ihren Job und rufen Sie die Ausgaben ab | Anrufe pro Video-Endpunkt — Verwalten Sie die Dateischleife und die Ergebnisspeicherung in Ihrer Integration |
| Verschieben Sie lange Sammlungen in Hintergrundjobs | Asynchrone, Batch- und Bulk-APIs — Job IDs beibehalten, Status verfolgen und Ergebnisse abrufen | Synchrone YouTube-Anrufe — Stellen Sie Per-Video-Anrufe in Ihrem Mitarbeiter in die Warteschlange und überprüfen Sie sie |
| Strukturierte und lesbare Ausgabe | JSON, Klartext oder Markdown — Ausgewählt über API Antwortheader | JSON API und CLI Formate — CLI exportiert auch CSV, Tabellen und Markdown |
| Terminalinstallation | Eigenständige ausführbare Datei — Linux, macOS und Windows; keine Node/Python Laufzeit | npm CLI — @scrapecreators/cli |
| MCP und Agentenfähigkeiten | Ja | Ja |
| Fahren Sie von den Daten bis zur gehosteten Medienbereitstellung fort | Ja — YouTube In Ihren Speicher herunterladen; separate Erlaubnis und GB-basierte Preise | Separater Downloader-Workflow — YouTube Metadaten- und Transkript-APIs liefern keine Mediendateien |

Beide bieten Prepaid-Zugang, MCP, einen CLI und Agentenkenntnisse. ScrapeCreators deckt auch andere soziale Plattformen und YouTube Kommentare ab. Unterstützte Cache-Hits sind kostenlos.

### Aktualisieren Sie die Videos, die Ihnen wichtig sind

Niedrigere Nutzungsraten pro Anfrage sind wichtig, wenn Sie sich ändernde Metriken aktualisieren oder Untertitel für neue Videos sammeln. Behalten Sie gespeicherte Transkripte und fordern Sie Metadaten nur dann an, wenn sie aktualisiert werden müssen.

### Beginnen Sie mit einem kleineren Einkauf

FlashData Guthabenaufladungen beginnen bei $10. Verschieben Sie zuerst einen Workload YouTube, während Ihre bestehende Integration weiterhin Kommentare und andere soziale Plattformen verarbeitet.

### Wählen Sie die genaue Untertitelspur

Wählen Sie explizit vom Uploader bereitgestellte oder von YouTube generierte Untertitel aus. Fordern Sie bis zu 10 vorhandene Sprachen in einer Transkriptanfrage an und verarbeiten Sie das Ergebnis jeder Sprache separat.

<a id="costs"></a>
## Vergleichen Sie neue Anfragen, Cache-Hits und Vorabkäufe

| ScrapeCreators Angebot | Einmaliger Kauf | Credits | Pro 1,000 neue Ein-Credit-Anrufe | Monatliche Gebühr |
| --- | --- | --- | --- | --- |
| Kostenloses Erstangebot | $0 | 100 einmal | Kostenlose Einstiegsvergütung | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Unternehmen | Benutzerdefiniert | 1,000,000+ | Benutzerdefiniert | $0 für Prepaid-Guthaben |

Dabei handelt es sich um Prepaid-Pakete ohne monatliche Verlängerung. Business ist genau $0.994 pro 1,000 One-Credit-Anrufe; $0.99 wird gerundet. Gekaufte Credits verfallen gemäß der aktuellen Richtlinie nicht. Anfängliche und erworbene Bonusguthaben sind vom Modell ausgeschlossen.

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

FlashData Eingeschlossene-Anfrage-Zählungen weisen den gesamten gemeinsamen Saldo den Standarddaten YouTube zu. Für die erweiterte Suche und den Download gelten separate Tarife. [Vollpreis](https://flashdata.dev/de/pricing/youtube-data).

### Beispiel: Metadaten und Untertitel für 1,000 Videos

2,000 Anfragen, keine Discovery-Suchen. FlashData Pay-as-you-go vs. ScrapeCreators Freelance. Zählt nur beobachtete Cache-Treffer; Anfragen, die über Ihren eigenen lokalen Speicher vermieden werden, werden an keinen der Anbieter weitergeleitet.

| Kostenlose Cache-Hits | FlashData Anrufe | FlashData Nutzung | FlashData Kauf | ScrapeCreators Credits | ScrapeCreators Nutzungswert | ScrapeCreators Kauf |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 2,000 | $1.00 | $10.00 | 2,000 | $3.76 | $47.00 |
| 1,000 | 2,000 | $1.00 | $10.00 | 1,000 | $1.88 | $47.00 |
| 2,000 | 2,000 | $1.00 | $10.00 | 0 | $0.00 | $0.00 |

USD, ein Monat Anfragen. Für eine neue Metadatensuche, ein natives Untertitelergebnis oder eine Standardsuchanfrage wird ein Guthaben von ScrapeCreators verbraucht. Metadaten plus Untertitel verwenden zwei Anfragen auf beiden Seiten. Nur die oben eingegebenen Metadaten/transcript-Cache-Treffer werden abgezogen; Such-Caching wird nicht vorausgesetzt. Dieses Modell zählt zurückgegebene Untertitel, nicht Versuche mit fehlenden Titeln und schließt die KI-Generierung aus. FlashData verwendet die aktuellen Standarddatenpreise YouTube und weist das gesamte ausgewählte Planvolumen vor der zusätzlichen Nutzung zu. Erweiterte Suche und Download werden separat berechnet. Startguthaben, Testversionen, Bonusguthaben, Steuern und andere Nutzungen sind ausgeschlossen. Käufe beginnen bei Nullsaldo: FlashData Aufladungen haben ein Minimum von $10; ScrapeCreators Einkäufe werden auf ganze ausgewählte Pakete aufgerundet. Ungenutzte erworbene Credits können für spätere Aufgaben verwendet werden. ScrapeCreators hat keine monatliche Paketverlängerung; Für einen ausgewählten FlashData-Monatsplan gilt weiterhin eine Gebühr von null Anfragen.

### Cache-Verhalten

Auf unterstützten Metadaten/transcript-Endpunkten akzeptiert cache_max_age 1d, 3d, 7d, 14d oder 30d. Treffer verbrauchen null Credits und melden cached_at; Bei Fehlschlägen wird die normale Rate verwendet. Such-Cache-Treffer werden nicht angenommen. Entscheiden Sie, ob die gespeicherten Daten aktuell genug für die Aufgabe sind. [Ergebnisse speichern und wiederverwenden](https://flashdata.dev/de/docs/guides/save-results/reference.md).

### Startangebote

ScrapeCreators beginnt mit 100 kostenlosen Credits. Berechtigte FlashData-Anmeldungen können eine anfängliche Berechtigung von bis zu 4,000 Standard YouTube Datenanforderungen erhalten. Diese Angebote werden nicht monatlich zurückgesetzt. Der separate temporäre agent trial erscheint unten.

<a id="migration"></a>
## Migrieren Sie ein Video und seine Untertitel-Zeitstempel

### 1. Zugang einrichten und Strecke auswählen

Erstellen oder verwenden Sie einen Schlüssel mit der Berechtigung youtube_transcript plus youtube_metadata für den optionalen Metadatenaufruf. [API Schlüssel](https://flashdata.dev/app/api-keys) · [Credits](https://flashdata.dev/app/billing). Speichern Sie FLASHDATA_API_KEY in der Umgebung oder verwenden Sie die versteckte Eingabeaufforderung des Skripts; Füge es niemals in den Chat ein.

Bestehende Anfrage, nur für die Zuordnung:

```bash
# Existing call, for mapping only; reuse your saved key.
curl --get --fail-with-body --silent --show-error \
  'https://api.scrapecreators.com/v1/youtube/video/transcript' \
  --header "x-api-key: $SCRAPECREATORS_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'language=en'
```

FlashData POST https://data.flashdata.dev/v1/queries/realtime mit X-API-Key und diesem JSON-Körper:

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

original_audio=true wählt die gesprochene Sprache. FlashData params.auto=true wählt YouTube-generierte Untertitel aus. Geben Sie Sprache und Herkunft getrennt an.

### 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 creator-research.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")
    transcript = []
    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")
        transcript.append({"text": text,
                           "startMs": str(math.floor(start * 1000 + 0.5)),
                           "endMs": str(math.floor(end * 1000 + 0.5)),
                           "startTimeText": f"{int(start) // 60}:{int(start) % 60:02d}"})
    normalized = {"videoId": item["videoId"],
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "transcript": transcript, "transcript_only_text": item.get("fullText"),
                  "language": item.get("languageName"), "languageCode": item["languageCode"],
                  "isAutoGenerated": item["isAutoGenerated"]}
else:
    duration = item.get("duration")
    if duration is not None and (type(duration) not in (int, float)
                                or not math.isfinite(duration) or duration < 0):
        raise SystemExit("Invalid video duration")
    normalized = {"id": item["videoId"], "title": item.get("title"),
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "description": item.get("description"),
                  "viewCountInt": item.get("viewCount"), "likeCountInt": item.get("likeCount"),
                  "commentCountInt": item.get("commentCount"),
                  "durationMs": None if duration is None else math.floor(duration * 1000 + 0.5),
                  "channel": {"id": item.get("channelId"), "title": item.get("channel")},
                  "uploadDateRaw": item.get("uploadDate")}
(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 Ordner aus ein Video mit einem vorhandenen englischen Titel aus. Metadaten sind eine separate optionale Anfrage; Lassen Sie bei einem vorübergehenden Test mindestens eine Sekunde zwischen den Anrufen.

```bash
python creator-research.py transcript FUfGcZ092b0 captions-001
# Optional metadata, run separately:
python creator-research.py metadata FUfGcZ092b0 metadata-001
```

Für vom Uploader bereitgestellte Untertitel ergänze --origin manual. Standardmäßig werden von YouTube erzeugte englische Untertitel verwendet.

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

```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
      if .duration == null then .
      elif (.duration | type) != "number" then error("Invalid video duration")
      elif (.duration | isfinite | not) or .duration < 0 then error("Invalid video duration") else . end
      | {id: .videoId, title, url: ("https://www.youtube.com/watch?v=" + .videoId), description,
         viewCountInt: .viewCount, likeCountInt: .likeCount, commentCountInt: .commentCount,
         durationMs: (if .duration == null then null else (.duration * 1000 | round) end),
         channel: {id: .channelId, title: .channel}, uploadDateRaw: .uploadDate}
    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
      | if (.segments | type) != "array" then error("Expected caption segments") else . end
      | {videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
         transcript_only_text: .fullText, language: .languageName, languageCode, isAutoGenerated,
         transcript: [.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, startMs: (.start * 1000 | round | tostring), endMs: (.end * 1000 | round | tostring),
            startTimeText: (((.start / 60 | floor) | tostring) + ":" +
              ((.start | floor) % 60 | if . < 10 then "0" + tostring else tostring end))} 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"

```

```bash
bash creator-research.sh transcript FUfGcZ092b0 captions-001
# Optional metadata, run separately:
bash creator-research.sh metadata FUfGcZ092b0 metadata-001
```

Für vom Uploader bereitgestellte Untertitel fügen Sie ein Handbuch bei. Jeder neue Ausgabeordner sendet eine Anfrage. Die gleichen Argumente und Ordner verwenden die gespeicherte Ausgabe wieder; Verwenden Sie einen neuen Ordner für eine absichtliche Aktualisierung, nachdem Sie den vorherigen Versuch überprüft haben.

### 3. Lesen Sie die zugeordnete Ausgabe und die tatsächliche Nutzung

Bildunterschriften-001/normalized.json ist ein Feldadapter; response.json behält die rohe Antwort und tatsächliche Nutzung. Sekunden werden zu String-Millisekunden. languageCode und isAutoGenerated behalten die ausgewählte Spur bei. Dies ist keine vollständige Drop-in-Antwort: keine hergestellten Guthaben, Cache-Flags, Uploader-Attribution oder Datumsfelder. Metadaten bewahren fehlende Metriken als null und sein ursprüngliches Datum als uploadDateRaw.

```json
{
  "videoId": "FUfGcZ092b0",
  "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
  "transcript": [
    {
      "text": "Example caption text.",
      "startMs": "1250",
      "endMs": "3500",
      "startTimeText": "0:01"
    }
  ],
  "transcript_only_text": "Example caption text.",
  "language": "English",
  "languageCode": "en-orig",
  "isAutoGenerated": true
}
```

| ScrapeCreators Integration | FlashData ändern |
| --- | --- |
| GET /v1/youtube/video?url=… | POST die Abfrage API mit Quelle: youtube_metadata und video_id. Ergebnisse lesen[0], nicht den Antwortstamm. |
| GET /v1/youtube/video/transcript?url=… | Quelle verwenden: youtube_transcript. Legen Sie params.language und params.auto explizit fest. |
| Transkript[].startMs / endMs | FlashData Start/Ende sind Sekunden. Multiplizieren Sie jedes mit 1,000 und serialisieren Sie es als Zeichenfolgen für einen vorhandenen Millisekunden-Reader. |
| original_audio=true | Wählt die gesprochene Sprache in ScrapeCreators aus, nicht automatisch generierte Untertitel. Lösen Sie die erforderliche Sprache in Ihrer App auf. params.auto wählt stattdessen den Ursprung der Beschriftung aus. |
| Sprache und transcript_only_text | Karte languageName und fullText. Bewahren Sie languageCode separat auf; Ein Sprachname und ein Sprachcode sind unterschiedliche Felder. |
| viewCountInt, likeCountInt, commentCountInt | Karte viewCount, likeCount, commentCount. Behalten Sie null bei, wenn eine Metrik fehlt. |
| durationMs und publishDate | Konvertieren Sie Dauersekunden in Millisekunden. Behalten Sie uploadDate als Rohfeld bei, bis Ihre App das benötigte Datumsformat validiert. |
| Kanal / Uploader / ownerByline | FlashData-Kanal und channelId reproduzieren nicht alle drei Identitäten. Ordnen Sie nur die Felder zu, die Ihr Leser benötigt. Behalten Sie einen separaten Pfad für die Zuordnung von Musiktiteln bei. |
| cached, cached_at, credits_charged | Behalten Sie die FlashData-Rohantwort und -Nutzung bei. Notieren Sie Ihre eigene Abrufzeit; Erstellen Sie keine Anbieter-Cache-Flags und übersetzen Sie keine Guthaben zwischen Anbietern. |

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

### Wenn die erste Anfrage fehlschlägt

- 401/403: Überprüfen Sie den gespeicherten Schlüssel und die Quellberechtigung; stoppen, wenn widerrufen.
- 402: Füllen Sie das Besitzerguthaben auf, bevor Sie fortfahren.
- 429: liest den gespeicherten Retry-After-Header; Reduzieren Sie die Anforderungshäufigkeit. Temporäre Testversionen erlauben eine Anfrage pro Sekunde.
- Fehlender Titel: Überprüfen Sie die verfügbare Sprache und Herkunft. ScrapeCreators kann eine erfolgreiche Antwort mit einem null-Transkript zurückgeben; Verwechseln Sie dies nicht mit einem completed FlashData-Track.
- Zeitüberschreitung oder unvollständiger Ordner: Überprüfen Sie den Verlauf und die Ausgabe, bevor Sie es erneut versuchen. Skripte bewahren den Versuch ohne automatische erneute Übermittlung auf.

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

<a id="workflow"></a>
## Finden → Auswahlliste → Anreichern → Zitieren

| Schritt | Arbeit | Anzahl der Anfragen |
| --- | --- | --- |
| Entdecken | Führen Sie P YouTube Suchanfragen aus | P Standardsuchanfragen. Zählen Sie tatsächliche Anfragen und nicht jedes zurückgegebene Video als separate Suche. |
| Auswählen | N-Video IDs deduplizieren und in die engere Auswahl nehmen | Lokale Filterung; Noch keine Metadaten- oder Untertitelanfrage. |
| Bereichern | Metadaten für die in die engere Wahl gezogenen IDs abrufen | N Metadatenanfragen; Wiederholen Sie dies nur, wenn die Messwerte aktualisiert werden müssen. |
| Zitieren | Rufen Sie pro ID einen vorhandenen Untertiteltrack ab | N Transkriptanfragen, sofern verfügbar. Speichern Sie Sprache, Herkunft und Cue-Timings mit der Quelle URL. |
| Wiederverwendung | Lesen Sie gespeicherte Ergebnisse für die nächste Aufgabe | Keine Anbieteranfrage, wenn Ihre App ihre eigene gespeicherte Datei wiederverwenden kann. |

10-Suchanfragen plus 50 in die engere Wahl gezogene Videos mit Metadaten und Untertiteln erfordern 110-Standardanfragen vor der lokalen Wiederverwendung. Trennen Sie Entdeckungskosten von Anreicherungskosten. Ein Suchergebnis ist selbst keine separate Suchanfrage.

### Die Suche ist keine Drop-in-Cursor-Migration

ScrapeCreators kann mit continuationToken mehrere Ergebnistypen zurückgeben. Die Standardsuche von FlashData liefert Videoergebnisse; Für die erweiterte Suche gelten separate Beschränkungen und Preise. Starten Sie einen neuen Erkennungslauf, anstatt einen alten Cursor wiederzuverwenden.

[YouTube Suchreferenz](https://flashdata.dev/de/docs/sources/youtube_search/reference.md)

### Bewahren Sie Beweise mit der Antwort auf

Speichern Sie das Video ID, URL, die gewählte Sprache, den Ursprung der Untertitel und die Startzeit des Segments. Ein Zitierlink kann auf diesen Zeitstempel verweisen. Kennzeichnen Sie eine fehlende Untertitelspur nicht als leeres erfolgreiches Transkript.

[Rezept für zeitgestempelte Untertitel](https://flashdata.dev/de/docs/guides/timestamped-captions-recipe/reference.md)

### Scale die ID-Liste separat

Nachdem eine Suche erfolgreich war, verwenden Sie batch-Anfragen für eine Liste oder die Massenverarbeitung für eine Datei. Verfolgen Sie Job IDs, speichern Sie completed-Ausgaben und wiederholen Sie nur failed-Elemente. Machen Sie Ihren Läufer für den Zeitplan verantwortlich.

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

<a id="agents"></a>
## Beweisen Sie die Migration, bevor Sie sie planen

Berechtigte Agenten können mit 1 credit (bis zu 100 Standard YouTube Datenanforderungen) für 72 Stunden beginnen. Metadaten, Bildunterschriften und Suche teilen sich die Zulage.

1. Überprüfen Sie die erforderlichen Felder, die Absicht und Aktualität der Beschriftung. Gespeicherten Zugriff wiederverwenden; Behalten Sie unabhängige Anrufe über soziale Netzwerke bei.
2. Führen Sie ein bekanntes Video mit CLI, SDK oder MCP aus. Speichern Sie die Ausgabe und überprüfen Sie Timing, Nullen und tatsächliche Nutzung.
3. Der Eigentümer meldet sich an oder registriert sich, überprüft die E-Mail-Adresse und genehmigt die Inanspruchnahme, den Umfang und die Nutzung des gemeinsamen Guthabens. Nicht genutzte Testguthaben werden nicht übertragen.
4. Behalten Sie die Eigentümeranmeldeinformationen für die wiederkehrende Verwendung bei. Ausgaben wiederverwenden und bei Widerruf oder unzureichendem Guthaben stoppen.

```text
Migrate only this app's YouTube metadata and native-caption calls to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/agents.md first.
Reuse saved access; start an eligible trial only if needed. Keep credentials out of chat.
Inspect our current fields, language choice, original_audio behavior and cache freshness requirements.
Keep comments, other social platforms and unsupported fields on their existing path.
Run one known video with explicit language and caption origin. Save the raw response and usage.
Map timestamps from seconds to string milliseconds; preserve null counts and missing-track errors.
Reuse saved output before requesting it again. Do not retry an uncertain submission automatically.
Before recurring use, ask the owner to claim access and approve permissions and shared-balance use.
Persist the resulting credential and stop on revocation or insufficient balance.
```

[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-Setup](https://flashdata.dev/de/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Bevor Sie wechseln

### Handelt es sich um monatliche Abonnements?

ScrapeCreators Freelance und Business sind Prepaid-Pakete, keine Abonnements. Für beide fällt eine monatliche Gebühr von $0 an. FlashData bietet nutzungsbasiertes Guthaben sowie optionale Monatspläne. Vergleichen Sie den verbrauchten Verbrauch und den benötigten Einkauf separat mit Ihrem aktuellen Guthaben.

### Was passiert, wenn die meisten meiner ScrapeCreators Anfragen zwischengespeichert werden?

Unterstützte Metadaten- und Transkript-Cache-Treffer kosten keine Credits. Geben Sie die beobachteten Treffer in den Rechner ein. Wenn Ihre App ihr Alter akzeptiert, können sie weniger kosten als neue FlashData-Anfragen. Sie können die Ausgabe beider Anbieter auch lokal speichern und so die nächste Anfrage ganz vermeiden.

### Verfallen ungenutzte Credits?

ScrapeCreators besagt, dass gekaufte Credits gemäß der aktuellen Richtlinie nicht verfallen. Das kostenlose 100-Guthaben-Startangebot ist keine monatliche Aufladung. FlashDatas Testversion als Zeitagent läuft ab; Auf den Preis- und Kontoseiten werden die geltenden Eigentümerguthabenbedingungen beschrieben.

### Funktioniert original_audio=true als params.auto=true?

Nein. Der erste wählt eine Sprache basierend auf dem gesprochenen Audio aus; Der zweite wählt YouTube-generierte Untertitel aus. Legen Sie bewusst eine Sprache und einen Ursprung fest. Keiner der nativen Untertitelendpunkte der beiden Dienste erstellt Sprache-zu-Text, wenn kein passender Titel vorhanden ist.

### Kann ich alle meine Social-Media-Datenanrufe ersetzen?

Diese Migration umfasst YouTube Videometadaten und vorhandene Untertitel. Behalten Sie Kommentare, Community-Beiträge, soziale Profile und alle anderen nicht unterstützten Antwortfelder in ihrem vorhandenen Pfad bei. FlashData bietet auch Google Suche und gehosteten YouTube Download mit eigenen Berechtigungen und Preisen.

### Unterstützt ScrapeCreators auch KI-Agenten?

Ja. Es bietet MCP, OAuth, ein CLI und Agentenfähigkeiten. Der Agentenfluss von FlashData fügt eine berechtigte temporäre Testversion, Eigentümerbeanspruchung und gespeicherte Anmeldeinformationen für die weitere Verwendung hinzu. Wählen Sie den API und den Workflow, den Ihre Aufgabe benötigt; MCP Support allein macht keinen Unterschied.
