Wie handhabt Seedance 2.0 die Audio- und Lippensynchronisation?

Das Modell generiert Audio und Video gemeinsam und bietet eine native audio-visuelle Synchronisierung mit Lippensynchronisation auf Phonemebene in 8+ Sprachen für natürliche Sprache und Soundeffekte.

Erlaubt Seedance 2.0 die Bearbeitung und Erweiterung bestehender Videos?

Ja — das Modell unterstützt die Videoerweiterung und gezielte Bearbeitung wie das Hinzufügen von Szenen, das Ersetzen von Charakteren oder das Ändern bestimmter Segmente, wobei unbearbeitete Teile 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 sich frei kombinieren lassen für eine reichhaltige, steuerbare Generierung.

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

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

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

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

Wie funktionieren referenzierende Assets (Bilder, Videoclips) in Prompts für Seedance 2.0?

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

Kann Seedance 2.0 die Konsistenz von Charakteren und Stil über mehrere Aufnahmen hinweg beibehalten?

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

Eignet sich Seedance 2.0 für professionelle Kreativprojekte wie Marketing oder erzählerische Kurzfilme?

Ja — die multimodale Steuerung, die Kontinuität über mehrere Shots und die hohe Wiedergabetreue von Seedance 2.0 machen es geeignet für Marketingvideos, erzählerische Kurzfilme, Werbespots und andere professionelle Anwendungen.

Bytedance

Verfügbar Beliebt

doubao-seedance-2-0

Seedance 2-0 API

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.

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

Element	Details
Produktfamilie	ByteDance Seedance Video-Generierungsfamilie
CometAPI-Slug	doubao-seedance-2-0
Anbieter	ByteDance / BytePlus ModelArk
Modelltyp	Modell zur Videogenerierung
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
Ausgabedauer	4–15 Sekunden
API-Stil	Asynchrone, auf Aufgaben basierende Videogenerierung

Was ist Doubao Seedance 2.0?

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

Hauptfunktionen von Doubao Seedance 2.0 auf CometAPI

Einheitliche 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.
Regieartige Steuerung: Das Modell folgt Prompts für Darstellung, Beleuchtung, Schatten, Kamerabewegung, Bewegungsrhythmus und Klangcharakteristika.
Videobearbeitung und -erweiterung: Seedance 2.0 ist nicht auf die Erstgenerierung beschränkt; es unterstützt die Bearbeitung spezifischer Clips, Charaktere, Aktionen und Handlungsstränge sowie Vorwärts-/Rückwärts-Erweiterung.
Starke audiovisuelle Synchronisation: ByteDance hebt zweikanalige Stereoausgabe sowie synchronisierte Hintergrundmusik, Umgebungsgeräusche und Voice-over-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 Seitenverhältnis-, Dauer- und Wasserzeichen-Einstellungen, was das Modell für wiederholbare Content-Workflows praxistauglich macht.

Benchmark-Leistung

ByteDance sagt, Seedance 2.0 nutze die interne SeedVideoBench-2.0-Bewertung und belege in den Disziplinen Text-zu-Video, Bild-zu-Video und multimodale Aufgaben eine führende Position. Das Modell verbessert Generierungsqualität, physikalische Genauigkeit, Realismus und Steuerbarkeit gegenüber Seedance 1.5, insbesondere bei komplexen Interaktions- 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 bei leichten Qualitätsabstrichen	ByteDance sagt, es behält die gleichen Modellfähigkeiten wie Seedance 2.0, generiert jedoch schneller.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Audio-Video-Erstellung der vorherigen 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 vs Wettbewerber:

vs Kling 3.0: Bessere multimodale Referenzkontrolle und native Audioausgabe.
vs Sora 2: Überlegene Referenzpräzision und Multi-Shot-Fähigkeit; leicht kürzere maximale Dauer.
vs Veo 3.1: Stärker bei Charakterkonsistenz und Prompt-Befolgung für referenzlastige Workflows; Veo führt bei reiner filmischer Grading-Qualität und längeren Clips.

Hervorragend bei menschenzentrierten und darstellungsgetriebenen Videos.

Seedance 2.0 AI Video Generator auf CometAPI ausprobieren

Schritt 1: Schritt 1: Für API-Schlüssel registrieren

Starten Sie direkt im CometAPI Playground, um Doubao Seedance 2.0 ohne Einrichtung oder Coding auszuprobieren. 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 Audio-Synchronisation handhabt.

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

Erstellen Sie einen CometAPI-Schlüssel oder verwenden Sie Ihren bestehenden, um vollen Zugriff auf Doubao Seedance 2.0 zu aktivieren. Nachdem Sie sich angemeldet haben, navigieren Sie in Ihrer Konsole zum Bereich API Token, erzeugen 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 Video-Generierungsanfrage 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 auf Basis von Seedance 2.0 skalieren.

Dieser Workflow ermöglicht schnelles Experimentieren im Playground und einen reibungslosen Übergang in den Produktionseinsatz ü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
Integriertes Job-Handling für asynchrone Videogenerierung

Vereinheitlichte und entwicklerfreundliche API

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

Kosteneffiziente Preisgestaltung

