ModellePreiseUnternehmen
500+ KI-Modell-APIs, Alles in einer API. Nur bei CometAPI
Modelle-API
Entwickler
SchnellstartDokumentationAPI Dashboard
Unternehmen
Über unsUnternehmen
Ressourcen
KI-ModelleBlogÄnderungsprotokollSupport
NutzungsbedingungenDatenschutzrichtlinie
© 2026 CometAPI · All rights reserved
Home/Models/Doubao/Doubao-Seedance-2-0
D

Doubao-Seedance-2-0

Pro Sekunde:$0.08
Seedance 2.0 ist das multimodale Video‑Foundation‑Modell der nächsten Generation von ByteDance, das auf filmische, narrative Videogenerierung mit mehreren Einstellungen fokussiert ist. Im Unterschied zu Text‑zu‑Video‑Demos mit nur einer Einstellung betont Seedance 2.0 referenzbasierte Steuerung (Bilder, kurze Clips, Audio), kohärente Figuren‑ und Stilkonsistenz über Einstellungen hinweg sowie native Audio-/Video‑Synchronisation — mit dem Ziel, KI‑Video für professionelle Kreativ- und Previsualisierungs‑Workflows nutzbar zu machen.
Neu
Kommerzielle Nutzung
Überblick
Funktionen
Preisgestaltung
API
Versionen

Technische Spezifikationen von Doubao Seedance 2.0

ElementDetails
ProduktfamilieByteDance Seedance Video-Generierungsfamilie
CometAPI-Slugdoubao-seedance-2-0
AnbieterByteDance / BytePlus ModelArk
ModelltypVideogenerierungsmodell
EingabemodalitätenText, Bild, Audio, Video
ReferenzkapazitätBis zu 9 Bilder, 3 Videoclips und 3 Audioclips in einer einzigen multimodalen Anfrage
AusgabetypMP4-Video
Ausgabeauflösung480p, 720p, 1080p
Seitenverhältnisse21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Ausgabedauer4–15 Sekunden
API-StilAsynchrone, auf Aufgaben basierende Videogenerierung

Was ist Doubao Seedance 2.0?

Doubao Seedance 2.0 ist das multimodale Videogenerierungs-Flaggschiffmodell von ByteDance (veröffentlicht im Februar 2026). Es verwendet eine einheitliche Architektur zur gemeinsamen Erzeugung von Audio und Video, die durch gleichzeitiges Referenzieren mehrerer Bilder, Videoclips und Audiodateien eine präzise Regie-Kontrolle ermöglicht. Es überzeugt bei der Produktion filmischer, bewegungsstabiler Videos mit nativer Audiosynchronisierung — ideal für professionelle Creator, die realistische Physik, konsistente Charaktere und komplexe Szenenkomposition benötigen.

Hauptfunktionen von Doubao Seedance 2.0 auf CometAPI

  • Vereinheitlichte multimodale Generierung: Akzeptiert Text-, Bild-, Audio- und Videoeingaben in einem Workflow, sodass Nutzer eine Szene mit reichhaltigerem Referenzmaterial als bei einem reinen Textgenerator anleiten können.
  • Regisseurartige Steuerung: Das Modell ist darauf ausgelegt, Prompts für Darbietung, Beleuchtung, Schatten, Kamerabewegung, Bewegungsrhythmus und Klangeigenschaften zu befolgen.
  • Videobearbeitung und -erweiterung: Seedance 2.0 ist nicht auf die Erstdurchlauf-Generierung beschränkt; es unterstützt das Bearbeiten spezifischer Clips, Charaktere, Aktionen und Handlungsstränge sowie Vorwärts-/Rückwärtsverlängerung.
  • Starke Audio-Video-Synchronisierung: ByteDance hebt den zweikanaligen Stereoausgang sowie synchronisierte Hintergrundmusik, Umgebungsgeräusche und Voiceover-Verhalten für immersivere Ergebnisse hervor.
  • Hohe Steuerbarkeit bei komplexen Szenen: Es betont eine verbesserte Handhabung komplexer Interaktionen, Bewegungsszenen und physikalischer Plausibilität im Vergleich zu Seedance 1.5.
  • Produktionsorientierte Ausgabe: Die API unterstützt konfigurierbare Einstellungen für Verhältnis, Dauer und Wasserzeichen, was das Modell für wiederholbare Content-Workflows praktikabel macht.

