Aller au contenu
FR
Obtenir une clé API
Parcourir la documentation

Référence API

API de téléchargement YouTube

Obtenir une clé API

Téléchargez des vidéos ou de l’audio YouTube dans votre stockage cloud. Choisissez la résolution, le format et la durée de l’extrait, puis suivez la tâche asynchrone jusqu’à la fin.

API de téléchargement de vidéos YouTube — exemples Python

Préparer une requête

L’identifiant à 11 caractères de l’URL de la vidéo, et non l’URL complète.

Options avancées pour les médias

Le sélecteur de format remplace les réglages de qualité, de fréquence d’images et de piste audio. Le format de sortie et les limites de l’extrait restent appliqués. La fin doit être postérieure au début ; chaque limite peut être omise.

Destination de stockage

Si ce champ est vide, la date UTC d’envoi vers le stockage est utilisée (YYYYMMDD).

Ajoutez vos identifiants de stockage sur votre serveur avant d’exécuter le code. Ils doivent autoriser l’envoi de fichiers.

Identifiants du fournisseur et conditions de stockage
Webhook de fin de tâcheContenu du webhook, vérification et nouvelles tentatives

Markdown s’applique aux résultats une fois le traitement terminé. Les reçus et l’état des tâches conservent leurs champs d’origine.

POSThttps://data.flashdata.dev/v1/queries
import gzip
import json
import random
import time
import urllib.error
import urllib.request

api_key = "YOUR_API_KEY"
payload = {
    "source": "youtube_download",
    "video_id": "jNQXAC9IVRw",
    "params": {
        "download_type": "audio_video",
        "video_quality": "<=720",
        "audio_language": "default",
        "upload_metadata": False,
        "output_format": "mp4",
        "storage": {
            "storage_type": "s3",
            "storage_url": "your-media-bucket",
            "access_key": "YOUR_ACCESS_KEY",
            "secret_key": "YOUR_SECRET_KEY",
            "region": "us-east-1",
        },
    },
}

def api_get(url):
    request = urllib.request.Request(url, headers={"X-API-Key": api_key})
    with urllib.request.urlopen(request, timeout=60) as response:
        return json.load(response), response.headers

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, request, file_pointer, code, message, headers, new_url):
        return None

def read_result(url):
    request = urllib.request.Request(url, headers={"X-API-Key": api_key})
    try:
        with urllib.request.build_opener(NoRedirect).open(request, timeout=60):
            raise RuntimeError("Expected a result redirect")
    except urllib.error.HTTPError as response:
        if response.code != 302 or not response.headers.get("Location"):
            raise
        storage_url = response.headers["Location"]
        response.close()
    # Never forward the API key to storage.
    with urllib.request.urlopen(urllib.request.Request(storage_url, headers={"Accept-Encoding": "gzip"}), timeout=60) as response:
        content = response.read()
        if response.headers.get("Content-Encoding") == "gzip":
            content = gzip.decompress(content)
        return json.loads(content)

def link(job, relation):
    return next(item["href"] for item in job["links"] if item["rel"] == relation)

request = urllib.request.Request(
    "https://data.flashdata.dev/v1/queries",
    data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
    headers={"Content-Type": "application/json", "X-API-Key": api_key},
    method="POST",
)
with urllib.request.urlopen(request, timeout=120) as response:
    submission = json.load(response)
jobs = submission.get("queries", [submission])
for submitted in jobs:
    print("Job:", submitted["id"])
    deadline = time.monotonic() + 300
    while time.monotonic() < deadline:
        status, headers = api_get(link(submitted, "self"))
        job = status.get("job", status)
        if job["status"] == "completed":
            result = job.get("result") if submitted["source"] == "youtube_download" and job.get("result") is not None else read_result(link(submitted, "results"))
            print(json.dumps(result, ensure_ascii=False, indent=2))
            break
        if job["status"] == "failed":
            raise RuntimeError(f"{submitted['id']}: {job.get('error', 'Job failed')}")
        hint = headers.get("Retry-After", "1")
        delay = max(1, min(5, int(hint))) if hint.isdigit() else 5
        time.sleep(min(delay * random.uniform(1, 1.2), max(0, deadline - time.monotonic())))
    else:
        raise TimeoutError(f"Still running; save this job ID: {submitted['id']}")
