# Supadata Alternatief voor YouTube Gegevens

Vergelijk YouTube transcriptie- en metadatakosten, native ondertitelingsfuncties en agenttoegang. Migreer vanuit Supadata met uitvoerbare voorbeelden Python en Bash.

Supadata feiten beoordeeld 2026-11-10. FlashData prijzen en proefvergoedingen maken gebruik van de huidige openbare catalogi.

- [Kenmerken](#features)
- [Kosten vergelijken](#costs)
- [Een transcriptie migreren](#migration)
- [Metagegevens en bulk](#workflows)
- [Voor AI-agenten](#agents)
- [Veelgestelde vragen](#faq)

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

Voor apps en agenten die bestaande YouTube ondertitels en metadata verzamelen.

### Blijf betaald YouTube ophalen voordelig

| Functie | FlashData | Supadata |
| --- | --- | --- |
| Betaald gebruik zonder abonnement | Ja — Pay-as-you-go-tegoeden; aankopen vanaf $10 | Betaalde abonnementen — Basic: $60/jaar · Pro: $17/maand |
| Native transcript of metadata · prijs per 1,000 | $0.50 — Pay as you go · geen maandelijkse kosten | $5.67 op Pro — $17 / 3,000 included credits; full allowance gebruikt |
| Batch zonder maandabonnement | Maximaal 100 zoekopdrachten/batch — Pay-as-you-go-eigenaarssleutel; proeflimiet is apart | Pro en hoger — Video en transcriptie batch eindpunten |

### Zoek video's en bouw een onderzoeksbibliotheek

| Functie | FlashData | Supadata |
| --- | --- | --- |
| Zoek video's op onderwerp | Ja — Zoeken op trefwoord met datum, duur, type en sorteerfilters | Ja — Zoeken naar video's, kanalen en afspeellijsten met filters |
| Vernieuw videometadata zonder ondertiteling op te halen | Ja — Titel, kanaal, duur, thumbnails en betrokkenheidsaantallen | Ja — Afzonderlijk metadata-eindpunt met auteur-, media- en statistiekvelden |
| Ondertitelingstalen in videometadata | Ja — hasTranscripts en transcriptLanguages | In het transcriptantwoord — availableLangs; afzonderlijk metadataschema |

### Houd transcripties nuttig voor citaten en analyses

| Functie | FlashData | Supadata |
| --- | --- | --- |
| Tekst met tijdstempel voor bronvermeldingen | JSON segmenten in seconden — Tekst met begin- en eindtijd | JSON stukjes in milliseconden — Tekst met offset en duur |
| Volledige tekst en tijdstempels van hetzelfde antwoord | Ja — fullText en segmenten worden samen geretourneerd | Kies tekst of stukjes — tekst=true retourneert een tekenreeks; sluit je anders aan bij de brokken in je app |
| Meerdere bestaande ondertitelingstalen in één verzoek | Maximaal 10 talen — Tracks en fouten per taal | Eén voorkeurstaal — lang-parameter op het transcripteindpunt |
| Selecteer door de uploader geleverde of door YouTube gegenereerde ondertiteling | Ja — Expliciet params.auto=false of true | Geen herkomstkiezer gedocumenteerd — modus selecteert native ophalen versus AI-generatie |
| Behandel niet-beschikbare ondertiteling expliciet | Alleen bestaande nummers — Taalarrays retourneren tracks plus fouten; geen nieuwe transcriptie | Kies native of AI-fallback — mode=auto kan spraak-naar-tekst genereren; native beperkt het ophalen van bestaande ondertitels |

### Ga van één verzoek naar een herhaalbare workflow

| Functie | FlashData | Supadata |
| --- | --- | --- |
| Interactieve en achtergrondverzoeken | Realtime of async — Kies de uitvoeringsmodus en sla de taak op ID | Resultaat- of transcriptieopdracht — HTTP 200 retourneert gegevens; HTTP 202 retourneert een taak ID |
| Verwerk een voorbereide lijst met video's | Batch-console API of Bulk Jobs — Upload een ID bestand; bewaar de manifest- en resultaatdelen | Asynchroon batch API · Pro+ — Accepteert videolijsten, afspeellijsten of kanalen |
| Verzamel een hele afspeellijst of kanaal | Bied expliciete video IDs aan — Bereid de lijst voor vóór batch- of bulkverwerking | Afspeellijst of kanaal batch invoer — Regular videos; excludes Shorts and live video's |
| Uitvoer voor applicaties en LLM's | JSON, platte tekst of Markdown — Kies het antwoord- en inhoudsformaat | JSON met tekst of stukjes — Gebruik de transcriptie-inhoud in uw toepassing of prompt |
| Taal-SDK's | Python, TypeScript en Go | Python en JavaScript / TypeScript |
| MCP toegang voor een agenthost | Ja — Afstandsbediening MCP met OAuth of een API sleutel | Ja — MCP server met Supadata inloggegevens |
| Programmatische proefperiode vóór aanmelding door de eigenaar | Ja — Maximaal 100 native transcriptieverzoeken · 72 uur | Rekeningnummer API eerst — 100 gratis credits elke maand na aanmelding |

Supadata ondersteunt door AI gegenereerde transcriptie en meerdere sociale platforms. De ondertitelingseindpunten van FlashData halen bestaande YouTube-tracks op. Beide services bieden MCP en SDK's.

### Houd een kleine onderzoekslast betaalbaar

Betaal voor de YouTube gegevensverzoeken die u gebruikt. Voeg later een abonnement toe als het lagere tarief en het inbegrepen saldo bij uw volume passen.

[Prijs uw werklast](#costs)

### Houd de bron van het bijschrift expliciet

Selecteer door YouTube gegenereerde of door uploader geleverde ondertitels, behoud de geretourneerde taal en bewaar tijdstempels voor citaten. Vraag bestaande tracks in meerdere talen aan zonder nieuwe spraak-naar-tekst te genereren.

[Breng uw transcriptielezer in kaart](#migration)

### Groei van één video naar een pipeline

Gebruik dezelfde verzoekvorm voor realtime, async en batch werk. Voeg Google Zoeken toe aan de onderzoeksworkflow met hetzelfde account en gedeeld saldo.

[Bouw de volgende stap](#workflows)

<a id="costs"></a>
## Prijs de volledige videoworkflow

USD. Eén native transcript in één taal of één zoekopdracht met metadata is één verzoek en één Supadata credit. Metagegevens plus een native transcript zijn twee verzoeken per video. FlashData gebruikt de live YouTube gegevenscatalogus, waarbij de inbegrepen kredietwaarde wordt toegepast vóór verder gebruik. Het weergegeven eenheidstarief is een gebruikstarief; Supadata is de abonnementskosten gedeeld door de volledige maandelijkse vergoeding. Basic is alleen jaarlijks: $60 vooraf betaald, weergegeven als $5/maand equivalent met 300 credits per maand, niet 3,600 onmiddellijk beschikbaar. Andere Supadata-abonnementen gebruiken maandelijkse catalogusprijzen. Automatisch opladen is in deze schatting uitgeschakeld totdat dit wordt geselecteerd; wanneer geselecteerd, dekken de kleinste hele gepubliceerde pakketten het tekort. De werkelijke timing voor automatisch opladen kan eerder zijn. Aankoopbedragen gaan niet uit van een startsaldo. FlashData opwaarderingen beginnen bij $10; bij een aankoop kan er geld overblijven voor later. Supadata maandelijkse tegoeden worden niet overgedragen. Proeftegoeden, belastingen, ander API gebruik, jaarlijkse kortingen op andere abonnementen, het genereren en vertalen van AI zijn uitgesloten. Bij nul aanvragen blijft het geselecteerde abonnementstarief van kracht en is het effectieve tarief niet gedefinieerd.

### FlashData YouTube Data-abonnementen

| FlashData plan | Per 1,000 verzoeken | Maandelijkse kosten | Inbegrepen verzoeken per maand |
| --- | --- | --- | --- |
| Betalen naar gebruik | $0.50 | $0.00 | 0 |
| Micro | $0.40 | $49.00 | 125,000 |
| Starter | $0.35 | $199.00 | 571,428 |
| Pro | $0.30 | $499.00 | 1,666,666 |
| Scale | $0.25 | $999.00 | 4,000,000 |
| Business | $0.20 | $1,999.00 | 10,000,000 |

[Volledige YouTube Dataprijzen](https://flashdata.dev/nl/pricing/youtube-data)

### Supadata gepubliceerde plannen

| Supadata plan | Betaling plannen | Tegoeden / maand | Per 1,000 met volledige vergoeding | Automatisch oplaadpakket |
| --- | --- | --- | --- | --- |
| Gratis | $0.00 / maand | 100 | $0.00 | Niet beschikbaar |
| Basic · annual only | $60.00 / jaar ($5.00 / maand equivalent) | 300 | $16.67 | $10.00 / 1,000 tegoeden |
| Pro · monthly | $17.00 / maand | 3,000 | $5.67 | $10.00 / 1,000 tegoeden |
| Mega · monthly | $47.00 / maand | 30,000 | $1.57 | $10.00 / 5,000 tegoeden |
| Giga · monthly | $297.00 / maand | 300,000 | $0.99 | $20.00 / 20,000 tegoeden |
| Supa · monthly | $897.00 / maand | 1,000,000 | $0.90 | $20.00 / 20,000 tegoeden |

### Voorbeeld: metadata plus een native transcript voor elke video

FlashData betalen per gebruik versus Supadata Mega maandelijks, inclusief automatisch opladen. Dit is een expliciete planvergelijking; selecteer andere plannen onafhankelijk in de rekenmachine HTML.

| Video's / maand | Gegevensverzoeken | FlashData gemodelleerd gebruik | Supadata Mega + hele oplaadpakketten | Pakketten opladen |
| --- | --- | --- | --- | --- |
| 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 |

### Gratis toegang en AI-generatie

Supadata Gratis bijvullen 100 maandelijks tegoed. Het oorspronkelijke transcript gebruikt één credit; AI-generatie gebruikt twee credits per minuut. Een gegenereerd transcript van 30 minuten gebruikt daarom 60 credits. De standaard automatische modus kan generatie activeren; mode=native vermijdt die terugval. Generatie, vertaling en Uitgebreid zoeken zijn uitgesloten van deze vergelijking.

In aanmerking komende geverifieerde FlashData-aanmeldingen kunnen een initiële vergoeding ontvangen van maximaal 4,000 standaard YouTube Gegevensverzoeken. Het is geen maandelijks gratis niveau.

<a id="migration"></a>
## Migreer een native transcriptielezer

| Verandering | Supadata | FlashData | Wat te doen |
| --- | --- | --- | --- |
| Verzoek | GET /v1/transcript met url, lang, tekst en modus | POST /v1/queries/realtime met bron, video_id en parameters | Extraheer het 11-teken YouTube ID. Een sleutel Supadata authenticeert niet met FlashData. |
| Authenticatie | x-api-key: uw Supadata sleutel | X-API-Key: uw FlashData sleutel | Maak of hergebruik een inloggegevens met toestemming youtube_transcript. Headernamen zijn niet hoofdlettergevoelig; de legitimatie verandert. |
| Native versus gegenereerd | mode=native haalt bestaande ondertitels op; auto kan terugvallen op AI; genereren maakt altijd gebruik van AI | youtube_transcript leest bestaande YouTube bijschriften | Verplaats het oorspronkelijke ophalen eerst. Houd een aparte spraak-naar-tekst-stap aan voor video's waarvoor een nieuwe transcriptie nodig is. |
| Oorsprong van het bijschrift | modus selecteert ophalen versus genereren | params.auto=true selecteert door YouTube gegenereerde ondertitels; false selecteert door de uploader geleverde ondertitels | Deze automatische instellingen zijn niet gelijkwaardig. FlashData automatisch start nooit spraak-naar-tekst. |
| Taal | lang heeft de voorkeur; niet-beschikbare talen kunnen terugvallen op de eerst beschikbare talen | params.language is expliciet; auto=true probeert de -orig variant en vervolgens de gevraagde code | Vink languageCode en requestedLanguageCode aan. FlashData kiest niet stilzwijgend een andere taal of ondertiteloorsprong. |
| Segmenten | content[]: tekst, offset en duur in milliseconden | resultaten[0].segments[]: tekst, begin en einde in seconden | offset = rond(begin × 1000); duur = round((einde − begin) × 1000). Behoud overlappingen in plaats van signalen te verschuiven. |
| Platte tekst | tekst=true retourneert inhoud als een tekenreeks | resultaten[0].fullText | Lees fullText voor samenvatting en bewaar de segmenten voor tijdstempelcitaten. |
| Taal ontdekking | availableLangs in het transcriptantwoord | transcriptLanguages in youtube_metadata | Haal metagegevens op wanneer uw app de volledige taallijst nodig heeft. Verzin availableLangs niet uit één geretourneerd spoor. |
| Voltooiing | HTTP 200 resultaat, of HTTP 202 + jobId | Realtimestatus=done; async inzendingen retourneren FlashData taak IDs | Behandel de statussen van elke provider afzonderlijk. Voltooi daar bestaande Supadata taken voordat u nieuw werk migreert. |

### 1. Toegang instellen

Maak of hergebruik een sleutel FlashData met toestemming youtube_transcript in [API Toetsen](https://flashdata.dev/app/api-keys). Voeg youtube_metadata toe voor de optionele metadatataak. Vink [beschikbare kredieten](https://flashdata.dev/app/billing) aan of gebruik [in aanmerking komende proeftoegang voor agenten](#agents). Bewaar sleutels in een omgeving of geheime winkel.

Supadata native verzoek wordt vervangen:

```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 vervanging JSON behuizing voor POST /v1/queries/realtime:

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

### 2. Sla het script op en voer het uit

Kies Python of Bash. Elke nieuwe uitvoermap dient één verzoek in; Als u een map opnieuw gebruikt, wordt de opgeslagen uitvoer gelezen zonder nog een API-aanroep. De versies delen het opgeslagen bestandsformaat. Kies een video met de gevraagde ondertitelingstrack.

#### Python

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

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

```

Uitvoeren vanuit die werkmap:

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

Hiermee worden door YouTube gegenereerde Engelse ondertitels geselecteerd. Voeg --origin handleiding toe voor een door de uploader geleverde track, of --language CODE om een taal te kiezen.

Optioneel afzonderlijk metadataverzoek:

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

#### Bash

Vereist Bash, cURL 7.76+ en jq 1.6+. Bewaar dit volledige script als youtube-migrate.sh in uw werkmap vóór running:

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

```

Uitvoeren vanuit die werkmap:

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

Optionele argumenten na de map zijn taal en oorsprong; En manual selecteert bijvoorbeeld door de uploader geleverde Engelse ondertitels.

Optioneel afzonderlijk metadataverzoek:

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

Voor tijdelijke proeftoegang voert u aanvragen opeenvolgend uit met een tussenpoos van ten minste één seconde.

### 3. Lees de uitvoer

response.json behoudt het onbewerkte resultaat en gebruik. normalized.json converteert transcriptsegmentseconden naar offset/duration milliseconden. Dit is een segmentadapter, geen volledig Supadata-compatibel antwoord: availableLangs is niet verzonnen. Metagegevensuitvoer behoudt nulwaarden. Mislukte of onderbroken verzoeken behouden hun bewijsmateriaal en stoppen.

Illustratief normalized.json:

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

[Transcriptieschema](https://flashdata.dev/nl/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## Metagegevens en bulkworkflows

| Gegevens | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Video-identiteit | id | resultaten[0].videoId |
| Titel en beschrijving | titel, beschrijving | resultaten[0].titel, resultaten[0].beschrijving |
| Kanaal | author.displayName; additionalData.channelId | resultaten[0].kanaal; resultaten[0].channelId |
| Betrokkenheid | stats.views, stats.likes, stats.comments | resultaten[0].viewCount, likeCount, commentCount |
| Duur | media.duration (seconden) | resultaten[0].duur (seconden) |
| Miniatuur | media.thumbnailUrl | resultaten[0].thumbnails[]; kies de grootte die uw app nodig heeft |
| Publicatiedatum | createdAt | resultaten[0].uploadDate; normaliseer het formaat ervan in uw app |
| Bijschrift ontdekking | Lees availableLangs uit een transcriptieantwoord | resultaten[0].hasTranscripts en transcriptLanguages |

### Meerdere bestaande talen in één aanvraag

Verzend een taalarray om tracks en fouten te ontvangen, zelfs voor een array die één taal bevat. Inspecteer fouten, zelfs als de status done is. Dit zijn bestaande tracks, geen vertaalde of gegenereerde ondertitels.

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

### Verrijk een onderzoeksbibliotheek

Haal de metadata één keer op, sla de video ID en de beschikbare ondertitelingstalen op en haal vervolgens de track op die je nodig hebt. Houd nulbare betrokkenheidstellingen op null in plaats van ze naar nul te converteren.

[YouTube Best practices voor gegevens](https://flashdata.dev/nl/docs/guides/youtube-data-guide/reference.md)

### Verwerk een lijst met video IDs

Breid uw invoer uit naar expliciete video IDs en gebruik vervolgens batch- of bulkbestand. FlashData accepteert geen Supadata playlistId als drop-in batch invoer. Bewaar de status en uitvoer per item voordat u failed items opnieuw probeert.

[Referentie voor bulkverwerking](https://flashdata.dev/nl/docs/reference/bulk-processing/reference.md)

### Voer onderzoek uit volgens een schema

Behoud de inloggegevens van de eigenaar, controleer completed video's en lees de opgeslagen uitvoer bij opnieuw opstarten. Stop bij ingetrokken toegang of onvoldoende saldo; maak geen nieuwe proefversie aan om een ​​geplande taak voort te zetten.

[Terugkerende agenttaken](https://flashdata.dev/nl/docs/guides/recurring-tasks/reference.md)

### Production migratiebeslissingen

- Los invoer van afspeellijst/channel op in expliciete video IDs vóór FlashData Batch- of bulkbestandsverwerking; Supadata playlistId is geen drop-in-invoer.
- Supadata zoeken kost één credit per 20-resultaatpagina, of ceil(limit/20) met limiet. FlashData standaard YouTube Zoeken ondersteunt maximaal 20 resultaten; Uitgebreid Zoeken kent een apart tarief. Wijs filters toe en draag geen paginatokens over.
- Supadata documenteert een completed transcriptieresultaatvenster van één uur. Haal daar bestaande banen weg en sla de resultaten op voordat u nieuw werk migreert. Houd de providerspecifieke taak IDs gescheiden.
- Houd platformonafhankelijke media, AI-extractie, vertaling en audiotranscriptie op hun bestaande paden, tenzij een gelijkwaardige workflow is geïmplementeerd.

<a id="agents"></a>
## Agentproef, claim en terugkerend gebruik

In aanmerking komende agenten kunnen beginnen met 1 studiepunten, tot 100 native transcriptverzoeken voor 72 uur. Metadata en transcripties delen deze vergoeding.

1. Hergebruik eerst bestaande toegang; start anders één in aanmerking komende proefperiode met alleen de benodigde machtigingen.
2. Retourneer een nuttig resultaat, sla onbewerkte uitvoer en gebruik op en behoud hetzelfde profiel en dezelfde statusmap.
3. De eigenaar logt in of registreert zich, verifieert de e-mail en keurt claims, bereiken en toegang tot gedeeld saldo goed.
4. Hergebruik de eigenaarsreferentie voor terugkerende taken. Ongebruikte proeftegoeden worden niet overgedragen. Stop na herroeping of onvoldoende saldo; maak nooit een nieuwe proefperiode aan om door te gaan.

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

[Proberen en claimen](https://flashdata.dev/nl/docs/guides/agent-onboarding/reference.md) · [Standalone CLI](https://flashdata.dev/nl/docs/guides/flashdata-cli/reference.md) · [MCP-verbinding](https://flashdata.dev/nl/docs/integrations/mcp-clients/reference.md)

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

### Kan FlashData de AI-transcriptie van Supadata vervangen?

De transcriptie- en ondertitelingsbronnen van FlashData halen ondertitels op die al aanwezig zijn op YouTube. Ze transcriberen geen audio, vertalen geen tekst en voeren geen visuele analyse uit. Verplaats native YouTube ophalen naar FlashData; houd een aparte service voor spraak-naar-tekst, platformonafhankelijke video of AI-extractie wanneer uw toepassing dit nodig heeft.

### Wat koop je met één verzoek?

De rekenmachine omvat één bestaand transcript in één taal of één zoekopdracht met videometadata. Voor het ophalen van beide worden twee verzoeken per video gebruikt. Supadata factureert elk van deze bewerkingen met één credit. FlashData gebruikt de datasnelheid YouTube van het geselecteerde abonnement. Uitgebreid zoeken, AI-transcriptie, vertaling en medialevering vallen buiten deze schatting.

### Is FlashData altijd goedkoper?

Vergelijk uw werkelijke werklast en geselecteerde plannen. Supadata bevat elke maand 100 gratis credits. De proeftijd van FlashData is beperkt en loopt af; het is geen maandelijks gratis niveau. Bij een laag volume kan een gratis vergoeding de hele taak dekken. Betaalde abonnementskosten, opwaardeerpakketten en ongebruikte saldi zijn van invloed op het bedrag dat u betaalt.

### Ondersteunt Supadata al MCP en SDK's?

Ja. Beide services ondersteunen MCP en Python/JavaScript integraties. FlashData biedt ook een Go SDK, standalone CLI en een proefperiode voor tijdelijke agenten die kan worden geclaimd voor terugkerende toegang. Kies de interface die uw host ondersteunt; MCP alleen is geen reden om over te stappen.

### Wat gebeurt er als er een ondertitelingstrack ontbreekt?

Beschouw het als een datalek. FlashData schakelt niet tussen door de uploader geleverde en door YouTube gegenereerde ondertiteling en synthetiseert geen transcript. Inspecteer voor een taalarray fouten, zelfs als het verzoek done is. Supadata kan een transcriptie genereren in de automatische modus, terwijl de native modus HTTP 206 kan retourneren voor een niet-beschikbare transcriptie; de documentatie factureert die respons op één credit.

### Kan ik de bestaande reactievorm van de aanvraag behouden?

Houd uw eigen adapter. In het voorbeeld worden FlashData segmenten geconverteerd naar inhoudsitems met verschuiving en duur in milliseconden, maar wordt geen volledig Supadata-compatibel antwoord geclaimd. Lees metadata FlashData als u beschikbare talen nodig heeft, en migreer taakstatus, fout- en gebruiksafhandeling expliciet.

[Verkrijg een sleutel API](https://flashdata.dev/signup)