Benchmark-Leistung

ByteDance sagt, dass Seedance 2.0 die interne SeedVideoBench-2.0-Evaluierung nutzt und in den Dimensionen Text-zu-Video, Bild-zu-Video und multimodale Aufgaben eine führende Position einnimmt. Das Modell verbessert die Generierungsqualität, physische Genauigkeit, Realismus und Steuerbarkeit gegenüber Seedance 1.5, insbesondere bei komplexen Interaktionen und Bewegungsszenen.

Seedance-2.0-API und Seedance-2.0-Fast-API-Modi auf CometAPI

ModellModellname in CometAPIAm besten geeignet fürHauptunterschied
Seedance 2.0doubao-seedance-2-0Multimodale Videoproduktion in höchster QualitätBreitester Referenz-Stack und stärkste Steuerbarkeit innerhalb der Seedance-2.0-Familie.
Seedance 2.0 fastdoubao-seedance-2-0-fastSchnellere Produktion, wenn Qualität etwas tauschbar istByteDance sagt, es behält die gleichen Modellfähigkeiten wie Seedance 2.0 bei, generiert jedoch schneller.
Seedance 1.5 Prodoubao-seedance-1-5-proAudio-Video-Erzeugung der vorherigen GenerationSeedance 1.5 Pro ist als natives gemeinsames Audio-Video-Modell positioniert, während Seedance 2.0 den multimodalen Referenz- und Bearbeitungs-Stack erweitert.

Stärken gegenüber Wettbewerbern:

  • vs Kling 3.0: Bessere multimodale Referenzsteuerung und natives Audio.
  • vs Sora 2: Überlegene Referenzpräzision und Fähigkeit für mehrere Einstellungen; leicht geringere maximale Dauer.
  • vs Veo 3.1: Stärker bei Charakterkonsistenz und Prompt-Befolgung für referenzlastige Workflows; Veo führt bei rohem filmischem Grading und längeren Clips.

Hervorragend bei menschenzentrierten und darstellungsorientierten Videos.

Seedance 2.0 AI Video Generator auf CometAPI ausprobieren

Schritt 1: Schritt 1: Registrieren Sie sich für einen API-Schlüssel

Starten Sie direkt im CometAPI Playground, um Doubao Seedance 2.0 ohne Einrichtung oder Coding zu erleben. Melden Sie sich einfach bei Ihrem CometAPI-Konto an, gehen Sie zur Modellseite für doubao-seedance-2-0, laden Sie Ihre Referenzbilder, kurzen Videoclips oder Audiodateien hoch, fügen Sie einen aussagekräftigen Prompt hinzu und generieren Sie sofort Vorschauvideos. Dies ist der schnellste Weg, um zu verstehen, wie Seedance 2.0 Bewegungs­konsistenz, Charakter­erscheinung, Kamerabewegungen und native Audiosynchronisierung handhabt.

Schritt 2: API-Zugang für Seedance 2.0 auf CometAPI erhalten

Erstellen Sie einen neuen oder verwenden Sie Ihren vorhandenen CometAPI-Schlüssel, um vollen Zugriff auf Doubao Seedance 2.0 zu aktivieren. Navigieren Sie nach dem Login in Ihrem Konsolenbereich zum Abschnitt API-Token, generieren Sie einen neuen Schlüssel und kopieren Sie ihn. Besuchen Sie anschließend die Modell-Detailseite Seedance 2.0 und die API-Dokumentation auf CometAPI, um die unterstützten Parameter für die Integration in Ihre Projekte zu prüfen.

Schritt 3: Senden Sie Ihre erste Anfrage mit der Seedance-2.0-API