Tâche acceptée ; suivez son état pour récupérer le résultatAuthentification X-API-Key

Paramètres

Envoyez source et video_id à la racine de l’objet JSON. Placez les options de la source dans params. Vous pouvez omettre les champs facultatifs.

Corps de la requête

sourcestring / Obligatoire
Définissez ce champ sur youtube_download.
video_idstring / Obligatoire
Identifiant YouTube de la vidéo, composé de 11 caractères, par exemple FUfGcZ092b0. Les lettres, chiffres, tirets bas et traits d’union sont acceptés.
Exactement 11 caractèresPar défaut : Non défini
Format accepté^[A-Za-z0-9_-]{11}$
paramsobject / Obligatoire
Paramètres de cette requête.
callback_urlstring · nullable / Facultatif
Async et Batch uniquement. URL HTTPS publique de notification sur le port 443, de 2 048 caractères maximum, sans identifiants ni fragment. Omettez ce champ, ou utilisez null ou une chaîne vide pour désactiver les notifications. Dans un Batch, définissez-le pour chaque requête, en dehors de params.
Par défaut : Non défini

Vidéo et audio

params.download_typestring / Facultatif
audio_video fusionne la vidéo et l’audio ; video sélectionne uniquement la vidéo ; audio sélectionne uniquement l’audio.
1 à 11 caractèresValeurs : audio_video / video / audioPar défaut : "audio_video"
params.video_qualitystring / Facultatif
Résolution vidéo souhaitée. Omettez ce champ pour un téléchargement audio seul.
1 à 40 caractèresValeurs : best / worst / <=144 / ==144 / >=144 / <=360 / ==360 / >=360 / <=480 / ==480 / >=480 / <=720 / ==720 / >=720 / <=1080 / ==1080 / >=1080 / <=1440 / ==1440 / >=1440 / <=2160 / ==2160 / >=2160 / <=4320 / ==4320 / >=4320Par défaut : "<=720"
params.fpsstring / Facultatif
Contrainte de fréquence d’images : >=, <= ou == suivi d’une valeur de 1 à 240. Omettez ce champ pour un téléchargement audio seul.
1 à 6 caractèresPar défaut : Non défini
Format accepté^(?:>=|<=|==)(?:[1-9]\d?|1\d\d|2[0-3]\d|240)$
params.audio_languagestring / Facultatif
Sélection de la piste audio. S’applique à audio_video et audio.
1 à 8 caractèresValeurs : default / originalPar défaut : "default"
params.audio_qualitystring / Facultatif
Débit de l’audio seul en kbps, ou best. Envoyez les valeurs numériques sous forme de chaînes. Omettez ce champ pour les téléchargements vidéo.
1 à 10 caractèresValeurs : best / 320 / 256 / 192 / 128Par défaut : "best"
params.output_formatstring / Facultatif
Vidéo : mp4, webm ou mkv. Audio : m4a, mp3 ou opus.
1 à 10 caractèresValeurs : mp4 / webm / mkv / m4a / mp3 / opusPar défaut : mp4 (video) / m4a (audio)
params.yt_dlp_formatstring / Facultatif
Sélecteur de format avancé, de 1 à 1 024 caractères après suppression des espaces en début et en fin. Les caractères de contrôle sont refusés. Remplace video_quality, fps et audio_language, dont les valeurs sont alors ignorées ; le format de sortie et les limites de l’extrait restent appliqués.
1 à 1 024 caractèresPar défaut : Non défini
params.upload_metadataboolean / Facultatif
Envoyez un fichier JSON de métadonnées avec le fichier multimédia dans votre stockage.
true ou falsePar défaut : false

