Wie handhabt Seedance 2.0 Audio- und Lippensynchronisation?

Das Modell erzeugt Audio und Video gemeinsam und bietet eine native audio-visuelle Synchronisation mit Lippensynchronisation auf Phonemebene in mehr als 8 Sprachen für natürlich klingende Sprache und Soundeffekte.

Ermöglicht Seedance 2.0 die Bearbeitung und Erweiterung bestehender Videos?

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

Welche Arten von Eingaben unterstützt Seedance 2.0 für die Videogenerierung?

Seedance 2.0 unterstützt multimodale Eingaben, darunter Textprompts, bis zu 9 Bilder, bis zu 3 kurze Videoclips und bis zu 3 Audiodateien, die frei kombiniert werden können, um eine reichhaltige, steuerbare Generierung zu ermöglichen.

Welche Ausgaben und Qualitätsstufen kann ich bei Seedance 2.0-Videos erwarten?

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.

Welche bekannten Einschränkungen oder typischen Generierungslängen gibt es bei Seedance 2.0?

Typische Ausgabelängen reichen von etwa 5 bis etwa 60 Sekunden pro Video, und die Kombination vieler Assets oder hochauflösender Einstellungen kann die Generierungszeit erhöhen.

Wie funktionieren Referenz-Assets (Bilder, Videoclips) in Seedance 2.0-Prompts?

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

Kann Seedance 2.0 die Konsistenz von Charakteren und Stil über mehrere Videoaufnahmen hinweg aufrechterhalten?

Ja — Seedance 2.0 ist auf kohärentes Multi-Shot-Storytelling ausgelegt, mit konsistenten Charakteren, visuellem Stil und Atmosphäre über Szenen hinweg, wodurch gängige Drift-Probleme bei KI-Videos reduziert werden.

Eignet sich Seedance 2.0 für professionelle kreative Projekte wie Marketing oder narrative Kurzfilme?

Ja — die multimodale Steuerung, die Multi-Shot-Kontinuität und die Ausgabe mit hoher Wiedergabetreue von Seedance 2.0 machen es geeignet für Marketingvideos, narrative Kurzfilme, Anzeigen und andere professionelle Anwendungen.

Bytedance

Verfügbar Beliebt

doubao-seedance-2-0

Seedance 2-0 API

Seedance 2.0 ist das multimodale Video-Grundlagenmodell der nächsten Generation von ByteDance, das auf filmische, narrative Videogenerierung mit mehreren Einstellungen ausgerichtet ist. Im Gegensatz zu Text-zu-Video-Demos mit nur einer Einstellung legt Seedance 2.0 den Schwerpunkt auf referenzbasierte Steuerung (Bilder, kurze Clips, Audio), durchgängige Konsistenz von Charakteren und Stil über mehrere Einstellungen hinweg sowie native Audio-/Video-Synchronisierung — mit dem Ziel, KI-Video für professionelle Kreativ- und Previsualisierungs-Workflows nutzbar zu machen.

Startpreis

$0.056 / Sekunde

Nutzungsbasierte Abrechnung

API-Status

Verfügbar

Produktions-Endpunkt

Antwortzeit

Asynchron bereit

Gemessene API-Antwortzeit

Veröffentlicht

Apr 19, 2026

Bytedance

Playground

Testen Sie Seedance 2-0 mit einer echten Anfrage, prüfen Sie die Parameter und validieren Sie die Ausgabe vor der API-Integration.

Überblick

Ein praktischer Überblick über Seedance 2-0, einschließlich wichtigem Verhalten und Hinweisen zur Integration.

Technische Spezifikationen von Doubao Seedance 2.0

Punkt	Details
Produktfamilie	ByteDance Seedance Videogenerierungsfamilie
CometAPI-Slug	doubao-seedance-2-0
Anbieter	ByteDance / BytePlus ModelArk
Modelltyp	Videogenerierungsmodell
Eingabemodalitäten	Text, Bild
Ausgabetyp	MP4-Video
Ausgabeauflösung	480p, 720p, 1080p
Seitenverhältnisse	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Ausgabledauer	4–15 Sekunden
API-Stil	Asynchrone, auf Aufgaben basierende Videogenerierung

Was ist Doubao Seedance 2.0?

