Saltar al contenido
ES
Obtener clave API

YouTube Download / Python

Descargar el audio YouTube a su cubo S3

Presentar una descarga de audio, rastrear el trabajo de fondo y recuperar la ubicación del archivo MP3 entregado.

FlashData · Publicado

Una forma de onda de audio entregada al almacenamiento de objetos

Prepare su cubo

Necesita Python 3, una tecla FlashData API con créditos disponibles, un cubo Amazon S3 y credenciales de almacenamiento que pueden escribir a ese cubo. Mantenga esas credenciales en su servidor.

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'

Use su región de cubo real. MEDIA_BUCKET es el nombre del cubo, sin un s3:// prefijo o ruta de directorio. Ver el Ajustes de almacenamiento para destinos compatibles con S3.

Presentar y rastrear la descarga

Guardar el script como delivery.py. Presenta una descarga de audio POST /v1/queries, elige la salida MP3 y proporciona el destino 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

El script imprime el trabajo ID antes de la votación. Ahorre que ID en su solicitud para que un reinicio o un timeout no pierda el enlace al trabajo ya presentado.

Lea el recibo del trabajo

Una presentación de descarga devuelve un recibo, no el archivo multimedia. Este recibo registrado contiene el trabajo ID y los enlaces utilizados para rastrear el progreso y leer el resultado final.

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"
    }
  ]
}

Utilice la misma tecla API para leer el enlace de estado. Si el plazo de votación expira, mantenga la ID y compruebe más tarde. No cree automáticamente un trabajo de reemplazo.

Utilice el archivo entregado

Una vez que el archivo es subido, el trabajo se convierte completed. El punto final de resultados redirige a JSON almacenado; el script sigue que redirecciona sin enviar la tecla API al almacenamiento.

Leer file_url, file_size y los campos de formato de salida del resultado. Para un cubo privado, utilice sus credenciales de almacenamiento para leer el archivo o crear un enlace firmado para su usuario final. El archivo URL en sí no hace el objeto público.

Guardar el resultado JSON del trabajo dentro de su período de retención 24. El objeto multimedia permanece sujeto a la configuración del ciclo de vida de tu propio cubo. El uso de descargas se basa en el volumen de datos descargado real.