# Apify Alternative aux données YouTube

Comparez les acteurs FlashData avec les acteurs Apify YouTube : prix spécifiques aux acteurs, budgets d'utilisation mensuels, flux de travail de métadonnées et de sous-titres, et exemples de migration exécutables Python et Bash.

Des courses d'acteur aux recherches vidéo directes. Commencez par IDs connu, conservez vos champs d'application et déplacez un producteur avant de modifier le reste du pipeline.

Les faits de Apify ont examiné 2026-11-10. Les tarifs et les quotas d'essai de FlashData utilisent ses catalogues publics actuels.

- [Caractéristiques](#features)
- [Tarification des acteurs](#actors)
- [Comparer les coûts](#costs)
- [Migrer une recherche](#migration)
- [Ensembles de données et calendriers](#production)
- [Pour les agents IA](#agents)
- [FAQ](#faq)

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

### Gardez les recherches ciblées économiques

| Caractéristique | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Utilisation payante sans abonnement mensuel | Oui — Crédits à la carte ; recharges à partir de $10 | Budget gratuit, puis forfait payant — $5/mois gratuitement ; Starter $19/mois avec utilisation $19 |
| Métadonnées pour 1,000 vidéo connue IDs | $0.50 — Tarif d'utilisation à la carte | $3.00 — streamers/youtube-scraper · Taux Starter, déduit du budget du plan |
| Recherche d'une seule vidéo | Oui — Un video_id explicite | Dépendant de l'acteur — Les streamers le prennent en charge ; API Dojo exclut actuellement la vidéo unique URLs |

### Trouvez et enrichissez les vidéos dont votre application a besoin

| Caractéristique | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Découverte de mots clés avec des filtres de recherche | Oui — Filtres de date, de durée, de type et de tri | Oui — searchQueries plus filtres de tri, de date et vidéo |
| Données sur le titre, la chaîne et l'engagement | Oui — Recherche de métadonnées dédiées par vidéo ID | Oui — Enregistrements vidéo dans l'ensemble de données Actor |
| Actualiser les métadonnées séparément des légendes | Oui — Demandez seulement youtube_metadata pour le rafraîchissement | Oui — Exécuter avec transcriptionAndSubtitle=AUCUN |

### Préparez des preuves de légende pour votre demande

| Caractéristique | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Choisissez plusieurs langues de sous-titres existantes | Jusqu'à 10 langages explicites — Pistes et erreurs par langue dans une seule demande de transcription | Acteur principal : une langue ou une autre — Différents acteurs peuvent exposer différentes contributions |
| Sélectionnez une origine de légende stricte | Téléchargeur ou généré par YouTube — params.auto sélectionne une origine ; pas de repli d'origine croisée | Acteur principal : préférence d’origine — preferAutoGeneratedSubtitles est une préférence, pas le même contrat |
| Texte horodaté pour les citations de sources | Segments JSON normalisés — Texte avec start/end fois en secondes | Sous-titres SRT, VTT ou XML — Analyser le format de sous-titre sélectionné pour les horaires de citation |
| Texte brut pour le résumé | fullText à côté des segments | format de sous-titre en texte brut — Ou analysez et rejoignez la sortie des sous-titres chronométrés |
| Vidéos sans transcription existante | Signaler la piste manquante — Pas de génération de synthèse vocale | Transcription IA facultative — Modes de repli ou de toujours transcrire ; frais d'utilisation séparés |

### Exécutez le workflow avec moins de code d'intégration

| Caractéristique | FlashData | Apify YouTube acteurs |
| --- | --- | --- |
| Résultat direct sans gérer les ressources de l'acteur | Résultats en temps réel[] + utilisation — Aucun acteur ID, paramètre de build ou de mémoire | Exécution de l'acteur + schéma d'entrée — Le point de terminaison de synchronisation peut également renvoyer des résultats en un seul appel HTTP |
| Traiter une liste enregistrée dans une console de navigateur | Bulk Jobs avec un fichier vidéo-ID — Suivez les progrès et récupérez les parties du manifeste et des résultats | Console d'acteur avec entrées URL — Prend en charge les importations de feuilles CSV ou Google |
| Résultats en arrière-plan après la déconnexion du client | Enregistré async ou travail en masse ID — Reprendre les vérifications d'état et récupérer les sorties completed | Exécution d'acteur et ensemble de données enregistrés IDs — Inspecter l'exécution et récupérer ses éléments d'ensemble de données |
| Formats de sortie des applications et des agents | JSON, texte brut ou Markdown | Exportations d'ensembles de données — JSON, CSV, Excel et autres formats |
| Collecte récurrente | Votre planificateur ou agent hébergeur — Réutiliser les informations d'identification du propriétaire et l'état de la tâche enregistré | Horaires des acteurs hébergés — Cron, paramètres de fuseau horaire et webhooks facultatifs |
| Métadonnées, légendes et recherche Google dans un seul contrat API | Une requête API, autorisations spécifiques à la source — Solde du compte partagé ; prix spécifiques à la source | Plateforme partagée ; Schémas spécifiques à l'acteur — Choisir et maintenir les entrées et sorties des acteurs pertinentes |
| CLI, SDK et MCP pour l'automatisation | Oui — Autonome CLI ; SDK Python, TypeScript et Go ; MCP | Oui — Apify CLI, Python/JavaScript clients et MCP |

Les lignes spécifiques à l'acteur font référence aux streamers/youtube-scraper sauf si un autre acteur est nommé. Les deux services proposent des SDK, CLI et MCP. Apify exécute également du code personnalisé, des plannings hébergés et des scrapers d'autres sites Web.

### Limitez les recherches d'une vidéo

Passez une vidéo ID et recevez directement les métadonnées. Utilisez un accès payant lorsque le travail ne nécessite pas d'abonnement à la plateforme ou d'exploration des chaînes.

### Conservez le modèle de données de votre application

Mappez les champs que votre application lit réellement. Conservez le nombre de null, gardez les dates de publication explicites et enregistrez un tableau JSON pour les consommateurs qui ont déjà lu les éléments de l'ensemble de données.

### Séparez la découverte de l’enrichissement

Continuez un workflow de découverte utile, dédupliquez sa vidéo IDs, puis enrichissez uniquement les vidéos dont votre produit a besoin avec FlashData.

<a id="actors"></a>
## Il n'y a pas de prix unique Apify YouTube

Les auteurs d’acteurs choisissent les entrées, les sorties et les modèles de tarification. Ces trois acteurs utilisent des événements par résultat, mais ont des capacités différentes. Les prix ci-dessous sont de USD pour 1,000 vidéos retournées.

| Acteur | Vidéos gratuites / 1,000 | Starter | Scale | Business | Choisissez-le pour |
| --- | --- | --- | --- | --- | --- |
| streamers/youtube-scraper | $4.00 | $3.00 | $2.60 | $2.40 | Vidéo URLs, découverte et sous-titres existants en option. C’est l’acteur de la calculatrice. |
| streamers/youtube-channel-scraper | $1.30 | $1.00 | $0.80 | $0.50 | Découverte de chaînes avec des données vidéo de base. Il ne s'agit pas d'une recherche complète de métadonnées pour un ID arbitraire. |
| apidojo/youtube-scraper | $0.50 | $0.50 | $0.50 | $0.50 | Entrées de découverte. Son README actuel exclut les vidéos uniques URLs et nécessite au moins 10 vidéos par entrée. Démo gratuite : 5 exécutions/mois, au maximum 10 éléments/run. |

Forfaits mensuels libre-service : Starter correspond à Bronze, Scale à Silver et Business à Gold. Les acteurs de découverte les moins chers ne sont pas remplacés par le calculateur de vidéo connue.

### Vérifier l'événement facturable

Apify prend en charge les modèles de paiement par événement, de paiement par utilisation et combinés. Pour les streamers/youtube-scraper, comptez les événements de résultat et les modules complémentaires sélectionnés ; n'ajoutez pas automatiquement de frais de calcul génériques. Inspectez la répartition des événements de votre propre course d'acteur.

### Séparez les sous-titres existants de la transcription IA

L'Acteur principal peut inclure des sous-titres existants dans son résultat. Sa transcription IA est facturée à la minute démarrée par vidéo : sur Starter, une vidéo de 10 minute ajoute $0.41 avant l'événement résultat $0.003. Les résumés IA, les descriptions et le filtrage par date de chaîne ont également leurs propres prix d'événement. FlashData récupère les pistes existantes ; il ne génère pas de légendes manquantes.

### Séparez la découverte de l’enrichissement

Utilisez la vidéo connue IDs lorsque c'est ce que votre application possède déjà. Une exploration de découverte peut renvoyer des vidéos que vous n’utilisez jamais. Découverte du budget et tout enrichissement ultérieur séparément.

<a id="costs"></a>
## Comparez les tarifs unitaires et les frais mensuels

USD, plans de liste mensuels. Ce modèle utilise l'événement de résultat des streamers/youtube-scraper, une vidéo renvoyée par entrée ID, avec filtrage de date et modules complémentaires d'IA désactivés. Les sous-titres existants utilisent son paramètre ALWAYS_SUBTITLES ; les métadonnées plus les légendes sont un résultat d'acteur mais deux requêtes FlashData. Les prix FlashData proviennent de son catalogue de données YouTube actuel. L’intégralité du solde inclus de chaque forfait est allouée à ce flux de travail avant qu’une utilisation supplémentaire ne soit ajoutée. Apify Arrêts gratuits à son budget $5 ; les forfaits payants ajoutent une utilisation au-dessus du budget inclus. Les achats FlashData à partir d'un solde nul incluent sa recharge minimale $10 lorsqu'un crédit supplémentaire est nécessaire. Les taxes, remises annuelles, autres acteurs, frais de stockage séparé/export et tentatives failed sont exclus. À zéro vidéo, un forfait payant sélectionné a toujours ses frais mensuels ; le coût effectif par vidéo n’est pas défini.

### Apify plans de plateforme

| Forfait Apify | Frais mensuels | Utilisation incluse / mois | Acteur principal / 1,000 vidéos | Vidéos dans ce budget |
| --- | --- | --- | --- | --- |
| Gratuit | $0.00 | $5.00 | $4.00 | 1,250 |
| Starter | $19.00 | $19.00 | $3.00 | 6,333 |
| Scale | $199.00 | $199.00 | $2.60 | 76,538 |
| Business | $999.00 | $999.00 | $2.40 | 416,250 |

Ces décomptes allouent l'intégralité du budget aux événements de résultat sans modules complémentaires ni autre utilisation de la plateforme. Si vous conservez Apify pour les autres Acteurs, son abonnement demeure ; comparez l'utilisation incrémentielle à votre budget restant.

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

Il s'agit de débits de données standard de YouTube. La recherche étendue et le téléchargement ont des prix distincts. [Tarif complet](https://flashdata.dev/fr/pricing/youtube-data).

### Exemples travaillés

FlashData payez au fur et à mesure contre Apify Starter et streamers/youtube-scraper. Les métadonnées plus les sous-titres existants sont un événement de résultat d'acteur, mais deux requêtes FlashData. Il s'agit d'estimations d'utilisation et de coûts mensuels, et non d'une revendication de champs de réponse identiques.

| Vidéos | Flux de travail | FlashData requêtes | FlashData utilisation modélisée | Utilisation des événements d'acteur | Apify coût mensuel, frais compris |
| --- | --- | --- | --- | --- | --- |
| 1,000 | Métadonnées pour la vidéo connue IDs | 1,000 | $0.50 | $3.00 | $19.00 |
| 1,000 | Métadonnées + légendes existantes | 2,000 | $1.00 | $3.00 | $19.00 |
| 10,000 | Métadonnées pour la vidéo connue IDs | 10,000 | $5.00 | $30.00 | $30.00 |
| 10,000 | Métadonnées + légendes existantes | 20,000 | $10.00 | $30.00 | $30.00 |
| 100,000 | Métadonnées pour la vidéo connue IDs | 100,000 | $50.00 | $300.00 | $300.00 |
| 100,000 | Métadonnées + légendes existantes | 200,000 | $100.00 | $300.00 | $300.00 |

Les achats de FlashData avec un solde nul nécessitent une recharge minimale de $10. Les frais de Apify contiennent déjà son utilisation incluse ; n'ajoutez pas cette utilisation deux fois. La calculatrice HTML vous permet de choisir les deux forfaits indépendamment.

### Accès gratuit

Apify Free a un budget partagé mensuel de $5 ; Des restrictions individuelles concernant les démos d'acteurs peuvent également s'appliquer. L'acteur Dojo API illustré ci-dessus limite Free à cinq exécutions de démonstration par mois et à dix éléments par exécution.

Les inscriptions admissibles vérifiées FlashData peuvent recevoir une allocation initiale allant jusqu'à 4,000 standard YouTube. Cela ne se réinitialise pas mensuellement.

<a id="migration"></a>
## Conservez le lecteur de jeux de données ; remplacer une recherche

Commencez par une vidéo publique connue ID. L'exemple écrit les champs Actor familiers sélectionnés sous forme de tableau JSON et enregistre la réponse complète FlashData séparément.

### 1. Configurer l'accès et cartographier la demande

Créez ou réutilisez une clé avec l'autorisation youtube_metadata dans [API Clés](https://flashdata.dev/app/api-keys) et cochez [crédits disponibles](https://flashdata.dev/app/billing). Les agents doivent d’abord réutiliser l’accès ou utiliser un essai éligible. Gardez les clés en dehors du chat.

Appel d'acteur existant, pour référence de migration :

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

FlashData JSON corps pour POST /v1/queries/realtime:

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

Le point de terminaison de synchronisation Actor peut déjà renvoyer des éléments dans une seule réponse HTTP. Migrer la demande, l'enveloppe et les champs ; n'ajoutez pas de sondages inutiles.

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

Choisissez Python ou Bash. Chaque nouveau dossier de sortie soumet une demande. La réutilisation du dossier lit la sortie enregistrée ; interrompu ou les tentatives failed s'arrêtent pour inspection. Les deux versions utilisent les mêmes fichiers.

#### 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 video-lookup.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("video_id")
parser.add_argument("folder", type=Path)
args = parser.parse_args()
if not re.fullmatch(r"[A-Za-z0-9_-]{11}", args.video_id):
    raise SystemExit("Use an 11-character YouTube video ID")
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
out = args.folder
if not out.exists():
    key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
    if not key.strip():
        raise SystemExit("An API key is required")
    out.mkdir(parents=True)
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime", json=body,
            headers={"X-API-Key": key, "Accept": "application/json"},
            timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit("Outcome unknown. Keep this folder and check History before retrying.")
    (out / "response.json").write_bytes(response.content)
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""), encoding="utf-8")
else:
    print("Reading saved output; no API call.")

try:
    saved = json.loads((out / "request.json").read_text(encoding="utf-8"))
    status = (out / "http-status.txt").read_text(encoding="utf-8").strip()
except (OSError, ValueError):
    raise SystemExit("Incomplete attempt. Inspect this folder and History before retrying.")
if saved != body:
    raise SystemExit("This folder belongs to a different request. Use a new folder.")
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect response.json and retry-after.txt")
data = json.loads((out / "response.json").read_text(encoding="utf-8"))
if not isinstance(data, dict) or data.get("status") != "done" or data.get("source") != body["source"]:
    raise SystemExit("Request did not complete successfully; inspect response.json")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict):
    raise SystemExit("Expected one metadata result")
item = items[0]
if item.get("videoId") != args.video_id:
    raise SystemExit("Returned video does not match the request")
seconds = item.get("duration")
duration = None
if seconds is not None:
    if type(seconds) not in (int, float) or not math.isfinite(seconds) or seconds < 0:
        raise SystemExit("Invalid duration")
    whole = int(seconds)
    duration = f"{whole // 3600:02d}:{whole % 3600 // 60:02d}:{whole % 60:02d}"
mapped = [{
    "id": item["videoId"],
    "url": "https://www.youtube.com/watch?v=" + item["videoId"],
    "title": item.get("title"), "text": item.get("description"),
    "channelName": item.get("channel"), "channelId": item.get("channelId"),
    "viewCount": item.get("viewCount"), "likes": item.get("likeCount"),
    "commentsCount": item.get("commentCount"), "duration": duration,
    "uploadDateRaw": item.get("uploadDate"),
    "captionLanguages": item.get("transcriptLanguages"),
}]
(out / "dataset-items.json").write_text(
    json.dumps(mapped, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/dataset-items.json; actual usage: {json.dumps(data.get('usage'))}")

```

Exécutez à partir de ce dossier, en remplaçant le ID par une vidéo publique de votre ensemble de données :

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

#### Bash

Nécessite Bash, cURL 7.76+ et jq 1.6+. Enregistrez le script complet ci-dessous sous le nom video-lookup.sh dans votre dossier de travail :

```bash
#!/usr/bin/env bash
set -euo pipefail
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Set OUTPUT_FOLDER}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || { echo 'Invalid video ID' >&2; exit 1; }
body=$(jq -n --arg id "$video_id" '{source: "youtube_metadata", video_id: $id,
  params: {include_formats: false, include_chapters: true}}')
if [[ ! -e "$out" ]]; then
  if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
    read -r -s -p 'FlashData API key: ' FLASHDATA_API_KEY; printf '\n'
  fi
  : "${FLASHDATA_API_KEY:?An API key is required}"
  mkdir -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep this folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved status, response and Retry-After header.\n' >&2; exit 1;
}
mapped=$(jq -e --arg id "$video_id" '
  def pad: tostring | if length < 2 then "0" + . else . end;
  def hms:
    if . == null then null
    elif type != "number" then error("Invalid duration")
    elif (isfinite | not) or . < 0 then error("Invalid duration")
    else floor | [(./3600 | floor | pad), ((.%3600)/60 | floor | pad), (.%60 | pad)] | join(":") end;
  if .source != "youtube_metadata" or .status != "done" then error("Request not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $id then error("Wrong video") else . end
  | [{id: .videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
      title, text: .description, channelName: .channel, channelId,
      viewCount, likes: .likeCount, commentsCount: .commentCount,
      duration: (.duration | hms), uploadDateRaw: .uploadDate,
      captionLanguages: .transcriptLanguages}]' "$out/response.json")
printf '%s\n' "$mapped" > "$out/dataset-items.json"
printf 'Saved %s/dataset-items.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

Exécutez à partir de ce dossier :

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

### 3. Lire la sortie enregistrée

vidéo-001/dataset-items.json est un tableau pour votre lecteur d'applications. response.json conserve le résultat original et l'utilisation. Il s'agit d'un adaptateur de champ, et non du jeu de données Apify API. Il ne crée pas d'ensemble de données ID, peuple des métriques inconnues ou fabrique des commentaires ou des champs de monétisation.

dataset-items.json d’illustration :

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

| Champ Acteur existant | FlashData métadonnées | Action migratoire |
| --- | --- | --- |
| identifiant / URL | videoId | Conservez l'identifiant et construisez la montre canonique YouTube URL. |
| titre / texte | titre/description | Mappez la description en texte si votre lecteur attend le nom du champ de l’acteur. |
| channelName / channelId | canal / channelId | Conservez le nom et ID. Ne déduisez pas un handle de canal à partir de son nom d’affichage. |
| j'aime / commentsCount / viewCount | likeCount / commentCount / viewCount | Conservez les valeurs manquantes sous la forme null. Une métrique manquante n’est pas nulle. |
| durée, souvent HH:MM:SS | durée en secondes | L'exemple convertit les secondes en une chaîne HH:MM:SS, en conservant null. |
| date, qui peut être absolue ou relative | uploadDate | L'exemple conserve uploadDateRaw. Ajoutez votre propre analyseur de date avant de renseigner une date normalisée. |
| sous-titres[] / transcriptionUrl | Une demande distincte youtube_transcript ou youtube_captions | Les pistes existantes et la synthèse vocale générée sont des entrées différentes dans votre application. |
| Champs d'enrichissement réservés aux acteurs | Pas d'équivalent automatique | Conservez une étape d'enrichissement distincte pour les commentaires, l'expansion des canaux et l'analyse générée par l'IA. |

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

### Reprendre l'intention des sous-titres

| Entrée de l'acteur principal | FlashData migration |
| --- | --- |
| ALWAYS_SUBTITLES | Ajoutez une demande youtube_transcript ou youtube_captions distincte pour les pistes existantes. |
| subtitlesLanguage | Utilisez params.language. Un tableau allant jusqu'à 10 langues renvoie les pistes ainsi que les erreurs par langue. |
| preferAutoGeneratedSubtitles | C'est une préférence. FlashData params.auto sélectionne strictement les sous-titres générés par YouTube ou fournis par le téléchargeur, sans repli d'origine croisée. |
| TRANSCRIPTION_AS_FALLBACK / ALWAYS_TRANSCRIBE | Gardez la parole au texte séparée ; FlashData ne génère pas de piste manquante. |
| sous-titres[].srt / transcriptionUrl | Mappez des segments horodatés ou formatez explicitement un fichier. Un texte brut généré URL n'est pas un tableau de segments horodatés. |

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

<a id="production"></a>
## Ensembles de données, tâches et plannings longs running

Si vos outils dépendent de l'ensemble de données Apify IDs et des planifications, conservez un acteur personnalisé comme orchestrateur : appelez FlashData à l'intérieur et écrivez les éléments mappés dans son ensemble de données. Budgétisez le temps d’exécution et le stockage de cet acteur parallèlement à l’utilisation de FlashData. La calculatrice ci-dessus modélise les appels directs FlashData.

| Préoccupation | Apify | FlashData |
| --- | --- | --- |
| Demande | Options Acteur ID + build/input ; Tâche enregistrée facultative | source + video_id + paramètres ; pas d'options de construction ou de mémoire d'acteur |
| Résultat synchrone | run-sync-get-dataset-items renvoie un tableau d'éléments ; sa limite documentée de HTTP est de 300 secondes | La réponse en temps réel a un statut, des résultats[] et une utilisation ; extraire les résultats avant de mapper les champs |
| Travail long running | Démarrez une exécution, enregistrez l'exécution ID, attendez un état du terminal, lisez defaultDatasetId | Soumettez un travail async ou batch, enregistrez son ID, interrogez son statut et récupérez son résultat |
| Stockage de sortie | Éléments de l'ensemble de données plus enregistrements de valeur-clé facultatifs référencés par URL | Enregistrez la réponse ou exportez-la vers votre propre stockage durable ; un ensemble de données Apify ID n'est pas un travail FlashData ID |
| Travail récurrent | Apify Le programme démarre Acteurs/Tasks ; les webhooks informent les consommateurs en aval | Utilisez votre application, cron, CI ou hôte d'agent pour appeler FlashData ; migrer le planning et le consommateur ensemble |

### Déplacer un ensemble de données existant

Exportez chaque page de l’ensemble de données existant avant de changer de producteur. Conservez les fichiers de sous-titres référencés dont vous avez encore besoin. Ne réexécutez pas un Actor uniquement pour télécharger la sortie déjà collectée.

[Enregistrez et réutilisez les résultats](https://flashdata.dev/fr/docs/guides/save-results/reference.md)

### Actualiser une vidéothèque

Dédupliquez la vidéo IDs, vérifiez chaque résultat et conservez l'entrée-sortie IDs. Utilisez le traitement par lots ou en masse pour les listes plus volumineuses ; réessayez les éléments failed après avoir inspecté leurs erreurs.

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

### Gardez le travail programmé prévisible

Reportez le fuseau horaire, la cadence, les informations d'identification et votre destination de sortie. Enregistrez une fenêtre de planification de completed avant de retirer l'ancien producteur, afin que les planifications qui se chevauchent ne créent pas de travail en double.

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

### Liste de contrôle de basculement

1. Enregistrez l'acteur exact, la construction, l'entrée de tâche, les événements facturables, les champs de sortie et le consommateur en aval.
2. Videz les analyses existantes et exportez toutes les pages de l’ensemble de données. clean=true peut ignorer des enregistrements, donc une courte page à elle seule ne constitue pas une preuve que l'exportation est terminée ; vérifiez les métadonnées de pagination.
3. Vérifiez l'adaptateur par rapport aux IDs enregistrés, y compris les métriques null, les dates et l'origine de la légende.
4. Déplacez la cadence, le fuseau horaire et la destination dans votre coureur. Gardez les points de contrôle. maxTotalChargeUsd n'est pas un plafond de dépenses clé FlashData API ; ajoutez des contrôles de dépenses au niveau des applications.
5. Changez de producteur pour la fenêtre de planification suivante sans exécutions en double. Préserver les exportations. Arrêtez le travail récurrent sur les informations d'identification révoquées ou le solde insuffisant.

<a id="agents"></a>
## Codage et agents personnels

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

1. Identifiez l'intégration de l'acteur et réutilisez d'abord un identifiant FlashData existant.
2. Prouvez une recherche vidéo et enregistrez la sortie brute et mappée avec l'utilisation réelle.
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é. 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. Arrêt sur révocation ; ne créez pas de nouveaux essais.

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

[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

### Est-ce un remplacement de la plateforme Apify ?

Il remplace les appels de données YouTube spécifiques dans votre flux de travail. Apify fournit également un marché Actor, des environnements d'exécution personnalisés, des planifications hébergées et un stockage. Conservez ces pièces là où vous les utilisez ou transférez leurs responsabilités dans votre propre application.

### Pourquoi ne pas comparer tous les acteurs à un seul prix ?

Les développeurs d’acteurs choisissent différents modèles de tarification, résultats et restrictions d’entrée. Le calculateur utilise des streamers/youtube-scraper. La table des acteurs comprend également un acteur de découverte moins cher ; ses restrictions sur une seule vidéo sont importantes lors du remplacement d'une recherche à la demande.

### Un abonnement de Apify est-il facturé deux fois pour l'utilisation incluse ?

Non. Les frais du forfait incluent un budget d’utilisation prépayé. Le calculateur soustrait ce budget avant d'ajouter une utilisation supplémentaire de l'acteur. Cela suppose que l'intégralité du budget est disponible pour ce flux de travail. Si d'autres Acteurs en consomment, il en reste moins pour YouTube.

### Puis-je conserver un consommateur d'ensemble de données Apify ?

L'exemple écrit un tableau JSON avec des noms de champs familiers sélectionnés. Il ne crée pas d'ensemble de données Apify et n'exécute pas ID. Lisez le nouveau fichier directement, publiez-le via votre propre stockage ou conservez un acteur personnalisé qui écrit ces éléments mappés dans son ensemble de données pour votre consommateur existant.

### Qu’arrive-t-il aux sous-titres et à la transcription IA ?

L'acteur principal de Apify propose des sous-titres existants et une transcription IA en option. FlashData récupère les pistes YouTube existantes. Demandez les métadonnées et les légendes séparément, vérifiez la langue et l'origine renvoyées et séparez toute étape de synthèse vocale ou de résumé de l'IA.

### Mon planning actuel ou mon plafond de dépenses d'exécution seront-ils transférés ?

Non. Recréez le calendrier dans le programme d'exécution de votre choix et ajoutez une vérification budgétaire au niveau de l'application. Un paramètre Apify maxTotalChargeUsd n'est pas un plafond de dépenses clé FlashData API. Les clés de propriétaire utilisent le solde du compte partagé.