Doubao Seedance 2.0 ist ByteDance’s Flaggschiff unter den multimodalen Videogenerierungsmodellen (veröffentlicht im Februar 2026). Es nutzt eine einheitliche Audio-Video-Gemeinschaftsgenerierungsarchitektur, die eine präzise Kontrolle auf Regieebene ermöglicht, indem gleichzeitig mehrere Bilder, Videoclips und Audiodateien referenziert werden. Es glänzt bei der Produktion kinoreifer, bewegungsstabiler Videos mit nativer Audiosynchronisierung — ideal für professionelle Kreative, die realistische Physik, konsistente Charaktere und eine komplexe Szenenkomposition benötigen.

Hauptfunktionen von Doubao Seedance 2.0 auf CometAPI

Einheitliche multimodale Generierung: Es akzeptiert Text-, Bild-, Audio- und Videoeingaben in einem Workflow, sodass Nutzer eine Szene mit reichhaltigerem Referenzmaterial inszenieren können als mit einem reinen Textgenerator.
Regieähnliche Kontrolle: Das Modell ist darauf ausgelegt, Anweisungen zu Performance, Beleuchtung, Schatten, Kamerabewegung, Bewegungsrhythmus und Klangeigenschaften zu befolgen.
Videobearbeitung und -erweiterung: Seedance 2.0 ist nicht auf die Erstgenerierung beschränkt; es unterstützt das Editieren spezifischer Clips, Charaktere, Aktionen und Handlungsstränge sowie Vorwärts-/Rückwärtsverlängerung.
Starke Audio-Video-Synchronität: ByteDance hebt den zweikanaligen Stereoausgang sowie synchronisierte Hintergrundmusik, Umgebungsgeräusche und Voice-over-Verhalten für noch 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 konfigurierbares Seitenverhältnis, Dauer und Wasserzeichen-Einstellungen, wodurch das Modell für wiederholbare Content-Workflows praktisch wird.

Benchmark-Leistung

ByteDance gibt an, dass Seedance 2.0 die interne SeedVideoBench-2.0-Evaluierung nutzt und in den Bereichen Text-zu-Video, Bild-zu-Video und multimodale Aufgaben führend platziert ist. Das Modell verbessert die Generierungsqualität, physikalische Genauigkeit, den Realismus und die 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

Modell	Modellname in CometAPI	Am besten geeignet für	Hauptunterschied
Seedance 2.0	doubao-seedance-2-0	Multimodale Videoproduktion in höchster Qualität	Größter Referenz-Stack und stärkste Steuerbarkeit innerhalb der Seedance 2.0-Familie.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Schnellere Produktion, wenn leichte Qualitätseinbußen akzeptiert werden können	ByteDance sagt, dass die gleichen Modellfähigkeiten wie bei Seedance 2.0 erhalten bleiben, jedoch mit schnellerer Generierung.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Audiovideo-Erstellung der früheren Generation	Seedance 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 im Vergleich zu Wettbewerbern:

vs Kling 3.0: Bessere multimodale Referenzkontrolle und natives Audio.
vs Sora 2: Überlegene Referenzpräzision und Mehrfachaufnahmefähigkeit; etwas geringere maximale Dauer.
vs Veo 3.1: Stärker bei Charakterkonsistenz und Prompt-Compliance für referenzlastige Workflows; Veo führt beim cinematischen Grading und bei längeren Clips.

Hervorragend in menschenzentrierten und performanceorientierten Videos.

Probieren Sie den Seedance 2.0 KI-Videogenerator auf CometAPI aus

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 Setup oder Coding zu erleben. Melden Sie sich einfach in Ihrem CometAPI-Konto an, gehen Sie zur Modellseite für doubao-seedance-2-0, laden Sie Ihre Referenzbilder, kurze Videoclips oder Audiodateien hoch, fügen Sie einen beschreibenden Prompt hinzu und generieren Sie sofort Vorschauvideos. Dies ist der schnellste Weg, um zu verstehen, wie Seedance 2.0 Bewegungskonsistenz, Charakteraussehen, 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 bestehenden CometAPI-Schlüssel, um vollen Zugriff auf Doubao Seedance 2.0 zu aktivieren. Melden Sie sich an, navigieren Sie in Ihrer Konsole zum Bereich 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-Endpunkt, 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. Anschließend können Sie 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 Ihnen schnelles Experimentieren im Playground und einen reibungslosen Übergang in die Produktionsnutzung über die CometAPI.

Hauptgrü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
Integriertes Job-Handling für asynchrone Videogenerierung

Einheitliche und entwicklerfreundliche API