Verwenden Sie den CometAPI-Endpoint, um Ihre erste Videogenerierungsanfrage mit einem klaren Text-Prompt und optionalen Referenzdateien (Bilder, Video oder Audio) einzureichen. Das System verarbeitet die Aufgabe asynchron, gibt eine Task-ID zurück und stellt nach Abschluss ein herunterladbares MP4-Video bereit. Sie können dann Ihre Prompts verfeinern, Einstellungen anpassen und für Marketingvideos, Social-Media-Inhalte, automatisierte Videopipelines oder kreative Anwendungen mit Seedance 2.0 hochskalieren.

Dieser Workflow ermöglicht schnelles Experimentieren im Playground und einen reibungslosen Übergang in die Produktion über die CometAPI.

Top-Gründe für Seedance 2.0 auf CometAPI

Warum CometAPI für Seedance 2.0 verwenden

  • Direkter Zugriff über API oder Playground
  • Einfache Parametersteuerung (Dauer, Auflösung, Format)
  • Unterstützt sowohl Text-zu-Video als auch Bild-zu-Video Workflows
  • Integrierte Job-Verwaltung für asynchrone Videogenerierung

Vereinheitlichte und entwicklerfreundliche API

CometAPI bietet einen klaren, standardisierten Endpoint, der nahtlos mit vertrauten OpenAI-ähnlichen Formaten oder dedizierten Video-Task-Endpoints funktioniert. Sie erhalten unkomplizierte Auftragserstellung, Polling und MP4-Downloads, ohne sich mit der komplexen Authentifizierung von Volcengine oder regionalen Beschränkungen befassen zu müssen.

Kosteneffiziente Preisgestaltung

CometAPI liefert in der Regel wettbewerbsfähigere Sekundenpreise als direkte Anbieter, sodass Sie hochwertige Videos in großem Maßstab für Marketing, Social Media oder automatisierte Pipelines generieren können, ohne Ihr Budget zu sprengen.

Schnelles Testen mit dem Playground

Experimentieren Sie sofort im CometAPI Playground. Laden Sie Referenzbilder, Videos und Audiodateien hoch, passen Sie Prompts an und sehen Sie Vorschau­ergebnisse in wenigen Minuten — ideal, um Stil, Bewegung und Audiosynchronisierung zu iterieren, bevor Sie in die Produktion gehen.

Kurz gesagt, wenn Sie die kreative Power von Seedance 2.0 — erstklassige Referenzkontrolle, natürliche Bewegung und natives Audio — ohne den Aufwand des direkten ByteDance-Zugriffs möchten, ist CometAPI derzeit eine der besten Plattformen, um es zu nutzen.

FAQ

What kinds of inputs does Seedance 2.0 support for video generation?

Seedance 2.0 unterstützt multimodale Eingaben, darunter Text-Prompts, bis zu 9 Bilder, bis zu 3 kurze Videoclips und bis zu 3 Audiodateien, die sich frei kombinieren lassen für eine reichhaltige, kontrollierbare Generierung.

Can Seedance 2.0 maintain character and style consistency across multiple video shots?

Ja — Seedance 2.0 ist für kohärentes Storytelling über mehrere Shots hinweg ausgelegt, mit konsistenten Charakteren, visuellem Stil und Atmosphäre über die Szenen hinweg, wodurch typische Drift-Probleme bei KI-Videos verringert werden.

What outputs and quality levels can I expect from Seedance 2.0 videos?

Seedance 2.0 kann Videos in Kinoqualität (bis zu 2K-Auflösung) mit nativem Audio, synchronisiertem Dialog und natürlicher Bewegungssynthese erzeugen, typischerweise in Clips von 5–60 Sekunden.

How does Seedance 2.0 handle audio and lip synchronization?

Das Modell erzeugt Audio und Video gemeinsam und bietet eine native audiovisuelle Synchronisation mit Lippensynchronität auf Phonemebene in 8+ Sprachen für natürliche Sprache und Soundeffekte.

Is Seedance 2.0 suitable for professional creative projects like marketing or narrative shorts?

Ja — die multimodale Steuerung, die Kontinuität über mehrere Shots hinweg und die Ausgabe mit hoher Wiedergabetreue von Seedance 2.0 machen es geeignet für Marketingvideos, narrative Kurzfilme, Werbespots und andere professionelle Anwendungen.

How do referencing assets (images, video clips) work in Seedance 2.0 prompts?

