# Supadata Alternative aux données YouTube

Comparez les coûts de transcription et de métadonnées de YouTube, les fonctionnalités de sous-titres natives et l'accès des agents. Migrez depuis Supadata avec des exemples exécutables Python et Bash.

Supadata faits examinés 2026-11-10. Les prix et les indemnités d'essai FlashData utilisent ses catalogues publics en vigueur.

- [Caractéristiques](#features)
- [Comparer les coûts](#costs)
- [Migrer une transcription](#migration)
- [Métadonnées et masse](#workflows)
- [Pour les agents IA](#agents)
- [FAQ](#faq)

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

Pour les applications et les agents collectant des légendes et métadonnées YouTube existantes.

### Gardez payé YouTube récupération économique

| Caractéristique | FlashData | Supadata |
| --- | --- | --- |
| Utilisation payante sans abonnement | Oui — Crédits à la carte ; achats à partir de $10 | Forfaits payants — Basic: $60/an · Pro: $17/mois |
| Transcription ou métadonnées natives · prix par 1,000 | $0.50 — Payez au fur et à mesure · pas de frais mensuels | $5.67 sur Pro — $17 / 3,000 included credits; full allowance utilisé |
| Lot sans forfait mensuel | Jusqu'à 100 requêtes / Batch — Clé du propriétaire avec paiement à l'utilisation ; la limite d'essai est distincte | Pro et plus — Vidéo et transcription batch points de terminaison |

### Trouvez des vidéos et créez une bibliothèque de recherche

| Caractéristique | FlashData | Supadata |
| --- | --- | --- |
| Rechercher des vidéos par sujet | Oui — Recherche par mot-clé avec filtres de date, de durée, de type et de tri | Oui — Recherche de vidéos, de chaînes et de playlists avec filtres |
| Actualiser les métadonnées vidéo sans récupérer les sous-titres | Oui — Titre, chaîne, durée, miniatures et nombre d'engagements | Oui — Point de terminaison de métadonnées séparé avec les champs auteur, média et statistiques |
| Langues de sous-titres dans les métadonnées vidéo | Oui — hasTranscripts et transcriptLanguages | Dans la réponse de transcription — availableLangs ; schéma de métadonnées distinct |

### Conservez les transcriptions utiles pour les citations et les analyses

| Caractéristique | FlashData | Supadata |
| --- | --- | --- |
| Texte horodaté pour les citations de sources | JSON segments en secondes — Texte avec heures de début et de fin | JSON morceaux en millisecondes — Texte avec décalage et durée |
| Texte intégral et horodatages de la même réponse | Oui — fullText et les segments sont renvoyés ensemble | Choisissez du texte ou des morceaux — text=true renvoie une chaîne ; sinon rejoignez les morceaux dans votre application |
| Plusieurs langues de sous-titres existantes dans une seule demande | Jusqu'à 10 langues — Pistes et erreurs par langue | Une langue préférée — paramètre lang sur le point de terminaison de la transcription |
| Sélectionnez les sous-titres fournis par le téléchargeur ou générés par YouTube | Oui — Explicite params.auto=false ou true | Aucun sélecteur d'origine documenté — le mode sélectionne la récupération native par rapport à la génération IA |
| Gérer explicitement les sous-titres indisponibles | Pistes existantes uniquement — Les tableaux de langues renvoient des pistes et des erreurs ; pas de nouvelle transcription | Choisissez une solution de secours native ou IA — mode=auto peut générer de la parole en texte ; les limites natives de la récupération aux sous-titres existants |

### Passer d'une requête à un workflow reproductible

| Caractéristique | FlashData | Supadata |
| --- | --- | --- |
| Demandes interactives et en arrière-plan | Temps réel ou async — Choisissez le mode d'exécution et enregistrez le travail ID | Résultat ou travail de transcription — HTTP 200 renvoie des données ; HTTP 202 renvoie un travail ID |
| Traiter une liste préparée de vidéos | Lot API ou Bulk Jobs console — Téléchargez un fichier ID ; conserver les parties manifeste et résultat | Asynchrone batch API · Pro+ — Accepte les listes de vidéos, les listes de lecture ou les chaînes |
| Collectez une playlist ou une chaîne entière | Fournir une vidéo explicite IDs — Préparer la liste avant le traitement par lots ou en masse | Vidéos Entrée de playlist ou de chaîne batch — Regular videos; excludes Shorts and live |
| Sortie pour les applications et les LLM | JSON, texte brut ou Markdown — Choisissez la réponse et le format du contenu | JSON avec du texte ou des morceaux — Utilisez le contenu de la transcription dans votre candidature ou votre invite |
| SDK linguistiques | Python, TypeScript et c'est parti | Python et JavaScript / TypeScript |
| Accès MCP pour un hôte agent | Oui — Télécommande MCP avec OAuth ou une clé API | Oui — Serveur MCP avec identifiants Supadata |
| Essai programmatique avant l'inscription du propriétaire | Oui — Jusqu'à 100 demandes de relevés de notes natifs · 72 heures | Clé du compte API en premier — 100 crédits gratuits chaque mois après l'inscription |

Supadata prend en charge la transcription générée par l'IA et plusieurs plateformes sociales. Les points de terminaison de légende de FlashData récupèrent les pistes YouTube existantes. Les deux services proposent MCP et des SDK.

### Gardez une petite charge de travail de recherche abordable

Payez pour les YouTube demandes de données que vous utilisez. Ajoutez un abonnement plus tard si son tarif inférieur et son solde inclus correspondent à votre volume.

[Évaluez votre charge de travail](#costs)

### Gardez la source de la légende explicite

Sélectionnez les légendes générées par YouTube ou fournies par le téléchargeur, conservez la langue renvoyée et conservez les horodatages pour les citations. Demandez des pistes existantes en plusieurs langues sans générer de nouvelle synthèse vocale.

[Cartographiez votre lecteur de transcription](#migration)

### Passez d'une vidéo à un pipeline

Utilisez la même forme de demande pour les travaux realtime, async et batch. Ajoutez Google Recherche au flux de travail de recherche en utilisant le même compte et le même solde partagé.

[Construisez la prochaine étape](#workflows)

<a id="costs"></a>
## Tarifez le flux de travail vidéo complet

USD. Une transcription native dans une langue ou une recherche de métadonnées représente une demande et un crédit Supadata. Les métadonnées plus une transcription native correspondent à deux requêtes par vidéo. FlashData utilise son catalogue de données YouTube en direct, en appliquant la valeur de crédit incluse avant une utilisation supplémentaire. Son taux unitaire affiché est un taux d'utilisation ; Supadata correspond aux frais du plan divisés par l’allocation mensuelle complète. Basic est annuel uniquement : $60 payé d'avance, affiché comme $5/mois équivalent à 300 crédits chaque mois, et non 3,600 disponible immédiatement. D'autres forfaits Supadata utilisent des prix catalogue mensuels. La recharge automatique est désactivée dans cette estimation jusqu'à ce qu'elle soit sélectionnée ; une fois sélectionnés, les plus petits packs entiers publiés couvrent le déficit. Le calendrier réel de recharge automatique peut être acheté plus tôt. Les montants d’achat ne supposent aucun solde de départ. FlashData les recharges commencent à $10 ; un achat peut laisser des fonds pour plus tard. Supadata les crédits mensuels ne sont pas reconduits. Les crédits d'essai, les taxes, les autres utilisations API, les remises annuelles sur d'autres forfaits, la génération d'IA et la traduction sont exclus. À zéro demande, les frais du plan sélectionné demeurent et le taux effectif n'est pas défini.

### FlashData YouTube Forfaits de données

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

[Tarification complète des données en YouTube](https://flashdata.dev/fr/pricing/youtube-data)

### Supadata plans publiés

| Forfait Supadata | Paiement du régime | Crédits / mois | Par 1,000 à pleine allocation | Pack de recharge automatique |
| --- | --- | --- | --- | --- |
| Gratuit | $0.00 / mois | 100 | $0.00 | Non disponible |
| Basic · annual only | $60.00/an ($5.00/mois équivalent) | 300 | $16.67 | $10.00 / 1,000 crédits |
| Pro · monthly | $17.00 / mois | 3,000 | $5.67 | $10.00 / 1,000 crédits |
| Mega · monthly | $47.00 / mois | 30,000 | $1.57 | $10.00 / 5,000 crédits |
| Giga · monthly | $297.00 / mois | 300,000 | $0.99 | $20.00 / 20,000 crédits |
| Supa · monthly | $897.00 / mois | 1,000,000 | $0.90 | $20.00 / 20,000 crédits |

### Exemple : métadonnées et transcription native pour chaque vidéo

FlashData payez au fur et à mesure contre Supadata Mega mensuellement, avec recharge automatique incluse. Il s’agit d’une comparaison explicite de plans ; sélectionnez d'autres forfaits indépendamment dans le calculateur HTML.

| Vidéos / mois | Demandes de données | FlashData utilisation modélisée | Supadata Mega + packs de recharges entiers | Packs de recharge |
| --- | --- | --- | --- | --- |
| 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 |

### Accès gratuit et génération d'IA

Supadata Recharges gratuites 100 crédits mensuels. Sa transcription native utilise un crédit ; La génération d'IA utilise deux crédits par minute. Une transcription générée en 30 minutes utilise donc 60 crédits. Le mode automatique par défaut peut déclencher la génération ; mode=native évite ce repli. La génération, la traduction et la recherche étendue sont exclues de cette comparaison.

Les inscriptions vérifiées éligibles de FlashData peuvent recevoir une allocation initiale pouvant aller jusqu'à 4,000 de demandes de données standard de YouTube. Il ne s'agit pas d'un niveau gratuit mensuel.

<a id="migration"></a>
## Migrer un lecteur de transcription natif

| Changement | Supadata | FlashData | Que faire |
| --- | --- | --- | --- |
| Demande | GET /v1/transcript avec URL, langue, texte et mode | POST /v1/queries/realtime avec source, video_id et paramètres | Extrayez le caractère 11 YouTube ID. Une clé Supadata ne s'authentifie pas auprès de FlashData. |
| Authentification | x-api-key : votre clé Supadata | X-API-Key : votre clé FlashData | Créez ou réutilisez un identifiant avec l'autorisation youtube_transcript. Les noms d'en-tête ne sont pas sensibles à la casse ; les informations d'identification changent. |
| Natif versus généré | mode=native récupère les sous-titres existants ; l'auto peut recourir à l'IA ; générer utilise toujours l'IA | youtube_transcript lit les légendes YouTube existantes | Déplacez d'abord la récupération native. Conservez une étape de conversion parole-texte distincte pour les vidéos qui nécessitent une nouvelle transcription. |
| Origine de la légende | le mode sélectionne la récupération plutôt que la génération | params.auto=true sélectionne les légendes générées par YouTube ; false sélectionne les sous-titres fournis par le téléchargeur | Ces paramètres automatiques ne sont pas équivalents. FlashData auto ne démarre jamais la synthèse vocale. |
| Langue | la langue est préférable ; les langues indisponibles peuvent revenir à la première disponible | params.language est explicite ; auto=true essaie la variante -orig puis le code demandé | Cochez languageCode et requestedLanguageCode. FlashData ne choisit pas silencieusement une autre langue ou une autre origine de légende. |
| Segments | content[] : texte, décalage et durée en millisecondes | results[0].segments[] : texte, début et fin en secondes | offset = round(début × 1000); durée = tour ((fin − début) × 1000). Préservez les chevauchements plutôt que de décaler les repères. |
| Texte brut | text=true renvoie le contenu sous forme de chaîne | résultats[0].fullText | Lisez fullText pour le résumé et conservez les segments pour les citations d'horodatage. |
| Découverte des langues | availableLangs dans la réponse de transcription | transcriptLanguages dans youtube_metadata | Récupérez les métadonnées lorsque votre application a besoin de la liste complète des langues. N'inventez pas availableLangs à partir d'une seule piste renvoyée. |
| Achèvement | HTTP 200 résultat, ou HTTP 202 + jobId | Statut en temps réel=done ; async retour des soumissions FlashData travail IDs | Gérez les états de chaque fournisseur séparément. Terminez-y les Supadata emplois existants avant de migrer de nouveaux travaux. |

### 1. Configurer l'accès

Créez ou réutilisez une clé FlashData avec l'autorisation youtube_transcript dans [API Clés](https://flashdata.dev/app/api-keys). Ajoutez youtube_metadata pour la tâche facultative de métadonnées. Cochez [crédits disponibles](https://flashdata.dev/app/billing) ou utilisez [accès à l'essai d'agent éligible](#agents). Conservez les clés dans un environnement ou un magasin secret.

Supadata requête native en cours de remplacement :

```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 remplacement JSON corps pour POST /v1/queries/realtime:

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

### 2. Enregistrez le script, puis exécutez-le

Choisissez Python ou Bash. Chaque nouveau dossier de sortie soumet une demande ; la réutilisation d'un dossier lit la sortie enregistrée sans autre appel API. Les versions partagent le format de fichier enregistré. Choisissez une vidéo avec la piste de sous-titres demandée.

#### Python

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-migrate.py avant de l’exécuter.

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

```

Exécutez à partir de ce dossier de travail :

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

Cela sélectionne les sous-titres anglais générés par YouTube. Ajoutez --origin manuel pour une piste fournie par le téléchargeur, ou --language CODE pour choisir une langue.

Demande de métadonnées distincte facultative :

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

#### Bash

Nécessite Bash, cURL 7.76+ et jq 1.6+. Enregistrez ce script complet sous youtube-migrate.sh dans votre dossier de travail avant 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"

```

Exécutez à partir de ce dossier de travail :

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

Les arguments facultatifs après le dossier sont la langue et l'origine ; par exemple, en manuel, sélectionne les sous-titres en anglais fournis par le téléchargeur.

Demande de métadonnées distincte facultative :

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

Pour un accès temporaire à l’essai, exécutez les requêtes de manière séquentielle à au moins une seconde d’intervalle.

### 3. Lire la sortie

response.json préserve le résultat brut et l'utilisation. normalized.json convertit les secondes du segment de transcription en millisecondes offset/duration. Il s'agit d'un adaptateur de segment, pas d'une réponse complète compatible avec Supadata : availableLangs n'est pas fabriqué. La sortie des métadonnées préserve les valeurs nullables. Les demandes échouées ou interrompues conservent leurs preuves et s'arrêtent.

normalized.json d’illustration :

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

[Schéma de transcription](https://flashdata.dev/fr/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## Métadonnées et workflows groupés

| Données | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Identité vidéo | id | résultats[0].videoId |
| Titre et description | titre, description | résultats[0].titre, résultats[0].description |
| Chaîne | author.displayName; additionalData.channelId | résultats[0].canal ; résultats[0].channelId |
| Fiançailles | stats.views, stats.likes, stats.comments | résultats[0].viewCount, likeCount, commentCount |
| Durée | media.duration (secondes) | résultats[0].durée (secondes) |
| Miniature | media.thumbnailUrl | résultats[0].thumbnails[]; choisissez la taille dont votre application a besoin |
| Date de parution | createdAt | résultats[0].uploadDate; normalisez son format dans votre application |
| Découverte des légendes | Lire availableLangs à partir d'une réponse de transcription | résultats[0].hasTranscripts et transcriptLanguages |

### Plusieurs langues existantes en une seule demande

Envoyez un tableau de langues pour recevoir des pistes et des erreurs, même pour un tableau contenant une seule langue. Inspectez les erreurs même lorsque le statut est done. Il s'agit de pistes existantes, non de sous-titres traduits ou générés.

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

### Enrichir une bibliothèque de recherche

Récupérez les métadonnées une fois, enregistrez sa vidéo ID et les langues de sous-titres disponibles, puis récupérez la piste dont vous avez besoin. Conservez les comptes d'engagement nullables comme null plutôt que de les convertir à zéro.

[YouTube Bonnes pratiques en matière de données](https://flashdata.dev/fr/docs/guides/youtube-data-guide/reference.md)

### Traiter une liste de vidéos IDs

Développez votre entrée en vidéo explicite IDs, puis utilisez Batch ou un fichier groupé. FlashData n'accepte pas un Supadata playlistId comme entrée batch. Enregistrez l'état et la sortie par élément avant de réessayer les éléments failed.

[Référence de traitement en masse](https://flashdata.dev/fr/docs/reference/bulk-processing/reference.md)

### Exécuter des recherches selon un calendrier

Conservez les informations d'identification du propriétaire, vérifiez les vidéos du point completed et lisez la sortie enregistrée au redémarrage. Arrêtez-vous pour accès révoqué ou solde insuffisant ; ne créez pas un autre essai pour poursuivre une tâche planifiée.

[Tâches récurrentes des agents](https://flashdata.dev/fr/docs/guides/recurring-tasks/reference.md)

### Production décisions de migration

- Résoudre les entrées de la playlist/channel en vidéo explicite IDs avant FlashData le traitement par lots ou en masse des fichiers ; Supadata playlistId n'est pas une entrée directe.
- La recherche Supadata coûte un crédit par page de résultats 20, ou plafond (limite/20) avec limite. FlashData standard YouTube La recherche prend en charge jusqu'à 20 résultats ; La recherche étendue a un tarif distinct. Filtrez les cartes et ne transférez pas les jetons de page.
- Supadata documente une fenêtre de résultats de tâche de transcription completed d'une heure. Videz-y les tâches existantes et stockez les résultats avant de migrer de nouvelles tâches. Gardez le travail spécifique au fournisseur IDs séparé.
- Conservez les médias multiplateformes, l’extraction IA, la traduction et la transcription audio sur leurs chemins existants, à moins qu’un flux de travail équivalent n’ait été mis en œuvre.

<a id="agents"></a>
## Essai d'agent, réclamation et utilisation récurrente

Les agents éligibles peuvent commencer avec 1 crédit(s), jusqu'à 100 demandes de relevé de notes natif pour 72 heures. Les métadonnées et les transcriptions partagent cette allocation.

1. Réutilisez d’abord l’accès existant ; sinon, démarrez un essai éligible avec uniquement les autorisations nécessaires.
2. Renvoyez un résultat utile, enregistrez la sortie brute et l'utilisation, et conservez le même profil et le même répertoire d'état.
3. Le propriétaire se connecte ou s'inscrit, vérifie les e-mails et approuve les réclamations, les étendues et l'accès au solde partagé.
4. Réutilisez les informations d'identification du propriétaire pour les tâches récurrentes. Les crédits d'essai inutilisés ne sont pas transférés. Arrêt après révocation ou solde insuffisant ; ne créez jamais un autre essai pour continuer.

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

[Essai et réclamation](https://flashdata.dev/fr/docs/guides/agent-onboarding/reference.md) · [Autonome CLI](https://flashdata.dev/fr/docs/guides/flashdata-cli/reference.md) · [MCP connexion](https://flashdata.dev/fr/docs/integrations/mcp-clients/reference.md)

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

### FlashData peut-il remplacer la transcription IA de Supadata ?

Les sources de transcription et de sous-titres de FlashData récupèrent les sous-titres déjà présents sur YouTube. Ils ne transcrivent pas l’audio, ne traduisent pas de texte et n’effectuent pas d’analyse visuelle. Déplacer la récupération native YouTube vers FlashData ; conservez un service distinct pour la synthèse vocale, la vidéo multiplateforme ou l'extraction d'IA lorsque votre application en a besoin.

### Qu'est-ce qu'une demande achète ?

Le calculateur couvre une transcription existante dans une langue ou une recherche de métadonnées vidéo. La récupération des deux utilise deux requêtes par vidéo. Supadata facture chacune de ces opérations à raison d'un crédit. FlashData utilise le débit de données YouTube du forfait sélectionné. La recherche étendue, la transcription par l’IA, la traduction et la diffusion multimédia ne font pas partie de cette estimation.

### Est-ce que FlashData est toujours moins cher ?

Comparez votre charge de travail réelle et les plans sélectionnés. Supadata comprend 100 crédits chaque mois gratuitement. L'essai d'agent temporaire de FlashData est limité et expire ; ce n'est pas un niveau gratuit mensuel. À faible volume, une allocation gratuite peut couvrir l'ensemble de la tâche. Les frais des forfaits payés, les packs de recharge et les soldes inutilisés affectent le montant que vous payez.

### Est-ce que Supadata prend déjà en charge MCP et les SDK ?

Oui. Les deux services prennent en charge les intégrations MCP et Python/JavaScript. FlashData fournit également un Go SDK, un CLI autonome et un essai d'agent temporaire qui peut être réclamé pour un accès récurrent. Choisissez l'interface prise en charge par votre hôte ; MCP à lui seul n’est pas une raison pour changer.

### Que se passe-t-il si une piste de sous-titres est manquante ?

Traitez-le comme une lacune dans les données. FlashData ne bascule pas entre les sous-titres fournis par le téléchargeur et ceux générés par YouTube et ne synthétise pas une transcription. Pour un tableau de langues, inspectez les erreurs même lorsque la requête est done. Supadata peut générer une transcription en mode automatique, tandis que le mode natif peut renvoyer HTTP 206 pour une transcription indisponible ; sa documentation facture cette réponse à un crédit.

### Puis-je conserver la forme de réponse d’application existante ?

Gardez votre propre adaptateur. L'exemple convertit les segments FlashData en entrées de contenu avec un décalage et une durée en millisecondes, mais ne revendique pas une réponse complète compatible avec Supadata. Lisez les métadonnées FlashData si vous avez besoin des langues disponibles et migrez explicitement l'état du travail, la gestion des erreurs et de l'utilisation.

[Obtenez une clé API](https://flashdata.dev/signup)
