Mit Python Videos hochskalieren: Batch-Pipeline und Kosten

Um Videos mit Python in echten Mengen hochzuskalieren, ist die Herausforderung nicht der API-Aufruf. Ein Clip ist ein POST und eine Polling-Schleife, zwanzig Zeilen, fertig. Das Problem ist die Hundert-Clip-Version: unter dem Rate-Limit bleiben während der Abfrage, die Rechnung vor dem Absenden kennen und einen Batch wiederherstellen, der bei Clip 61 ausgefallen ist, ohne die Clips 1 bis 60 erneut zu bezahlen.

Dieser Leitfaden erstellt diese Pipeline gegen die Video-Verbesserungs-Endpunkte von reAPI, wobei Topaz Video Upscaler $0.044/s des Quellvideos auf der Standard-Stufe kostet und enhance-video-1.0 bei $0.002054/s beginnt^[1][2]. Jede Zahl und jedes Vertragsdetail unten stammt aus den Live-Modellseiten im August 2026. Wenn du stattdessen den Werkzeugvergleich möchtest (Open Source, Desktop, API), ist das ein separater Leitfaden: Videos mit AI hochskalieren.

TL;DR

• Der API-Vertrag ist von vornherein batchfreundlich: asynchrones Absenden gibt sofort eine Task-ID zurück, die Abrechnung erfolgt pro Sekunde des vom Server geprüften Quellvideos, und fehlgeschlagene Tasks erstatten automatisch, sodass ein abgestürzter Batch nie doppelt berechnet wird^[1].
• Die einzige harte Einschränkung ist 5 Anfragen/Sekunde pro Benutzer, Polling eingeschlossen^[1]. Vier Worker, die alle 2,5 Sekunden abrufen, verbrauchen etwa ein Drittel dieses Budgets und lassen Platz für Zustellungen.
• Schätze vor dem Absenden: 100 Einminutenclips kosten $264 durch Topaz Standard, $24.64 durch enhance-video-1.0 Standard 1080p^[1][2]. Die Stufenentscheidung ist zehnmal wertvoller als jede Code-Optimierung.
• Speichere Task-IDs auf Festplatte, während du sie absendest. Die Wiederaufnahme kostet dann nichts: abgeschlossene Aufgaben sind bereits bezahlt und ihre Ausgabe-URLs funktionieren noch.
• Die vollständige Pipeline umfasst etwa 80 Zeilen, Standardbibliothek plus requests.

Was der API-Vertrag einer Batch-Aufgabe bietet

Drei Vertragsdetails prägen das gesamte Design, alle aus der Modellreferenz selbst^[1]:

Absenden ist asynchron. POST /api/v1/videos/generations gibt {"id", "status": "processing"} sofort zurück; das Rendering erfolgt serverseitig und du fragst GET /api/v1/tasks/<id> ab, bis status completed oder failed ist. Ein Batch ist daher eine Menge von offenen Aufgaben, die du verfolgst, nicht eine Warteschlange, auf der du blockierst.

Die Abrechnung folgt dem Quellclip, nicht der Ausgabe. Die Plattform prüft die Länge des Quellvideos serverseitig und rechnet pro Sekunde davon ab: $0.044/s Standard oder $0.077/s Max für Topaz-Hochskalierung, $0.002054/s bis $0.016429/s für enhance-videos Standard-Stufe je nach Zielauflösung^[1][2]. Das macht die Kosten zu einer reinen Funktion der Videodauer, weshalb der unten stehende Rechner funktioniert.

Fehler erstatten sich selbst. Credits werden bei Absenden reserviert und vollständig erstattet, wenn eine Aufgabe fehlschlägt^[1]. Der Client benötigt nie Ausgleichslogik; er muss nur aufzeichnen, was fehlgeschlagen ist, und entscheiden, ob er es erneut absenden möchte.

Schätze die Rechnung vor dem Absenden

Die Dauer ist die einzige Eingabe, die zählt. Wenn die Clips lokal vor dem Hochladen vorliegen, liest ffprobe sie in einem Aufruf aus; wenn sie bereits gehostet werden, nimm Durations aus deinen eigenen Metadaten.

import subprocess, json

def probe_seconds(path: str) -> float:
    out = subprocess.run(
        ["ffprobe", "-v", "quiet", "-print_format", "json",
         "-show_format", path],
        capture_output=True, text=True, check=True,
    )
    return float(json.loads(out.stdout)["format"]["duration"])

RATES = {                     # $ pro Sekunde Quelle, August 2026
    "topaz-standard": 0.044,
    "topaz-max": 0.077,
    "enhance-720p": 0.002054,
    "enhance-1080p": 0.004107,
    "enhance-4k": 0.016429,
}

def estimate(paths, rate_key):
    total = sum(probe_seconds(p) for p in paths)
    return total, total * RATES[rate_key]

Wie diese Arithmetik für 100 Einminutenclips aussieht:

Die 37-fache Spanne zwischen der billigsten und der teuersten Reihe ist die wirkliche Optimierungsfläche. Keine Python-Straffung senkt eine Rechnung so wie die Wahl der richtigen Stufe; die Auswahllogik ist einfach genug, um als Regel codiert zu werden (saubere Quelle, Auflösung aufsteigend: enhance-Stufe; beschädigte Quelle, Detailwiederherstellung nötig: Topaz).

Videos mit Python hochskalieren: eine 80-zeilige Batch-Pipeline

Das Design: Alles direkt absenden (Zustellungen sind billig und schnell), die Task-Zuordnung sofort auf Festplatte speichern, dann mit einem kleinen Worker-Pool abfragen. Der Zustand lebt in einer JSON-Datei, die nach Quell-URL indexiert ist.

import json, pathlib, time
from concurrent.futures import ThreadPoolExecutor
import requests

API = "https://reapi.ai/api/v1"
HEADERS = {"Authorization": "Bearer rk_live_..."}
STATE = pathlib.Path("batch_state.json")
POLL_INTERVAL = 2.5   # 4 Worker / 2.5s ≈ 1.6 req/s, weit unter der 5/s-Kappe
WORKERS = 4

def load_state():
    return json.loads(STATE.read_text()) if STATE.exists() else {}

def save_state(state):
    STATE.write_text(json.dumps(state, indent=2))

def submit(video_url, state):
    if video_url in state:          # bei einem vorherigen Durchlauf bereits abgesendet
        return
    r = requests.post(f"{API}/videos/generations", headers=HEADERS, json={
        "model": "topaz-video-upscaler",
        "video_url": video_url,
        "upscale_factor": "2",
    }, timeout=30)
    r.raise_for_status()
    state[video_url] = {"task_id": r.json()["id"], "status": "processing"}
    save_state(state)               # vor dem Fortfahren speichern

def poll_one(video_url, entry):
    while True:
        r = requests.get(f"{API}/tasks/{entry['task_id']}", headers=HEADERS)
        body = r.json()
        if body["status"] in ("completed", "failed"):
            return video_url, body
        time.sleep(POLL_INTERVAL)

def run(video_urls):
    state = load_state()
    for url in video_urls:
        submit(url, state)
        time.sleep(0.25)            # Zustellungen: 4/s, im Budget

    open_items = [
        (u, e) for u, e in state.items() if e["status"] == "processing"
    ]
    with ThreadPoolExecutor(max_workers=WORKERS) as pool:
        for url, body in pool.map(lambda p: poll_one(*p), open_items):
            state[url]["status"] = body["status"]
            if body["status"] == "completed":
                state[url]["output"] = body["output"]
            else:
                state[url]["error"] = body.get("error")
            save_state(state)

    done = sum(1 for e in state.values() if e["status"] == "completed")
    failed = [u for u, e in state.items() if e["status"] == "failed"]
    print(f"{done} abgeschlossen, {len(failed)} fehlgeschlagen")
    for u in failed:
        print("FEHLGESCHLAGEN:", u, state[u].get("error"))

run([
    "https://your-cdn.com/clip-001.mp4",
    "https://your-cdn.com/clip-002.mp4",
])

Tausche die Nutzlast gegen enhance-video-1.0 aus (tool_version, scene, resolution statt upscale_factor) und sonst ändert sich nichts^[2]. Quell-URLs müssen öffentliches HTTPS sein; Base64-Uploads werden plattformweit abgelehnt.

Das Rate-Limit-Budget, explizit

Die Plattform begrenzt jeden Benutzer auf 5 Anfragen/Sekunde, und Polling zählt^[1]. Der Verbrauch der Pipeline:

• Zustellungen: gedrosselt auf 4/s während der Zustellungsphase, die kurz ist.
• Polling: 4 Worker × eine Anfrage pro 2,5 s = 1.6 req/s Steady State.
• Spielraum: ~3,4 req/s übrig für ein zweites Skript, ein Dashboard oder manuelle curl-Überprüfungen.

Wenn du WORKERS auf 12 mit 2,5 s Intervall erhöhst, würde Polling allein zu 4,8 req/s führen und würde beginnen, 429er zurückzugeben, sobald etwas anderes die API berührt. Mehr Worker machen Renders nicht schneller; die Render-Zeit ist serverseitig. Worker binden nur, wie schnell du Vollendung bemerkst, und 2,5 Sekunden später zu bemerken kostet nichts.

Fehler behandeln ohne doppelt zu zahlen

Der Fehlervertrag der Plattform macht die schwere Arbeit: eine fehlgeschlagene Aufgabe erstattet seine reservierten Credits vollständig und automatisch^[1]. Die Aufgabe der Pipeline reduziert sich auf Buchführung:

1. Zeichne den Fehler auf, einschließlich des error-Objekts mit seinem code, message und request_id (die Fehlercode-Referenz lebt in den API-Docs^[3]).
2. Nicht blind automatisch erneut absenden. Ein Clip, der fehlgeschlagen ist, weil die Quell-URL 404er ist, wird beim gleichen Kostenersatz von Null erneut fehlschlagen, aber eine Welle von Wiederholungen brennt dein Rate-Budget. Behebe die Eingabe, dann führe das Skript erneut aus; die Zustandsdatei überspringt alles bereits Abgeschlossene.
3. Vertraue der Wiederaufnahme. Abgeschlossene Einträge behalten ihre Ausgabe-URLs, die auf CDN-neu gehostete Dateien zeigen, die nicht ablaufen^[1], sodass ein bei Clip 61 unterbrochener Batch mit 60 bezahlten Ergebnissen intakt neu startet und nur der Rest offen ist.

FAQ

Wie kann ich Videos mit Python kostenlos hochskalieren?

Nicht über eine gehostete API; das Rendering kostet jemandem GPU-Zeit. Der kostenlose Weg ist das Ausführen von Open-Source-Hochskalierern wie video2x oder Real-ESRGAN auf deinem eigenen GPU, was Geld gegen Hardware und Einrichtung eintauscht, abgedeckt in unserem Werkzeugvergleich. Der API-Weg beginnt bei $0.002054 pro Quell-Sekunde^[2], und Anmeldekredite decken die ersten Test-Aufrufe ab.

Wie viele Clips kann ich parallel verarbeiten?

Sende so viele ab, wie du möchtest; die Einschränkung ist die Anfragerate, nicht offene Aufgaben. Halten Sie den gesamten Anfragedurchsatz, Zustellungen plus Polling, unter 5 pro Sekunde^[1]. Vier Polling-Worker bei 2,5-Sekunden-Intervall sind ein komfortabler Steady State.

Was kostet es, 100 Videos hochzuskalieren?

Die Dauer entscheidet. Bei einer Minute pro Clip: von $12.32 (enhance-video, 720p) bis $462 (Topaz Max)^[1][2]. Führe den Rechner auf echten Durations aus, bevor du absendest; es sind vier Zeilen ffprobe.

Kann ich einen Batch nach einem Skriptabsturz fortsetzen?

Ja, wenn Task-IDs bei Absenden beibehalten wurden. Abgeschlossene Aufgaben bleiben abgeschlossen und bezahlt, ihre Ausgabe-URLs bleiben gültig, und fehlgeschlagene Aufgaben wurden bereits erstattet^[1]. Das State-File-Muster oben macht Resume zum Standardverhalten statt zu einer Recovery-Funktion.

Sollte ich in einer Batch-Aufgabe auf 4K hochskalieren?

Nur, wenn der Zielbildschirm es erfordert. Die 4K-Stufe kostet das 8-fache der 720p-Stufe bei enhance-video^[2], und Social-Feeds rekomprimieren Uploads trotzdem. Ein gemeinsames Muster ist die Batchverarbeitung alles auf 1080p und das erneute Ausführen einer Handvoll Hero-Clips auf 4K.

Wie weiß ich, wie lange das Quellvideo die Plattform berechnet?

Die Plattform prüft die gehostete Datei serverseitig und rechnet ihre echte Länge ab^[1]. Lokales ffprobe auf derselben Datei ergibt die gleiche Zahl; Abweichungen bedeuten, dass die gehostete Kopie von der lokalen abweicht, was es wert ist, vor dem Absenden von hundert davon zu fangen.

Den ersten Batch ausführen

Beginne mit drei Clips, nicht hundert: einer sauber, einer beschädigt, einer lang. Dieser Durchlauf validiert die Zustandsdatei, zeigt echte Pro-Clip-Kosten gegen die Schätzung und zeigt Eingabeprobleme, während sie Cents kosten. Dann richte das Skript auf die vollständige Liste und lass den Erstattungsvertrag und die Zustandsdatei alles absorbieren, was schiefgeht. Der ganze Sinn davon, das in Python zu tun, ist, dass um Videos mit Python ein zweites Mal hochzuskalieren, der Befehl einfach das Skript erneut ist, und der zweite Durchlauf nur für das bezahlt, das der erste nicht beendet hat.

References

1. reAPI. Topaz Video Upscaler — model page: live pricing, task lifecycle, rate limits. Retrieved August 2026 from reapi.ai/models/topaz-video-upscaler
2. reAPI. Enhance Video 1.0 — model page: live per-second tier pricing. Retrieved August 2026 from reapi.ai/models/enhance-video-1-0
3. reAPI. API error codes reference. Retrieved August 2026 from reapi.ai/docs/api/errors

Further reading

• reAPI. Upscale video with AI: open source, desktop, or API. reapi.ai/blog/upscale-video-with-ai
• reAPI. Topaz Video Upscaler API docs. reapi.ai/docs/topaz-video-upscaler