Nutzer können Referenz-Assets hochladen und dann in natürlicher Sprache beschreiben, wie jedes einzelne die Bewegung, Kamerabewegung oder stilistische Elemente beeinflussen soll, was eine feingranulare Kontrolle über die generierten Inhalte ermöglicht.

Does Seedance 2.0 allow editing and extension of existing videos?

Ja — das Modell unterstützt die Erweiterung von Videos und gezielte Bearbeitungen wie das Hinzufügen von Szenen, das Ersetzen von Charakteren oder das Ändern bestimmter Segmente, wobei unbearbeitete Teile erhalten bleiben.

What are known limitations or typical generation lengths with Seedance 2.0?

Typische Ausgabelängen liegen bei ~5 bis ~60 Sekunden pro Video, und das Kombinieren vieler Assets oder hochauflösender Einstellungen kann die Generierungszeit erhöhen.

Funktionen für Doubao-Seedance-2-0

Entdecken Sie die wichtigsten Funktionen von Doubao-Seedance-2-0, die darauf ausgelegt sind, Leistung und Benutzerfreundlichkeit zu verbessern. Erfahren Sie, wie diese Fähigkeiten Ihren Projekten zugutekommen und die Benutzererfahrung verbessern können.

Preise für Doubao-Seedance-2-0

Entdecken Sie wettbewerbsfähige Preise für Doubao-Seedance-2-0, die für verschiedene Budgets und Nutzungsanforderungen konzipiert sind. Unsere flexiblen Tarife stellen sicher, dass Sie nur für das bezahlen, was Sie nutzen, und erleichtern die Skalierung entsprechend Ihren wachsenden Anforderungen. Erfahren Sie, wie Doubao-Seedance-2-0 Ihre Projekte verbessern kann, während die Kosten überschaubar bleiben.

doubao-seedance Video Generation Pricing

Parameters

ParameterDescription
Duration (seconds)4–15 seconds, default 5 seconds
Aspect Ratio (size)21:9 / 16:9 / 4:3 / 1:1 / 3:4 / 9:16, default 16:9
Resolution480p / 720p / 1080p*, default 720p

*1080p only available for doubao-seedance-1-5-pro and doubao-seedance-1-0-pro

Pricing (Per Second)

Model480p720p1080p
doubao-seedance-2-0$0.08$0.24—
doubao-seedance-2-0-fast$0.064$0.192—
doubao-seedance-1-5-pro$0.018$0.04147$0.09331
doubao-seedance-1-0-pro$0.01875$0.0432$0.0972

💡 Billed per second. Total cost = price per second × video duration (seconds). Duration range: 4–15 seconds.

Beispielcode und API für Doubao-Seedance-2-0

Greifen Sie auf umfassende Beispielcodes und API-Ressourcen für Doubao-Seedance-2-0 zu, um Ihren Integrationsprozess zu optimieren. Unsere detaillierte Dokumentation bietet schrittweise Anleitungen und hilft Ihnen dabei, das volle Potenzial von Doubao-Seedance-2-0 in Ihren Projekten zu nutzen.
POST
/v1/videos
Python
JavaScript
Curl
import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}

def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False

def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600

def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")

def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

headers = {"Authorization": f"Bearer {COMETAPI_KEY}"}

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
        "resolution": (None, "720p"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

    print(f"Status: {status}, progress: {progress}")

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

Python Code Example

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}


def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False


def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600


def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")


def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

