Pular para o conteúdo
PT
Obter chave API

YouTube Download / Python

Baixe o áudio YouTube para o seu balde S3

Envie um download de áudio, rastreie o trabalho de fundo e recupere a localização do arquivo MP3 entregue.

FlashData · Publicado

Uma forma de onda de áudio entregue ao armazenamento de objetos

Prepare seu balde

Você precisa de Python 3, uma chave FlashData API com créditos disponíveis, um balde Amazon S3 e credenciais de armazenamento que podem escrever para aquele balde. Mantenha essas credenciais em seu 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 sua região de baldes. MEDIA_BUCKET é o nome do balde, sem um s3:// prefixo ou um diretório. Veja o configurações de armazenamento Para destinos compatíveis com S3.

Submeta e rastreie o download

Salve o script como delivery.py. Ele envia um download de áudio para POST /v1/queries, escolhe saída MP3 e fornece o 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

O roteiro imprime o trabalho ID antes da votação. Guarde esse ID em sua aplicação para que um reinício ou tempo limite não perca o link para o trabalho já submetido.

Leia o recibo do trabalho

Uma submissão de download devolve um recibo, não o arquivo de mídia. Este recibo gravado contém o trabalho ID e os links usados para rastrear o progresso e ler o 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"
    }
  ]
}

Use a mesma chave API para ler o link de status. Se o prazo expirar, mantenha o ID e verifique depois. Não crie automaticamente um trabalho de substituição.

Use o arquivo entregue

Uma vez que o arquivo é carregado, o trabalho torna-se completed. Os resultados são redirecionados para o JSON armazenado, o script segue esse redirecionamento sem encaminhar sua chave API para o armazenamento.

Leia file_url, file_size e os campos de formatação de saída do resultado. Para um balde privado, use suas credenciais de armazenamento para ler o arquivo ou criar um link assinado para seu usuário final. O arquivo URL em si não torna o objeto público.

Economize o resultado JSON dentro do seu período de retenção de 24. O objeto da mídia continua sujeito às configurações do seu próprio ciclo de vida. O uso do download é baseado no volume de dados baixados.