Découpe

params.start_atstring / Facultatif
Début de l’extrait au format H:MM:SS ou HH:MM:SS, de 00:00:00 à 12:00:00. Vaut 00:00:00 si seul end_at est fourni.
1 à 8 caractèresPar défaut : Non défini
Format accepté^\d{1,2}:[0-5]\d:[0-5]\d$
params.end_atstring / Facultatif
Fin de l’extrait au format H:MM:SS ou HH:MM:SS, jusqu’à 12:00:00. Doit être postérieure à start_at.
1 à 8 caractèresPar défaut : Non défini
Format accepté^\d{1,2}:[0-5]\d:[0-5]\d$

Destination de stockage

params.storageobject / Obligatoire
Destination des fichiers multimédias une fois le traitement terminé. Seuls les champs de stockage indiqués sont acceptés.
params.storage.storage_typestring / Obligatoire
Fournisseur de stockage : s3, s3_compatible, oss, gcs, azure, cos, bos ou tos.
params.storage.storage_urlstring / Obligatoire
Nom de bucket ou de conteneur non vide, de 1 024 caractères maximum. Les espaces en début et en fin sont supprimés. Pour s3, utilisez un nom de bucket AWS valide, sans URL ni chemin de dossier ; indiquez les dossiers dans object_prefix.
params.storage.object_prefixstring / Facultatif
Préfixe des clés d’objet, de 1 à 512 caractères. Chaque segment séparé par une barre oblique accepte les lettres ASCII, chiffres, points, tirets bas et traits d’union ; les segments vides, . et .. sont refusés. Aucune barre oblique initiale. Les espaces en début et en fin ainsi qu’une barre oblique finale sont supprimés. YYYYMMDD représente la date UTC d’envoi vers le stockage, y compris dans archive/YYYYMMDD.
Par défaut : "YYYYMMDD"
params.storage.access_keystring / Facultatif
Clé d’accès pour S3, un stockage compatible S3, OSS, COS, BOS ou TOS ; à associer à secret_key.
params.storage.secret_keystring / Facultatif
Clé secrète pour S3, un stockage compatible S3, OSS, COS, BOS ou TOS.
params.storage.endpoint_urlstring / Facultatif
URL HTTPS publique du service de stockage compatible S3 ou OSS. Pour COS, BOS et TOS, cette URL est déterminée à partir de region.
params.storage.regionstring / Facultatif
Obligatoire pour COS, BOS et TOS ; à fournir également pour les téléchargements vers S3 et les stockages compatibles S3. Les noms de bucket COS incluent l’APPID.
params.storage.service_accountobject / Facultatif
Compte de service GCS : project_id, client_email et private_key au format PEM.
params.storage.account_namestring / Facultatif
Nom du compte de stockage Azure. Utilisez le nom du conteneur dans storage_url.
params.storage.sas_tokenstring / Facultatif
Jeton SAS du conteneur Azure autorisant l’écriture, avec date d’expiration et signature.

Réponse

Le générateur soumet les téléchargements en mode Async ou Batch et exige params.storage. HTTP 200 avec status: pending confirme l’acceptation de la requête, pas la livraison du fichier. Batch renvoie un accusé de réception de tâche par identifiant vidéo.

À la soumission, usage.credits est 0. Les téléchargements sont facturés selon le volume multimédia effectivement livré ; les fichiers de métadonnées facultatifs ne sont pas inclus dans cette facturation.

Vérifiez régulièrement job.status jusqu'à completed, puis récupérez le résultat JSON. Consultez les informations du fichier dans results[0], notamment son emplacement file_url, sa taille et sa somme de contrôle.

Lire le résultat

Une fois la tâche terminée, enregistrez le JSON obtenu via son lien de résultats dans response.json. Enregistrez le script ci-dessous dans read-response.py, dans le même dossier, puis exécutez python read-response.py. Il lit les informations sur les fichiers sans télécharger de média ni envoyer de nouvelle requête.

