# ScrapeCreators Alternatief voor YouTube Gegevens

Vergelijk YouTube metadata en ondertitelingskosten, prepaidpakketten en cachehits. Migreer naar FlashData met uitvoerbare veldadapters Python en Bash voor apps en agenten.

Nieuwe videogegevens. Een kleinere startuitgaven. Verplaats YouTube metadata en ondertitelingsoproepen terwijl u de rest van uw sociale-data-integratie behoudt.

ScrapeCreators feiten herzien 2026-11-10. FlashData prijzen en trial vergoedingen komen uit de huidige openbare catalogi.

- [Kenmerken](#features)
- [Prijzen en cache](#costs)
- [Een aanvraag migreren](#migration)
- [Onderzoeksworkflow](#workflow)
- [Voor AI-agenten](#agents)
- [Veelgestelde vragen](#faq)

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

### Verlaag de kosten van nieuwe YouTube gegevens

| Functie | FlashData | ScrapeCreators |
| --- | --- | --- |
| Toegangstarief / 1,000 metadata of ondertitelingsoproepen | $0.50 — Pay-as-you-go-gebruik | $1.88 — Freelance · nieuwe oproepen met één tegoed |
| Laagste vermelde eenheidstarief / 1,000 oproepen | $0.20 — Optioneel maandabonnement; de vergoeding is nog steeds van toepassing | $0.994 — Business · $497 prepaidpakket; aangepaste Enterprise uitgesloten |
| Eerste betaalde kredietaankoop | Vanaf $10 | $47 — 25,000-tegoed Freelance pakket |
| Pay as you go zonder maandelijkse kosten | Ja | Ja |

### Vind video's en ververs de feiten die je nodig hebt

| Functie | FlashData | ScrapeCreators |
| --- | --- | --- |
| Vind video's op trefwoord en filters | Ja — Datum-, duur-, type- en sorteerfilters | Ja — Zoekfilters en paginering van vervolgtokens |
| Metagegevens voor een bekende video | Ja — Titel, kanaal, duur, thumbnails en betrokkenheidsaantallen | Ja — Video/Short Details eindpunt |
| Hoofdstukmarkeringen voor navigatie | Ja — include_chapters; titels met start/end tijden, indien aanwezig | Ja — hoofdstukken in de videoreactie, indien aanwezig |
| Ontdek beschikbare ondertitelingstracks | Taallijst metagegevens — hasTranscripts en transcriptLanguages | Metagegevens captionTracks — Taalcodes en trackdetails |

### Houd de selectie van ondertitels en bewijsmateriaal expliciet

| Functie | FlashData | ScrapeCreators |
| --- | --- | --- |
| Tekst en tijdstempels van hetzelfde antwoord | Volledige tekst + getimede segmenten — Start/end keer in seconden | Volledige tekst + getimede segmenten — startMs/endMs als milliseconde snaren |
| Verschillende ondertiteltalen in één verzoek | Maximaal 10 talen — Bestaande tracks plus fouten per taal | Eén geselecteerde taal — taal of original_audio selectie per transcriptieoproep |
| Kies de oorsprong van het bijschrift expliciet | Uploader of YouTube gegenereerd — params.auto selecteert één oorsprong | Taal- en gesproken audioselectie — original_audio is geen wijziging van ondertiteloorsprong |
| Behandeling van ontbrekende bijschriften | Bestaande tracks en expliciete fouten — Taalarrays behouden succesvolle tracks en rapporteren ontbrekende selecties | Nul transcriptievelden — Ontbrekende aangevraagde nummers kosten nul credits; geen YouTube AI-transcriptie |
| Kies hoe oud hergebruikte gegevens mogen zijn | Cachebeleid in uw toepassing — Bespaar ophaaltijden en bepaal wanneer u opnieuw wilt ophalen | cache_max_age — 1–30-dagen opties; cachehits kosten nul credits en geven cached_at bloot |

### Voer een herhaalbare gegevensworkflow uit

| Functie | FlashData | ScrapeCreators |
| --- | --- | --- |
| Verwerk een opgeslagen videobestand IDs | Beheerde bulktaken — Verzend het bestand, volg de taak ervan en haal de uitvoer op | Eindpuntgesprekken per video — Beheer de bestandslus en resultaatopslag in uw integratie |
| Verplaats lange verzamelingen naar achtergrondtaken | Asynchrone, batch- en bulk-API's — Houd taak IDs vol, volg de status en haal de resultaten op | Synchrone YouTube oproepen — Wachtrij- en controlepunt-per-videogesprekken in uw werknemer |
| Gestructureerde en leesbare output | JSON, platte tekst of Markdown — Geselecteerd via API antwoordheaders | JSON API en CLI formaten — CLI exporteert ook CSV, tabellen en Markdown |
| Terminal-installatie | Op zichzelf staand uitvoerbaar bestand — Linux, macOS en Windows; geen Node/Python runtime | npm CLI — @scrapecreators/cli |
| MCP en vaardigheden van agenten | Ja | Ja |
| Ga verder van data naar gehoste medialevering | Ja — YouTube Downloaden naar uw opslag; afzonderlijke toestemming en GB-gebaseerde prijzen | Afzonderlijke downloader-workflow — YouTube API's voor metadata en transcripties leveren geen mediabestanden |

Beide bieden prepaid-toegang, MCP, een CLI en agentvaardigheden. ScrapeCreators omvat ook andere sociale platforms en YouTube opmerkingen. Ondersteunde cachehits zijn gratis.

### Vernieuw de video's die je interessant vindt

Lagere gebruikspercentages per verzoek zijn van belang wanneer u veranderende statistieken vernieuwt of ondertiteling voor nieuwe video's verzamelt. Bewaar opgeslagen transcripties en vraag alleen metadata op als deze moet worden bijgewerkt.

### Begin met een kleinere aankoop

Het opwaarderen van tegoeden voor FlashData begint bij $10. Verplaats eerst één YouTube-werklast, terwijl uw bestaande integratie reacties en andere sociale platforms blijft verwerken.

### Kies het exacte ondertitelingsspoor

Selecteer expliciet door de uploader geleverde of door YouTube gegenereerde ondertiteling. Vraag maximaal 10 bestaande talen aan in één transcriptieverzoek en behandel het resultaat van elke taal afzonderlijk.

<a id="costs"></a>
## Vergelijk nieuwe verzoeken, cachehits en aankopen vooraf

| ScrapeCreators aanbieding | Eenmalige aankoop | Kredieten | Per 1,000 nieuwe oproepen met één tegoed | Maandelijkse kosten |
| --- | --- | --- | --- | --- |
| Eerste gratis aanbieding | $0 | 100 één keer | Gratis startvergoeding | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Onderneming | Aangepast | 1,000,000+ | Aangepast | $0 voor prepaidtegoeden |

Dit zijn prepaidpakketten zonder maandelijkse verlenging. Business is precies $0.994 per 1,000 oproepen met één tegoed; $0.99 is afgerond. Gekochte credits hebben geen vervaldatum onder het huidige beleid. Initiële en verdiende bonuscredits zijn uitgesloten van het model.

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

Met FlashData opgenomen aantallen aanvragen wordt het volledige gedeelde saldo toegewezen aan standaardgegevens YouTube. Uitgebreid zoeken en downloaden hebben aparte tarieven. [Volledige prijzen](https://flashdata.dev/nl/pricing/youtube-data).

### Voorbeeld: metadata en ondertiteling voor 1,000 video's

2,000 verzoeken, geen ontdekkingszoekopdrachten. FlashData betalen naar gebruik versus ScrapeCreators Freelance. Tel alleen waargenomen cachehits; verzoeken die via uw eigen lokale opslag worden vermeden, worden bij geen van beide providers ingediend.

| Gratis cachehits | FlashData oproepen | FlashData gebruik | FlashData aankoop | ScrapeCreators tegoeden | ScrapeCreators gebruikswaarde | ScrapeCreators aankoop |
| --- | --- | --- | --- | --- | --- | --- |
| 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, één maand aan verzoeken. Voor één nieuwe opzoeking van metagegevens, een resultaat van de oorspronkelijke ondertiteling of een standaardzoekopdracht wordt één credit ScrapeCreators gebruikt. Metadata plus bijschriften gebruiken twee verzoeken aan beide kanten. Alleen metadata/transcript cachehits die hierboven zijn ingevoerd, worden afgetrokken; Er wordt niet uitgegaan van zoekcaching. Dit model telt geretourneerde ondertitels, geen ontbrekende pogingen, en sluit AI-generatie uit. FlashData gebruikt de huidige standaard YouTube Dataprijzen, waarbij het gehele geselecteerde abonnementsbedrag vóór extra gebruik wordt toegewezen. Uitgebreid zoeken en downloaden zijn afzonderlijk geprijsd. Startsaldo, proefversies, bonuskredieten, belastingen en ander gebruik zijn uitgesloten. Aankopen beginnen vanaf een nulsaldo: FlashData opwaarderingen hebben een minimum van $10; ScrapeCreators aankopen worden afgerond op hele geselecteerde pakketten. Ongebruikte gekochte credits kunnen latere taken vervullen. ScrapeCreators heeft geen maandelijkse pakketverlenging; voor een geselecteerd maandabonnement FlashData zijn er nog steeds kosten verbonden aan nul verzoeken.

### Cache-gedrag

Op ondersteunde metadata/transcript-eindpunten accepteert cache_max_age 1d, 3d, 7d, 14d of 30d. Hits gebruiken nul credits en rapporteren cached_at; missers gebruiken het normale tarief. Er wordt niet uitgegaan van zoekcachehits. Bepaal of de opgeslagen gegevens recent genoeg zijn voor de taak. [Bewaar en hergebruik resultaten](https://flashdata.dev/nl/docs/guides/save-results/reference.md).

### Startaanbiedingen

ScrapeCreators begint met 100 gratis credits. In aanmerking komende geverifieerde FlashData-aanmeldingen kunnen een initiële vergoeding ontvangen van maximaal 4,000 standaard YouTube Dataverzoeken. Deze aanbiedingen worden niet maandelijks gereset. De afzonderlijke proef met tijdelijke functionarissen verschijnt hieronder.

<a id="migration"></a>
## Migreer één video en de tijdstempels van de ondertiteling

### 1. Stel de toegang in en kies de track

Maak of hergebruik een sleutel met de machtiging youtube_transcript, plus youtube_metadata voor de optionele metadata-aanroep. [API Toetsen](https://flashdata.dev/app/api-keys) · [Kredieten](https://flashdata.dev/app/billing). Bewaar FLASHDATA_API_KEY in de omgeving of gebruik de verborgen prompt van het script; Plak het nooit in de chat.

Bestaand verzoek, alleen voor mapping:

```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 met X-API-Key en dit JSON lichaam:

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

original_audio=true kiest gesproken taal. FlashData params.auto=true selecteert door YouTube gegenereerde bijschriften. Vermeld taal en herkomst apart.

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

Python 3.10+ vereist. Installeer de afhankelijkheid met python -m pip install requests. Sla het volledige onderstaande script in een nieuwe werkmap op als creator-research.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")
    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'))}")

```

Ren vanuit die map met behulp van een video met een bestaand Engels nummer. Metagegevens zijn een afzonderlijk optioneel verzoek; bij een tijdelijke proefperiode moet u minimaal één seconde tussen de gesprekken laten.

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

Voor door de uploader geleverde ondertiteling kunt u de handleiding --origin toevoegen. De standaardinstelling is door YouTube gegenereerde Engelse ondertiteling.

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

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

Voor door de uploader geleverde ondertiteling kunt u een handleiding bijvoegen. Elke nieuwe uitvoermap dient één verzoek in. Dezelfde argumenten en map hergebruiken opgeslagen uitvoer; gebruik een nieuwe map voor een opzettelijke vernieuwing na inspectie van de vorige poging.

### 3. Lees de in kaart gebrachte output en het daadwerkelijke gebruik

Bijschriften-001/normalized.json is een veldadapter; response.json behoudt de ruwe respons en het werkelijke gebruik. Seconden worden string milliseconden. languageCode en isAutoGenerated behouden de geselecteerde track. Dit is geen complete drop-in reactie: geen gefabriceerde credit balances, cache vlaggen, uploader attribution of datum velden. Metadata bewaart ontbrekende metrics als null en de oorspronkelijke 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 integratie | FlashData wijzigen |
| --- | --- |
| GET /v1/youtube/video?url=… | POST de zoekopdracht API met bron: youtube_metadata en video_id. Lees resultaten [0], niet de antwoordwortel. |
| GET /v1/youtube/video/transcript?url=… | Gebruik bron: youtube_transcript. Stel params.language en params.auto expliciet in. |
| transcriptie[].startMs / endMs | FlashData begin / einde zijn seconden. Vermenigvuldig elk met 1,000 en serialiseer als tekenreeksen voor een bestaande millisecondelezer. |
| original_audio=true | Selecteert de gesproken taal in ScrapeCreators, niet automatisch gegenereerde ondertiteling. Los de gewenste taal op in uw app; params.auto selecteert in plaats daarvan de oorsprong van het bijschrift. |
| taal en transcript_only_text | Kaart languageName en fullText. Bewaar languageCode apart; een taalnaam en een taalcode zijn verschillende velden. |
| viewCountInt, likeCountInt, commentCountInt | Kaart viewCount, likeCount, commentCount. Behoud null als een metriek ontbreekt. |
| durationMs en publishDate | Converteer duur seconden naar milliseconden. Bewaar uploadDate als onbewerkt veld totdat uw app de benodigde datumnotatie valideert. |
| kanaal / uploader / ownerByline | FlashData kanaal en channelId reproduceren niet alle drie de identiteiten. Breng alleen de velden in kaart die uw lezer nodig heeft; houd een apart pad aan voor de toekenning van muziekcredits. |
| cached, cached_at, credits_charged | Bewaar de ruwe respons en het gebruik van FlashData. Registreer uw eigen ophaaltijd; vervaardig geen cachevlaggen van providers en vertaal geen tegoeden tussen providers. |

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

### Als het eerste verzoek mislukt

- 401/403: controleer de opgeslagen sleutel en bronmachtiging; stop indien ingetrokken.
- 402: vul het eigenaarssaldo aan voordat u verdergaat.
- 429: lees de opgeslagen Retry-After header; verzoekfrequentie verminderen. Tijdelijke proefversies staan ​​één verzoek per seconde toe.
- Ontbrekend spoor: verifieer beschikbare taal en herkomst. ScrapeCreators kan een succesvol antwoord retourneren met een null transcript; verwar dit niet met een nummer completed FlashData.
- Time-out of onvolledige map: controleer de geschiedenis en uitvoer voordat u het opnieuw probeert. Scripts bewaren de poging zonder automatische herindiening.

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

<a id="workflow"></a>
## Zoek → shortlist → verrijk → citeer

| Stap | Werk | Vraag telling aan |
| --- | --- | --- |
| Ontdek | Voer P YouTube Zoekverzoeken uit | P standaard zoekopdrachten. Tel daadwerkelijke verzoeken, niet elke geretourneerde video als een afzonderlijke zoekopdracht. |
| Selecteer | Ontdubbelen en shortlist N video IDs | Lokale filtering; nog geen metadata- of ondertitelingsverzoek. |
| Verrijk | Haal metadata op voor de shortlist IDs | N metadataverzoeken; herhaal dit alleen als de statistieken moeten worden vernieuwd. |
| Citeer | Haal één bestaande ondertitelingstrack op per ID | N transcriptieverzoeken indien beschikbaar. Bewaar taal, oorsprong en cue-timings met de bron URL. |
| Hergebruik | Lees opgeslagen resultaten voor de volgende taak | Geen providerverzoek wanneer uw app zijn eigen opgeslagen bestand kan hergebruiken. |

Voor 10 zoekverzoeken plus 50 video's op de shortlist met metadata en bijschriften zijn 110 standaardverzoeken vereist voordat ze lokaal kunnen worden hergebruikt. Scheid ontdekkingskosten van verrijking. Een zoekresultaat is zelf geen afzonderlijke zoekopdracht.

### Zoeken is geen drop-in cursormigratie

ScrapeCreators kan verschillende resultaattypen retourneren met continuationToken. De standaardzoekopdracht van FlashData levert videoresultaten op; de Uitgebreide zoekopdracht heeft afzonderlijke limieten en prijzen. Start een nieuwe ontdekkingsrun in plaats van een oude cursor opnieuw te gebruiken.

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

### Bewaar bewijsmateriaal bij het antwoord

Bewaar de video ID, URL, de gekozen taal, de oorsprong van het bijschrift en de starttijd van het segment. Een citatielink kan naar dat tijdstempel verwijzen. Label een ontbrekend ondertitelingsspoor niet als een leeg, succesvol transcript.

[Recept met ondertiteling met tijdstempel](https://flashdata.dev/nl/docs/guides/timestamped-captions-recipe/reference.md)

### Scale de lijst ID afzonderlijk

Nadat één zoekopdracht werkt, gebruikt u batch-verzoeken voor een lijst of bulkverwerking voor een bestand. Volg taak IDs, sla uitvoer completed op en probeer alleen failed items opnieuw. Houd uw loper verantwoordelijk voor het schema.

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

<a id="agents"></a>
## Bewijs de migratie voordat u deze plant

In aanmerking komende agenten kunnen beginnen met 1 credit (tot 100 standaard YouTube Dataverzoeken) voor 72 uren. Metadata, bijschriften en zoekopdrachten delen de vergoeding.

1. Inspecteer de vereiste velden, de intentie van de bijschriften en de versheid ervan. Hergebruik opgeslagen toegang; houd niet-gerelateerde oproepen via sociale gegevens bij.
2. Voer één bekende video uit met CLI, SDK of MCP. Sla de uitvoer op en controleer de timing, nulwaarden en het daadwerkelijke gebruik.
3. De eigenaar logt in of registreert zich, verifieert de e-mail en keurt claims, scopes en gedeeld saldogebruik goed. Ongebruikte proeftegoeden worden niet overgedragen.
4. Bewaar de eigenaarsreferentie voor terugkerend gebruik. Hergebruik outputs en stop bij intrekking of onvoldoende saldo.

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

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

<a id="faq"></a>
## Voordat je overstapt

### Zijn dit maandabonnementen?

ScrapeCreators Freelance en Business zijn prepaidpakketten, geen abonnementen. Voor beide geldt een maandelijks bedrag van $0. FlashData heeft pay-as-you-go-tegoeden plus optionele maandabonnementen. Vergelijk het verbruikte verbruik en de benodigde aankoop apart van uw huidige saldo.

### Wat moet ik doen als de meeste van mijn ScrapeCreators-verzoeken in de cache worden opgeslagen?

Ondersteunde metadata en transcriptcache-hits kosten nul credits. Voer de waargenomen treffers in de rekenmachine in. Als uw app hun leeftijd accepteert, kunnen ze minder kosten dan nieuwe FlashData-aanvragen. U kunt de uitvoer van beide providers ook lokaal opslaan en voorkomen dat u het volgende verzoek helemaal hoeft in te dienen.

### Vervallen ongebruikte tegoeden?

ScrapeCreators zegt dat gekochte credits onder het huidige beleid niet verlopen. Het gratis startaanbod van 100-tegoed is geen maandelijkse bijvulling. De proeftijd van FlashData loopt af; op de prijs- en accountpagina's worden de toepasselijke voorwaarden voor het eigenaarssaldo beschreven.

### Zal original_audio=true werken als params.auto=true?

Nee. De eerste kiest een taal op basis van de gesproken audio; de tweede kiest YouTube-gegenereerde ondertitels. Stel bewust een taal en herkomst in. Het native caption-eindpunt van geen van beide services creëert spraak-naar-tekst wanneer een overeenkomende track ontbreekt.

### Kan ik al mijn sociale-dataoproepen vervangen?

Deze migratie omvat YouTube videometagegevens en bestaande ondertitels. Houd opmerkingen, communityposts, sociale profielen en andere niet-ondersteunde antwoordvelden op hun bestaande pad. FlashData biedt ook Google Zoeken en gehost YouTube Downloaden, met hun eigen machtigingen en prijzen.

### Ondersteunt ScrapeCreators ook AI-agents?

Ja. Het biedt MCP, OAuth, a CLI en agentvaardigheden. De agentstroom van FlashData voegt een in aanmerking komende tijdelijke proefperiode toe, waarbij de eigenaar claimt en inloggegevens opslaat voor voortgezet gebruik. Kies de API en workflow die uw taak nodig heeft; MCP ondersteuning alleen maakt niet het verschil.
