# Oxylabs Alternative aux données YouTube | FlashData

Comparez FlashData et Oxylabs pour les métadonnées et les légendes YouTube : unités de facturation, coûts d'abonnement, accès des agents et migration Python/Bash depuis Classic ou Web API.

Recherche vidéo sans engagement mensuel. Déplacez les tâches de métadonnées et de sous-titres vers FlashData PAYG tout en préservant la langue, l'origine et l'horodatage.

Cette page couvre les données YouTube. [Oxylabs Alternative SERP](https://flashdata.dev/fr/compare/oxylabs/reference.md) couvre Google Recherchez séparément.

Les faits de Oxylabs ont examiné 2026-11-10; Les prix et quotas FlashData utilisent ses catalogues publics actuels.

- [Caractéristiques](#features)
- [Tarifs](#pricing)
- [Migrations](#migration)
- [Production & agents](#production)
- [Questions](#faq)

<a id="features"></a>
## Comparaison des fonctionnalités

### Flexible dépenses pour la recherche vidéo

| Caractéristique | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Utilisation payante sans abonnement mensuel | Oui — PAYG ; les recharges de crédit commencent à $10 | Non — Le libre-service payant actuel nécessite un abonnement actif |
| Recherche de métadonnées uniquement · 1,000 vidéos | $0.50 — 1,000 requêtes source standard · PAYG | Confirmer le taux du point final — Le prix des données vidéo publiques API est par Go, pas un devis de demande de métadonnées |
| Recherche sous-titres uniquement · 1,000 vidéos | $0.50 — Une piste existante sélectionnée par vidéo · PAYG | Point de terminaison dédié aux sous-titres — Confirmez son unité de facturation dans votre compte |
| Recherche Google partagée et solde YouTube | Oui | Oui — Solde créditeur des produits partagés |

### Rechercher des vidéos et actualiser leurs métadonnées

| Caractéristique | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Découverte de mots clés et suggestions de recherche | Oui — Sources de recherche, de recherche étendue et de suggestions | Oui — YouTube recherche, recherche/max et points de terminaison de saisie semi-automatique |
| Métadonnées pour une vidéo connue ID | Oui — Titre, chaîne, durée, miniatures et nombre d'engagements | Oui — Le point de terminaison de métadonnées dédié accepte une vidéo ID |
| Chapitres et langues de sous-titres disponibles | Oui — Chapitres facultatifs plus transcriptLanguages | Oui — Marqueurs de chapitre et langues de sous-titres dans les métadonnées |

### Contrôlez quelles preuves de sous-titres parviennent à votre application

| Caractéristique | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Récupérer les légendes indépendamment des métadonnées | Oui — Sources de transcription et de sous-titres dédiées | Oui — Point de terminaison dédié aux sous-titres YouTube |
| Sélectionnez la langue et l'origine des sous-titres | Oui — Langage explicite et sélection automatique | Oui — language_code et subtitle_origin |
| Plusieurs langues en une seule demande | Jusqu'à 10 langues sélectionnées — Un tableau de langage explicite renvoie les pistes et les erreurs | Une langue sélectionnée ou toutes — Omettez language_code pour toutes les langues ; omettre subtitle_origin pour les deux origines |
| Texte et timing des citations de sources | Segments normalisés + fullText — JSON start/end fois en secondes | YouTube charges utiles de la piste de sous-titres — Texte et horaires regroupés par langue et origine |
| Pistes demandées indisponibles | Erreurs par langue dans les requêtes de tableau — Gardez des traces de réussite ; inspecter les erreurs même lorsque le statut est done | Résultat vide pour une piste manquante — Un code de langue valide sans correspondance renvoie {} |
| Préparer les données pour une candidature ou un LLM | JSON, texte brut ou Markdown — Sélectionnez le format de réponse et de contenu API | Suivre les données ou extraire JSON personnalisé — L'extraction de sous-titres accepte une invite ou un schéma |

### Traitez les listes et gardez l’accès des agents réutilisable

| Caractéristique | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Modes interactif, async et batch | Oui — Même forme de requête source dans tous les modes d'exécution | Oui — Les métadonnées Web API et les sous-titres prennent en charge la synchronisation, async et batch |
| Soumettre une liste de vidéos préparée | ID fichier dans Bulk Jobs — Console ou API ; surveiller les progrès et récupérer les parties des résultats | Tableau ID dans le lot API — Les paramètres partagés s'appliquent à chaque tâche dans le batch |
| Enregistrez une grande collection dans votre stockage | Manifestes en masse et parties de résultats — Stockage géré ou client pour la production en masse | Livraison de stockage asynchrone — S3, stockage compatible S3, GCS et TOS |
| Essai d'agent avant la configuration du compte propriétaire | Oui — Agents éligibles : jusqu'à 100 demandes standards, puis propriétaire réclamant | Créez d'abord un compte — $5 crédit de bienvenue unique par équipe |
| Autonome CLI sans Node.js ou Python | Oui — Linux, macOS et Windows | HTTP API, MCP et compétences — Aucun binaire autonome équivalent vérifié dans les documents d'installation examinés |
| MCP et compétences pour un agent hébergeur | Oui — Réutiliser l'accès propriétaire approuvé pour les tâches en cours | Oui — Web API MCP compétences serveur et agent |

### Gardez les recherches occasionnelles abordables

FlashData le paiement au fur et à mesure n'a pas de frais mensuels. Récupérez les vidéos dont votre tâche a besoin et conservez un solde pour Google Recherche et YouTube.

### Budget dans les demandes source

Comptez séparément la récupération des métadonnées et des légendes. Une actualisation des métadonnées ne nécessite pas une autre demande de sous-titre ; une piste de sous-titres enregistrée peut servir à une analyse ultérieure.

### Conservez les preuves, pas seulement le résumé

Enregistrez le texte de la légende avec sa langue, son origine et son horodatage. Les exemples de migration créent des liens sources pour chaque segment et préservent la réponse brute et l'utilisation.

<a id="pricing"></a>
## Comparez les forfaits et les unités de facturation

| Forfait FlashData | Par 1,000 requêtes | Frais mensuels | Requêtes incluses par mois |
| --- | --- | --- | --- |
| Paiement à l’usage | $0.50 | $0.00 | 0 |
| Micro | $0.40 | $49.00 | 125,000 |
| Starter | $0.35 | $199.00 | 571,428 |
| Pro | $0.30 | $499.00 | 1,666,666 |
| Scale | $0.25 | $999.00 | 4,000,000 |
| Business | $0.20 | $1,999.00 | 10,000,000 |

FlashData compte une recherche de métadonnées et une recherche de légende comme deux requêtes par vidéo. Les décomptes inclus allouent l'intégralité du solde partagé aux données standard YouTube ; La recherche étendue et le téléchargement utilisent des tarifs distincts. Les recharges PAYG commencent à $10. [Tarif complet](https://flashdata.dev/fr/pricing/youtube-data).

| Forfait Oxylabs | Frais mensuels | Solde partagé inclus | Taux de données vidéo publiées API | Métadonnées incluses/caption requêtes |
| --- | --- | --- | --- | --- |
| Starter | $15.00 | $15.00 | $2.00/GB | Aucun décompte fixe publié |
| Basic | $100.00 | $100.00 | $2.00/GB | Aucun décompte fixe publié |
| Flexible | $500.00 | $500.00 | $1.60/GB | Aucun décompte fixe publié |

Enterprise commence à $2,500/mois avec des conditions personnalisées. USD ; Taxes, autres utilisations de produits et contrats personnalisés exclus.

Oxylabs répertorie les données vidéo API en Go. Sa table publique n'établit pas de prix par requête pour les points de terminaison des métadonnées et des sous-titres. Utilisez l'unité de facturation et le tarif de votre compte pour ces appels ; le prix générique Scrape « from » n’est pas un devis YouTube. Une allocation de Go ne peut pas être convertie en un nombre fixe de vidéos.

Le libre-service payant Oxylabs utilise un abonnement actif et un solde créditeur mensuel partagé. Le solde inutilisé expire au moment du renouvellement ; le service s'arrête à zéro jusqu'à une recharge ou une mise à niveau. Le crédit de bienvenue $5 est une allocation d'équipe unique et non un quota mensuel. Les contrats classiques ou personnalisés existants peuvent avoir des conditions différentes.

Les inscriptions admissibles vérifiées FlashData peuvent recevoir une allocation initiale allant jusqu'à 4,000 standard YouTube. Il s'agit d'un solde initial, et non d'un quota mensuel.

<a id="migration"></a>
## Migrer une piste de sous-titres existante

### 1. Identifier la demande existante

Il s'agit de demandes de référence pour le même morceau en anglais généré par YouTube. Les deux utilisent une vidéo ID, pas une URL. Classic utilise des entrées de contexte ; Web API utilise des options de niveau supérieur.

```bash
# Existing Classic request; use your current credential environment.
curl --fail-with-body --silent --show-error \
  --user "$OXYLABS_USERNAME:$OXYLABS_PASSWORD" \
  --header 'Content-Type: application/json' \
  --data '{
    "source": "youtube_subtitles",
    "query": "FUfGcZ092b0",
    "context": [
      {"key": "language_code", "value": "en"},
      {"key": "subtitle_origin", "value": "auto_generated"}
    ]
  }' \
  'https://realtime.oxylabs.io/v1/queries'
```

```bash
# Newer Web API request; query is a video ID, not a URL.
curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $OXYLABS_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "query": "FUfGcZ092b0",
    "language_code": "en",
    "subtitle_origin": "auto_generated"
  }' \
  'https://webapi.oxylabs.io/v1/scrape/media/youtube/subtitles'
```

### 2. Configurez FlashData et enregistrez les fichiers

Créez ou réutilisez une clé avec l'autorisation youtube_captions. [API Clés](https://flashdata.dev/app/api-keys) · [Crédits disponibles](https://flashdata.dev/app/billing). Lisez FLASHDATA_API_KEY depuis le magasin secret ou utilisez l'invite cachée du script. Gardez les informations d'identification hors du chat et du contrôle de source.

Créez youtube-migration/ et enregistrez-le sous youtube-migration/request.json:

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

Python 3.10+ requis. Installez la dépendance avec python -m pip install requests. Dans un nouveau dossier de travail, enregistrez le script complet ci-dessous sous youtube-migration/captions.py avant de l’exécuter.

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

import requests

parser = argparse.ArgumentParser()
parser.add_argument("folder", help="New output folder, or an existing saved caption request")
out = Path(parser.parse_args().folder)

if not out.exists():
    body = Path("request.json").read_bytes()
    request = json.loads(body)
    if (not isinstance(request, dict) or request.get("source") != "youtube_captions"
            or not isinstance(request.get("video_id"), str)
            or not re.fullmatch(r"[A-Za-z0-9_-]{11}", request["video_id"])):
        raise SystemExit("Use youtube_captions and an 11-character video_id")
    options = request.get("params")
    if (not isinstance(options, dict) or not isinstance(options.get("language"), str)
            or not re.fullmatch(r"[A-Za-z0-9-]{1,35}", options["language"])
            or type(options.get("auto")) is not bool):
        raise SystemExit("Set one language code and auto: true or false explicitly")
    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()
    (out / "request.json").write_bytes(body)
    (out / "requested-at.txt").write_text(
        datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), encoding="utf-8"
    )
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime",
            headers={"X-API-Key": key, "Content-Type": "application/json",
                     "Accept": "application/json"},
            data=body, timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit(f"Request interrupted. Keep {out} and check History before retrying.")
    (out / "result.json").write_bytes(response.content)
    (out / "response-headers.txt").write_text(
        "\n".join(f"{k}: {v}" for k, v in response.headers.items()), encoding="utf-8"
    )
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
else:
    print(f"Reading saved response from {out}; no API call.")

if not (out / "http-status.txt").exists():
    raise SystemExit("Incomplete attempt. Keep the folder and check History before retrying.")
status = (out / "http-status.txt").read_text().strip()
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect {out}/result.json and response-headers.txt")
try:
    data = json.loads((out / "result.json").read_bytes())
except ValueError:
    raise SystemExit("Invalid JSON; inspect the saved result.json")
request = json.loads((out / "request.json").read_bytes())
if not isinstance(data, dict) or data.get("source") != "youtube_captions" or data.get("status") != "done":
    raise SystemExit("Caption request did not finish successfully; inspect result.json")
tracks = data.get("results")
if not isinstance(tracks, list) or len(tracks) != 1 or not isinstance(tracks[0], dict):
    raise SystemExit("Expected one caption track; inspect result.json")
track = tracks[0]
language = request["params"]["language"]
allowed_languages = [language]
if request["params"]["auto"] and not language.endswith("-orig"):
    allowed_languages.append(language + "-orig")
if (track.get("videoId") != request["video_id"]
        or track.get("languageCode") not in allowed_languages
        or track.get("requestedLanguageCode", track.get("languageCode")) != language
        or track.get("isAutoGenerated") is not request["params"]["auto"]):
    raise SystemExit("Returned video, language or caption origin does not match the request")
if not isinstance(track.get("segments"), list):
    raise SystemExit("Expected a segments array; inspect result.json")
segments = []
for cue in track["segments"]:
    if not isinstance(cue, dict):
        raise SystemExit("Expected caption segment objects")
    start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
    if (type(start) not in (int, float) or not math.isfinite(start) or start < 0
            or type(end) not in (int, float) or not math.isfinite(end) or end < start
            or not isinstance(text, str)):
        raise SystemExit("Invalid caption timing or text; inspect result.json")
    segments.append({**cue, "url": f"https://www.youtube.com/watch?v={track['videoId']}&t={math.floor(start)}s"})
captions = {**track, "segments": segments}
record = {"request": request, "requested_at": (out / "requested-at.txt").read_text().strip(),
          "usage": data.get("usage"), "segment_count": len(segments), "result_file": "result.json"}
for filename, value in (("captions.json", captions), ("record.json", record)):
    (out / filename).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Saved {len(segments)} segments to {out}/captions.json")
if not any(cue["text"].strip() for cue in segments):
    print("No caption text to cite. Keep the empty track and report the gap.")

```

Depuis youtube-migration/, exécutez :

```bash
python captions.py track-001
python -m json.tool track-001/captions.json
python -m json.tool track-001/record.json
```

Vous pouvez également utiliser Bash, cURL 7.76+ et jq 1.6+. Enregistrez le script complet sous youtube-migration/captions.sh:

```bash
#!/usr/bin/env bash
set -euo pipefail
out="${1:?Usage: bash captions.sh OUTPUT_FOLDER}"

if [[ ! -e "$out" ]]; then
  jq -e '.source == "youtube_captions" and
    (.video_id | if type == "string" then length == 11 and test("^[A-Za-z0-9_-]{11}$") else false end) and
    (.params.language | if type == "string" then length > 0 and length <= 35 and
      (test("[^A-Za-z0-9-]") | not) else false end) and
    (.params.auto | type == "boolean")' request.json > /dev/null
  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 -- "$out"
  cp request.json "$out/request.json"
  date -u +'%Y-%m-%dT%H:%M:%SZ' > "$out/requested-at.txt"
  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" \
    --dump-header "$out/response-headers.txt" --output "$out/result.json" \
    --write-out '%{http_code}' > "$out/http-status.txt" || {
      printf 'Request failed. Keep %s and inspect its saved files before retrying.\n' "$out" >&2
      exit 1
    }
else
  printf 'Reading saved response from %s; no API call.\n' "$out"
fi

if [[ ! -f "$out/http-status.txt" ]] || [[ "$(cat "$out/http-status.txt")" != 200 ]]; then
  printf 'Incomplete or failed attempt. Inspect the saved files and History before retrying.\n' >&2
  exit 1
fi
captions=$(jq -e --slurpfile request "$out/request.json" '
  if .source != "youtube_captions" or .status != "done"
  then error("Expected a successful youtube_captions response") else . end
  | .results
  | if type != "array" then error("Expected a results array")
    elif length != 1 then error("Expected exactly one track") else .[0] end
  | $request[0].params.language as $language
  | if type != "object" then error("Expected a caption object")
    elif .videoId != $request[0].video_id or (.requestedLanguageCode // .languageCode) != $language
      or (.languageCode != $language and ($request[0].params.auto != true
        or ($language | endswith("-orig")) or .languageCode != ($language + "-orig")))
      or .isAutoGenerated != $request[0].params.auto
    then error("Returned video, language or caption origin does not match the request") else . end
  | if (.segments | type) != "array" then error("Expected a segments array") else . end
  | .videoId as $id
  | .segments |= map(
      if type != "object" then error("Expected caption segment objects") else . end
      | if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
        then error("Invalid caption timing or text")
        elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
        then error("Invalid caption timing")
        else . + {url: ("https://www.youtube.com/watch?v=" + $id + "&t=" + (.start | floor | tostring) + "s")} end
    )' "$out/result.json")
printf '%s\n' "$captions" > "$out/captions.json"
jq --slurpfile request "$out/request.json" --slurpfile captions "$out/captions.json" \
  --arg requested_at "$(tr -d '\r\n' < "$out/requested-at.txt")" \
  '{request: $request[0], requested_at: $requested_at, usage,
    segment_count: ($captions[0].segments | length), result_file: "result.json"}' \
  "$out/result.json" > "$out/record.json"
printf 'Saved %s segments to %s/captions.json\n' "$(jq '.segments | length' "$out/captions.json")" "$out"
if ! jq -e 'any(.segments[]; .text | test("\\S"))' "$out/captions.json" > /dev/null; then
  printf 'No caption text to cite. Keep the empty track and report the gap.\n'
fi

```

Depuis youtube-migration/, exécutez :

```bash
bash captions.sh track-001
jq . track-001/captions.json
jq . track-001/record.json
```

Un nouveau dossier soumet une demande. Répétez la même commande pour lire sa réponse enregistrée sans appel API. Chaque dossier est propriétaire de sa requête ; changer request.json ne modifie pas une exécution existante. Résolvez les tentatives incomplètes avant de créer un autre dossier.

### 3. Vérifiez la piste avant de la citer

piste...001/captions.json contient des segments vérifiés avec des liens sources; record.json conserve la demande, le temps et l'utilisation; result.json est la réponse brute. Le script vérifie la vidéo, la langue et l'origine, accepte une variante auto-caption -orig correspondante et préserve les segments qui se chevauchent. Les temps de segment sont des secondes. Les sous-titres manquants ou vides constituent une lacune dans les données, et non une transcription générée.

Extrait illustratif captions.json :

```json
{
  "videoId": "FUfGcZ092b0",
  "languageCode": "en",
  "isAutoGenerated": true,
  "segments": [
    {
      "start": 12.5,
      "end": 16.2,
      "text": "Illustrative caption text; the actual track varies.",
      "url": "https://www.youtube.com/watch?v=FUfGcZ092b0&t=12s"
    }
  ]
}
```

| Préoccupation | Intégration Oxylabs existante | FlashData changement |
| --- | --- | --- |
| Authentification | Classique : HTTP Basic nom d'utilisateur/password. Web API : Clé porteur API. | X-API-Key : FLASHDATA_API_KEY. Les identifiants Oxylabs existants ne sont pas transférés. |
| Métadonnées | Classique youtube_metadata ; La requête Web API /media/youtube/metadata. est la vidéo ID. | source : youtube_metadata, video_id : le même caractère 11 ID. |
| Légendes | Classique youtube_subtitles ; Web API /media/youtube/subtitles. | source : youtube_captions pour le texte et le timing ; youtube_transcript lorsque votre analyseur a également besoin de fullText. |
| Langue et origine | Entrées de contexte classiques ; Web API language_code et subtitle_origin. Les omettre peut renvoyer plusieurs pistes. | Définissez explicitement params.language et params.auto. auto : true = YouTube généré ; false = fourni par le téléchargeur. Ne remplacez jamais silencieusement une piste. |
| Analyseur de réponse | Classique et Web API ont des enveloppes de résultats différentes et une sortie de sous-titres groupés. | Vérifiez l'état : done, puis les résultats[].videoId, languageCode, isAutoGenerated et les segments. Le début du segment /end est en secondes. |
| Asynchrone IDs | Internet API metadata.request_id ; Le travail classique IDs utilise ses propres points de terminaison de résultat. | Enregistrez le reçu de soumission FlashData et utilisez ses points de terminaison de tâche de gestion. Gardez le fournisseur IDs séparé ; ne réutilisez pas un sondage Oxylabs URL. |

### Tâche de métadonnées facultative

Accordez l'autorisation youtube_metadata. POST ce corps à https://data.flashdata.dev/v1/queries/realtime avec X-API-Key. Il s’agit d’une demande standard distincte. Vérifier l'état : done avant de lire les résultats[0].

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

[Champs de légende](https://flashdata.dev/fr/docs/sources/youtube_captions/reference.md) · [Champs de métadonnées](https://flashdata.dev/fr/docs/sources/youtube_metadata/reference.md).

<a id="production"></a>
## Tâches récurrentes et récupération

Collectez une fois, analysez plusieurs fois. Réutilisez la piste enregistrée pour les résumés et les intégrations ; actualisez les données sources uniquement lorsque la tâche en a besoin.

| Situation | Que faire |
| --- | --- |
| Une piste sélectionnée est absente | Oxylabs peut renvoyer un objet vide pour une langue valide sans sous-titres correspondants. Traitez le texte de légende manquant ou vide comme une lacune dans les données ; ne fabriquez pas de transcription. |
| Un gros batch est en partie accepté | Oxylabs Web API documente jusqu'à 5,000 tâches par batch et des entrées /rejected acceptées distinctes. Conserver le IDs accepté. Pour FlashData, regroupez le maxBatchSize du compte et conservez chaque tâche renvoyée ID. |
| Un appel realtime expire | Conservez le dossier de demande et inspectez l’historique avant une autre soumission. Pour les longues files d'attente running, utilisez la soumission async, enregistrez sa réception immédiatement et interrogez le travail existant. |
| Un compte ou des changements d’identifiants | Conservez les clés API dans la boutique secrète de l'hôte. Arrêtez-vous sur 401/403 ; résoudre le solde sur 402 ; honorez Retry-After sur 429. Ne recommencez pas de nouveaux essais pour contourner un solde épuisé. |

| Forfait FlashData | Requêtes simultanées | Requêtes par demande de lot |
| --- | --- | --- |
| Paiement à l’usage | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

La concurrence ne correspond pas à des requêtes par seconde. Pour les ensembles de données de la taille d’un fichier, utilisez le traitement en masse. [Temps réel et async](https://flashdata.dev/fr/docs/reference/realtime-and-async/reference.md) · [Lot et vrac](https://flashdata.dev/fr/docs/reference/batch-and-bulk/reference.md) · [Points de terminaison groupés](https://flashdata.dev/fr/docs/reference/bulk-processing/reference.md) · [Erreurs](https://flashdata.dev/fr/docs/errors/reference.md).

Les agents éligibles peuvent commencer avec le crédit 1 (jusqu'à la demande standard 100) pour les heures 72.

Réutilisez d’abord l’accès existant. Pour une utilisation récurrente, le propriétaire revendique la connexion et approuve les autorisations et l'accès au solde partagé. Les crédits temporaires non utilisés ne sont pas transférés. Conservez les informations d’identification entre les exécutions et arrêtez-vous en cas de révocation ou de solde épuisé.

```text
Migrate one Oxylabs YouTube subtitle task to FlashData.
Read https://flashdata.dev/auth.md and reuse existing access first.
Use youtube_captions with the same video ID, language and caption origin.
Keep the source request, raw response, usage and timestamped segments.
Check the video, language and origin; report an absent track instead of inventing text.
Save the script before running it, and reuse a completed output folder.
For recurring work, finish owner claiming and store its credential securely.
Stop on revoked access or depleted balance. Never paste credentials into chat.
```

[Essai et réclamation](https://flashdata.dev/fr/docs/guides/agent-onboarding/reference.md) · [Tâches récurrentes](https://flashdata.dev/fr/docs/guides/recurring-tasks/reference.md) · [Enregistrer les résultats](https://flashdata.dev/fr/docs/guides/save-results/reference.md).

<a id="faq"></a>
## Questions migratoires

### Est-ce que FlashData est un remplacement immédiat ?

Non. Modifiez l'authentification, les champs de requête, l'analyse des réponses et la récupération des tâches. Les exemples adaptent une tâche de sous-titrage en un enregistrement d'application stable ; ils n'imitent pas une enveloppe de réponse de Oxylabs.

### Puis-je conserver mon intégration Classic Oxylabs pendant la migration ?

Oui. Déplacez une tâche à la fois, conservez les résultats Classic enregistrés et conservez les informations d'identification et le travail IDs séparés par fournisseur. Le mappage couvre à la fois les requêtes source classique /context et les requêtes de point de terminaison Web API plus récentes.

### Est-ce que FlashData génère une transcription lorsque des sous-titres sont manquants ?

Ces sources récupèrent les sous-titres YouTube existants. auto : true sélectionne les sous-titres générés par YouTube ; il ne nécessite pas de nouvelle synthèse vocale. Signalez les pistes manquantes ou gérez la transcription comme un flux de travail distinct.

### Et si vous téléchargiez la vidéo elle-même ?

YouTube Le téléchargement est un produit FlashData distinct avec sa propre autorisation et une tarification basée sur l'octet. Cette comparaison et les exemples couvrent les métadonnées et les légendes ; ils ne téléchargent pas de fichiers vidéo ou audio.

### Que doit rester dans mon flux de travail Oxylabs existant ?

Conservez l’infrastructure proxy, les autres plateformes sociales et tous les contrats personnalisés d’extraction, de rappel ou de livraison de stockage dont votre application a encore besoin. Les deux prestataires prennent en charge async de travail, batch de collecte, MCP et de compétences ; ces capacités à elles seules ne constituent pas une raison pour migrer.

[Obtenez une clé API](https://flashdata.dev/signup) · [Google Comparaison de recherche](https://flashdata.dev/fr/compare/oxylabs/reference.md).