read-response.py
import json
from pathlib import Path

response = json.loads(Path("response.json").read_text(encoding="utf-8-sig"))
if response.get("status") not in ("done", "completed") or not isinstance(response.get("results"), list):
    raise SystemExit("Expected completed result JSON; inspect the response or job status.")
if not response["results"]:
    print("[]")
    raise SystemExit(0)
result = response["results"][0]

output = {name: result.get(name) for name in (
    "file_url", "file_size", "md5", "duration", "output_format"
)}
# Use your storage credentials to access the media at file_url.
print(json.dumps(output, ensure_ascii=False, indent=2))

La réponse d’état peut inclure les informations du fichier dans job.result. Les exemples JSON par défaut les utilisent si elles sont présentes ; sinon, ils suivent le lien rel: results ; ne supposez pas que le résultat est toujours inclus dans la réponse d’état.

Tous les champs de la réponse à la soumission
ChampDescription
idstringIdentifiant de la tâche de téléchargement.
sourcestringyoutube_download.
statusstringpending lorsque la tâche est acceptée.
created_atstringDate et heure de création de la tâche au format ISO 8601.
usage.creditsnumber0 à la soumission. Après la fin du traitement, les téléchargements sont facturés selon le volume de données livré.
linksarraySuivez le lien self pour consulter l’état de la tâche et le lien results pour récupérer le résultat une fois le traitement terminé.
links[].relstringself ou results.
links[].hrefstringURL à appeler avec la même clé API.
links[].methodstringGET.
Champs du fichier livré
ChampDescription
results[0].file_urlstringEmplacement du fichier multimédia dans votre stockage.
results[0].file_sizeintegerTaille du fichier multimédia en octets.
results[0].downloaded_bytesintegerNombre d’octets multimédias livrés utilisé pour la facturation.
results[0].md5stringSomme de contrôle MD5 du fichier multimédia.
results[0].resolutionstring · nullableRésolution vidéo, ou null pour un fichier audio seul ou si la hauteur est indisponible.
results[0].durationnumber · nullableDurée en secondes, si disponible.
results[0].output_formatstringFormat du fichier livré.
results[0].fpsnumber · nullableFréquence d’images, si disponible.
results[0].video_codecstring · nullableCodec vidéo, si disponible.
results[0].audio_codecstring · nullableCodec audio, si disponible.
results[0].dynamic_rangestring · nullablePlage dynamique de la vidéo, si disponible.
results[0].metadataobject · optionalChamps file_url, file_size et md5 du fichier de métadonnées lorsque upload_metadata vaut true. Les octets de métadonnées ne sont pas facturés au titre du téléchargement.

Les champs ci-dessus décrivent la réponse JSON par défaut. Les options de format s’appliquent à l’enregistrement de livraison, pas au fichier multimédia. Formats JSON, texte brut et Markdown.

Cycle de traitement Async et Batch

La soumission renvoie un reçu, pas les résultats. Async crée une tâche ; Batch renvoie une tâche distincte dans queries[] pour chaque requête acceptée. Suivez chaque tâche et récupérez ses résultats séparément.

Soumettez les requêtes à data.flashdata.dev ; lisez l’état et les résultats sur api.flashdata.dev avec la même clé X-API-Key. Les exemples liés dans les bases de l’API utilisent Python et cURL.

  1. 1. Enregistrer les identifiants de tâche

    Soumettez un téléchargement en mode Async, ou placez plusieurs requêtes de téléchargement dans le tableau queries d’une requête Batch. Chaque entrée doit inclure params.storage. Enregistrez tous les identifiants de tâche retournés.

    Requête Async et reçu de soumission · Corps de requête Batch

  2. 2. Vérifier l’état

    GET https://api.flashdata.dev/v2/jobs/{jobId}

    pending / processing : attendez entre les vérifications et respectez Retry-After lorsqu’il est présent. completed : récupérez les résultats. failed : consultez job.error.

    Lisez job.status, et non le champ status du reçu de soumission.

    Vérifier l’état · Python et cURL

    Référence API : état d’une tâche
  3. 3. Récupérer les résultats

    GET https://api.flashdata.dev/v2/jobs/{jobId}/results

    Après la fin du traitement, authentifiez la requête de lecture du résultat, puis récupérez l’URL de stockage renvoyée par la redirection 302, sans votre clé API. Enregistrez le JSON dans les 24 heures suivant la fin du traitement.

    Le JSON décrit les fichiers multimédias livrés dans votre stockage. Accéder au fichier multimédia.

    Récupérer les résultats · Python et cURL · Formats de réponse

    Référence API : récupération des résultats

