Überspringen zum Inhalt
DE
API-Schlüssel

YouTube Download / Python

Laden Sie YouTube Audio auf Ihren S3 Bucket herunter

Senden Sie einen Audio-Download, verfolgen Sie den Hintergrundjob und rufen Sie den Speicherort der gelieferten MP3-Datei ab.

FlashData · Veröffentlicht

Eine Audiowellenform, die an den Objektspeicher geliefert wird

Bereiten Sie Ihren Eimer vor

Sie benötigen Python 3, einen FlashData API-Schlüssel mit verfügbaren Credits, einen Amazon S3-Bucket und Speicherdaten, die in diesen Bucket schreiben können. Bewahren Sie diese Anmeldeinformationen auf Ihrem Server auf.

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'

Verwenden Sie Ihre tatsächliche Bucket Region. MEDIA_BUCKET ist der Bucket-Name, ohne s3:// ein Präfix oder ein Verzeichnispfad. Siehe Speichereinstellungen für S3-kompatible Destinationen.

Senden und verfolgen Sie den Download

Speichern Sie das Skript als delivery.py. Es wird ein Audio-Download an POST /v1/queries, wählt MP3-Ausgabe und stellt das S3-Ziel bereit.

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

Das Skript druckt den Job ID vor der Abstimmung. Speichern Sie ID in Ihrer Anwendung, damit ein Neustart oder ein Timeout den Link zur bereits eingereichten Arbeit nicht verliert.

Lesen Sie den Job Receipt

Eine Download-Einreichung gibt eine Quittung zurück, nicht die Mediendatei. Diese aufgezeichnete Quittung enthält den Job ID und die Links, die verwendet werden, um den Fortschritt zu verfolgen und das eventuelle Ergebnis zu lesen.

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

Verwenden Sie den gleichen API-Schlüssel, um den Statuslink zu lesen. Wenn die Wahlfrist abläuft, behalten Sie den ID und überprüfen Sie ihn später. Erstellen Sie nicht automatisch einen Ersatzjob.

Verwenden Sie die gelieferte Datei

Sobald die Datei hochgeladen wurde, wird der Job completed. Der Endpunkt der Ergebnisse leitet zu gespeichertem JSON um; das Skript folgt dieser Umleitung, ohne Ihren API-Schlüssel an den Speicher weiterzuleiten.

Lesen file_url, file_size und die Ausgabeformatfelder aus dem Ergebnis. Verwenden Sie für einen privaten Bucket Ihre Speicherdaten, um die Datei zu lesen oder einen signierten Link für Ihren Endbenutzer zu erstellen. Die Datei URL selbst macht das Objekt nicht öffentlich.

Speichern Sie das JSON-Ergebnis des Jobs innerhalb seiner 24-Stunden-Aufbewahrungsdauer. Das Medienobjekt unterliegt weiterhin den Lifecycle-Einstellungen Ihres eigenen Buckets. Die Download-Nutzung basiert auf dem tatsächlichen heruntergeladenen Datenvolumen.