Salta al contenuto
IT
Ottieni la chiave API

YouTube Download / Python

Scarica l'audio YouTube al secchio S3

Invia un download audio, traccia il lavoro di sfondo e recuperare la posizione del file MP3 consegnato.

FlashData · Pubblicato

Una forma d'onda audio consegnata all'archiviazione oggetti

Prepara il secchio

Hai bisogno di Python 3, una chiave FlashData API con crediti disponibili, un secchio Amazon S3 e credenziali di archiviazione che possono scrivere a quel secchio. Tieni quelle credenziali sul tuo server.

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'

Usa la tua vera e propria regione del secchio. MEDIA_BUCKET è il nome del secchio, senza s3:// prefisso o percorso directory. Vedi il impostazioni di archiviazione per destinazioni compatibili con S3.

Inviare e monitorare il download

Salvare lo script come delivery.py. Presenta un download audio per POST /v1/queries, sceglie l'uscita MP3 e fornisce la destinazione 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

Lo script stampa il lavoro ID prima di inquinare. Salvare che ID nella vostra applicazione in modo da un riavvio o timeout non perde il link per lavorare già presentato.

Leggi la ricevuta del lavoro

Una presentazione di download restituisce una ricevuta, non il file multimediale. Questa ricevuta registrata contiene il lavoro ID e i link utilizzati per monitorare il progresso e leggere il risultato finale.

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

Utilizzare lo stesso tasto API per leggere il link di stato. Se il termine di inquinamento scade, mantenere la ID e controllarlo più tardi. Non creare automaticamente un lavoro di sostituzione.

Utilizzare il file consegnato

Una volta che il file viene caricato, il lavoro diventa completed. Il endpoint dei risultati reindirizza a JSON memorizzato; lo script segue che reindirizza senza inoltrare la chiave API per lo storage.

Leggi tutto file_url, file_size e i campi di output-format dal risultato. Per un secchio privato, utilizzare le credenziali di archiviazione per leggere il file o creare un link firmato per l'utente finale. Il file URL stesso non rende l'oggetto pubblico.

Salvare il risultato JSON del lavoro all'interno del suo periodo di conservazione 24-ora. L'oggetto multimediale rimane soggetto alle impostazioni del ciclo di vita del proprio secchio. L'utilizzo del download si basa sul volume dei dati scaricati.