La vérification de l’état et la récupération de résultats existants ne consomment aucun crédit de requête. Un délai de vérification dépassé n’annule pas la tâche : conservez son identifiant pour éviter de soumettre des doublons facturables. Codes d’erreur et nouvelles tentatives.

Webhooks de fin de tâche

Configurer chaque requête

Définissez callback_url à la racine d’une requête Async, ou dans chaque requête d’un Batch, en dehors de params. Aucune requête distincte d’enregistrement de webhook n’est nécessaire.

Utilisez une URL HTTPS publique sur le port 443. FlashData envoie une notification POST pour chaque tâche atteignant l’état completed ou failed ; l’événement contient des liens, pas le résultat lui-même.

Accuser réception et vérifier

Renvoyez 2xx après avoir enregistré durablement l’événement. Dédupliquez à l’aide de delivery_id, également envoyé dans X-Delivery-Id. Les redirections ne sont pas suivies.

Les envois en échec sont retentés avec un délai exponentiel, dans la limite de 8 tentatives au total et au plus tard 24 heures après la fin du traitement. Conservez la vérification périodique de l’état comme solution de secours.

Les notifications ne sont pas signées. Vérifiez l’identifiant, la source et l’état final de la tâche via l’endpoint d’état authentifié avant de traiter la notification. L’identifiant d’envoi sert à la déduplication ; il ne prouve pas l’authenticité.

Exemple d’événement webhook et ses champs
Exemple de notification de fin de tâche
{
  "delivery_id": "completion:job_example0001",
  "id": "job_example0001",
  "source": "youtube_download",
  "status": "completed",
  "links": [
    {
      "rel": "self",
      "href": "https://api.flashdata.dev/v2/jobs/job_example0001",
      "method": "GET"
    },
    {
      "rel": "results",
      "href": "https://api.flashdata.dev/v2/jobs/job_example0001/results",
      "method": "GET"
    }
  ]
}
ChampDescription
delivery_idstringIdentifiant de livraison stable. Utilisez-le pour dédupliquer les notifications ; il est aussi envoyé dans l’en-tête X-Delivery-Id.
idstringIdentifiant de la tâche.
sourcestringSource de données demandée.
statusstringcompleted ou failed.
linksarrayLiens vers l’état et les résultats. Les notifications ne contiennent ni les résultats ni de clé API.
links[].relstringself ou results.
links[].hrefstringURL absolue de l’API de gestion ; authentifiez la requête avec votre clé API.
links[].methodstringGET.

Contrat complet des webhooks et restrictions des URL

Traitement de fichiers Bulk

Importez un fichier contenant un identifiant vidéo par ligne et créez la tâche Bulk avec source : youtube_download. Les options communes s’appliquent à tous les identifiants du fichier.

Indiquez la destination de stockage obligatoire dans options.storage et les paramètres multimédias dans options. Pour les téléchargements individuels ou Batch, utilisez params.storage à la place.

Les fichiers multimédias sont livrés dans votre stockage cloud. Une fois le traitement terminé, le résultat Bulk comprend un manifeste et des fichiers de résultats décrivant les téléchargements. Enregistrez le manifeste et les fichiers de résultats dans les 24 heures suivant la fin de la tâche Bulk entière.

API de traitement Bulk · Python et cURL · Requêtes JSON Batch

