# Bright Data Alternative aux données YouTube

Comparez les demandes FlashData YouTube avec les enregistrements de scraper Bright Data : tarifs payés, allocations mensuelles, limites de tâches et Python/Bash migration des instantanés vers les tâches enregistrées.

Créez des recherches vidéo autour des requêtes sources. Comparez l'ensemble de la tâche, puis déplacez un flux de travail d'instantané vers des tâches enregistrées et pouvant être reprises.

Il s'agit de la comparaison YouTube. [Bright Data Alternative pour Google Recherche](https://flashdata.dev/fr/compare/brightdata/reference.md) est une page distincte.

Les faits de Bright Data ont examiné 2026-11-10. Les tarifs et quotas FlashData utilisent ses catalogues publics actuels.

- [Caractéristiques](#features)
- [Tarifs](#pricing)
- [Quotas et limites](#limits)
- [Migrer un emploi](#migration)
- [Flux de travail des agents](#agents)
- [FAQ](#faq)

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

### Coûts payés inférieurs pour les recherches vidéo ciblées

| Caractéristique | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Recherche de métadonnées payante · 1,000 vidéos | $0.50 — 1,000 requêtes sources · PAYG | $1.50 — 1,000 enregistrements vidéo livrés · PAYG |
| Métadonnées + légendes existantes · 1,000 vidéos | $1.00 — 2,000 requêtes sources · PAYG | $1.50 — 1,000 enregistrements vidéo lorsque les champs de sous-titres sont inclus |
| Forfait mensuel d'entrée | $49.00 — Micro/mois; solde d'utilisation partagé inclus | $499 — Scale/mois · Enregistrements 384,000 inclus |
| Payez au fur et à mesure sans abonnement mensuel | Oui | Oui |

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

| Caractéristique | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Découvrez des vidéos par mot-clé | Oui — Rechercher avec des filtres de date, de durée, de type et de tri | Oui — Modes de découverte de mots clés et de filtres de recherche |
| Métadonnées pour une vidéo connue | Oui — Titre, chaîne, durée, miniatures et nombre d'engagements | Oui — Enregistrements vidéo avec champs d'identité, de canal et d'engagement |
| Marqueurs de chapitre pour la navigation | Oui — include_chapters ; durée des chapitres en secondes | Oui — Titres des chapitres, aperçus et heures de début en millisecondes |
| Découvrez les langues de sous-titres disponibles | Liste des langues dans les métadonnées | Liste des pistes dans l'enregistrement vidéo — Comprend des informations sur la langue et les sous-titres automatiques |

### Rendre les légendes utilisables comme preuve

| Caractéristique | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Demander des sous-titres sans actualiser les métadonnées | Source de transcription dédiée — Une demande standard par vidéo | Champs de légende dans l'enregistrement vidéo — YouTube Grattoir de vidéos |
| Demander plusieurs langues de sous-titres | Jusqu'à 10 langages explicites — Pistes et erreurs par langue | Une langue sélectionnée — Sélectionnez la langue lors de la collecte de l'enregistrement vidéo |
| Sélectionnez le téléverseur ou l'origine du sous-titre automatique | Oui — params.auto sélectionne une origine sans repli d'origine croisée | Origine affichée dans les métadonnées de la piste — Aucune entrée de sélection d'origine répertoriée pour le grattoir de vidéos examinées |
| Texte intégral et citations horodatées | Texte intégral + segments chronométrés — Start/end fois en secondes | Texte intégral + segments chronométrés — Début, fin et durée du segment en millisecondes |

### Exécutez la collecte dans votre application ou votre agent

| Caractéristique | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Collection interactive et en arrière-plan | Temps réel ou async — Choisissez le mode ; sauvegardez le travail ID pour le travail en arrière-plan | Synchronisation du scrape ou du déclencheur async — Le travail de synchronisation dépassant une minute se poursuit sous forme d'instantané |
| Traiter une grande liste préparée | Bulk Jobs avec un fichier vidéo-ID — Console ou API ; parties de progression, de manifeste et de résultat | Lots d'entrée asynchrones — Déclencher une collection et récupérer ou livrer son instantané |
| Sortie pour les applications et les LLM | JSON, texte brut ou Markdown | Formats d'exportation d'instantanés — JSON, NDJSON et CSV |
| Conserver les résultats completed pour une analyse ultérieure | Enregistrez les résultats ou utilisez le stockage en masse — Conservez les données brutes et les manifestes dans votre propre stockage | Livraison d'instantanés et de stockage — Instantanés conservés pendant 30 jours |
| Client terminal autonome | Natif CLI — Linux, macOS et Windows ; pas d'exécution Node/Python | Node.js CLI — Commande bdata installée par npm |
| MCP, compétences et SDK accès | Oui | Oui |

Les tarifs payés excluent les allocations gratuites. Les deux proposent async emplois, une collecte groupée et des outils d’agent. Conservez la collecte de commentaires, les autres plateformes sociales, les ensembles de données gérés et les intégrations de stockage-livraison existantes lorsque cela est nécessaire.

### Payez pour les champs dont votre tâche a besoin

Récupérez les métadonnées de votre liste restreinte. Demandez des sous-titres uniquement pour les vidéos que vous analyserez. Une actualisation des métadonnées n’a pas besoin de répéter l’étape de transcription.

### Choisissez explicitement la piste de sous-titres

Demandez une langue et sélectionnez les sous-titres fournis par le téléchargeur ou générés par YouTube. Gardez les erreurs de langue visibles au lieu de modifier silencieusement les données de recherche.

### Conserver le travail au fil des sessions d'agent

Enregistrez le travail accepté ID avant l'interrogation. Un processus ultérieur reprend le même travail et réutilise le résultat téléchargé sans soumettre une autre requête.

<a id="pricing"></a>
## Comparez la tâche vidéo complète

L'enregistrement vidéo de Bright Data peut inclure des métadonnées et des sous-titres. FlashData utilise une demande de métadonnées et une demande de légende distincte. Une entrée de découverte peut renvoyer plusieurs enregistrements facturables ; cette calculatrice couvre uniquement les recherches de vidéos connues.

| Offre Bright Data YouTube | Frais mensuels | Enregistrements inclus | Tarif payant / 1,000 enregistrements |
| --- | --- | --- | --- |
| Piscine gratuite éligible | $0 | Jusqu'à 5,000/mois partagés entre les produits éligibles | Dans les limites de l'allocation |
| Paiement à l’usage | $0.00 | Aucune allocation de régime payée | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Entreprise | Personnalisé | Personnalisé | Personnalisé |

Scale inclut les enregistrements 384,000 pour $499/mois ; les enregistrements supplémentaires coûtent $1.30 par 1,000. L'entreprise personnalisée et la correspondance des dépôts promotionnels ne sont pas modélisé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 |

Le décompte des demandes incluses attribue le solde complet du plan partagé aux données standard YouTube. La recherche étendue et le téléchargement ont des tarifs distincts. [Tarif complet](https://flashdata.dev/fr/pricing/youtube-data).

### 10,000 vidéos : payez au fur et à mesure des deux côtés

| Tâche | FlashData requêtes | FlashData facture modélisée | Bright Data enregistrements gratuits appliqués | Bright Data facture modélisée |
| --- | --- | --- | --- | --- |
| Métadonnées vidéo | 10,000 | $5.00 | 0 | $15.00 |
| Métadonnées vidéo | 10,000 | $5.00 | 5,000 | $7.50 |
| Métadonnées + légendes existantes | 20,000 | $10.00 | 0 | $15.00 |
| Métadonnées + légendes existantes | 20,000 | $10.00 | 5,000 | $7.50 |

USD pour un mois de recherches vidéo réussies. Un enregistrement vidéo Bright Data renvoyé peut contenir des métadonnées et des sous-titres existants ; la tâche combinée FlashData utilise deux requêtes source. La découverte, les commentaires, la transcription IA, la recherche étendue et les téléchargements multimédias sont exclus. Saisissez uniquement Bright Data les crédits gratuits encore disponibles pour ces enregistrements ; le pool de crédits 5,000 est partagé et les crédits gratuits récurrents ne se cumulent pas avec Scale. Les prix FlashData proviennent de son catalogue public actuel ; l'intégralité du solde du forfait sélectionné est allouée ici avant toute utilisation supplémentaire. Les soldes de départ FlashData et les essais d'inscription/agent sont exclus. La facture modélisée mesure l'utilisation plus les frais mensuels, et non un nouvel achat de portefeuille : les recharges FlashData commencent à $10. Aucune taxe, aucune promotion de dépôt, aucun tarif personnalisé ou remise annuelle n'est inclus.

### Offres de départ

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 récurrent.

Les comptes Bright Data éligibles reçoivent 5,000 de crédits gratuits par mois partagés entre les produits éligibles, y compris Scraper API. Un enregistrement YouTube livré consomme un crédit. Les crédits gratuits non utilisés ne sont pas reportés ; les comptes de pré-engagement ne reçoivent pas de crédits gratuits récurrents. Ne cumulez pas le pool mensuel gratuit avec Scale.

<a id="limits"></a>
## Allocations, batch tailles et running emplois

| Préoccupation | FlashData | Bright Data Grattoir API |
| --- | --- | --- |
| Qu'est-ce qui consomme l'allocation ? | Chaque requête source ; les métadonnées et les légendes sont séparées | Dossiers livrés avec succès ; une entrée de découverte peut en renvoyer plusieurs |
| Une demande interactive | POST /v1/queries/realtime ; choisissez async pour le travail en arrière-plan | POST /datasets/v3/scrape ; après 1 minute, HTTP 202 renvoie un instantané ID et le travail continue |
| Entrées plus importantes | La taille du lot dépend du plan ; utiliser le traitement en masse pour un fichier de IDs | Async /trigger accepte jusqu'à 1 Go d'entrée ; le nombre minimum d'entrées dépend du grattoir |
| Travaux en cours | La simultanéité des comptes dépend du plan sélectionné, indiqué ci-dessous | 5,000 emplois actifs/snapshots ; le dépassement de la limite renvoie 429 |
| Recul | Honneur Retry-After ; les essais d'agents temporaires autorisent une requête par seconde | Honneur Retry-After ; Les réponses 25 HTTP 429 par IP en 5 minutes peuvent déclencher un blocage 1 heures API |
| Résultats enregistrés | Téléchargez et conservez le JSON dans votre propre stockage de tâches | Instantanés conservés pendant 30 jours ; les demandes de téléchargement prennent en charge jusqu'à 5 Go, avec récupération partielle pour des résultats plus volumineux |

| 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. Les crédits s'appliquent toujours à chaque requête. [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) · [Référence de traitement en masse](https://flashdata.dev/fr/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## D'un instantané à une tâche enregistrée

### 1. Préparer l'accès et cartographier la demande

Créez ou réutilisez une clé avec l'autorisation youtube_metadata. [API Clés](https://flashdata.dev/app/api-keys) · [Crédits disponibles](https://flashdata.dev/app/billing). Stockez FLASHDATA_API_KEY dans un magasin secret ou saisissez-le dans l'invite cachée du script.

Soumission Bright Data existante, pour référence de migration :

```bash
# Existing Bright Data job submission, for migration reference.
curl --fail-with-body --silent --show-error --max-time 120 \
  --request POST \
  'https://api.brightdata.com/datasets/v3/trigger?dataset_id=gd_lk56epmy2i5g7lzu0k&format=json' \
  --header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{"input":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}]}'
```

FlashData POST https://data.flashdata.dev/v1/queries avec X-API-Key :

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

### 2. Enregistrez le script avant running

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

```python
# Save as migrate-video.py in your working folder.
import argparse
import getpass
import json
import os
import re
import time
from pathlib import Path
from urllib.parse import urlsplit

import requests

parser = argparse.ArgumentParser()
parser.add_argument("video_id")
parser.add_argument("folder", help="A new folder name, such as video-001")
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")
if not re.fullmatch(r"[A-Za-z0-9_-]+", args.folder):
    raise SystemExit("Use a simple output folder name")
os.umask(0o077)
out = Path(args.folder)
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
key = None

def read(name):
    return json.loads((out / name).read_text(encoding="utf-8"))

def call(method, url, name, payload=None, authenticated=True):
    global key
    headers = {"Accept": "application/json"}
    if authenticated:
        if key is None:
            key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
        if not key.strip():
            raise SystemExit("An API key is required")
        headers["X-API-Key"] = key
    try:
        response = requests.request(method, url, json=payload, headers=headers,
                                    timeout=(10, 120), allow_redirects=False)
    except requests.RequestException:
        raise SystemExit("Network outcome unknown. Keep this folder and check History; do not resubmit.")
    (out / name).write_bytes(response.content)
    (out / (name + ".http")).write_text(str(response.status_code))
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""))
    return response

if not out.exists():
    out.mkdir()
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    submitted = call("POST", "https://data.flashdata.dev/v1/queries", "submission.json", body)
    if submitted.status_code not in (200, 201, 202):
        raise SystemExit(f"HTTP {submitted.status_code}. Inspect submission.json and retry-after.txt.")
else:
    try:
        if read("request.json") != body:
            raise SystemExit("This folder belongs to another request. Use a new folder.")
    except (OSError, ValueError):
        raise SystemExit("Incomplete attempt. Check the folder and History before resubmitting.")
try:
    receipt = read("submission.json")
    job_id = receipt["id"]
    status = (out / "submission.json.http").read_text().strip()
    if status not in ("200", "201", "202") or receipt["source"] != body["source"] or not re.fullmatch(r"[A-Za-z0-9_-]+", job_id):
        raise ValueError()
except (OSError, ValueError, KeyError, TypeError):
    raise SystemExit("No valid saved receipt. Check History; this script will not submit again.")

if not (out / "result.json").exists():
    url = "https://api.flashdata.dev/v2/jobs/" + job_id
    for attempt in range(12):
        response = call("GET", url, "job.json")
        if response.status_code != 200:
            raise SystemExit(f"HTTP {response.status_code}. Resolve the error; then resume this folder.")
        job = response.json()["job"]
        if job["id"] != job_id or job["source"] != body["source"]:
            raise SystemExit("Job does not match the saved receipt")
        if job["status"] == "completed":
            break
        if job["status"] not in ("pending", "processing"):
            raise SystemExit("Job " + job["status"] + ". Inspect job.json; do not resubmit.")
        delay = response.headers.get("Retry-After", "5")
        if attempt == 11 or not delay.isdigit() or int(delay) > 60:
            raise SystemExit("Still running. Wait for Retry-After, then run the same command to resume.")
        time.sleep(max(1, int(delay)))
    result = call("GET", url + "/results", "result.pending.json")
    if result.status_code == 302:
        location = result.headers.get("Location", "")
        parsed = urlsplit(location)
        if parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password:
            raise SystemExit("Expected an HTTPS storage URL")
        # Separate request: the API key is never sent to storage.
        result = call("GET", location, "result.pending.json", authenticated=False)
    if result.status_code != 200:
        raise SystemExit(f"HTTP {result.status_code}. Resolve the error, then resume this folder.")
    data = result.json()
else:
    print("Reading saved result; no API call.")
    data = read("result.json")
if not isinstance(data, dict) or data.get("source") != body["source"] or data.get("status") != "done":
    raise SystemExit("Result did not complete successfully")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict) or items[0].get("videoId") != args.video_id:
    raise SystemExit("Expected the requested video in results")
item = items[0]
mapped = [{"video_id": item["videoId"], "url": "https://www.youtube.com/watch?v=" + item["videoId"],
           "title": item.get("title"), "description": item.get("description"),
           "views": item.get("viewCount"), "likes": item.get("likeCount"),
           "num_comments": item.get("commentCount"), "video_length": item.get("duration"),
           "channelName": item.get("channel"), "channelId": item.get("channelId"),
           "uploadDateRaw": item.get("uploadDate"), "captionLanguages": item.get("transcriptLanguages")}]
if not (out / "result.json").exists():
    (out / "result.pending.json").replace(out / "result.json")
(out / "video-records.json").write_text(json.dumps(mapped, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Saved {out}/video-records.json; actual usage: {json.dumps(data.get('usage'))}")

```

Exécuter à partir du même dossier :

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

Vous pouvez également utiliser Bash, cURL 7.76+ et jq 1.6+. Enregistrez le script complet ci-dessous sous le nom migrate-video.sh dans un nouveau dossier de travail.

```bash
#!/usr/bin/env bash
# Save as migrate-video.sh in your working folder.
set -euo pipefail
umask 077
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Use a folder name such as video-001}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ && "$out" =~ ^[A-Za-z0-9_-]+$ ]] || exit 2
body=$(jq -n --arg id "$video_id" '{source:"youtube_metadata", video_id:$id,
  params:{include_formats:false, include_chapters:true}}')
call() {
  local method="$1" url="$2" name="$3" authenticated="$4" payload="${5:-}"
  local -a options=(--silent --show-error --compressed --proto '=https'
    --connect-timeout 10 --max-time 120 --request "$method"
    --header 'Accept: application/json' --output "$out/$name"
    --dump-header "$out/$name.headers" --write-out '%{http_code}')
  if [[ "$authenticated" == yes ]]; 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}"
    options+=(--header "X-API-Key: $FLASHDATA_API_KEY")
  fi
  if [[ -n "$payload" ]]; then options+=(--header 'Content-Type: application/json' --data-binary "$payload"); fi
  curl "${options[@]}" "$url" > "$out/$name.http" || {
    echo 'Network outcome unknown. Keep this folder and check History; do not resubmit.' >&2; exit 1;
  }
  status=$(cat "$out/$name.http")
}
if [[ ! -e "$out" ]]; then
  mkdir -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  call POST 'https://data.flashdata.dev/v1/queries' submission.json yes "@$out/request.json"
  [[ "$status" =~ ^20[012]$ ]] || { echo "HTTP $status. Inspect submission.json and its headers." >&2; exit 1; }
else
  jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null || {
    echo 'Incomplete or different request. Check this folder and History.' >&2; exit 1;
  }
fi
[[ "$(cat "$out/submission.json.http")" =~ ^20[012]$ ]] || exit 1
id=$(jq -er 'select(.source == "youtube_metadata") | .id | select(type == "string" and test("^[A-Za-z0-9_-]+$"))' "$out/submission.json")
if [[ ! -f "$out/result.json" ]]; then
  url="https://api.flashdata.dev/v2/jobs/$id"
  for attempt in {1..12}; do
    call GET "$url" job.json yes
    [[ "$status" == 200 ]] || { echo "HTTP $status. Inspect job.json and its headers; resume after resolving." >&2; exit 1; }
    state=$(jq -er --arg id "$id" 'select(.job.id == $id and .job.source == "youtube_metadata") | .job.status' "$out/job.json")
    [[ "$state" == completed ]] && break
    [[ "$state" == pending || "$state" == processing ]] || { echo "Job $state. Do not resubmit." >&2; exit 1; }
    delay=$(awk 'tolower($1)=="retry-after:" {sub(/\r$/, "", $2); print $2}' "$out/job.json.headers")
    delay="${delay:-5}"
    [[ "$attempt" -lt 12 && "$delay" =~ ^[0-9]+$ && "$delay" -le 60 ]] || {
      echo 'Still running. Wait for Retry-After, then run the same command to resume.' >&2; exit 1;
    }
    [[ "$delay" -gt 0 ]] || delay=1
    sleep "$delay"
  done
  call GET "$url/results" result.pending.json yes
  if [[ "$status" == 302 ]]; then
    location=$(awk 'tolower($1)=="location:" {sub(/\r$/, "", $2); print $2}' "$out/result.pending.json.headers")
    [[ "$location" =~ ^https://[^/@[:space:]]+(/|$) ]] || { echo 'Expected HTTPS storage URL.' >&2; exit 1; }
    # Separate request, without the API key. Do not add -L to an authenticated request.
    call GET "$location" result.pending.json no
  fi
  [[ "$status" == 200 ]] || { echo "HTTP $status. Resolve it, then resume this folder." >&2; exit 1; }
  result="$out/result.pending.json"
else
  echo 'Reading saved result; no API call.'
  result="$out/result.json"
fi
mapped=$(jq -e --arg id "$video_id" '
  if .source != "youtube_metadata" or .status != "done" then error("Result 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
  | [{video_id:.videoId, url:("https://www.youtube.com/watch?v=" + .videoId), title, description,
      views:.viewCount, likes:.likeCount, num_comments:.commentCount, video_length:.duration,
      channelName:.channel, channelId, uploadDateRaw:.uploadDate, captionLanguages:.transcriptLanguages}]' "$result")
[[ "$result" == "$out/result.json" ]] || mv -- "$result" "$out/result.json"
printf '%s\n' "$mapped" > "$out/video-records.json"
printf 'Saved %s/video-records.json; actual usage: ' "$out"
jq -c '.usage' "$out/result.json"

```

Exécuter à partir du même dossier :

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

Si toujours running, répétez la même commande pour reprendre la tâche enregistrée. Les exécutions terminées réutilisent result.json sans appel API. Un nouveau dossier soumet une nouvelle demande ; vérifiez l'historique avant de réessayer une soumission incertaine. Gardez les clés hors du chat et ne les transférez jamais vers un stockage signé URLs.

### 3. Lire l'enregistrement mappé

vidéo-001/video-records.json préserve les noms de champs vidéo communs; result.json conserve les données brutes et l'utilisation. Les métriques manquantes restent null. channelName est un nom d'affichage, et non une poignée; uploadDateRaw n'est pas une date normalisée. Les champs Transcription et Médias ne sont pas fabriqués.

```json
[
  {
    "video_id": "FUfGcZ092b0",
    "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
    "title": "Example video",
    "description": "Example description",
    "views": 1200,
    "likes": null,
    "num_comments": null,
    "video_length": 197,
    "channelName": "Example channel",
    "channelId": "UC_EXAMPLE",
    "uploadDateRaw": "2025-01-15",
    "captionLanguages": [
      "en",
      "es"
    ]
  }
]
```

| Préoccupation | Intégration existante | FlashData changement |
| --- | --- | --- |
| Sélection du grattoir | dataset_id=gd_lk56epmy2i5g7lzu0k | source=youtube_metadata ; les légendes utilisent youtube_transcript séparément |
| Entrée | Une montre URL dans le tableau d'entrée | Un caractère 11 video_id |
| Authentification | Autorisation : Porteur | X-API-Key avec l'autorisation source demandée |
| Soumettre | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → identifiant ; conservez le reçu |
| Suivre | Progression de l'instantané → ready | GET /v2/jobs/{id} → job.status=completed |
| Récupérer | Téléchargez un instantané au format JSON, NDJSON ou CSV | GET /v2/jobs/{id}/results → stockage signé URL ; récupérer sans la clé API |
| Champs vidéo | video_id, title, description, views, likes, num_comments, video_length | videoId, titre, description, viewCount, likeCount, commentCount, durée (secondes) |
| Chaîne et date | youtuber est un pseudo ; date_posted est une date | Conservez channelName, channelId et uploadDateRaw ; ne pas renommer un nom d'affichage en handle |
| Transcription | Peut être inclus comme transcription et formatted_transcript dans l'enregistrement vidéo | Demande de piste séparée ; fullText et les segments utilisent des secondes. Mapper les horodatages si l'analyseur existant attend des millisecondes |
| Médias directs URL | video_url est un URL en streaming | Utilisez le workflow de téléchargement YouTube séparé pour la livraison vers votre stockage |

### Légendes facultatives

Accordez l'autorisation youtube_transcript. Soumettez ce corps à POST https://data.flashdata.dev/v1/queries avec X-API-Key et enregistrez son propre travail ID. Cela ajoute une requête standard par vidéo :

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

auto=false sélectionne les sous-titres fournis par le téléchargeur. Préserver la langue et l’origine. Bright Data les temps de transcription formatés utilisent des millisecondes ; Les segments FlashData utilisent des secondes. Multipliez par 1,000 pour un analyseur attendant des millisecondes. [Recette de sous-titres horodatés exécutables](https://flashdata.dev/fr/docs/guides/timestamped-captions-recipe/reference.md).

### Récupération

- En attente/processing: reprend le ID enregistré. Le scrutin est limité et honore le numérique Retry-After.
- 401/403: résoudre l'authentification ou la permission; arrêter la révocation.
- 402 : restaurez le solde disponible du propriétaire avant de continuer.
- 429 : arrêter l'envoi et honorer Retry-After ; ne réessayez pas automatiquement les soumissions.
- Délai d'expiration sans reçu : inspectez l'historique avant de créer un autre dossier.

[Erreurs et codes d'état](https://flashdata.dev/fr/docs/errors/reference.md).

<a id="agents"></a>
## Une connexion, des tâches réutilisables

Les agents éligibles peuvent démarrer avec le crédit 1 (jusqu'à 100 standard YouTube) pour les heures 72. Réutiliser l'accès sauvegardé d'abord; métadonnées et sous-titres partagent l'allocation.

1. Découvrez les vidéos et la présélection avant d'enrichir.
2. Récupérez une vidéo, vérifiez les champs et la sélection des légendes, puis enregistrez la sortie brute.
3. Demandez au propriétaire de finaliser l'inscription/sign-in et d'approuver les étendues et le solde partagé. Les crédits temporaires non utilisés ne sont pas transférés.
4. Conservez les informations d'identification et exécutez des dossiers sur des tâches récurrentes. Réutilisez les résultats et arrêtez-vous en cas de révocation ou de solde épuisé.

```text
Migrate one Bright Data YouTube video lookup to FlashData.
Read https://flashdata.dev/auth.md and reuse saved access first.
Inspect the current video-record parser and list its required fields.
Fetch metadata for one known video. Request captions separately only if needed.
Keep channel handles, dates, caption origin and timestamp units explicit.
Save the submission receipt, job ID, raw JSON and normalized output.
Resume accepted work; do not submit again after a timeout or agent restart.
Verify the output before scheduling. Have the owner claim access and approve
the required permissions and shared balance for continued use.
Keep keys in the host's secret store. Stop on revoked access or insufficient balance.
```

[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 la comparaison de recherche Bright Data Google ?

Cette page couvre le YouTube Grattoir API. Google Search utilise le produit SERP de Bright Data, avec différentes unités de tarification et configuration de demande. La comparaison de recherche Google possède sa propre page.

### Est-ce que Bright Data facture deux fois les métadonnées et une transcription ?

Son schéma vidéo YouTube inclut des champs de métadonnées et de légende dans l'enregistrement vidéo renvoyé. Ne comptez pas automatiquement deux enregistrements. FlashData utilise des requêtes de métadonnées et de transcription distinctes ; la charge de travail combinée dans le calculateur compte deux requêtes FlashData par vidéo. Un champ de légende peut être indisponible pour une vidéo particulière.

### Quel fournisseur propose la plus grande allocation gratuite ?

Bright Data propose aux comptes éligibles 5,000 des crédits partagés chaque mois. L'allocation d'inscription éligible de FlashData est un solde initial et son essai d'agent temporaire est distinct. Ces offres ont des règles de renouvellement différentes. Utilisez l'entrée d'enregistrement libre restante pour modéliser Bright Data PAYG avec précision.

### Puis-je remplacer chaque Bright Data grattoir ?

Déplacez les workflows de métadonnées, de recherche, de canal et de sous-titres YouTube pris en charge dont vous avez besoin. Conservez la collecte de commentaires, les autres plateformes sociales, les ensembles de données gérés et les intégrations de stockage-livraison existantes là où votre application en dépend toujours.

### Les deux fournisseurs prennent-ils en charge les agents IA ?

Oui. Les deux offrent MCP, un CLI et des compétences d'agent. Le CLI autonome de FlashData, les autorisations de source et le solde Google/YouTube partagé sont utiles pour un flux de travail de recherche ciblé. Réutilisez l'accès enregistré et demandez au propriétaire d'approuver l'accès continu au compte avant de planifier un travail récurrent.

### Puis-je réutiliser un instantané ID après la migration ?

Non. Enregistrez l'instantané Bright Data et le nouveau travail FlashData ID en tant qu'identifiants distincts. L'exemple réutilise uniquement son reçu FlashData enregistré et vérifie que la vidéo renvoyée correspond au ID demandé.

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