headers = {"Authorization": f"Bearer {COMETAPI_KEY}"}

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
        "resolution": (None, "720p"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

    print(f"Status: {status}, progress: {progress}")

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

JavaScript Code Example

import fs from "fs";
import path from "path";

// Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
const api_key = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const base_url = "https://api.cometapi.com";
const output_dir = "./output";
const poll_interval_ms = 10_000;
const retry_delay_ms = 5_000;
const max_create_attempts = 5;
const max_query_attempts = 3;
const terminal_statuses = new Set(["success", "completed", "failed", "error"]);
const success_statuses = new Set(["success", "completed"]);

function is_progress_complete(progress) {
  if (typeof progress === "number") {
    return progress >= 100;
  }

  if (typeof progress === "string") {
    const numeric = Number(progress.replace(/%$/, ""));
    return Number.isFinite(numeric) && numeric >= 100;
  }

  return false;
}

function is_transient_status(status) {
  return status === 429 || status >= 500;
}

async function fetch_with_retry(url, options, attempts, label) {
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    const response = await fetch(url, options);
    if (response.ok) {
      return response;
    }

    if (!is_transient_status(response.status) || attempt === attempts) {
      return response;
    }

    console.log(`${label} returned ${response.status}, retrying...`);
    await new Promise((resolve) => setTimeout(resolve, retry_delay_ms));
  }

  throw new Error(`${label} failed`);
}

if (api_key === "<YOUR_COMETAPI_KEY>") {
  console.log("Set COMETAPI_KEY before running this example.");
  process.exit(0);
}

const headers = {
  Authorization: `Bearer ${api_key}`,
};

const form = new FormData();
form.set("prompt", "A slow cinematic camera push across a coastal landscape at sunrise.");
form.set("model", "doubao-seedance-2-0");
form.set("seconds", "5");
form.set("size", "16:9");
form.set("resolution", "720p");

const create_response = await fetch_with_retry(`${base_url}/v1/videos`, {
  method: "POST",
  headers,
  body: form,
}, max_create_attempts, "Create request");

if (!create_response.ok) {
  console.log(await create_response.text());
  process.exit(1);
}

const create_result = await create_response.json();
const task_id = create_result.id || create_result.task_id;

if (!task_id) {
  console.log(JSON.stringify(create_result, null, 2));
  process.exit(1);
}

console.log(`Task created: ${task_id}`);
console.log(`Initial status: ${create_result.status}`);

while (true) {
  const task_response = await fetch_with_retry(`${base_url}/v1/videos/${task_id}`, {
    headers,
  }, max_query_attempts, "Status request");

  if (!task_response.ok) {
    console.log(await task_response.text());
    process.exit(1);
  }

  const task = await task_response.json();
  const status = String(task.status || "unknown");
  const normalized_status = status.toLowerCase();
  const progress = task.progress;
  const should_try_download = success_statuses.has(normalized_status) || (
    normalized_status === "unknown" && is_progress_complete(progress)
  );

  console.log(`Status: ${status}, progress: ${progress}`);

  if (should_try_download || terminal_statuses.has(normalized_status)) {
    if (should_try_download) {
      const video_url = task.video_url || "";
      const content_url = `${base_url}/v1/videos/${task_id}/content`;
      const output_path = path.join(output_dir, `${task_id}.mp4`);

      if (!fs.existsSync(output_dir)) {
        fs.mkdirSync(output_dir, { recursive: true });
      }

      const video_response = await fetch(content_url, { headers });
      if (!video_response.ok) {
        console.log(await video_response.text());
        process.exit(1);
      }

      const video_buffer = Buffer.from(await video_response.arrayBuffer());
      fs.writeFileSync(output_path, video_buffer);

      console.log(`Video URL: ${video_url}`);
      console.log(`Content endpoint: ${content_url}`);
      console.log(`Saved to ${output_path}`);
      console.log(`File size: ${fs.statSync(output_path).size} bytes`);
    } else {
      console.log(JSON.stringify(task, null, 2));
      process.exit(1);
    }
    break;
  }

  await new Promise((resolve) => setTimeout(resolve, poll_interval_ms));
}

Curl Code Example

#!/bin/bash

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

if [[ -z "${COMETAPI_KEY:-}" ]]; then
  echo "Set COMETAPI_KEY before running this example."
  exit 0
fi

BASE_URL="https://api.cometapi.com"
OUTPUT_DIR="./output"
POLL_INTERVAL_SECONDS=10
RETRY_DELAY_SECONDS=5
MAX_CREATE_ATTEMPTS=5
MAX_QUERY_ATTEMPTS=3

is_progress_complete() {
  local progress="$1"
  local normalized="${progress%%%}"

  if [[ -z "$normalized" ]]; then
    return 1
  fi

  [[ "$normalized" =~ ^[0-9]+([.][0-9]+)?$ ]] || return 1
  awk -v value="$normalized" 'BEGIN { exit !(value >= 100) }'
}