Préparer un traitement Bulk pour cette source · Mettre en pause, reprendre et résoudre les erreurs

Téléchargement vidéo en lot — boîte à outils Python

Destination de stockage

Incluez params.storage dans chaque requête de téléchargement. Définissez storage_url sur le nom de votre bucket ou conteneur et fournissez des identifiants autorisant l’écriture. Conservez les identifiants de stockage sur votre serveur.

params.storage · Destination compatible S3
{
  "storage_type": "s3_compatible",
  "storage_url": "your-media-bucket",
  "object_prefix": "archive/YYYYMMDD",
  "endpoint_url": "https://your-s3-endpoint.example.com",
  "region": "your-provider-region",
  "access_key": "<storage-access-key>",
  "secret_key": "<storage-secret-key>"
}

object_prefix vaut par défaut YYYYMMDD, remplacé par la date UTC d’envoi vers le stockage. Utilisez un dossier fixe ou un modèle tel que archive/YYYYMMDD.

s3
Fournissez access_key et secret_key avec des droits d’écriture. Définissez region sur la région AWS de votre bucket.
s3 exemple
params.storage · s3
{
  "storage_type": "s3",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "us-east-1"
}
s3_compatible
Fournissez access_key, secret_key et une endpoint_url HTTPS publique. Définissez region selon les exigences de votre fournisseur ; Cloudflare R2 utilise auto.
s3_compatible exemple
params.storage · s3_compatible
{
  "storage_type": "s3_compatible",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "endpoint_url": "https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com",
  "region": "auto"
}
azure
Fournissez account_name et sas_token. Le SAS du conteneur doit autoriser l’écriture (sp inclut w) et contenir la ressource sr=c, l’expiration se, la version sv et la signature sig. storage_url est le nom du conteneur. N’envoyez pas endpoint_url, access_key ni secret_key.
azure exemple
params.storage · azure
{
  "storage_type": "azure",
  "storage_url": "your-media-container",
  "account_name": "yourstorageaccount",
  "sas_token": "sv=2023-11-03&sr=c&sp=w&se=2099-01-01T00%3A00%3A00Z&sig=YOUR_SAS_SIGNATURE"
}
bos
Fournissez access_key, secret_key et region : bj, su ou hkg. Si l’URL du service n’est pas fournie, elle est déterminée à partir de region. Utilisez un nom de bucket sans points.
bos exemple
params.storage · bos
{
  "storage_type": "bos",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "bj"
}
cos
Fournissez access_key, secret_key et une region de la forme ap-*, comme ap-hongkong. storage_url doit inclure le suffixe APPID. N’envoyez pas endpoint_url ; cette URL est déterminée à partir de region.
cos exemple
params.storage · cos
{
  "storage_type": "cos",
  "storage_url": "your-media-bucket-1234567890",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "ap-hongkong"
}
gcs
Fournissez service_account avec project_id, client_email (une adresse en .gserviceaccount.com) et la private_key au format PEM de votre compte de service. Ce compte doit avoir un accès en écriture au bucket. N’envoyez pas access_key, secret_key, region ni endpoint_url.
gcs exemple
params.storage · gcs
{
  "storage_type": "gcs",
  "storage_url": "your-media-bucket",
  "service_account": {
    "project_id": "your-project-id",
    "client_email": "[email protected]",
    "private_key": "-----BEGIN PRIVATE KEY-----\nYOUR_PRIVATE_KEY\n-----END PRIVATE KEY-----\n"
  }
}
oss
Fournissez access_key, secret_key et l’endpoint_url HTTPS publique correspondant à la région du bucket.
oss exemple
params.storage · oss
{
  "storage_type": "oss",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "endpoint_url": "https://oss-cn-hongkong.aliyuncs.com"
}
tos
Fournissez access_key, secret_key et region avec un préfixe cn-, ap-, eu- ou us-. Si l’URL du service n’est pas fournie, elle est déterminée à partir de region. Utilisez un nom de bucket sans points.
tos exemple
params.storage · tos
{
  "storage_type": "tos",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "cn-beijing"
}

