# Seedance 2.0 API: Text-zu-Video und Bild-zu-Video mit Python

> Seedance 2.0 aus Python aufrufen: ein Skript für Text-zu-Video und Bild-zu-Video, mit Feldern, Polling, Limits, Fehlercodes und zwei echten 720p-Clips.

- Canonical HTML: https://omniakey.com/de/blog/seedance-2-0-api
- Markdown: https://omniakey.com/de/blog/seedance-2-0-api.md
- Published: 2026-10-30 (updated 2026-10-30)
- Author: Kiki, COO at OmniaKey
- Language: de
- Category: API setup
- Reading time: 11 min
- All posts: https://omniakey.com/blog/llms.txt

---

[Seedance 2.0](https://omniakey.com/de/dreamina-seedance-2-0-260128) läuft in der Medien-API von OmniaKey unter der Modell-ID `dreamina-seedance-2-0-260128`. Sie senden eine Aufgabe per POST an `https://api.omniakey.com/v1/media/tasks`, fragen die Task-ID ab und laden danach die MP4 herunter. Unsere zwei 5-Sekunden-Clips in 720p, einer aus Text und einer aus einem Standbild, brauchten am 30. Oktober 2026 159 und 139 Sekunden.

## Kurze Antwort

- Modell-ID `dreamina-seedance-2-0-260128` mit drei Operationen: `text_to_video`, `image_to_video` und `reference_to_video` (OmniaKeys [Dokumentation zur Video-API](https://docs.omniakey.com/en/media/video), geprüft am 30. Oktober 2026).
- Anlegen, abfragen, herunterladen: Der Create-Aufruf antwortet mit 202 und einer ID, danach rufen Sie alle paar Sekunden `GET /v1/media/tasks/{id}` auf, bis der Status `succeeded` lautet (OmniaKeys [Überblick zur Medien-API](https://docs.omniakey.com/en/media/overview), geprüft am 30. Oktober 2026).
- Die Dauer reicht von 4 bis 15 vollen Sekunden, und die volle 2.0-ID rendert 480P, 720P und 1080P.
- Der gesamte Request-Body bleibt unter 1 MiB, inklusive Inline-Base64.
- Unsere zwei 5-Sekunden-Renders in 720p waren nach 159 Sekunden (Text-zu-Video) und 139 Sekunden (Startbild) fertig.

## Was brauchen Sie vor dem ersten Aufruf?

Einen API-Key von OmniaKey, Python 3 und die genaue Modell-ID. Das Skript importiert nur die Standardbibliothek, läuft also ohne virtuelle Umgebung und ohne Paketinstallation.

Legen Sie den Key als `OMNIAKEY_API_KEY` in der Umgebung ab, bevor Sie den ersten Aufruf starten. Das Skript liest ihn einmal und schickt ihn bei jeder Anfrage als Bearer-Token mit, so bleibt der Key aus der Datei und aus der Git-Historie heraus.

Anlegen mit `POST https://api.omniakey.com/v1/media/tasks`, Status abfragen mit `GET https://api.omniakey.com/v1/media/tasks/{id}`. Diese beiden plus `POST /v1/media/tasks/{id}/cancel` sind die ganze Medien-API (Überblick zur Medien-API, geprüft am 30. Oktober 2026).

Schreiben Sie Modell-IDs vollständig aus. OmniaKey bedient die Kurzaliase `seedance-2` und `seedance-2-5` nicht, sie antworten mit `503 no_available_channel` (Dokumentation zur Video-API, geprüft am 30. Oktober 2026).

Video-Jobs werden pro Sekunde erzeugter Ausgabe im Voraus berechnet, und die Belastung kommt automatisch zurück, wenn ein Job als `failed` oder `canceled` endet (Überblick zur Medien-API, geprüft am 30. Oktober 2026). Was eine Sekunde aktuell kostet, steht auf der [Modellseite von Seedance 2.0](https://omniakey.com/de/dreamina-seedance-2-0-260128).

## Welche Felder nimmt eine Anfrage an Seedance 2.0 an?

Vier Felder auf oberster Ebene tragen den Job, ein `parameters`-Objekt trägt die Ausgabeeinstellungen. Nur `duration` hat keinen sinnvollen Standardwert, senden Sie es immer mit.

- `model`: die vollständige Modell-ID (Kurzaliase schlagen fehl)
- `type`: `video` (die Medienart)
- `operation`: `text_to_video`, `image_to_video`, `reference_to_video` (reiner Name, kein Präfix)
- `input.prompt`: eine Zeichenkette (Szene, Aktion und Kamera, bis 12.000 Zeichen)
- `input.media[]`: `{"type": "first_frame", "url": …}` (ein Startbild oder `reference_image`)

Innerhalb von `parameters`:

- `duration`: 4 bis 15, volle Sekunden (bestimmt den Preis)
- `resolution`: `480P`, `720P`, `1080P` (Fast und Mini enden bei 720P)
- `ratio`: `16:9`, `9:16`, `1:1`, `4:3`, `3:4`, `21:9`, `adaptive` (`adaptive` folgt dem Bild)
- `generate_audio`: standardmäßig `true`, oder `false` (`false` ergibt eine MP4 ohne Ton)
- `n`: `1` (muss 1 sein)

Beide Listen folgen OmniaKeys [Dokumentation zur Video-API](https://docs.omniakey.com/en/media/video) und dem [Überblick zur Medien-API](https://docs.omniakey.com/en/media/overview) (geprüft am 30. Oktober 2026), das Prompt-Limit stammt von der Modellseite.

Senden Sie den reinen Operationsnamen; das Präfix für den Medientyp setzt OmniaKey selbst davor (Dokumentation zur Video-API, geprüft am 30. Oktober 2026). Parameter, die es nicht kennt, reicht OmniaKey unverändert an den Anbieter weiter (Überblick zur Medien-API, geprüft am 30. Oktober 2026).

Eine Falle erwischt alle, die mit der Anbieter-Dokumentation anfangen: Die Create-Task-API von BytePlus legt Felder in `content[]` und auf oberster Ebene ab, Code aus einem BytePlus-Tutorial läuft daher nicht unverändert gegen `/v1/media/tasks` (BytePlus' Create-Task-API, geprüft am 30. Oktober 2026).

## Das Python-Skript

Eine Datei erledigt beide Operationen, der einzige Unterschied ist der Body, den sie baut. Speichern Sie sie als `seedance_video.py` und starten Sie `python3 seedance_video.py`.

```python
import base64
import json
import os
import time
import urllib.error
import urllib.request
import uuid

API = "https://api.omniakey.com/v1/media/tasks"
KEY = os.environ["OMNIAKEY_API_KEY"]
MODEL = "dreamina-seedance-2-0-260128"

def request(method, url, body=None, extra_headers=None):
    headers = {"Authorization": f"Bearer {KEY}", "User-Agent": "omniakey-example/1"}
    data = None
    if body is not None:
        headers["Content-Type"] = "application/json"
        data = json.dumps(body).encode()
    headers.update(extra_headers or {})
    req = urllib.request.Request(url, data=data, headers=headers, method=method)
    with urllib.request.urlopen(req, timeout=120) as resp:
        return json.load(resp)

def poll(url, attempts=5):
    for attempt in range(attempts):
        try:
            return request("GET", url)
        except urllib.error.HTTPError as err:
            if err.code < 500 or attempt == attempts - 1:
                raise
        except urllib.error.URLError:
            if attempt == attempts - 1:
                raise
        time.sleep(5 * (attempt + 1))

def run_task(body, out_path):
    task = request("POST", API, body, {"Idempotency-Key": str(uuid.uuid4())})["id"]
    print("task", task, flush=True)
    for _ in range(180):  # 5-second polls, up to 15 minutes
        time.sleep(5)
        state = poll(f"{API}/{task}")
        if state["status"] not in ("queued", "processing"):
            break
    else:
        raise TimeoutError(f"{task} is still {state['status']}: poll it again later, do not resubmit")
    if state["status"] != "succeeded":
        raise RuntimeError(state.get("error") or state["status"])
    asset_url = state["assets"][0]["url"]  # signed link: short-lived, so download now
    req = urllib.request.Request(asset_url, headers={"User-Agent": "omniakey-example/1"})
    with urllib.request.urlopen(req, timeout=300) as resp, open(out_path, "wb") as f:
        f.write(resp.read())
    return task

def text_to_video(prompt, out_path, duration=5, resolution="720P", ratio="16:9"):
    body = {
        "model": MODEL,
        "type": "video",
        "operation": "text_to_video",
        "input": {"prompt": prompt},
        "parameters": {"duration": duration, "resolution": resolution, "ratio": ratio},
    }
    return run_task(body, out_path)

def image_to_video(prompt, image_path, out_path, duration=5, resolution="720P", audio=False):
    with open(image_path, "rb") as f:
        raw = f.read()
    if len(raw) > 700_000:  # base64 adds a third, and the whole body must stay under 1 MiB
        raise ValueError("first frame too large: save it as a JPEG about 1024 px wide")
    frame = "data:image/jpeg;base64," + base64.b64encode(raw).decode()
    body = {
        "model": MODEL,
        "type": "video",
        "operation": "image_to_video",
        "input": {"prompt": prompt, "media": [{"type": "first_frame", "url": frame}]},
        "parameters": {"duration": duration, "resolution": resolution, "ratio": "adaptive",
                       "generate_audio": audio},
    }
    return run_task(body, out_path)

if __name__ == "__main__":
    print("done", text_to_video(
        "Close-up of a tall glass on a wooden bar counter. Sparkling water is poured over ice; bubbles "
        "rise and the ice cubes clink and shift. Warm evening light from the left. The camera slowly "
        "pushes in. Sound of pouring, fizzing and clinking ice. No people, no text.",
        "sparkling-glass.mp4",
    ))
    print("done", image_to_video(
        "The cat slowly wakes, stretches its front paws and yawns, then looks toward the window. "
        "Raindrops keep running down the glass. The camera stays still.",
        "cat.jpg",
        "cat-wakes.mp4",
    ))
```

Sechs Stellen in dieser Datei zählen, bevor Sie etwas ändern.

- Jede Create-Anfrage trägt einen zufälligen `Idempotency-Key`; derselbe Key mit demselben Body liefert die ursprüngliche Aufgabe mit HTTP 200 zurück und wird nie doppelt berechnet (Überblick zur Medien-API, geprüft am 30. Oktober 2026).
- Die Schleife wartet 5 Sekunden zwischen den Abfragen und hört nach 180 Versuchen auf, also nach 15 Minuten.
- Ein Timeout heißt, dass der Job noch rendert. Fragen Sie dieselbe Task-ID später erneut ab und senden Sie sie nie neu, sonst zahlen Sie für einen zweiten Clip.
- `assets[0].url` ist ein signierter Link, der etwa eine Stunde gilt, deshalb lädt das Skript herunter, sobald die Aufgabe erfolgreich ist (Überblick zur Medien-API, geprüft am 30. Oktober 2026).
- `progress.percent` kann während des Jobs bei 0 stehen, die Schleife folgt deshalb nur `status` (Dokumentation zur Video-API, geprüft am 30. Oktober 2026).
- Die Bildfunktion lehnt eine Datei über 700.000 Byte ab, weil Base64 ein Drittel hinzufügt und der Body unter 1 MiB bleiben muss.

Der Aufbau der Anfrage entspricht [Kling 3.0 auf derselben API](https://omniakey.com/de/blog/kling-3-0-api), ein Modellwechsel ändert also die Modell-ID und die Parameter, nicht den Code drumherum.

## Wie senden Sie ein Startbild für Bild-zu-Video?

Legen Sie das Bild mit `"type": "first_frame"` in `input.media[]` ab, inline als URI der Form `data:image/jpeg;base64,...` — so wie in unserem Katzen-Clip.

`input.media[]` nimmt eine öffentliche HTTPS-URL oder eine Inline-Data-URI, und der gesamte Body ist auf 1 MiB begrenzt (Dokumentation zur Video-API, geprüft am 30. Oktober 2026). In OmniaKeys eigenem Test wurde ein gewöhnlicher HTTPS-Link für das Startbild mit `provider_submit_rejected` abgelehnt, deshalb sendet das Beispiel eine Data-URI (Dokumentation zur Video-API, geprüft am 30. Oktober 2026).

Base64 fügt ein Drittel hinzu, starten Sie also mit einem JPEG von etwa 1024 Pixeln Breite: Unser Startbild hatte 134.356 Byte, ein PNG mit 4 MB würde durchfallen.

Lassen Sie `parameters.ratio` hier auf `adaptive`: Der Wert folgt der Form des gesendeten Bildes, so wurde aus einem Standbild mit 1024×571 ein Clip mit 1280×720. Für `reference_to_video` nimmt dasselbe Array `"type": "reference_image"` (Dokumentation zur Video-API, geprüft am 30. Oktober 2026).

## Zwei Clips aus unserem Lauf

Beide Aufgaben gingen am 30. Oktober 2026 mit der obigen Datei unverändert raus. Die erste ist Text-zu-Video, Task `task_uF2QUtbeAAUW11lXEaLxNw1ZnBUoqvNk`, angelegt um 01:39:43 UTC und erfolgreich um 01:42:22 UTC. Der Prompt verlangte das Geräusch des Einschenkens, also blieb der Ton an.

```prompt
Close-up of a tall glass on a wooden bar counter. Sparkling water is poured over ice; bubbles rise and the ice cubes clink and shift. Warm evening light from the left. The camera slowly pushes in. Sound of pouring, fizzing and clinking ice. No people, no text.
```

![Acht Frames eines hohen Glases mit Sprudelwasser auf einer Holztheke, vom leeren Einschenken bis zum vollen Glas mit Bläschen am Boden.](https://omniakey.com/_img/blog/seedance-2-0-api/seedance-sparkling-glass-frames.e6c0aae7.1280.webp)

_Acht Frames aus dem Glas-Clip in zeitlicher Reihenfolge, 0.0 bis 5.0 Sekunden. Seedance 2.0 über die OmniaKey-API, Text-zu-Video, 5 Sekunden, 720P, erstellt am 30. Oktober 2026._

Die Frames zeigen ein Glas mit Eis auf einer Holztheke, dahinter unscharf Flaschen und warmes Licht. Das Glas wächst vom ersten bis zum letzten Frame, der Push-in aus dem Prompt, und endet voll mit Bläschen am Boden.

Die zweite ist Bild-zu-Video, Task `task_u85W0jn1sQLkrszJlxqXF1hxJYhsndxK`, angelegt um 01:42:33 UTC und erfolgreich um 01:44:52 UTC. Das Startbild ist ein Standbild einer roten Katze, die auf einem Stapel alter Bücher an einem regnerischen Fenster schläft (1024×571 Pixel), gesendet als Data-URI mit `"type": "first_frame"`.

```prompt
The cat slowly wakes, stretches its front paws and yawns, then looks toward the window. Raindrops keep running down the glass. The camera stays still.
```

![Acht Frames einer roten Katze, die auf einem Stapel Bücher an einem regnerischen Fenster schläft, aufwacht, die Vorderpfoten streckt und gähnt.](https://omniakey.com/_img/blog/seedance-2-0-api/seedance-cat-wakes-frames.32a57df5.1280.webp)

_Acht Frames aus dem Katzen-Clip in zeitlicher Reihenfolge, 0.0 bis 5.0 Sekunden. Seedance 2.0 über die OmniaKey-API, Bild-zu-Video, 5 Sekunden, 720P, erstellt am 30. Oktober 2026._

Die Katze hebt den Kopf, öffnet die Augen, streckt beide Vorderpfoten über die Buchkante, gähnt breit und dreht den Kopf zum Fenster, in der Reihenfolge, die der Prompt vorgab. Der Regen läuft weiter über die Scheibe, der Bildausschnitt bleibt ruhig, wie verlangt.

![Links das Standbild der roten Katze, das als Startbild gesendet wurde, rechts der letzte Frame des Clips, mit über die Bücher gestreckten Pfoten und zum Fenster gedrehtem Kopf.](https://omniakey.com/_img/blog/seedance-2-0-api/cat-first-last.60a2db0f.1600.webp)

_Links: das Standbild, das als Startbild gesendet wurde. Rechts: der letzte Frame des Katzen-Clips. Seedance 2.0 über die OmniaKey-API, Bild-zu-Video, 5 Sekunden, 720P, erstellt am 30. Oktober 2026._

Diese beiden Läufe decken Text-zu-Video und ein Startbild in 720P über 5 Sekunden ab. 1080P, Fast, Mini, 2.5, `reference_to_video`, einen HTTPS-Link fürs Startbild und andere Dauern haben wir nicht getestet.

### Die Messwerte der Dateien

Beide Downloads sind H.264-MP4 mit 1280×720 und 24 fps: 121 Frames, 5.04 Sekunden.

|Clip|Glas|Katze|
|-|-|-|
|Operation|Text-zu-Video|Bild-zu-Video|
|Dauer bis fertig|159 s|139 s|
|Dateigröße|2.070.248 Byte|1.352.027 Byte|
|Video|1280×720, 24 fps, 121 Frames|1280×720, 24 fps, 121 Frames|
|Audio|AAC-Tonspur|keine|

Die Tonspur des Glas-Clips enthält Einschenken, Sprudeln und klirrendes Eis, ohne Stimmen und ohne Musik. Der Katzen-Clip hat gar keine Tonspur, weil die Anfrage `generate_audio: false` gesendet hat.

Beide Task-Datensätze meldeten `usage.completion_tokens: 108900`, das ist 121 × 1280 × 720 ÷ 1024, die Token-Formel, mit der BytePlus die Videoabrechnung schätzt (BytePlus' Preisseite, geprüft am 30. Oktober 2026).

OmniaKeys Dokumentation nennt für einen 6-Sekunden-Clip in 720p meist etwa eine Minute (Dokumentation zur Video-API, geprüft am 30. Oktober 2026). Unsere brauchten 159 und 139 Sekunden, und drei 5-Sekunden-Clips in 720p aus unserem [Vergleich vom 26. Oktober](https://omniakey.com/de/blog/happyhorse-1-1-vs-seedance-2-0) brauchten 144.8, 319.0 und 184.7 Sekunden. Planen Sie 2 bis 5 Minuten ein und fragen Sie den Status ab, statt eine Anfrage offen zu halten.

## Welche Fehler und Limits treffen Sie?

Prüfen Sie zuerst drei Einstellungen: die Modell-ID, eine Dauer von 4 bis 15 und den Ton, den der Filter des Anbieters ablehnen kann.

|Status / Code|Was Sie ändern|
|-|-|
|400 `invalid_request`|Body oder `input.prompt`|
|400 `model_price_error`|Dauer auf 4–15 s|
|403 `model_not_allowed`|Modellzugriff des Keys|
|409 `idempotency_key_reused`|neuer Key pro Body|
|503 `no_available_channel`|volle ID, reiner Operationsname|
|fehlgeschlagener Task, Anbieterfehler|`error` lesen, dann erneut versuchen|

Diese Codes stammen aus dem Überblick zur Medien-API und der Dokumentation zur Video-API (geprüft am 30. Oktober 2026). Eine Aufgabe, die als `failed` endet, erstattet ihre Vorausbelastung, ein abgelehnter Render kostet Sie also nur Zeit.

Achten Sie auf die Toneinstellung. Seedance rendert standardmäßig eine Tonspur, und mit eingeschaltetem Ton hat der Anbieter eine 4-Sekunden-Anfrage in 480P mit `OutputAudioSensitiveContentDetected.PolicyViolation` abgelehnt; senden Sie `parameters.generate_audio: false`, wenn die Szene keinen Ton braucht (Dokumentation zur Video-API, geprüft am 30. Oktober 2026).

BytePlus schreibt, dass die 2.0-Serie keine Referenzbilder oder -videos mit echten menschlichen Gesichtern annimmt (BytePlus' Seedance-2.0-Seite, geprüft am 30. Oktober 2026). Seedance 2.0 kennt außerdem kein `seed` und kein `camera_fixed`, obwohl beides Felder der Create-Task-API des Anbieters sind (BytePlus' Create-Task-API, geprüft am 30. Oktober 2026).

Fünfzehn Sekunden sind das Maximum dieser Familie, und `duration: -1` bringt nichts darüber hinaus; eine 20- oder 30-Sekunden-Aufnahme gehört auf [Seedance 2.5](https://omniakey.com/de/dreamina-seedance-2-5-260628) (die Modellseite von Seedance 2.0, geprüft am 30. Oktober 2026).

OmniaKey veröffentlicht keine festen Rate-Limits; behandeln Sie HTTP 429 als wiederholbar, mit exponentiellem Backoff ([OmniaKeys Seite zu API-Fehlern](https://docs.omniakey.com/en/api/errors), geprüft am 30. Oktober 2026).

## Seedance 2.0, Fast, Mini oder 2.5?

Vier Stufen nehmen denselben Request-Body, ein Wechsel kostet also eine Modell-ID und bei Fast und Mini eine niedrigere Auflösungsobergrenze.

- [Seedance 2.0](https://omniakey.com/de/dreamina-seedance-2-0-260128), `dreamina-seedance-2-0-260128`: 480P, 720P und 1080P, 4 bis 15 Sekunden. BytePlus' Listenpreis für einen 5-Sekunden-Clip liegt bei $0.76 in 720p und $0.35 in 480p (BytePlus' Preisseite, geprüft am 30. Oktober 2026).
- [Seedance 2.0 Fast](https://omniakey.com/de/dreamina-seedance-2-0-fast-260128), `dreamina-seedance-2-0-fast-260128`: 480P und 720P, 4 bis 15 Sekunden. BytePlus' Listenpreis für einen 5-Sekunden-Clip liegt bei $0.60 in 720p und $0.28 in 480p.
- [Seedance 2.0 Mini](https://omniakey.com/de/dreamina-seedance-2-0-mini-260615), `dreamina-seedance-2-0-mini-260615`: 480P und 720P, 4 bis 15 Sekunden. BytePlus' Listenpreis für einen 5-Sekunden-Clip liegt bei $0.38 in 720p und $0.18 in 480p.
- [Seedance 2.5](https://omniakey.com/de/dreamina-seedance-2-5-260628), `dreamina-seedance-2-5-260628`: die einzige ID der Familie, die eine 20- oder 30-Sekunden-Aufnahme annimmt, und die langsamste: etwa vier Minuten für einen 4-Sekunden-Clip in 480P (Dokumentation zur Video-API, geprüft am 30. Oktober 2026). Unser [Test von Seedance 2.5](https://omniakey.com/de/blog/seedance-2-5-review) deckt die Bildseite ab.

OmniaKeys Modellseiten nennen für einen 4-Sekunden-Clip in 480P etwa eine Minute bei 2.0, zwei Minuten bei Fast und 100 Sekunden bei Mini (geprüft am 30. Oktober 2026).

Nehmen Sie die volle 2.0-ID, wenn Sie ein 1080P-Master brauchen, denn Fast und Mini enden bei 720P (Dokumentation zur Video-API, geprüft am 30. Oktober 2026). OmniaKey setzt für diese IDs eigene Preise; die aktuellen Sätze stehen auf der [Modellseite von Seedance 2.0](https://omniakey.com/de/dreamina-seedance-2-0-260128).

## FAQ

### Gibt es eine offizielle Seedance-2.0-API?

Ja. BytePlus ModelArk verkauft sie, und die Freischaltung dort braucht ein Kontoguthaben über USD 30, einen Savings Plan oder ein Seedance-Ressourcenpaket (BytePlus' Seedance-2.0-Seite, geprüft am 30. Oktober 2026). Das Skript oben ruft dieselbe Modell-ID stattdessen über die Medien-API von OmniaKey auf.

### Kann ich eine Bild-URL statt Base64 senden?

OmniaKeys Dokumentation nennt eine öffentliche HTTPS-URL neben der Inline-Data-URI (Dokumentation zur Video-API, geprüft am 30. Oktober 2026). Unsere Läufe gingen inline, weil ein HTTPS-Link fürs Startbild in OmniaKeys eigenem Test als `provider_submit_rejected` zurückkam; probieren Sie eine URL zuerst an einem Testclip aus.

### Wie schalte ich den Ton aus?

Senden Sie `parameters.generate_audio: false`, dann kommt die MP4 ganz ohne Tonspur an, wie beim Katzen-Clip. Bei diesem Modell ist der Ton standardmäßig an.

### Warum läuft meine Anfrage in einen Timeout?

Der Clip rendert meist noch, denn 5-Sekunden-Jobs in 720p brauchten in unseren Läufen 139 bis 319 Sekunden. Fragen Sie dieselbe Task-ID erneut ab, senden Sie sie nie neu, und erhöhen Sie das 15-Minuten-Limit der Schleife für 15-Sekunden-Clips.

### Wie lange gelten die Video-Links?

Der signierte Link in `assets[0].url` gilt etwa eine Stunde, und der Task-Datensatz selbst wird 24 Stunden nach dem Anlegen aufbewahrt (Überblick zur Medien-API, geprüft am 30. Oktober 2026). Laden Sie beim ersten Erfolg herunter oder fragen Sie die Aufgabe erneut ab, um einen frischen Link zu bekommen.

## Geprüfte Quellen

- [BytePlus ModelArk: Seedance-2.0-Leitfaden](https://docs.byteplus.com/en/docs/ModelArk/seedance-2-0), geprüft am 30. Oktober 2026
- [BytePlus ModelArk: API zum Anlegen einer Videoaufgabe](https://docs.byteplus.com/en/docs/ModelArk/create-video-generation-task-api), geprüft am 30. Oktober 2026
- [BytePlus ModelArk: Modellpreise und Token-Formel](https://docs.byteplus.com/en/docs/ModelArk/model-pricing), geprüft am 30. Oktober 2026

OmniaKeys eigene Dokumentation, geprüft am 30. Oktober 2026: [Video-API](https://docs.omniakey.com/en/media/video), [Überblick zur Medien-API](https://docs.omniakey.com/en/media/overview) und [API-Fehler](https://docs.omniakey.com/en/api/errors).
