Aller au contenu
FR
Obtenir une clé API

YouTube Download / Python

Télécharger l’audio d’une vidéo YouTube dans votre bucket S3

Lancez un téléchargement audio, suivez le job en arrière-plan et récupérez l’emplacement du fichier MP3 livré.

FlashData · Publié

Une forme d’onde audio livrée dans un stockage objet

Préparer votre bucket

Vous avez besoin de Python 3, d’une clé API FlashData associée à un compte disposant de crédits, d’un bucket Amazon S3 et d’identifiants autorisant l’écriture dans ce bucket. Conservez ces identifiants sur votre serveur.

bash
# Replace YOUR_API_KEY near the top of the code below.
export YOUTUBE_VIDEO_ID='FUfGcZ092b0'
export MEDIA_BUCKET='your-media-bucket'
export AWS_REGION='us-east-1'
export MEDIA_ACCESS_KEY='your-storage-access-key'
export MEDIA_SECRET_KEY='your-storage-secret-key'

Utilisez la région réelle de votre bucket. MEDIA_BUCKET est le nom du bucket, sans le préfixe s3:// ni chemin de répertoire. Consultez les paramètres de stockage pour les destinations compatibles S3.

Lancer et suivre le téléchargement

Enregistrez le script dans delivery.py. Il soumet un téléchargement audio à POST /v1/queries, choisit le format MP3 et précise la destination S3.

python
import json
import gzip
import os
import urllib.error
import urllib.request

API_URL = "https://data.flashdata.dev"
API_KEY = "YOUR_API_KEY"


def api_request(path, payload=None, response_headers=None, base_url=API_URL):
    target = path if path.startswith(("https://", "http://")) else base_url + path
    request = urllib.request.Request(
        target,
        data=json.dumps(payload).encode() if payload is not None else None,
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        method="POST" if payload is not None else "GET",
    )
    with urllib.request.urlopen(request, timeout=60) as response:
        if response_headers is not None:
            response_headers.update(response.headers)
        return json.load(response)


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


def result_request(url):
    request = urllib.request.Request(url, headers={"X-API-Key": API_KEY}, method="GET")
    try:
        with urllib.request.build_opener(NoRedirect).open(request, timeout=60):
            raise RuntimeError("Results endpoint did not redirect to storage")
    except urllib.error.HTTPError as response:
        if response.code != 302 or not response.headers.get("Location"):
            raise
        storage_url = response.headers["Location"]
        response.close()
    storage_request = urllib.request.Request(storage_url, headers={"Accept-Encoding": "gzip"})
    with urllib.request.urlopen(storage_request, timeout=60) as response:
        body = response.read()
        if response.headers.get("Content-Encoding") == "gzip":
            body = gzip.decompress(body)
        return json.loads(body)["results"]

import random
import time


def wait_for_job(submission, timeout_seconds=300):
    job_id = submission["id"]
    status_url = next(link["href"] for link in submission["links"] if link["rel"] == "self")
    deadline = time.monotonic() + timeout_seconds
    delay = 1.0
    while time.monotonic() < deadline:
        headers = {}
        payload = api_request(status_url, response_headers=headers)
        job = payload.get("job", payload)
        if job["status"] == "completed":
            results_url = next(link["href"] for link in job["links"] if link["rel"] == "results")
            return result_request(results_url)
        if job["status"] == "failed":
            raise RuntimeError(f"{job_id}: {job.get('error') or 'Job failed'}")
        hint = headers.get("Retry-After", headers.get("retry-after", "1"))
        delay = max(min(5.0, delay * 1.5), float(hint))
        time.sleep(min(delay * random.uniform(1.0, 1.2), max(0, deadline - time.monotonic())))
    raise TimeoutError(f"Keep this job ID and check again later: {job_id}")

storage = {
    "storage_type": "s3",
    "storage_url": os.environ["MEDIA_BUCKET"],
    "object_prefix": "YYYYMMDD",
    "region": os.environ["AWS_REGION"],
    "access_key": os.environ["MEDIA_ACCESS_KEY"],
    "secret_key": os.environ["MEDIA_SECRET_KEY"],
}

job = api_request("/v1/queries", {
    "source": "youtube_download",
    "video_id": os.environ["YOUTUBE_VIDEO_ID"],
    "params": {
        "download_type": "audio",
        "output_format": "mp3",
        "storage": storage,
    },
})
print("Save this job ID before polling:", job["id"], flush=True)
files = wait_for_job(job)
print(json.dumps(files, indent=2))
bash
python3 delivery.py

Le script affiche l’ID du job avant de commencer le suivi. Enregistrez cet ID dans votre application pour retrouver le travail déjà soumis après un redémarrage ou un délai dépassé.

Lire le reçu du job

L’envoi d’un téléchargement renvoie un reçu, pas le fichier multimédia. Cet exemple de reçu contient l’ID du job et les liens permettant de suivre son état et de lire son résultat.

json
{
  "id": "job_d265c693-950e-40bf-a13e-a432044d99ba",
  "source": "youtube_download",
  "status": "pending",
  "usage": {
    "credits": 0
  },
  "created_at": "2026-09-16T07:51:13.139Z",
  "links": [
    {
      "rel": "self",
      "href": "https://api.flashdata.dev/v2/jobs/job_d265c693-950e-40bf-a13e-a432044d99ba",
      "method": "GET"
    },
    {
      "rel": "results",
      "href": "https://api.flashdata.dev/v2/jobs/job_d265c693-950e-40bf-a13e-a432044d99ba/results",
      "method": "GET"
    }
  ]
}

Utilisez la même clé API pour consulter le lien de statut. Si le délai de suivi expire, conservez l’ID pour vérifier le job plus tard. Ne créez pas automatiquement un autre job.

Utiliser le fichier livré

Une fois le fichier transféré vers votre stockage, le job passe à l’état completed. L’endpoint de résultats redirige vers le JSON stocké ; le script suit cette redirection sans transmettre votre clé API au stockage.

Lisez file_url, file_size et les champs de format de sortie dans le résultat. Pour un bucket privé, utilisez vos identifiants de stockage pour lire le fichier ou créer un lien signé destiné à l’utilisateur final. L’URL du fichier ne rend pas l’objet public.

Enregistrez le résultat JSON du job pendant sa période de conservation de 24 heures. Le fichier multimédia reste soumis aux règles de cycle de vie de votre bucket. L’usage est calculé selon le volume réel de données téléchargées.