# Apify Alternatief voor YouTube Gegevens

Vergelijk FlashData met Apify YouTube actoren: acteurspecifieke prijzen, maandelijkse gebruiksbudgetten, workflows voor metadata en ondertiteling, en uitvoerbare Python en Bash migratievoorbeelden.

Van Actor-runs tot directe video-lookups. Begin met bekende IDs, behoud uw toepassingsvelden en verplaats één producent voordat u de rest van de pijplijn wijzigt.

Apify feiten herzien 2026-11-10. FlashData tarieven en trial emissierechten gebruiken de huidige openbare catalogi.

- [Kenmerken](#features)
- [Prijzen voor acteurs](#actors)
- [Kosten vergelijken](#costs)
- [Een zoekopdracht migreren](#migration)
- [Datasets en schema's](#production)
- [Voor AI-agenten](#agents)
- [Veelgestelde vragen](#faq)

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

### Houd gerichte zoekopdrachten voordelig

| Functie | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Betaald gebruik zonder maandelijks abonnement | Ja — Pay-as-you-go-tegoeden; opwaarderingen vanaf $10 | Gratis budget, daarna een betaald abonnement — $5/maand op Gratis; Starter $19/maand met $19 gebruik |
| Metagegevens voor 1,000 bekende video IDs | $0.50 — Gebruikstarief op basis van betalen | $3.00 — streamers/youtube-scraper · Starter-tarief, afgetrokken van het budget voor de planning |
| Zoeken in één video | Ja — Eén expliciete video_id | Acteur-afhankelijk — Streamers ondersteunt het; API Dojo sluit momenteel enkele video URLs uit |

### Vind en verrijk de video's die uw app nodig heeft

| Functie | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Zoekwoorden ontdekken met zoekfilters | Ja — Datum-, duur-, type- en sorteerfilters | Ja — searchQueries plus sorteer-, datum- en videofilters |
| Titel-, kanaal- en betrokkenheidsgegevens | Ja — Speciale metadata opzoeken per video ID | Ja — Video-opnamen in de Actor-gegevensset |
| Vernieuw metagegevens afzonderlijk van de bijschriften | Ja — Vraag slechts youtube_metadata aan voor de vernieuwing | Ja — Voer uit met transcriptionAndSubtitle=NONE |

### Bereid onderschriftbewijs voor uw aanvraag voor

| Functie | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Kies verschillende bestaande ondertitelingstalen | Maximaal 10 expliciete talen — Tracks plus fouten per taal in één transcriptverzoek | Hoofdrolspeler: één taal of welke taal dan ook — Verschillende actoren kunnen verschillende inputs blootleggen |
| Selecteer een strikte ondertiteloorsprong | Uploader of YouTube gegenereerd — params.auto selecteert één oorsprong; geen cross-origin fallback | Hoofdrolspeler: herkomstvoorkeur — preferAutoGeneratedSubtitles is een voorkeur, niet hetzelfde contract |
| Tekst met tijdstempel voor bronvermeldingen | Genormaliseerde JSON segmenten — Sms met start/end keer in seconden | SRT-, VTT- of XML-ondertitels — Parseer het geselecteerde ondertitelformaat voor citatietijden |
| Platte tekst voor samenvatting | fullText naast segmenten | ondertitelformaat in platte tekst — Of parseer en sluit je aan bij de getimede ondertiteluitvoer |
| Video's zonder bestaand transcript | Meld het ontbrekende spoor — Geen spraak-naar-tekstgeneratie | Optionele AI-transcriptie — Fallback- of altijd-transcribeermodi; afzonderlijke gebruikskosten |

### Voer de workflow uit met minder integratiecode

| Functie | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Direct resultaat zonder Actor-middelen te beheren | Realtime resultaten[] + gebruik — Geen acteur ID, build of geheugeninstelling | Acteursrun + invoerschema — Het synchronisatie-eindpunt kan ook resultaten retourneren in één HTTP-aanroep |
| Verwerk een opgeslagen lijst in een browserconsole | Bulk Jobs met een video-ID bestand — Volg de voortgang en haal de manifest- en resultaatdelen op | Acteurconsole met URL-ingangen — Ondersteunt het importeren van werkbladen CSV of Google |
| Achtergrondresultaten nadat de client de verbinding heeft verbroken | Opgeslagen async of bulkopdracht ID — Hervat statuscontroles en haal completed-uitvoer op | Opgeslagen Actor-run en dataset IDs — Inspecteer de run en haal de gegevenssetitems op |
| Uitvoerformaten voor applicaties en agenten | JSON, platte tekst of Markdown | Exporteren van gegevenssets — JSON, CSV, Excel en andere formaten |
| Terugkerende collectie | Uw planner of agenthost — Hergebruik de eigenaarsreferenties en de opgeslagen taakstatus | Programma's voor gehoste acteurs — Cron, tijdzone-instellingen en optionele webhooks |
| Metadata, bijschriften en Google zoeken in één API contract | Eén zoekopdracht API, bronspecifieke machtigingen — Gedeeld rekeningsaldo; bronspecifieke prijzen | Gedeeld platform; Acteurspecifieke schema's — Kies en onderhoud de relevante Actor-inputs en -outputs |
| CLI, SDK's en MCP voor automatisering | Ja — Zelfstandig CLI; Python, TypeScript en Go SDK's; MCP | Ja — Apify CLI, Python/JavaScript klanten en MCP |

Acteurspecifieke rijen verwijzen naar streamers/youtube-scraper tenzij een andere acteur wordt genoemd. Beide services bieden SDK's, CLI en MCP. Apify voert ook aangepaste code, gehoste schema's en scrapers van andere websites uit.

### Houd zoekopdrachten van één video klein

Geef een video ID door en ontvang direct metadata. Gebruik pay-as-you-go-toegang wanneer de taak geen platformabonnement of kanaalcrawl vereist.

### Behoud het datamodel van uw applicatie

Breng de velden in kaart die uw app daadwerkelijk leest. Bewaar null tellingen, houd publicatiedata expliciet en bewaar een JSON array voor consumenten die eerder datasetitems hebben gelezen.

### Houd ontdekking gescheiden van verrijking

Ga door met een nuttige ontdekkingsworkflow, ontdubbel de video IDs en verrijk vervolgens alleen de video's die uw product nodig heeft met FlashData.

<a id="actors"></a>
## Er is geen enkele prijs Apify YouTube

Acteurauteurs kiezen inputs, outputs en prijsmodellen. Deze drie actoren maken gebruik van gebeurtenissen per resultaat, maar hebben verschillende mogelijkheden. Onderstaande prijzen zijn USD per 1,000 geretourneerde video's.

| Acteur | Gratis / 1,000 video's | Starter | Scale | Business | Kies het voor |
| --- | --- | --- | --- | --- | --- |
| streamers/youtube-scraper | $4.00 | $3.00 | $2.60 | $2.40 | Video URLs, ontdekking en optionele bestaande ondertitels. Dit is de acteur van de rekenmachine. |
| streamers/youtube-channel-scraper | $1.30 | $1.00 | $0.80 | $0.50 | Kanaaldetectie met basisvideogegevens. Het is geen volledige opzoeking van metagegevens voor een willekeurige ID. |
| apidojo/youtube-scraper | $0.50 | $0.50 | $0.50 | $0.50 | Ontdekkingsingangen. De huidige README sluit single-video URLs uit en vereist minimaal 10 video's per invoer. Gratis demo: 5 runs/maand, maximaal 10 items/run. |

Zelfbedieningsmaandabonnementen: Starter verwijst naar Bronze, Scale naar Silver en Business naar Gold. De goedkopere ontdekkingsacteurs worden niet vervangen door de bekende videocalculator.

### Controleer de factureerbare gebeurtenis

Apify ondersteunt modellen voor betalen per gebeurtenis, betalen per gebruik en gecombineerde modellen. Tel voor streamers/youtube-scraper resultaatgebeurtenissen en geselecteerde add-ons; Voeg niet automatisch algemene rekenkosten toe. Inspecteer de evenementenspecificatie van uw eigen Actor-run.

### Scheid bestaande ondertitels van AI-transcriptie

De hoofdacteur kan bestaande ondertitels in zijn resultaat opnemen. De AI-transcriptie wordt gefactureerd per gestarte minuut per video: op Starter voegt een video van 10 minuten $0.41 toe vóór de resultaatgebeurtenis $0.003. AI-samenvattingen, beschrijvingen en kanaaldatumfiltering hebben ook hun eigen evenementprijzen. FlashData haalt bestaande nummers op; er worden geen ontbrekende bijschriften gegenereerd.

### Houd ontdekking gescheiden van verrijking

Gebruik bekende video IDs als uw app dat al heeft. Een ontdekkingscrawl kan video's retourneren die je nooit gebruikt. Budgetdetectie en eventuele daaropvolgende verrijking afzonderlijk.

<a id="costs"></a>
## Vergelijk eenheidstarieven en maandelijkse kosten

USD, maandelijkse lijstplannen. Dit model gebruikt de resultaatgebeurtenis van streamers/youtube-scraper, één geretourneerde video per invoer ID, met datumfiltering en AI-add-ons uitgeschakeld. Bestaande ondertitels gebruiken de instelling ALWAYS_SUBTITLES; metadata plus bijschriften is één Actor-resultaat maar twee FlashData-verzoeken. FlashData prijzen zijn afkomstig uit de huidige YouTube gegevenscatalogus. Het volledige inbegrepen saldo van elk plan wordt aan deze workflow toegewezen voordat er extra gebruik wordt toegevoegd. Apify Gratis stops binnen het budget $5; betaalde abonnementen voegen gebruik toe boven het inbegrepen budget. Bij FlashData aankopen vanaf een nulsaldo is de minimale opwaardering van $10 inbegrepen als er extra tegoed nodig is. Belastingen, jaarlijkse kortingen, andere Actoren, aparte opslag/export kosten en failed pogingen zijn uitgesloten. Bij nul video's heeft een geselecteerd betaald abonnement nog steeds zijn maandelijkse kosten; De effectieve kosten per video zijn niet gedefinieerd.

### Apify platformplannen

| Apify plan | Maandelijkse kosten | Inbegrepen gebruik / maand | Hoofdacteur / 1,000 video's | Video's binnen dit budget |
| --- | --- | --- | --- | --- |
| Gratis | $0.00 | $5.00 | $4.00 | 1,250 |
| Starter | $19.00 | $19.00 | $3.00 | 6,333 |
| Scale | $199.00 | $199.00 | $2.60 | 76,538 |
| Business | $999.00 | $999.00 | $2.40 | 416,250 |

Met deze tellingen wordt het volledige budget toegewezen aan resulterende evenementen zonder add-ons of ander platformgebruik. Als je Apify behoudt voor andere acteurs, blijft het abonnement behouden; vergelijk het incrementele gebruik met uw resterende budget.

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

Dit zijn standaard YouTube datasnelheden. Uitgebreid zoeken en downloaden hebben aparte prijzen. [Volledige prijzen](https://flashdata.dev/nl/pricing/youtube-data).

### Uitgewerkte voorbeelden

FlashData betalen naar gebruik versus Apify Starter en streamers/youtube-scraper. Metagegevens plus bestaande ondertitels vormen één Actor-resultaatgebeurtenis, maar twee FlashData-verzoeken. Dit zijn gebruiks- en maandelijkse kostenschattingen, geen claim van identieke antwoordvelden.

| Video's | Werkstroom | FlashData verzoeken | FlashData gemodelleerd gebruik | Gebruik van acteursevenementen | Apify maandelijkse kosten inclusief vergoeding |
| --- | --- | --- | --- | --- | --- |
| 1,000 | Metagegevens voor bekende video IDs | 1,000 | $0.50 | $3.00 | $19.00 |
| 1,000 | Metadata + bestaande bijschriften | 2,000 | $1.00 | $3.00 | $19.00 |
| 10,000 | Metagegevens voor bekende video IDs | 10,000 | $5.00 | $30.00 | $30.00 |
| 10,000 | Metadata + bestaande bijschriften | 20,000 | $10.00 | $30.00 | $30.00 |
| 100,000 | Metagegevens voor bekende video IDs | 100,000 | $50.00 | $300.00 | $300.00 |
| 100,000 | Metadata + bestaande bijschriften | 200,000 | $100.00 | $300.00 | $300.00 |

FlashData aankopen vanaf een nulsaldo hebben een minimale opwaardering van $10. Het tarief van Apify omvat al het inbegrepen gebruik; voeg dat gebruik niet twee keer toe. Met de rekenmachine HTML kunt u beide plannen onafhankelijk kiezen.

### Gratis toegang

Apify Gratis heeft een maandelijks gedeeld budget van $5; Er kunnen ook individuele demobeperkingen voor acteurs van toepassing zijn. De hierboven getoonde API Dojo-acteur beperkt Gratis tot vijf demoruns per maand en tien items per run.

In aanmerking komende geverifieerde FlashData-aanmeldingen kunnen een initiële vergoeding ontvangen van maximaal 4,000 standaard YouTube Dataverzoeken. Dit wordt niet maandelijks gereset.

<a id="migration"></a>
## Bewaar de datasetlezer; één zoekopdracht vervangen

Begin met een bekende openbare video ID. In het voorbeeld worden geselecteerde bekende actorvelden geschreven als een JSON-array en wordt het volledige FlashData-antwoord afzonderlijk opgeslagen.

### 1. Toegang instellen en de aanvraag in kaart brengen

Maak of hergebruik een sleutel met toestemming youtube_metadata in [API Toetsen](https://flashdata.dev/app/api-keys) en vink [beschikbare kredieten](https://flashdata.dev/app/billing) aan. Agenten moeten de toegang eerst opnieuw gebruiken of een in aanmerking komende proefversie gebruiken. Bewaar sleutels buiten de chat.

Bestaande acteuroproep, ter referentie voor migratie:

```bash
# The existing Actor call, shown for migration reference.
curl --fail-with-body --silent --show-error --max-time 310 \
  --request POST \
  'https://api.apify.com/v2/acts/streamers~youtube-scraper/run-sync-get-dataset-items' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"startUrls":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}],
    "maxResults":1,"maxResultsShorts":0,"maxResultStreams":0,
    "transcriptionAndSubtitle":"NONE","aiVideoDescription":false,"aiVideoSummary":false}'
```

FlashData JSON lichaam voor POST /v1/queries/realtime:

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

Het Actor-synchronisatie-eindpunt kan al items retourneren in één HTTP antwoord. Migreer het verzoek, de envelop en de velden; voeg geen onnodige polling toe.

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

Kies Python of Bash. Elke nieuwe uitvoermap dient één verzoek in. Als u de map opnieuw gebruikt, wordt de opgeslagen uitvoer gelezen; onderbroken of failed pogingen stoppen voor inspectie. Beide versies gebruiken dezelfde bestanden.

#### 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 video-lookup.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("video_id")
parser.add_argument("folder", type=Path)
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")
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
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 = 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 != 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") != body["source"]:
    raise SystemExit("Request did not complete successfully; inspect response.json")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict):
    raise SystemExit("Expected one metadata result")
item = items[0]
if item.get("videoId") != args.video_id:
    raise SystemExit("Returned video does not match the request")
seconds = item.get("duration")
duration = None
if seconds is not None:
    if type(seconds) not in (int, float) or not math.isfinite(seconds) or seconds < 0:
        raise SystemExit("Invalid duration")
    whole = int(seconds)
    duration = f"{whole // 3600:02d}:{whole % 3600 // 60:02d}:{whole % 60:02d}"
mapped = [{
    "id": item["videoId"],
    "url": "https://www.youtube.com/watch?v=" + item["videoId"],
    "title": item.get("title"), "text": item.get("description"),
    "channelName": item.get("channel"), "channelId": item.get("channelId"),
    "viewCount": item.get("viewCount"), "likes": item.get("likeCount"),
    "commentsCount": item.get("commentCount"), "duration": duration,
    "uploadDateRaw": item.get("uploadDate"),
    "captionLanguages": item.get("transcriptLanguages"),
}]
(out / "dataset-items.json").write_text(
    json.dumps(mapped, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/dataset-items.json; actual usage: {json.dumps(data.get('usage'))}")

```

Voer het uit vanuit die map en vervang de ID door een openbare video uit uw dataset:

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

#### Bash

Vereist Bash, cURL 7.76+ en jq 1.6+. Sla het volledige script hieronder op als video-lookup.sh in uw werkmap:

```bash
#!/usr/bin/env bash
set -euo pipefail
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Set OUTPUT_FOLDER}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || { echo 'Invalid video ID' >&2; exit 1; }
body=$(jq -n --arg id "$video_id" '{source: "youtube_metadata", video_id: $id,
  params: {include_formats: false, include_chapters: true}}')
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 this 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 status, response and Retry-After header.\n' >&2; exit 1;
}
mapped=$(jq -e --arg id "$video_id" '
  def pad: tostring | if length < 2 then "0" + . else . end;
  def hms:
    if . == null then null
    elif type != "number" then error("Invalid duration")
    elif (isfinite | not) or . < 0 then error("Invalid duration")
    else floor | [(./3600 | floor | pad), ((.%3600)/60 | floor | pad), (.%60 | pad)] | join(":") end;
  if .source != "youtube_metadata" 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 != $id then error("Wrong video") else . end
  | [{id: .videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
      title, text: .description, channelName: .channel, channelId,
      viewCount, likes: .likeCount, commentsCount: .commentCount,
      duration: (.duration | hms), uploadDateRaw: .uploadDate,
      captionLanguages: .transcriptLanguages}]' "$out/response.json")
printf '%s\n' "$mapped" > "$out/dataset-items.json"
printf 'Saved %s/dataset-items.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

Uitvoeren vanuit die map:

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

### 3. Lees de opgeslagen uitvoer

video-001/dataset-items.json is een array voor uw applicatielezer. response.json behoudt het oorspronkelijke resultaat en gebruik. Dit is een veldadapter, niet de Apify Dataset API. Het maakt geen dataset ID, populeert onbekende metrics of fabriceert opmerkingen of geldvelden.

Illustratief dataset-items.json:

```json
[
  {
    "id": "FUfGcZ092b0",
    "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
    "title": "Example video",
    "text": "Example description",
    "channelName": "Example channel",
    "channelId": "UC_EXAMPLE",
    "viewCount": 1200,
    "likes": null,
    "commentsCount": null,
    "duration": "00:03:17",
    "uploadDateRaw": "2025-01-15",
    "captionLanguages": [
      "en",
      "es"
    ]
  }
]
```

| Veld Bestaande acteur | FlashData metagegevens | Migratie actie |
| --- | --- | --- |
| ID/URL | videoId | Behoud id en construeer de canonieke YouTube watch URL. |
| titel / tekst | titel / beschrijving | Wijs de beschrijving toe aan tekst als uw lezer de veldnaam van de Acteur verwacht. |
| channelName / channelId | kanaal / channelId | Behoud de naam en ID. Leid een kanaalingang niet af op basis van de weergavenaam. |
| vind-ik-leuks / commentsCount / viewCount | likeCount / commentCount / viewCount | Behoud ontbrekende waarden als null. Een ontbrekende metriek is niet nul. |
| duur, vaak UU:MM:SS | duur in seconden | In het voorbeeld worden seconden omgezet in een tekenreeks UU:MM:SS, waarbij null behouden blijft. |
| datum, die absoluut of relatief kan zijn | uploadDate | In het voorbeeld blijft uploadDateRaw behouden. Voeg uw eigen datumparser toe voordat u een genormaliseerde datum invult. |
| ondertitels[] / transcriptionUrl | Een afzonderlijk youtube_transcript of youtube_captions verzoek | Bestaande tracks en gegenereerde spraak-naar-tekst zijn verschillende invoergegevens voor uw app. |
| Verrijkingsvelden alleen voor acteurs | Geen automatisch equivalent | Houd een aparte verrijkingsstap aan voor opmerkingen, kanaaluitbreiding en door AI gegenereerde analyses. |

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

### Draag de intentie van de ondertiteling over

| Inbreng van de hoofdacteur | FlashData migratie |
| --- | --- |
| ALWAYS_SUBTITLES | Voeg een afzonderlijk youtube_transcript of youtube_captions verzoek toe voor bestaande tracks. |
| subtitlesLanguage | Gebruik params.language. Een array van maximaal 10 talen retourneert tracks plus fouten per taal. |
| preferAutoGeneratedSubtitles | Dit is een voorkeur. FlashData params.auto selecteert strikt YouTube-gegenereerde of door uploader geleverde ondertitels, zonder terugval van verschillende oorsprong. |
| TRANSCRIPTION_AS_FALLBACK / ALWAYS_TRANSCRIBE | Houd spraak-naar-tekst gescheiden; FlashData genereert geen ontbrekend nummer. |
| ondertitels[].srt / transcriptionUrl | Wijs tijdstempelsegmenten toe of formatteer een bestand expliciet. Een gegenereerde platte tekst URL is geen segmentarray met tijdstempel. |

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

<a id="production"></a>
## Datasets, lange-running taken en planningen

Als uw tools afhankelijk zijn van Apify dataset IDs en schema's, gebruik dan een aangepaste Actor als orkestrator: roep FlashData erin aan en schrijf de toegewezen items in de dataset. Budgeteer de runtime en opslag van Actor naast het gebruik van FlashData. De bovenstaande rekenmachine modelleert directe FlashData-oproepen.

| Bezorgdheid | Apify | FlashData |
| --- | --- | --- |
| Verzoek | Acteur ID + build/input opties; optioneel opgeslagen taak | bron + video_id + parameters; geen acteur-build of geheugenopties |
| Synchronisch resultaat | run-sync-get-dataset-items retourneert een itemarray; de gedocumenteerde HTTP limiet is 300 seconden | Realtime respons heeft status, resultaten [] en gebruik; resultaten extraheren voordat velden worden toegewezen |
| Lang-running werk | Start een run, sla run ID op, wacht op een terminalstatus, lees defaultDatasetId | Dien een taak async of batch in, sla de taak ID op, controleer de status ervan en haal het resultaat op |
| Uitgangsopslag | Gegevenssetitems plus optionele sleutelwaarderecords waarnaar wordt verwezen met URL | Bewaar het antwoord of exporteer naar uw eigen duurzame opslag; een Apify dataset ID is geen FlashData taak ID |
| Terugkerende werkzaamheden | Apify Schema start Acteurs/Tasks; webhooks stellen downstream-consumenten op de hoogte | Gebruik uw applicatie, cron, CI of agenthost om FlashData te bellen; migreer het schema en de consument samen |

### Verplaats een bestaande gegevensset

Exporteer elke pagina van de bestaande dataset voordat u van producent verandert. Blijf verwijzen naar ondertitelbestanden die je nog nodig hebt. Voer een Actor niet opnieuw uit alleen maar om reeds verzamelde uitvoer te downloaden.

[Bewaar en hergebruik resultaten](https://flashdata.dev/nl/docs/guides/save-results/reference.md)

### Vernieuw een videobibliotheek

Ontdubbel video IDs, controleer elk resultaat en behoud input-to-output IDs. Gebruik batch- of bulkverwerking voor grotere lijsten; probeer failed items opnieuw nadat u de fouten ervan hebt gecontroleerd.

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

### Houd geplande werkzaamheden voorspelbaar

Draag tijdzone, cadans, inloggegevens en uw uitvoerbestemming over. Neem één planningsvenster van completed op voordat u de oude producent met pensioen gaat, zodat overlappende planningen geen dubbel werk creëren.

[Voer terugkerende taken uit](https://flashdata.dev/nl/docs/guides/recurring-tasks/reference.md)

### Controlelijst voor omschakeling

1. Registreer de exacte actor, build, taakinvoer, factureerbare gebeurtenissen, uitvoervelden en downstream-consument.
2. Maak bestaande runs leeg en exporteer alle datasetpagina's. clean=true kan records overslaan, dus een korte pagina alleen is geen bewijs dat de export voltooid is; controleer de metagegevens van de paginering.
3. Controleer de adapter aan de hand van opgeslagen IDs, inclusief null-statistieken, datums en oorsprong van het bijschrift.
4. Verplaats de cadans, tijdzone en bestemming naar uw hardloper. Houd controlepunten aan. maxTotalChargeUsd is geen bestedingslimiet met een FlashData API-toets; voeg uitgavencontroles op applicatieniveau toe.
5. Wijzig de producent voor het volgende planningsvenster zonder dubbele runs. Behoud de export. Stop met terugkerende werkzaamheden aan ingetrokken inloggegevens of onvoldoende saldo.

<a id="agents"></a>
## Codering en persoonlijke agenten

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

1. Identificeer de Actor-integratie en hergebruik eerst een bestaande FlashData-referentie.
2. Bewijs één video-opzoeking en sla zowel onbewerkte als toegewezen uitvoer op met daadwerkelijk gebruik.
3. De eigenaar logt in of registreert zich, verifieert de e-mail en keurt claims, bereiken en toegang tot gedeeld saldo goed. Ongebruikte proeftegoeden worden niet overgedragen.
4. Bewaar de eigenaarsreferentie voor terugkerend gebruik. Stoppen bij intrekking; maak geen nieuwe proeven.

```text
Replace this project's Apify YouTube metadata lookup with FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_metadata/reference.md.
Identify the exact Actor ID, build, input, output fields, schedule and storage consumer first.
Reuse a saved FlashData credential or start one eligible trial with youtube_metadata permission.
Run one known video ID. Save the raw response, actual usage and a mapped JSON item array.
Keep null metrics and preserve the raw publication date. Do not invent Actor-only fields.
Keep channel discovery, comments, AI transcription and hosted scheduling separate unless explicitly migrated.
Reuse saved results after restart. Ask the owner to claim before recurring use and store keys outside chat.
Stop after revocation or insufficient balance; never create more trials to continue.
```

[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

### Is dit een vervanging voor het Apify-platform?

Het vervangt specifieke YouTube dataoproepen in uw workflow. Apify biedt ook een Actor-marktplaats, aangepaste runtimes, gehoste schema's en opslag. Bewaar die onderdelen waar u ze gebruikt, of verplaats de verantwoordelijkheden ervan naar uw eigen toepassing.

### Waarom vergelijkt u niet elke acteur voor één prijs?

Acteur-ontwikkelaars kiezen verschillende prijsmodellen, outputs en inputbeperkingen. De rekenmachine gebruikt streamers/youtube-scraper. De acteurstabel bevat ook een goedkopere ontdekkingsacteur; de beperkingen voor één video zijn van belang bij het vervangen van een zoekopdracht op aanvraag.

### Brengt een abonnement van Apify tweemaal kosten in rekening voor het inbegrepen gebruik?

Nee. De abonnementskosten omvatten een vooraf betaald gebruiksbudget. De rekenmachine trekt dat budget af voordat er verder Actor-gebruik aan wordt toegevoegd. Er wordt van uitgegaan dat het volledige budget beschikbaar is voor deze workflow. Als andere actoren het consumeren, blijft er minder over voor YouTube.

### Kan ik een Apify datasetconsument behouden?

In het voorbeeld wordt een array JSON geschreven met geselecteerde bekende veldnamen. Er wordt geen gegevensset Apify gemaakt en er wordt geen ID uitgevoerd. Lees het nieuwe bestand rechtstreeks, publiceer het via uw eigen opslag of gebruik een aangepaste Actor die deze toegewezen items naar de dataset voor uw bestaande consument schrijft.

### Wat gebeurt er met ondertitels en AI-transcriptie?

De hoofdrolspeler van Apify biedt bestaande ondertitels en optionele AI-transcriptie. FlashData haalt bestaande YouTube tracks op. Vraag metadata en bijschriften afzonderlijk aan, controleer de geretourneerde taal en herkomst en houd eventuele spraak-naar-tekst- of AI-samenvattingsstappen gescheiden.

### Wordt mijn bestaande schema of bestedingslimiet overgedragen?

Nee. Maak het schema opnieuw voor de door u gekozen hardloper en voeg een budgetcontrole op toepassingsniveau toe. Een instelling van Apify maxTotalChargeUsd is geen bestedingslimiet met een sleutel van FlashData API. Eigenaarsleutels gebruiken het gedeelde accountsaldo.