create_task() {
  local attempt=1
  while (( attempt <= MAX_CREATE_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos" \
      -H "Authorization: Bearer $COMETAPI_KEY" \
      -F 'prompt="A slow cinematic camera push across a coastal landscape at sunrise."' \
      -F 'model="doubao-seedance-2-0"' \
      -F 'seconds="5"' \
      -F 'size="16:9"' \
      -F 'resolution="720p"')

    status_code=$(echo "$response" | tail -n 1)
    CREATE_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_CREATE_ATTEMPTS )); then
      echo "Create request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$CREATE_RESPONSE"
    return 1
  done
}

get_task() {
  local task_id="$1"
  local attempt=1
  while (( attempt <= MAX_QUERY_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos/${task_id}" \
      -H "Authorization: Bearer $COMETAPI_KEY")

    status_code=$(echo "$response" | tail -n 1)
    TASK_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_QUERY_ATTEMPTS )); then
      echo "Status request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$TASK_RESPONSE"
    return 1
  done
}

create_task

TASK_ID=$(echo "$CREATE_RESPONSE" | jq -r '.id // .task_id // empty')

if [[ -z "$TASK_ID" ]]; then
  echo "$CREATE_RESPONSE" | jq .
  echo "No task id returned."
  exit 1
fi

echo "Task created: $TASK_ID"
echo "Initial status: $(echo "$CREATE_RESPONSE" | jq -r '.status // empty')"

while true; do
  get_task "$TASK_ID"

  STATUS=$(echo "$TASK_RESPONSE" | jq -r '.status // empty')
  NORMALIZED_STATUS=$(echo "$STATUS" | tr '[:upper:]' '[:lower:]')
  PROGRESS=$(echo "$TASK_RESPONSE" | jq -r '.progress // empty')
  SHOULD_TRY_DOWNLOAD=0

  if [[ "$NORMALIZED_STATUS" == "success" || "$NORMALIZED_STATUS" == "completed" ]]; then
    SHOULD_TRY_DOWNLOAD=1
  elif [[ "$NORMALIZED_STATUS" == "unknown" ]] && is_progress_complete "$PROGRESS"; then
    SHOULD_TRY_DOWNLOAD=1
  fi

  echo "Status: ${STATUS}, progress: ${PROGRESS}"

  if [[ "$SHOULD_TRY_DOWNLOAD" == "1" || "$NORMALIZED_STATUS" == "failed" || "$NORMALIZED_STATUS" == "error" ]]; then
    if [[ "$SHOULD_TRY_DOWNLOAD" == "1" ]]; then
      VIDEO_URL=$(echo "$TASK_RESPONSE" | jq -r '.video_url // empty')
      CONTENT_URL="${BASE_URL}/v1/videos/${TASK_ID}/content"
      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "$CONTENT_URL" \
        -H "Authorization: Bearer $COMETAPI_KEY" \
        -o "$OUTPUT_PATH"

      if [[ ! -s "$OUTPUT_PATH" ]]; then
        echo "Failed to download video"
        exit 1
      fi

      echo "Video URL: ${VIDEO_URL}"
      echo "Content endpoint: ${CONTENT_URL}"
      echo "Saved to ${OUTPUT_PATH}"
      echo "File size: $(wc -c < "$OUTPUT_PATH" | tr -d ' ') bytes"
    else
      echo "$TASK_RESPONSE" | jq .
      exit 1
    fi
    break
  fi

  sleep "$POLL_INTERVAL_SECONDS"
done

Versionen von Doubao-Seedance-2-0

Der Grund, warum Doubao-Seedance-2-0 mehrere Snapshots hat, kann potenzielle Faktoren wie Änderungen der Ausgabe nach Updates umfassen, die ältere Snapshots für Konsistenz erfordern, Entwicklern eine Übergangszeit für Anpassung und Migration bieten und verschiedene Snapshots, die globalen oder regionalen Endpunkten entsprechen, um das Benutzererlebnis zu optimieren. Für detaillierte Unterschiede zwischen den Versionen lesen Sie bitte die offizielle Dokumentation.
version
doubao-seedance-2-0
doubao-seedance-2-0-fast