CometAPI bietet einen klaren, standardisierten Endpunkt, der nahtlos mit vertrauten OpenAI-ähnlichen Formaten oder dedizierten Video-Task-Endpunkten funktioniert. Sie erhalten eine unkomplizierte Aufgabenerstellung, Abfragen und MP4-Downloads, ohne sich mit der komplexen Authentifizierung oder regionalen Beschränkungen von Volcengine auseinandersetzen zu müssen.

Kosteneffiziente Preisgestaltung

CometAPI bietet in der Regel wettbewerbsfähigere Preise pro Sekunde als direkte Anbieter, sodass Sie hochwertige Videos in großem Maßstab für Marketing, soziale Medien 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, feilen Sie an Prompts und sehen Sie in Minuten Vorschauen — perfekt, 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 eines direkten ByteDance-Zugangs möchten, ist CometAPI derzeit eine der besten Plattformen, um es zu nutzen.

FAQ

Preisgestaltung

Nutzen Sie die obige Schnellschätzung für einen einzelnen Durchlauf und prüfen Sie anschließend den vollständigen Vergleich von CometAPI- und offiziellem Preis.

5-Sekunden-Test

$0.28

Geschätzte CometAPI-Nutzungskosten

10-Sekunden-Test

$0.56

Geschätzte CometAPI-Nutzungskosten

15-Sekunden-Test

$0.84

Geschätzte CometAPI-Nutzungskosten

Preise für Seedance 2-0

Entdecken Sie wettbewerbsfähige Preise für 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 Seedance 2-0 Ihre Projekte verbessern kann, während die Kosten überschaubar bleiben.

doubao-seedance Video Generation Pricing

Parameters

Parameter	Description
Duration (seconds)	4–15 seconds, default 5 seconds
size	Refer to documentation

*1080p is unavailable for doubao-seedance-2-0-fast and doubao-seedance-2-0-mini.

Pricing (Per Second)

Model	480p	720p	1080p	4k
`doubao-seedance-2-0`	$0.056	$0.1216	$0.2992	$0.624
`doubao-seedance-2-0-fast`	$0.0448	$0.096	—	—
`doubao-seedance-2-0-mini`	$0.032	$0.064	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—

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

API

Kopieren Sie einen funktionierenden Endpunkt und ein Codebeispiel; öffnen Sie bei Bedarf die vollständige API-Referenz für alle Parameter.

Eine API, produktionsreifer Modellzugriff

Einmal authentifizieren, den Modell-Endpunkt aufrufen und denselben Abrechnungs- und Monitoring-Workflow anbieterübergreifend beibehalten.

POST/v1/videos

Beispielcode und API für Seedance 2-0

Greifen Sie auf umfassende Beispielcodes und API-Ressourcen für Seedance 2-0 zu, um Ihren Integrationsprozess zu optimieren. Unsere detaillierte Dokumentation bietet schrittweise Anleitungen und hilft Ihnen dabei, das volle Potenzial von Seedance 2-0 in Ihren Projekten zu nutzen.

POST

/v1/videos

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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 $'
%{http_code}' "https://api.cometapi.com/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"')

    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 $'
%{http_code}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

cURL Code Example

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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}' "https://api.cometapi.com/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"')

    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}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

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"),
    }
)
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");

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));
}

Fähigkeiten

Prüfen Sie die wichtigsten Modellfakten, bevor Sie eine Architektur wählen oder die Produktionslast abschätzen.

Unterstützte Funktionen

Von der bestehenden Modell-API zurückgegebene Funktionen.

text-to-video

image-to-video

Eingabe und Ausgabe

Eingaben

text

Ausgaben

video

Produktionsprofil

Anbieter: Bytedance
Kontext: Modellabhängig
Kommerzielle Nutzung: Unterstützt

Anwendungsfälle

Nutzen Sie Seedance 2-0 für Produktions-Workflows entsprechend seiner video-Fähigkeiten und vergleichen Sie Alternativen vor einer langfristigen Integration.

Text-zu-Video-Konzepte und Social-Content

Produktdemos und filmische Storyboards

Bild-zu-Video-Bewegung und kreative Iteration

Weitere Modelle

Vergleichen Sie weitere über CometAPI verfügbare Modelle hinsichtlich Qualität, Latenz, Funktionsumfang und Preis.

Modellvergleich öffnen →

Aliyun

Wan3.0

From fast verification to cinematic output, billing is based on the generated video duration, selecting the appropriate resolution, and turning every generation into a planned creative investment activity rule

Modell ansehen

Flux

Flux 3

FLUX 3 - Real World Models: Towards Multimodal Flow Models as the Backbone of Visual Intelligence.

