# ScrapeCreators Alternative aux données YouTube

Comparez YouTube les coûts des métadonnées et des sous-titres, les packs prépayés et les accès au cache. Migrez vers FlashData avec les adaptateurs de terrain exécutables Python et Bash pour les applications et les agents.

Données vidéo fraîches. Une dépense de départ plus petite. Déplacez YouTube les métadonnées et les appels de sous-titres tout en conservant le reste de votre intégration de données sociales.

Les faits de ScrapeCreators ont examiné 2026-11-10. Les prix FlashData et les quotas d'essai proviennent de ses catalogues publics actuels.

- [Caractéristiques](#features)
- [Tarifs et cache](#costs)
- [Migrer une demande](#migration)
- [Flux de travail de recherche](#workflow)
- [Pour les agents IA](#agents)
- [FAQ](#faq)

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

### Réduisez le coût des nouvelles données YouTube

| Caractéristique | FlashData | ScrapeCreators |
| --- | --- | --- |
| Tarif d'entrée payé / 1,000 métadonnées ou appels de sous-titres | $0.50 — Utilisation payante | $1.88 — Freelance · nouveaux appels d'un crédit |
| Tarif unitaire le plus bas / 1,000 appels | $0.20 — Forfait mensuel en option ; ses frais s'appliquent toujours | $0.994 — Business · $497 pack prépayé ; Entreprise personnalisée exclue |
| Premier achat à crédit payé | À partir de $10 | $47 — Pack 25,000-crédit Freelance |
| Payez au fur et à mesure sans frais mensuels | Oui | Oui |

### Recherchez des vidéos et actualisez les faits dont vous avez besoin

| Caractéristique | FlashData | ScrapeCreators |
| --- | --- | --- |
| Rechercher des vidéos par mot-clé et filtres | Oui — Filtres de date, de durée, de type et de tri | Oui — Filtres de recherche et pagination des jetons de continuation |
| Métadonnées pour une vidéo connue | Oui — Titre, chaîne, durée, miniatures et nombre d'engagements | Oui — Video/Short Détails de l'extrémité |
| Marqueurs de chapitre pour la navigation | Oui — include_chapters ; titres avec des heures de début/end lorsqu'ils sont présents | Oui — chapitres dans la réponse vidéo lorsqu'ils sont présents |
| Découvrez les pistes de sous-titres disponibles | Liste des langues des métadonnées — hasTranscripts et transcriptLanguages | Métadonnées captionTracks — Codes de langue et détails de la piste |

### Gardez la sélection des légendes et des preuves explicites

| Caractéristique | FlashData | ScrapeCreators |
| --- | --- | --- |
| Texte et horodatage de la même réponse | Texte intégral + segments chronométrés — Start/end fois en secondes | Texte intégral + segments chronométrés — startMs/endMs en millisecondes de chaînes |
| Plusieurs langues de sous-titres en une seule demande | Jusqu'à 10 langues — Pistes existantes et erreurs par langue | Une langue sélectionnée — langue ou sélection original_audio par appel de transcription |
| Choisir explicitement l'origine de la légende | Téléchargeur ou généré par YouTube — params.auto sélectionne une origine | Sélection de la langue et de l'audio parlé — original_audio n'est pas un commutateur d'origine de légende |
| Gestion des sous-titres manquants | Pistes existantes et erreurs explicites — Les tableaux de langues préservent les pistes réussies et signalent les sélections manquantes | Champs de transcription nuls — Les pistes demandées manquantes ne coûtent aucun crédit ; pas de transcription YouTube AI |
| Choisissez l’ancienneté des données réutilisées | Politique de cache dans votre application — Économisez des temps de récupération et décidez quand récupérer à nouveau | cache_max_age — Options 1–30 jours ; les accès au cache ne coûtent aucun crédit et exposent cached_at |

### Exécuter un workflow de données reproductible

| Caractéristique | FlashData | ScrapeCreators |
| --- | --- | --- |
| Traiter un fichier vidéo enregistré IDs | Travaux en masse gérés — Soumettez le fichier, suivez son travail et récupérez les résultats | Appels de point de terminaison par vidéo — Gérez la boucle de fichiers et le stockage des résultats dans votre intégration |
| Déplacer les longues collections vers des tâches en arrière-plan | API asynchrones, par lots et en masse — Conserver la tâche IDs, suivre l'état et récupérer les résultats | Appels YouTube synchrones — File d'attente et point de contrôle par appel vidéo dans votre travailleur |
| Sortie structurée et lisible | JSON, texte brut ou Markdown — Sélectionné via les en-têtes de réponse API | Formats JSON API et CLI — CLI exporte également CSV, les tableaux et Markdown |
| Installation des bornes | Exécutable autonome — Linux, macOS et Windows ; pas d'exécution Node/Python | npm CLI — @scrapecreators/cli |
| MCP et compétences des agents | Oui | Oui |
| Passer des données à la diffusion multimédia hébergée | Oui — YouTube Téléchargez sur votre stockage ; autorisation séparée et tarification basée sur le Go | Flux de travail de téléchargement séparé — YouTube Les API de métadonnées et de transcription ne fournissent pas de fichiers multimédias |

Les deux offrent un accès prépayé, MCP, un CLI et des compétences d'agent. ScrapeCreators couvre également d'autres plateformes sociales et YouTube les commentaires. Les accès au cache pris en charge sont gratuits.

### Actualisez les vidéos qui vous intéressent

Des taux d'utilisation plus faibles par requête sont importants lorsque vous actualisez des statistiques changeantes ou collectez des sous-titres pour de nouvelles vidéos. Conservez les transcriptions enregistrées et demandez des métadonnées uniquement lorsqu'elles doivent être mises à jour.

### Commencez par un petit achat

Les recharges de crédit de FlashData commencent à $10. Déplacez d'abord une charge de travail YouTube, pendant que votre intégration existante continue de gérer les commentaires et autres plateformes sociales.

### Choisissez la piste de sous-titre exacte

Sélectionnez explicitement les sous-titres fournis par le téléchargeur ou générés par YouTube. Demandez jusqu’à 10 langues existantes dans une seule demande de transcription et gérez le résultat de chaque langue séparément.

<a id="costs"></a>
## Comparez les nouvelles demandes, les accès au cache et les achats initiaux

| Offre ScrapeCreators | Achat unique | Crédits | Par 1,000 nouveaux appels d'un crédit | Frais mensuels |
| --- | --- | --- | --- | --- |
| Offre initiale gratuite | $0 | 100 une fois | Indemnité de départ gratuite | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Entreprise | Personnalisé | 1,000,000+ | Personnalisé | $0 pour les crédits prépayés |

Ce sont des packs prépayés sans renouvellement mensuel. Business est exactement $0.994 pour 1,000 appels à un crédit ; $0.99 est arrondi. Les crédits achetés n’ont pas d’expiration selon la politique actuelle. Les crédits bonus initiaux et gagnés sont exclus du modèle.

| 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 nombre de demandes incluses FlashData attribue l'intégralité du solde 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).

### Exemple : métadonnées et légendes pour 1,000 vidéos

2,000 requêtes, aucune recherche de découverte. FlashData payez au fur et à mesure contre ScrapeCreators Freelance. Compter uniquement les accès au cache observés ; les demandes évitées via votre propre stockage local ne sont soumises à aucun des deux fournisseurs.

| Accès gratuits au cache | FlashData appels | FlashData utilisation | FlashData achat | ScrapeCreators crédits | ScrapeCreators valeur d'utilisation | ScrapeCreators achat |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 2,000 | $1.00 | $10.00 | 2,000 | $3.76 | $47.00 |
| 1,000 | 2,000 | $1.00 | $10.00 | 1,000 | $1.88 | $47.00 |
| 2,000 | 2,000 | $1.00 | $10.00 | 0 | $0.00 | $0.00 |

USD, un mois de demandes. Une nouvelle recherche de métadonnées, un résultat de légende native ou une demande de recherche standard utilise un crédit ScrapeCreators. Les métadonnées et les légendes utilisent deux requêtes des deux côtés. Seules les occurrences de métadonnées /transcript saisies ci-dessus sont déduites ; la mise en cache de recherche n’est pas supposée. Ce modèle compte les sous-titres renvoyés, pas les tentatives de perte de piste, et exclut la génération d'IA. FlashData utilise sa norme actuelle YouTube Prix des données, allouant la totalité de l'allocation du plan sélectionné avant une utilisation supplémentaire. La recherche étendue et le téléchargement sont facturés séparément. Les soldes de départ, les essais, les crédits bonus, les taxes et autres utilisations sont exclus. Les achats démarrent à partir d'un solde nul : les recharges de FlashData ont un minimum de $10 ; ScrapeCreators achats arrondis aux packs entiers sélectionnés. Les crédits achetés non utilisés peuvent servir à des tâches ultérieures. ScrapeCreators n'a pas de renouvellement de pack mensuel ; un forfait mensuel FlashData sélectionné a toujours ses frais à zéro demande.

### Comportement du cache

Sur les points de terminaison des métadonnées /transcript prises en charge, cache_max_age accepte 1d, 3d, 7d, 14d ou 30d. Les hits n'utilisent aucun crédit et rapportent cached_at ; les ratés utilisent le tarif normal. Les résultats du cache de recherche ne sont pas supposés. Décidez si les données enregistrées sont suffisamment récentes pour la tâche. [Enregistrez et réutilisez les résultats](https://flashdata.dev/fr/docs/guides/save-results/reference.md).

### Offres de départ

ScrapeCreators commence par des crédits gratuits 100. Les inscriptions admissibles vérifiées FlashData peuvent recevoir une allocation initiale allant jusqu'à 4,000 standard YouTube. Ces offres ne sont pas réinitialisées mensuellement. Le procès séparé des agents temporaires apparaît ci-dessous.

<a id="migration"></a>
## Migrer une vidéo et ses horodatages de sous-titres

### 1. Configurer l'accès et choisir la piste

Créez ou réutilisez une clé avec l'autorisation youtube_transcript, plus youtube_metadata pour l'appel de métadonnées facultatif. [API Clés](https://flashdata.dev/app/api-keys) · [Crédits](https://flashdata.dev/app/billing). Stockez FLASHDATA_API_KEY dans l'environnement ou utilisez l'invite cachée du script ; ne le collez jamais dans le chat.

Demande existante, pour le mappage uniquement :

```bash
# Existing call, for mapping only; reuse your saved key.
curl --get --fail-with-body --silent --show-error \
  'https://api.scrapecreators.com/v1/youtube/video/transcript' \
  --header "x-api-key: $SCRAPECREATORS_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'language=en'
```

FlashData POST https://data.flashdata.dev/v1/queries/realtime avec X-API-Key et ce corps JSON :

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

original_audio=true choisit la langue parlée. FlashData params.auto=true sélectionne les sous-titres générés par YouTube. Précisez la langue et l’origine séparément.

### 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 creator-research.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")
    transcript = []
    for cue in item["segments"]:
        if not isinstance(cue, dict):
            raise SystemExit("Invalid caption segment")
        start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
        if (type(start) not in (int, float) or type(end) not in (int, float)
                or not math.isfinite(start) or not math.isfinite(end)
                or start < 0 or end < start or not isinstance(text, str)):
            raise SystemExit("Invalid caption segment")
        transcript.append({"text": text,
                           "startMs": str(math.floor(start * 1000 + 0.5)),
                           "endMs": str(math.floor(end * 1000 + 0.5)),
                           "startTimeText": f"{int(start) // 60}:{int(start) % 60:02d}"})
    normalized = {"videoId": item["videoId"],
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "transcript": transcript, "transcript_only_text": item.get("fullText"),
                  "language": item.get("languageName"), "languageCode": item["languageCode"],
                  "isAutoGenerated": item["isAutoGenerated"]}
else:
    duration = item.get("duration")
    if duration is not None and (type(duration) not in (int, float)
                                or not math.isfinite(duration) or duration < 0):
        raise SystemExit("Invalid video duration")
    normalized = {"id": item["videoId"], "title": item.get("title"),
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "description": item.get("description"),
                  "viewCountInt": item.get("viewCount"), "likeCountInt": item.get("likeCount"),
                  "commentCountInt": item.get("commentCount"),
                  "durationMs": None if duration is None else math.floor(duration * 1000 + 0.5),
                  "channel": {"id": item.get("channelId"), "title": item.get("channel")},
                  "uploadDateRaw": item.get("uploadDate")}
(out / "normalized.json").write_text(
    json.dumps(normalized, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/normalized.json; actual usage: {json.dumps(data.get('usage'))}")

```

Exécutez à partir de ce dossier en utilisant une vidéo avec une piste en anglais existante. Les métadonnées constituent une demande facultative distincte ; lors d'un essai temporaire, laissez au moins une seconde entre les appels.

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

Pour les sous-titres fournis par le téléchargeur, ajoutez le manuel --origin. La valeur par défaut est celle des sous-titres anglais générés par YouTube.

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

```bash
#!/usr/bin/env bash
set -euo pipefail
operation="${1:?Use: transcript|metadata VIDEO_ID OUTPUT_FOLDER [LANGUAGE] [auto|manual]}"
video_id="${2:?Set VIDEO_ID}"
out="${3:?Set OUTPUT_FOLDER}"
language="${4:-en}"
origin="${5:-auto}"
[[ "$operation" == transcript || "$operation" == metadata ]] || exit 1
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || exit 1
[[ "$origin" == auto || "$origin" == manual ]] || exit 1
body=$(jq -n --arg source "youtube_$operation" --arg id "$video_id" \
  --arg language "$language" --arg origin "$origin" '
  {source: $source, video_id: $id, params:
    (if $source == "youtube_transcript" then {language: $language, auto: ($origin == "auto")}
     else {include_formats: false, include_chapters: true} end)}')
if [[ ! -e "$out" ]]; then
  if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
    read -r -s -p 'FlashData API key: ' FLASHDATA_API_KEY; printf '\n'
  fi
  : "${FLASHDATA_API_KEY:?An API key is required}"
  mkdir -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep the output folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved HTTP status, response and Retry-After header.\n' >&2; exit 1;
}
normalized=$(jq -e --argjson request "$body" '
  if .source != $request.source or .status != "done" then error("Request not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $request.video_id then error("Wrong video") else . end
  | if $request.source == "youtube_metadata" then
      if .duration == null then .
      elif (.duration | type) != "number" then error("Invalid video duration")
      elif (.duration | isfinite | not) or .duration < 0 then error("Invalid video duration") else . end
      | {id: .videoId, title, url: ("https://www.youtube.com/watch?v=" + .videoId), description,
         viewCountInt: .viewCount, likeCountInt: .likeCount, commentCountInt: .commentCount,
         durationMs: (if .duration == null then null else (.duration * 1000 | round) end),
         channel: {id: .channelId, title: .channel}, uploadDateRaw: .uploadDate}
    else
      if (.languageCode != $request.params.language and
          ($request.params.auto != true or ($request.params.language | endswith("-orig")) or
           .languageCode != ($request.params.language + "-orig"))) or
          .isAutoGenerated != $request.params.auto then error("Wrong language or origin") else . end
      | if (.segments | type) != "array" then error("Expected caption segments") else . end
      | {videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
         transcript_only_text: .fullText, language: .languageName, languageCode, isAutoGenerated,
         transcript: [.segments[] |
          if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
          then error("Invalid caption segment")
          elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
          then error("Invalid caption timing")
          else {text, startMs: (.start * 1000 | round | tostring), endMs: (.end * 1000 | round | tostring),
            startTimeText: (((.start / 60 | floor) | tostring) + ":" +
              ((.start | floor) % 60 | if . < 10 then "0" + tostring else tostring end))} end]}
    end' "$out/response.json")
printf '%s\n' "$normalized" > "$out/normalized.json"
printf 'Saved %s/normalized.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

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

Pour les sous-titres fournis par le téléchargeur, ajoutez un manuel. Chaque nouveau dossier de sortie soumet une demande. Les mêmes arguments et dossiers réutilisent la sortie enregistrée ; utilisez un nouveau dossier pour une actualisation intentionnelle après avoir inspecté la tentative précédente.

### 3. Lire la sortie mappée et l'utilisation réelle

Legends-001/normalized.json est un adaptateur de champ; response.json conserve la réponse brute et l'utilisation réelle. Les secondes deviennent des millisecondes de chaîne. languageCode et isAutoGenerated conservent la piste sélectionnée. Ce n'est pas une réponse drop-in complète : aucun solde de crédit fabriqué, drapeaux cache, attribution de téléverseur ou champs de date. Les métadonnées préservent les paramètres manquants comme null et sa date d ' origine uploadDateRaw.

```json
{
  "videoId": "FUfGcZ092b0",
  "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
  "transcript": [
    {
      "text": "Example caption text.",
      "startMs": "1250",
      "endMs": "3500",
      "startTimeText": "0:01"
    }
  ],
  "transcript_only_text": "Example caption text.",
  "language": "English",
  "languageCode": "en-orig",
  "isAutoGenerated": true
}
```

| ScrapeCreators intégration | FlashData changement |
| --- | --- |
| GET /v1/youtube/video?url=… | POST la requête API avec source : youtube_metadata et video_id. Lisez les résultats[0], pas la racine de la réponse. |
| GET /v1/youtube/video/transcript?url=… | Utiliser la source : youtube_transcript. Définissez explicitement params.language et params.auto. |
| transcription[].startMs / endMs | FlashData début/fin sont des secondes. Multipliez chacun par 1,000 et sérialisez sous forme de chaînes pour un lecteur milliseconde existant. |
| original_audio=true | Sélectionne la langue parlée en ScrapeCreators, pas les sous-titres générés automatiquement. Résolvez la langue requise dans votre application ; params.auto sélectionne à la place l'origine de la légende. |
| langue et transcript_only_text | Cartographiez languageName et fullText. Conservez languageCode séparément ; un nom de langue et un code de langue sont des champs différents. |
| viewCountInt, likeCountInt, commentCountInt | Carte viewCount, likeCount, commentCount. Conservez null lorsqu'une métrique est absente. |
| durationMs et publishDate | Convertissez les secondes de durée en millisecondes. Conservez uploadDate comme champ brut jusqu'à ce que votre application valide le format de date dont elle a besoin. |
| chaîne / téléchargeur / ownerByline | Les canaux FlashData et channelId ne reproduisent pas les trois identités. Cartographiez uniquement les champs dont votre lecteur a besoin ; conserver un chemin séparé pour l’attribution des crédits musicaux. |
| cached, cached_at, credits_charged | Conservez la réponse et l'utilisation brutes FlashData. Enregistrez votre propre temps de récupération ; ne fabriquez pas d’indicateurs de cache des fournisseurs et ne traduisez pas les soldes créditeurs entre les fournisseurs. |

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

### Si la première demande échoue

- 401/403 : vérifiez la permission de la clé enregistrée et de la source ; arrêtez si elle est révoquée.
- 402 : reconstituez le solde du propriétaire avant de reprendre.
- 429 : lit l'en-tête Retry-After enregistré ; réduire la fréquence des demandes. Les essais temporaires autorisent une requête par seconde.
- Piste manquante : vérifiez la langue et l'origine disponibles. ScrapeCreators peut renvoyer une réponse réussie avec une transcription null ; ne confondez pas cela avec une piste completed FlashData.
- Délai d'expiration ou dossier incomplet : inspectez l'historique et les résultats avant de réessayer. Les scripts conservent la tentative sans resoumission automatique.

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

<a id="workflow"></a>
## Rechercher → présélectionner → enrichir → citer

| Étape | Travail | Nombre de demandes |
| --- | --- | --- |
| Découvrez | Exécutez P YouTube Requêtes de recherche | P requêtes de recherche standards. Comptez les demandes réelles, et non chaque vidéo renvoyée, dans le cadre d'une recherche distincte. |
| Sélectionnez | Dédoublonner et présélectionner la vidéo N IDs | Filtrage local ; aucune demande de métadonnées ou de légende pour l'instant. |
| Enrichir | Récupérer les métadonnées pour les IDs présélectionnés | N demandes de métadonnées ; répétez uniquement lorsque les métriques doivent être actualisées. |
| Citer | Récupérer une piste de sous-titres existante par ID | N demandes de transcription lorsqu’elles sont disponibles. Stockez la langue, l'origine et les timings de repère avec la source URL. |
| Réutilisation | Lire les résultats enregistrés pour la tâche suivante | Aucune demande du fournisseur lorsque votre application peut réutiliser son propre fichier enregistré. |

10 requêtes de recherche plus 50 les vidéos présélectionnées avec métadonnées et sous-titres nécessitent 110 requêtes standard avant la réutilisation locale. Séparez les coûts de découverte de ceux d’enrichissement. Un résultat de recherche ne constitue pas en soi une demande de recherche distincte.

### La recherche n'est pas une migration de curseur instantanée

ScrapeCreators peut renvoyer plusieurs types de résultats avec continuationToken. La recherche standard de FlashData renvoie des résultats vidéo ; sa recherche étendue a des limites et des tarifs distincts. Démarrez une nouvelle exécution de découverte au lieu de réutiliser un ancien curseur.

[YouTube Rechercher une référence](https://flashdata.dev/fr/docs/sources/youtube_search/reference.md)

### Conservez les preuves avec la réponse

Enregistrez la vidéo ID, URL, la langue choisie, l'origine du sous-titre et l'heure de début du segment. Un lien de citation peut pointer vers cet horodatage. Ne qualifiez pas une piste de sous-titres manquante de transcription vide et réussie.

[Recette de sous-titres horodatés](https://flashdata.dev/fr/docs/guides/timestamped-captions-recipe/reference.md)

### Scale la liste ID séparément

Une fois qu'une recherche a fonctionné, utilisez les requêtes batch pour une liste ou le traitement groupé pour un fichier. Suivez la tâche IDs, enregistrez les sorties completed et réessayez uniquement les éléments failed. Gardez votre coureur responsable du calendrier.

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

<a id="agents"></a>
## Prouver la migration avant de la planifier

Les agents éligibles peuvent commencer par 1 credit (jusqu'à 100 standard YouTube Demandes de données) 72 heures. Les métadonnées, les légendes et la recherche partagent l'allocation.

1. Inspectez les champs obligatoires, l’intention de la légende et la fraîcheur. Réutiliser l'accès enregistré ; conserver les appels de données sociales sans rapport.
2. Exécutez une vidéo connue en utilisant CLI, SDK ou MCP. Enregistrez la sortie et vérifiez le timing, les valeurs nulles et l’utilisation réelle.
3. Le propriétaire se connecte ou s'inscrit, vérifie les e-mails et approuve les revendications, les portées et l'utilisation du solde partagé. Les crédits d'essai inutilisés ne sont pas transférés.
4. Conservez les informations d’identification du propriétaire pour une utilisation récurrente. Réutilisez les sorties et arrêtez-vous en cas de révocation ou de solde insuffisant.

```text
Migrate only this app's YouTube metadata and native-caption calls to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/agents.md first.
Reuse saved access; start an eligible trial only if needed. Keep credentials out of chat.
Inspect our current fields, language choice, original_audio behavior and cache freshness requirements.
Keep comments, other social platforms and unsupported fields on their existing path.
Run one known video with explicit language and caption origin. Save the raw response and usage.
Map timestamps from seconds to string milliseconds; preserve null counts and missing-track errors.
Reuse saved output before requesting it again. Do not retry an uncertain submission automatically.
Before recurring use, ask the owner to claim access and approve permissions and shared-balance use.
Persist the resulting credential and stop on revocation or insufficient balance.
```

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

<a id="faq"></a>
## Avant de changer

### S'agit-il d'abonnements mensuels ?

ScrapeCreators Freelance et Business sont des packs prépayés, pas des abonnements. Les deux ont des frais mensuels de $0. FlashData propose des crédits par répartition ainsi que des forfaits mensuels optionnels. Comparez séparément l'utilisation consommée et l'achat nécessaire à partir de votre solde actuel.

### Que se passe-t-il si la plupart de mes ScrapeCreators requêtes sont mises en cache ?

Les accès aux métadonnées et au cache de transcription pris en charge ne coûtent aucun crédit. Entrez les résultats observés dans la calculatrice. Si votre application accepte leur âge, elles peuvent coûter moins cher que les nouvelles demandes de FlashData. Vous pouvez également enregistrer localement la sortie de l’un ou l’autre fournisseur et éviter complètement de faire la demande suivante.

### Les crédits inutilisés expirent-ils ?

ScrapeCreators indique que les crédits achetés n'expirent pas selon la politique actuelle. Son offre de départ gratuite de 100 crédits n'est pas une recharge mensuelle. L'essai d'agent temporaire de FlashData expire ; ses pages de tarification et de compte décrivent les conditions applicables au solde du propriétaire.

### Est-ce que original_audio=true fonctionnera comme params.auto=true ?

Non. Le premier choisit une langue en fonction de l’audio parlé ; le second choisit les sous-titres générés par YouTube. Définissez délibérément une langue et une origine. Le point de terminaison de sous-titre natif d’aucun des deux services ne crée une synthèse vocale lorsqu’une piste correspondante est absente.

### Puis-je remplacer tous mes appels de données sociales ?

Cette migration couvre YouTube métadonnées vidéo et sous-titres existants. Conservez les commentaires, les publications de la communauté, les profils sociaux et tout autre champ de réponse non pris en charge sur leur chemin existant. FlashData propose également Google Recherche et hébergement YouTube Téléchargement, avec leurs propres autorisations et tarifs.

### ScrapeCreators prend-il également en charge les agents IA ?

Oui. Il propose MCP, OAuth, un CLI et des compétences d'agent. Le flux d'agent de FlashData ajoute un essai temporaire éligible, une réclamation du propriétaire et des informations d'identification enregistrées pour une utilisation continue. Choisissez le API et le flux de travail dont votre tâche a besoin ; MCP le support à lui seul ne fait pas la différence.