Weitere Modelle

O

Sora 2 Pro

Pro Sekunde:$0.24
Sora 2 Pro ist unser fortschrittlichstes und leistungsstärkstes Modell zur Mediengenerierung, das Videos mit synchronisiertem Audio generieren kann. Es kann aus natürlicher Sprache oder Bildern detaillierte, dynamische Videoclips generieren.
O

Sora 2

Pro Sekunde:$0.08
Äußerst leistungsstarkes Modell zur Videogenerierung, mit Soundeffekten, unterstützt das Chat-Format.
M

mj_fast_video

Pro Anfrage:$0.6
Midjourney video generation
X

Grok Imagine Video

Pro Sekunde:$0.04
Generieren Sie Videos aus Text-Prompts, animieren Sie Standbilder oder bearbeiten Sie vorhandene Videos mit natürlicher Sprache. Die API unterstützt konfigurierbare Dauer, Seitenverhältnis und Auflösung für generierte Videos — das SDK übernimmt das asynchrone Polling automatisch.
G

Veo 3.1 Pro

Pro Sekunde:$0.25
Veo 3.1-Pro bezeichnet die leistungsstarke Zugangs-/Konfigurationsstufe der Veo 3.1 Familie von Google — eine Generation von Kurzform-Videomodellen mit Audiofunktion, die reichhaltigeres natives Audio, verbesserte Steuerungsmöglichkeiten für Erzählung und Schnitt sowie Werkzeuge zur Szenenerweiterung bieten.
G

Veo 3.1

Pro Sekunde:$0.05
Veo 3.1 ist Googles inkrementelles, aber bedeutendes Update für seine Veo-Text-und-Bild→Video-Familie, das reichhaltigeren nativen Ton, längere und besser steuerbare Videoausgaben sowie feinere Bearbeitungs- und Steuerungsmöglichkeiten auf Szenenebene hinzufügt.

Verwandte Blogs

So verwenden Sie die Seedance-2.0-API
Apr 17, 2026

So verwenden Sie die Seedance-2.0-API

Seedance 2.0 API ist das neueste multimodale KI-Videogenerierungsmodell von ByteDance (gestartet am 9. April 2026). Es akzeptiert Text, Bilder, Videoclips und Audio in einer einzigen Anfrage, um filmische MP4-Videos von 4–15 Sekunden Länge mit nativer Audiosynchronisation, Kamerasteuerung auf Regie-Niveau und außergewöhnlicher Bewegungskonsistenz zu generieren. So verwenden Sie es: Melden Sie sich auf CometAPI.com an, erhalten Sie einen API-Schlüssel, reichen Sie per REST eine asynchrone Aufgabe ein, führen Sie Polling bis zur Fertigstellung durch und laden Sie die Video-URL herunter.
Was ist HappyHorse-1.0? Wie vergleicht man Seedance 2.0?
Apr 11, 2026
seedance-2-0

Was ist HappyHorse-1.0? Wie vergleicht man Seedance 2.0?

Erfahren Sie, was HappyHorse-1.0 ist, warum es an die Spitze der Video-Bestenliste von Artificial Analysis gelangte, wie es im Vergleich zu Seedance 2.0 abschneidet und was die neuesten Ranglisten für die KI-Videogenerierung bedeuten.
Was ist Seedance 2.0? Eine umfassende Analyse
Mar 24, 2026
seedance-2-0

Was ist Seedance 2.0? Eine umfassende Analyse

Seedance 2.0 ist ein von ByteDance entwickeltes multimodales KI-Videogenerierungsmodell der nächsten Generation, das aus Text, Bildern, Audio und Referenzvideos hochwertige, filmische Videos generieren kann. Es zeichnet sich durch gekoppelte Audio-Video-Generierung, Bewegungsstabilität und referenzbasierte Bearbeitung aus und hat globale Benchmarks wie das Artificial Analysis leaderboard schnell erklommen, womit es sich 2026 unter den führenden KI-Videomodellen positioniert.