Modell ansehen

Aliyun

Happy Horse 1.1

HappyHorse 1.1 ist ein multimodales Modell zur Videogenerierung, das für professionelle Inhaltserstellung, Werbung, Kurzfilme, Social-Media-Produktion und Storytelling konzipiert ist. Es erweitert die Fähigkeiten von HappyHorse 1.0 — das nach hohen Platzierungen in unabhängigen Evaluierungen zur Videogenerierung große Aufmerksamkeit erlangte — um eine stärkere Szenenkohärenz und eine verbesserte Bildtreue.

Modell ansehen

Google

Gemini omni fast

Gemini Omni Fast is a lightweight multimodal video generation model designed for fast and flexible content creation. It enables efficient video generation with support for multiple input types, making it suitable for interactive and iterative workflows.

Modell ansehen

OpenAI

Sora 2 Pro

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.

Modell ansehen

Aliyun

Happy Horse 1.0

Happy Horse 1.0 — A high-quality audio-video generation model that supports text-to-video and image-to-video creation. It can generate synchronized visuals, audio, and lip movements, making it suitable for short films, advertising creatives, and product showcases.

Modell ansehen

Uptime

Prüfen Sie Live-Heartbeat-Daten, Endpunktverfügbarkeit und gemessene Antwortzeiten vor dem Produktivbetrieb.

Versionen

Prüfen Sie verfügbare Modellkennungen, bevor Sie eine Produktionsintegration festlegen.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Weiter erkunden

Modelle vergleichen und Ihre Recherche fortsetzen

Bytedance

Verfügbar Beliebt

doubao-seedance-2-0

Seedance 2-0 API

Startpreis

$0.056 / Sekunde

Nutzungsbasierte Abrechnung

API-Status

Verfügbar

Produktions-Endpunkt

Antwortzeit

Asynchron bereit

Gemessene API-Antwortzeit

Veröffentlicht

Apr 19, 2026

Bytedance

Playground

Testen Sie Seedance 2-0 mit einer echten Anfrage, prüfen Sie die Parameter und validieren Sie die Ausgabe vor der API-Integration.

Überblick

Ein praktischer Überblick über Seedance 2-0, einschließlich wichtigem Verhalten und Hinweisen zur Integration.

Technische Spezifikationen von Doubao Seedance 2.0

Punkt	Details
Produktfamilie	ByteDance Seedance Videogenerierungsfamilie
CometAPI-Slug	doubao-seedance-2-0
Anbieter	ByteDance / BytePlus ModelArk
Modelltyp	Videogenerierungsmodell
Eingabemodalitäten	Text, Bild
Ausgabetyp	MP4-Video
Ausgabeauflösung	480p, 720p, 1080p
Seitenverhältnisse	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Ausgabledauer	4–15 Sekunden
API-Stil	Asynchrone, auf Aufgaben basierende Videogenerierung

Was ist Doubao Seedance 2.0?

Hauptfunktionen von Doubao Seedance 2.0 auf CometAPI

Einheitliche multimodale Generierung: Es akzeptiert Text-, Bild-, Audio- und Videoeingaben in einem Workflow, sodass Nutzer eine Szene mit reichhaltigerem Referenzmaterial inszenieren können als mit einem reinen Textgenerator.
Regieähnliche Kontrolle: Das Modell ist darauf ausgelegt, Anweisungen zu Performance, Beleuchtung, Schatten, Kamerabewegung, Bewegungsrhythmus und Klangeigenschaften zu befolgen.
Videobearbeitung und -erweiterung: Seedance 2.0 ist nicht auf die Erstgenerierung beschränkt; es unterstützt das Editieren spezifischer Clips, Charaktere, Aktionen und Handlungsstränge sowie Vorwärts-/Rückwärtsverlängerung.
Starke Audio-Video-Synchronität: ByteDance hebt den zweikanaligen Stereoausgang sowie synchronisierte Hintergrundmusik, Umgebungsgeräusche und Voice-over-Verhalten für noch 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 konfigurierbares Seitenverhältnis, Dauer und Wasserzeichen-Einstellungen, wodurch das Modell für wiederholbare Content-Workflows praktisch wird.

Benchmark-Leistung

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