CometAPI bietet in der Regel wettbewerbsfähigere Kosten pro Sekunde als Direktanbieter, sodass Sie hochwertige Videos in großem Maßstab für Marketing, Social Media oder automatisierte Pipelines erzeugen 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, justieren Sie Prompts und sehen Sie Ergebnisse in Minuten in der Vorschau — perfekt, um Stil, Bewegung und Audio-Sync zu iterieren, bevor es in die Produktion geht.

Kurz gesagt, wenn Sie die kreative Power von Seedance 2.0 — branchenführende Referenzkontrolle, natürliche Bewegung und native Audioausgabe — ohne den Aufwand des 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

Von der schnellen Verifizierung bis zur kinoreifen Ausgabe basiert die Abrechnung auf der Dauer des generierten Videos, der Auswahl der geeigneten Auflösung und darauf, jede Generierung in eine geplante kreative Investition zu verwandeln – Aktivitätsregel

Modell ansehen

MiniMax

MiniMax H3

minimax-h3 ist ein neues Videogenerierungsmodell, das für hochwertige kreative Produktion entwickelt wurde. Es bietet ein verbessertes Prompt-Verständnis, stärkere visuelle Konsistenz, flüssigere Bewegungen und eine flexiblere Kontrolle über Referenzbilder für filmische Workflows der Videogenerierung.

Modell ansehen

Bytedance

Seedance 2.5

seedance-2-5 ist ein Modell der nächsten Generation für die gemeinsame Audio-Video-Generierung, entwickelt für 30-Sekunden-Storytelling, mit präziser Referenzsteuerung und leistungsstarken Bearbeitungsfunktionen.

Modell ansehen

Flux

Flux 3

FLUX 3 - Modelle der realen Welt: Auf dem Weg zu multimodalen Flow-Modellen als Rückgrat visueller Intelligenz.

Modell ansehen

Aliyun

Happy Horse 1.1

HappyHorse 1.1 ist ein multimodales Videogenerationsmodell, das für professionelle Content-Erstellung, Werbung, Kurzfilme, Social-Media-Produktion und Storytelling entwickelt wurde. Es erweitert die Fähigkeiten von HappyHorse 1.0 — das nach hohen Platzierungen in unabhängigen Evaluierungen zur Videogenerierung große Aufmerksamkeit erhielt — um eine stärkere Szenenkohärenz und eine verbesserte visuelle Wiedergabetreue.

Modell ansehen

Aliyun

Happy Horse 1.0

Happy Horse 1.0 — ein hochwertiges Audio-Video-Generierungsmodell, das die Erstellung von Text-zu-Video- und Bild-zu-Video-Inhalten ermöglicht. Es kann synchronisiertes Bildmaterial, Audio und Lippenbewegungen generieren und eignet sich damit für Kurzfilme, Werbemittel und Produktpräsentationen.

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

Element	Details
Produktfamilie	ByteDance Seedance Video-Generierungsfamilie
CometAPI-Slug	doubao-seedance-2-0
Anbieter	ByteDance / BytePlus ModelArk
Modelltyp	Modell zur Videogenerierung
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
Ausgabedauer	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: Akzeptiert Text-, Bild-, Audio- und Videoeingaben in einem Workflow, sodass Nutzer eine Szene mit reichhaltigerem Referenzmaterial als bei einem reinen Textgenerator anleiten können.
Regieartige Steuerung: Das Modell folgt Prompts für Darstellung, Beleuchtung, Schatten, Kamerabewegung, Bewegungsrhythmus und Klangcharakteristika.
Videobearbeitung und -erweiterung: Seedance 2.0 ist nicht auf die Erstgenerierung beschränkt; es unterstützt die Bearbeitung spezifischer Clips, Charaktere, Aktionen und Handlungsstränge sowie Vorwärts-/Rückwärts-Erweiterung.
Starke audiovisuelle Synchronisation: ByteDance hebt zweikanalige Stereoausgabe sowie synchronisierte Hintergrundmusik, Umgebungsgeräusche und Voice-over-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 Seitenverhältnis-, Dauer- und Wasserzeichen-Einstellungen, was das Modell für wiederholbare Content-Workflows praxistauglich macht.

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 bei leichten Qualitätsabstrichen	ByteDance sagt, es behält die gleichen Modellfähigkeiten wie Seedance 2.0, generiert jedoch schneller.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Audio-Video-Erstellung der vorherigen 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 vs Wettbewerber:

vs Kling 3.0: Bessere multimodale Referenzkontrolle und native Audioausgabe.
vs Sora 2: Überlegene Referenzpräzision und Multi-Shot-Fähigkeit; leicht kürzere maximale Dauer.
vs Veo 3.1: Stärker bei Charakterkonsistenz und Prompt-Befolgung für referenzlastige Workflows; Veo führt bei reiner filmischer Grading-Qualität und längeren Clips.

Hervorragend bei menschenzentrierten und darstellungsgetriebenen Videos.

Seedance 2.0 AI Video Generator auf CometAPI ausprobieren

Schritt 1: Schritt 1: Für API-Schlüssel registrieren

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 schnelles Experimentieren im Playground und einen reibungslosen Übergang in den Produktionseinsatz ü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
Integriertes Job-Handling für asynchrone Videogenerierung

Vereinheitlichte 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 - Modelle der realen Welt: Auf dem Weg zu multimodalen Flow-Modellen als Rückgrat visueller Intelligenz.

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