Dans le résultat, le champ file_url identifie un objet dans votre stockage. Pour un objet privé, utilisez l’authentification de votre fournisseur de stockage ou une URL signée ; la clé API FlashData ne donne pas accès à votre bucket.

Pour un exemple complet de soumission, de suivi et de téléchargement, consultez Télécharger l’audio YouTube vers Amazon S3.

Livraison de fichiers

Le lien rel: results de la tâche renvoie par défaut une redirection vers le résultat JSON, pas vers un fichier MP4. FlashData envoie le fichier multimédia dans le bucket ou le conteneur que vous avez indiqué. Sa conservation dépend de la politique de votre bucket ; le résultat JSON de la tâche expire 24 heures après la fin du traitement.

results[0].file_url identifie l’objet, mais n’est pas nécessairement une URL publique ou signée. Accédez aux fichiers privés avec le SDK de votre fournisseur de stockage, ou générez une URL signée de courte durée sur votre serveur. N’envoyez pas votre clé API FlashData au fournisseur de stockage.

Activez upload_metadata pour envoyer un fichier {video_id}_meta.json dans le même préfixe que le fichier multimédia. Son emplacement et sa somme de contrôle figurent dans results[0].metadata.

Le téléchargement dans le navigateur est un mode propre à la console. L’API publique livre les fichiers dans votre stockage ; n’incluez pas les paramètres browser_delivery réservés à la console.

Résoudre les erreurs

En cas d’échec d’envoi vers le stockage ou d’erreur 403, vérifiez le fournisseur, le bucket, la région, l’URL du service et les droits d’écriture sur les objets. Une URL file_url inaccessible ou privée ne signifie pas forcément que l’envoi a échoué : vérifiez l’objet auprès de votre fournisseur de stockage.

Continuer à interroger la tâche ne permet pas de récupérer une vidéo supprimée ou indisponible. Si le format demandé est indisponible, consultez les formats dans les métadonnées, assouplissez les contraintes de qualité ou retirez le sélecteur avancé. Les requêtes audio seules nécessitent m4a, mp3 ou opus ; les requêtes vidéo nécessitent mp4, webm ou mkv.

Si le résultat JSON a expiré, recherchez d’abord le fichier livré dans votre bucket. Soumettre à nouveau la requête crée un nouveau téléchargement et peut entraîner une nouvelle facturation ; cela ne récupère pas l’ancien résultat JSON.

Pour les erreurs d’authentification, de solde, de format de requête ou de limite de débit, consultez la référence commune des erreurs. Une soumission ayant dépassé le délai d’attente peut tout de même avoir créé une tâche ; vérifiez les tâches existantes avant de réessayer.

Erreurs et codes d’état · Quand réessayer · Limites de débit

Guide étape par étape : Télécharger une vidéo et vérifier la livraison

Tarifs

PlansTarifs d’utilisationpar GB livréAbonnementsCrédits inclus par période de facturation
Paiement à l’usage0,10 $USPas de frais mensuelsRechargez selon vos besoins
Micro0,08 $US49,00 $US / mois1 000 crédits (50,00 $US d’utilisation de l’API) inclus
Starter0,07 $US199,00 $US / mois4 000 crédits (200,00 $US d’utilisation de l’API) inclus
Pro0,06 $US499,00 $US / mois10 000 crédits (500,00 $US d’utilisation de l’API) inclus
Scale0,05 $US999,00 $US / mois20 000 crédits (1 000,00 $US d’utilisation de l’API) inclus
Business0,04 $US1 999,00 $US / mois40 000 crédits (2 000,00 $US d’utilisation de l’API) inclus

Un seul forfait par compte. Des crédits partagés entre les trois produits. L’utilisation couverte par les crédits inclus n’est pas facturée à nouveau.

Tarifs actuels et limites des forfaits