Modell	Modellname in CometAPI	Am besten geeignet für	Hauptunterschied
Seedance 2.0	doubao-seedance-2-0	Multimodale Videoproduktion in höchster Qualität	Größter Referenz-Stack und stärkste Steuerbarkeit innerhalb der Seedance 2.0-Familie.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Schnellere Produktion, wenn leichte Qualitätseinbußen akzeptiert werden können	ByteDance sagt, dass die gleichen Modellfähigkeiten wie bei Seedance 2.0 erhalten bleiben, jedoch mit schnellerer Generierung.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Audiovideo-Erstellung der früheren Generation	Seedance 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 im Vergleich zu Wettbewerbern:

vs Kling 3.0: Bessere multimodale Referenzkontrolle und natives Audio.
vs Sora 2: Überlegene Referenzpräzision und Mehrfachaufnahmefähigkeit; etwas geringere maximale Dauer.
vs Veo 3.1: Stärker bei Charakterkonsistenz und Prompt-Compliance für referenzlastige Workflows; Veo führt beim cinematischen Grading und bei längeren Clips.

Hervorragend in menschenzentrierten und performanceorientierten Videos.

Probieren Sie den Seedance 2.0 KI-Videogenerator auf CometAPI aus

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

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

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

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

Hauptgrü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
Integriertes Job-Handling für asynchrone Videogenerierung

Einheitliche und entwicklerfreundliche API

Kosteneffiziente Preisgestaltung

Schnelles Testen mit dem Playground

FAQ

Preisgestaltung

Nutzen Sie die obige Schnellschätzung für einen einzelnen Durchlauf und prüfen Sie anschließend den vollständigen Vergleich von CometAPI- und offiziellem Preis.

5-Sekunden-Test

$0.28

Geschätzte CometAPI-Nutzungskosten

10-Sekunden-Test

$0.56

Geschätzte CometAPI-Nutzungskosten

15-Sekunden-Test

$0.84

Geschätzte CometAPI-Nutzungskosten

Preise für Seedance 2-0

doubao-seedance Video Generation Pricing

Parameters

Parameter	Description
Duration (seconds)	4–15 seconds, default 5 seconds
size	Refer to documentation

*1080p is unavailable for doubao-seedance-2-0-fast and doubao-seedance-2-0-mini.

Pricing (Per Second)

Model	480p	720p	1080p	4k
`doubao-seedance-2-0`	$0.056	$0.1216	$0.2992	$0.624
`doubao-seedance-2-0-fast`	$0.0448	$0.096	—	—
`doubao-seedance-2-0-mini`	$0.032	$0.064	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—

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

API

Kopieren Sie einen funktionierenden Endpunkt und ein Codebeispiel; öffnen Sie bei Bedarf die vollständige API-Referenz für alle Parameter.

Eine API, produktionsreifer Modellzugriff

Einmal authentifizieren, den Modell-Endpunkt aufrufen und denselben Abrechnungs- und Monitoring-Workflow anbieterübergreifend beibehalten.

POST/v1/videos

Beispielcode und API für Seedance 2-0

POST

/v1/videos

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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 $'
%{http_code}' "https://api.cometapi.com/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"')

    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 $'
%{http_code}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

cURL Code Example

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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}' "https://api.cometapi.com/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"')

    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}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

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"),
    }
)
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");

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));
}

Fähigkeiten

Prüfen Sie die wichtigsten Modellfakten, bevor Sie eine Architektur wählen oder die Produktionslast abschätzen.

Unterstützte Funktionen

Von der bestehenden Modell-API zurückgegebene Funktionen.

text-to-video

image-to-video

Eingabe und Ausgabe

Eingaben

text

Ausgaben

video

Produktionsprofil

Anbieter: Bytedance
Kontext: Modellabhängig
Kommerzielle Nutzung: Unterstützt

Anwendungsfälle

Nutzen Sie Seedance 2-0 für Produktions-Workflows entsprechend seiner video-Fähigkeiten und vergleichen Sie Alternativen vor einer langfristigen Integration.

Text-zu-Video-Konzepte und Social-Content

Produktdemos und filmische Storyboards

Bild-zu-Video-Bewegung und kreative Iteration

Weitere Modelle

Vergleichen Sie weitere über CometAPI verfügbare Modelle hinsichtlich Qualität, Latenz, Funktionsumfang und Preis.

Modellvergleich öffnen →

FLUX 3 - Real World Models: Towards Multimodal Flow Models as the Backbone of Visual Intelligence.

Uptime

Prüfen Sie Live-Heartbeat-Daten, Endpunktverfügbarkeit und gemessene Antwortzeiten vor dem Produktivbetrieb.

Versionen

Prüfen Sie verfügbare Modellkennungen, bevor Sie eine Produktionsintegration festlegen.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Weiter erkunden