Come gestisce Seedance 2.0 l'audio e la sincronizzazione labiale?

Il modello genera audio e video congiuntamente, offrendo una sincronizzazione audio-video nativa con sincronizzazione labiale a livello di fonema in oltre 8 lingue per parlato naturale ed effetti sonori.

Seedance 2.0 consente di modificare e ampliare video esistenti?

Sì — il modello supporta l'estensione dei video e l'editing mirato, come l'aggiunta di scene, la sostituzione di personaggi o la modifica di segmenti specifici, preservando le parti non modificate.

Quali tipi di input supporta Seedance 2.0 per la generazione di video?

Seedance 2.0 supporta input multimodali, inclusi prompt testuali, fino a 9 immagini, fino a 3 clip video brevi e fino a 3 file audio, che possono essere combinati liberamente per una generazione ricca e controllabile.

Quali output e livelli di qualità posso aspettarmi dai video di Seedance 2.0?

Seedance 2.0 può generare video di livello cinematografico (fino a risoluzione 2K) con audio nativo, dialoghi sincronizzati e sintesi del movimento naturale, tipicamente in clip da 5 a 60 secondi.

Quali sono le limitazioni note o le durate tipiche di generazione con Seedance 2.0?

Le durate tipiche dell'output vanno da ~5 a ~60 secondi per video e combinare molti asset o impostazioni ad alta risoluzione può aumentare il tempo di generazione.

Come funzionano gli asset di riferimento (immagini, clip video) nei prompt di Seedance 2.0?

Gli utenti possono caricare asset di riferimento e poi descrivere in linguaggio naturale come ciascuno dovrebbe influenzare il movimento, i movimenti di camera o gli elementi stilistici, offrendo un controllo granulare sul contenuto generato.

Seedance 2.0 può mantenere coerenza di personaggi e stile su più riprese video?

Sì — Seedance 2.0 è progettato per una narrazione multi-shot coerente, con personaggi, stile visivo e atmosfera consistenti tra le scene, riducendo i comuni problemi di deriva dei video generati dall'IA.

Seedance 2.0 è adatto a progetti creativi professionali come marketing o cortometraggi narrativi?

Sì — il controllo multimodale, la continuità multi-shot e l'output ad alta fedeltà di Seedance 2.0 lo rendono adatto a video di marketing, cortometraggi narrativi, spot pubblicitari e altre applicazioni professionali.

Bytedance

Disponibile Popolare

doubao-seedance-2-0

Seedance 2-0 API

Seedance 2.0 è il modello fondazionale video multimodale di nuova generazione di ByteDance, incentrato sulla generazione di video narrativi cinematografici a più inquadrature. A differenza delle demo di generazione da testo a video a singola inquadratura, Seedance 2.0 pone l’accento sul controllo basato su riferimenti (immagini, clip brevi, audio), sulla coerenza di personaggio e stile tra le inquadrature e sulla sincronizzazione nativa audio/video — con l’obiettivo di rendere i video generati dall’IA utili per flussi di lavoro professionali creativi e di previsualizzazione.

Prezzo di partenza

$0.056 / secondo

Fatturazione a consumo

Stato dell'API

Disponibile

Endpoint di produzione

Risposta

Pronto per l'async

Tempo di risposta API osservato

Pubblicato

Apr 19, 2026

Bytedance

Playground

Prova Seedance 2-0 con una richiesta reale, controlla i parametri e verifica l'output prima di integrare l'API.

Panoramica

Una panoramica pratica di Seedance 2-0, con comportamenti importanti e considerazioni per l'integrazione.

Specifiche tecniche di Doubao Seedance 2.0

Voce	Dettagli
Famiglia di prodotto	Famiglia di generazione video ByteDance Seedance
Slug CometAPI	doubao-seedance-2-0
Fornitore	ByteDance / BytePlus ModelArk
Tipo di modello	Modello di generazione video
Modalità di input	Testo, immagine
Tipo di output	Video MP4
Risoluzione di output	480p, 720p, 1080p
Proporzioni	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Durata di output	4–15 secondi
Stile API	Generazione video asincrona basata su task

Che cos’è Doubao Seedance 2.0?

Doubao Seedance 2.0 è il modello multimodale di generazione video di punta di ByteDance (rilasciato a febbraio 2026). Utilizza un’architettura unificata per la generazione congiunta audio‑video che consente un controllo a livello di regia facendo riferimento simultaneamente a più immagini, clip video e file audio. Eccelle nella produzione di video cinematografici, stabili nel movimento, con sincronizzazione audio nativa — ideale per creatori professionisti che necessitano di fisica realistica, coerenza dei personaggi e composizione di scene complesse.

Funzionalità principali di Doubao Seedance 2.0 su CometAPI

Generazione multimodale unificata: accetta input di testo, immagine, audio e video in un unico flusso di lavoro, così gli utenti possono dirigere una scena con materiale di riferimento più ricco rispetto a un generatore solo testo.
Controllo in stile regia: il modello è progettato per seguire prompt relativi a performance, illuminazione, ombre, movimenti di camera, ritmo del movimento e caratteristiche del suono.
Montaggio ed estensione video: Seedance 2.0 non si limita alla generazione iniziale; supporta il montaggio di clip, personaggi, azioni e trame specifici, oltre ad estensioni in avanti/indietro.
Forte sincronizzazione audiovisiva: ByteDance evidenzia l’uscita stereo a due canali e la sincronizzazione di musica di sottofondo, suoni ambientali e voce fuori campo per risultati più immersivi.
Alta controllabilità per scene complesse: sottolinea una migliore gestione delle interazioni complesse, delle scene in movimento e della plausibilità fisica rispetto a Seedance 1.5.
Output orientato alla produzione: l’API supporta impostazioni configurabili di proporzioni, durata e watermark, rendendo il modello pratico per flussi di lavoro ripetibili.

Prestazioni nei benchmark

ByteDance afferma che Seedance 2.0 utilizza la valutazione interna SeedVideoBench-2.0 e si colloca ai vertici nelle dimensioni text‑to‑video, image‑to‑video e dei compiti multimodali. Il modello migliora qualità di generazione, accuratezza fisica, realismo e controllabilità rispetto a Seedance 1.5, soprattutto in interazioni complesse e scene in movimento.

Modalità API Seedance 2.0 e Seedance 2.0 Fast su CometAPI

Modello	Nome del modello in CometAPI	Ideale per	Differenza principale
Seedance 2.0	doubao-seedance-2-0	Creazione video multimodale di massima qualità	Stack di riferimenti più ampio e massima controllabilità nella famiglia Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Produzione più rapida quando si può cedere un po’ di qualità	ByteDance afferma che mantiene le stesse capacità del modello di Seedance 2.0, ma genera più velocemente.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Creazione audio‑video di generazione precedente	Seedance 1.5 Pro è posizionato come modello nativo di generazione congiunta audio‑video, mentre Seedance 2.0 espande lo stack di riferimenti multimodali e di editing.

Punti di forza rispetto ai concorrenti:

vs Kling 3.0: Migliore controllo dei riferimenti multimodali e audio nativo.
vs Sora 2: Precisione dei riferimenti e capacità multi‑shot superiori; durata massima leggermente inferiore.
vs Veo 3.1: Superiore in coerenza dei personaggi e aderenza ai prompt per flussi di lavoro ricchi di riferimenti; Veo è in vantaggio nel color grading cinematografico grezzo e in clip più lunghe.

Eccelle in video incentrati sulle persone e guidati dalla performance.

Prova il generatore di video AI Seedance 2.0 su CometAPI

Passo 1: Passo 1: Registrati per ottenere una chiave API

Inizia direttamente dal Playground di CometAPI per provare Doubao Seedance 2.0 senza setup o codice. Accedi al tuo account CometAPI, vai alla pagina del modello per doubao-seedance-2-0, carica immagini di riferimento, brevi clip video o file audio, aggiungi un prompt descrittivo e genera immediatamente video di anteprima. È il modo più rapido per capire come Seedance 2.0 gestisce la coerenza del movimento, l’aspetto dei personaggi, i movimenti di camera e la sincronizzazione audio nativa.

Passo 2: Ottieni l’accesso API per Seedance 2.0 su CometAPI

Crea o usa la tua chiave CometAPI esistente per abilitare l’accesso completo a Doubao Seedance 2.0. Dopo l’accesso, vai alla sezione API Token nella console, genera una nuova chiave e copiala. Visita quindi la pagina del modello Seedance 2.0 e la documentazione API su CometAPI per rivedere i parametri supportati da integrare nei tuoi progetti.

Passo 3: Invia la tua prima richiesta con l’API Seedance 2.0

Usa l’endpoint di CometAPI per inviare la tua prima richiesta di generazione video con un prompt testuale chiaro e file di riferimento opzionali (immagini, video o audio). Il sistema elaborerà il task in modo asincrono, restituirà un ID del task e fornirà un video MP4 scaricabile una volta completato. Potrai quindi affinare i prompt, regolare le impostazioni ed effettuare lo scaling per video marketing, contenuti social, pipeline video automatizzate o applicazioni creative alimentate da Seedance 2.0.

Questo flusso di lavoro offre sperimentazione rapida nel Playground e una transizione fluida all’uso in produzione tramite CometAPI.

Motivi principali per scegliere Seedance 2.0 su CometAPI

Perché usare CometAPI per Seedance 2.0

Accesso diretto via API o Playground
Controllo dei parametri semplice (durata, risoluzione, formato)
Supporta sia workflow text-to-video che image-to-video
Gestione dei job integrata per la generazione video asincrona

API unificata e a misura di sviluppatore

CometAPI offre un endpoint pulito e standardizzato che funziona senza soluzione di continuità con formati in stile OpenAI o endpoint dedicati ai task video. Ottieni creazione dei task, polling e download MP4 immediati, senza dover gestire l’autenticazione complessa o le limitazioni regionali di Volcengine.

Prezzi convenienti

CometAPI in genere offre tariffe per secondo più competitive rispetto ai provider diretti, permettendoti di generare video di alta qualità su larga scala per marketing, social o pipeline automatizzate senza sforare il budget.

Test rapidi con il Playground

Sperimenta subito nel Playground di CometAPI. Carica immagini, video e audio di riferimento, modifica i prompt e visualizza anteprime in pochi minuti — perfetto per iterare su stile, movimento e sincronizzazione audio prima di andare in produzione.

In breve, se desideri la potenza creativa di Seedance 2.0 — controllo dei riferimenti allo stato dell’arte, movimento naturale e audio nativo — senza le complessità dell’accesso diretto a ByteDance, CometAPI è attualmente una delle migliori piattaforme per utilizzarlo.

FAQ

Prezzi

Usa la stima rapida sopra per una singola esecuzione, poi consulta il confronto completo tra CometAPI e prezzo ufficiale.

Test da 5 secondi

$0.28

Costo di utilizzo CometAPI stimato

Test da 10 secondi

$0.56

Costo di utilizzo CometAPI stimato

Test da 15 secondi

$0.84

Costo di utilizzo CometAPI stimato

Prezzi per Seedance 2-0

Esplora i prezzi competitivi per Seedance 2-0, progettato per adattarsi a vari budget e necessità di utilizzo. I nostri piani flessibili garantiscono che paghi solo per quello che usi, rendendo facile scalare man mano che i tuoi requisiti crescono. Scopri come Seedance 2-0 può migliorare i tuoi progetti mantenendo i costi gestibili.

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

Copia un endpoint funzionante e un esempio di codice, poi apri il riferimento API completo quando ti serve ogni parametro.

Un'unica API, accesso ai modelli pronto per la produzione

Autenticati una sola volta, chiama l'endpoint del modello e mantieni lo stesso flusso di fatturazione e osservabilità tra i fornitori.

POST/v1/videos

Codice di esempio e API per Seedance 2-0

Accedi a codice di esempio completo e risorse API per Seedance 2-0 per semplificare il tuo processo di integrazione. La nostra documentazione dettagliata fornisce una guida passo dopo passo, aiutandoti a sfruttare appieno il potenziale di Seedance 2-0 nei tuoi progetti.

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

Capacità

Consulta i dati chiave del modello prima di scegliere un'architettura o stimare il carico in produzione.

Capacità supportate

Funzionalità restituite dall'API del modello esistente.

text-to-video

image-to-video

Input e output

Input

text

Output

video

Profilo di produzione

Fornitore: Bytedance
Contesto: Dipende dal modello
Uso commerciale: Supportato

Casi d'uso

Usa Seedance 2-0 per flussi di produzione in linea con le sue capacità video, poi confronta altre alternative prima di un'integrazione a lungo termine.

Concetti da testo a video e contenuti social

Demo di prodotto e storyboard cinematografici

Movimento da immagine a video e iterazione creativa

Altri modelli

Confronta altri modelli disponibili tramite CometAPI in base a qualità, latenza, capacità e prezzo.

Apri confronto modelli →

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

Visualizza modello

Flux

Flux 3

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

Visualizza modello

Aliyun

Happy Horse 1.1

HappyHorse 1.1 è un modello multimodale di generazione di video progettato per la creazione di contenuti professionali, la pubblicità, i cortometraggi, la produzione per i social media e lo storytelling. Estende le capacità di HappyHorse 1.0—che ha ottenuto notevole attenzione dopo essersi classificato ai primi posti in valutazioni indipendenti sulla generazione di video—con una maggiore coerenza delle scene e una fedeltà visiva migliorata.

Visualizza modello

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.

Visualizza modello

OpenAI

Sora 2 Pro

Sora 2 Pro è il nostro modello di generazione di contenuti multimediali più avanzato e potente, in grado di generare video con audio sincronizzato. Può creare clip video dettagliate e dinamiche a partire da linguaggio naturale o immagini.

Visualizza modello

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.

Visualizza modello

Uptime

Controlla i dati di heartbeat in tempo reale, la disponibilità dell'endpoint e i tempi di risposta osservati prima di passare in produzione.

Versioni

Controlla gli identificatori dei modelli disponibili prima di fissare un'integrazione in produzione.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Continua a esplorare

Confronta i modelli e continua la tua ricerca

Bytedance

Disponibile Popolare

doubao-seedance-2-0

Seedance 2-0 API

Prezzo di partenza

$0.056 / secondo

Fatturazione a consumo

Stato dell'API

Disponibile

Endpoint di produzione

Risposta

Pronto per l'async

Tempo di risposta API osservato

Pubblicato

Apr 19, 2026

Bytedance

Playground

Prova Seedance 2-0 con una richiesta reale, controlla i parametri e verifica l'output prima di integrare l'API.

Panoramica

Una panoramica pratica di Seedance 2-0, con comportamenti importanti e considerazioni per l'integrazione.

Specifiche tecniche di Doubao Seedance 2.0

Voce	Dettagli
Famiglia di prodotto	Famiglia di generazione video ByteDance Seedance
Slug CometAPI	doubao-seedance-2-0
Fornitore	ByteDance / BytePlus ModelArk
Tipo di modello	Modello di generazione video
Modalità di input	Testo, immagine
Tipo di output	Video MP4
Risoluzione di output	480p, 720p, 1080p
Proporzioni	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Durata di output	4–15 secondi
Stile API	Generazione video asincrona basata su task

Che cos’è Doubao Seedance 2.0?

Funzionalità principali di Doubao Seedance 2.0 su CometAPI

Generazione multimodale unificata: accetta input di testo, immagine, audio e video in un unico flusso di lavoro, così gli utenti possono dirigere una scena con materiale di riferimento più ricco rispetto a un generatore solo testo.
Controllo in stile regia: il modello è progettato per seguire prompt relativi a performance, illuminazione, ombre, movimenti di camera, ritmo del movimento e caratteristiche del suono.
Montaggio ed estensione video: Seedance 2.0 non si limita alla generazione iniziale; supporta il montaggio di clip, personaggi, azioni e trame specifici, oltre ad estensioni in avanti/indietro.
Forte sincronizzazione audiovisiva: ByteDance evidenzia l’uscita stereo a due canali e la sincronizzazione di musica di sottofondo, suoni ambientali e voce fuori campo per risultati più immersivi.
Alta controllabilità per scene complesse: sottolinea una migliore gestione delle interazioni complesse, delle scene in movimento e della plausibilità fisica rispetto a Seedance 1.5.
Output orientato alla produzione: l’API supporta impostazioni configurabili di proporzioni, durata e watermark, rendendo il modello pratico per flussi di lavoro ripetibili.

Prestazioni nei benchmark

Modalità API Seedance 2.0 e Seedance 2.0 Fast su CometAPI

Modello	Nome del modello in CometAPI	Ideale per	Differenza principale
Seedance 2.0	doubao-seedance-2-0	Creazione video multimodale di massima qualità	Stack di riferimenti più ampio e massima controllabilità nella famiglia Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Produzione più rapida quando si può cedere un po’ di qualità	ByteDance afferma che mantiene le stesse capacità del modello di Seedance 2.0, ma genera più velocemente.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Creazione audio‑video di generazione precedente	Seedance 1.5 Pro è posizionato come modello nativo di generazione congiunta audio‑video, mentre Seedance 2.0 espande lo stack di riferimenti multimodali e di editing.

Punti di forza rispetto ai concorrenti:

vs Kling 3.0: Migliore controllo dei riferimenti multimodali e audio nativo.
vs Sora 2: Precisione dei riferimenti e capacità multi‑shot superiori; durata massima leggermente inferiore.
vs Veo 3.1: Superiore in coerenza dei personaggi e aderenza ai prompt per flussi di lavoro ricchi di riferimenti; Veo è in vantaggio nel color grading cinematografico grezzo e in clip più lunghe.

Eccelle in video incentrati sulle persone e guidati dalla performance.

Prova il generatore di video AI Seedance 2.0 su CometAPI

Passo 1: Passo 1: Registrati per ottenere una chiave API

Passo 2: Ottieni l’accesso API per Seedance 2.0 su CometAPI

Passo 3: Invia la tua prima richiesta con l’API Seedance 2.0

Questo flusso di lavoro offre sperimentazione rapida nel Playground e una transizione fluida all’uso in produzione tramite CometAPI.

Motivi principali per scegliere Seedance 2.0 su CometAPI

Perché usare CometAPI per Seedance 2.0

Accesso diretto via API o Playground
Controllo dei parametri semplice (durata, risoluzione, formato)
Supporta sia workflow text-to-video che image-to-video
Gestione dei job integrata per la generazione video asincrona

API unificata e a misura di sviluppatore

Prezzi convenienti

Test rapidi con il Playground

FAQ

Prezzi

Usa la stima rapida sopra per una singola esecuzione, poi consulta il confronto completo tra CometAPI e prezzo ufficiale.

Test da 5 secondi

$0.28

Costo di utilizzo CometAPI stimato

Test da 10 secondi

$0.56

Costo di utilizzo CometAPI stimato

Test da 15 secondi

$0.84

Costo di utilizzo CometAPI stimato

Prezzi per 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

Copia un endpoint funzionante e un esempio di codice, poi apri il riferimento API completo quando ti serve ogni parametro.

Un'unica API, accesso ai modelli pronto per la produzione

Autenticati una sola volta, chiama l'endpoint del modello e mantieni lo stesso flusso di fatturazione e osservabilità tra i fornitori.

POST/v1/videos

Codice di esempio e API per 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));
}

Capacità

Consulta i dati chiave del modello prima di scegliere un'architettura o stimare il carico in produzione.

Capacità supportate

Funzionalità restituite dall'API del modello esistente.

text-to-video

image-to-video

Input e output

Input

text

Output

video

Profilo di produzione

Fornitore: Bytedance
Contesto: Dipende dal modello
Uso commerciale: Supportato

Casi d'uso

Usa Seedance 2-0 per flussi di produzione in linea con le sue capacità video, poi confronta altre alternative prima di un'integrazione a lungo termine.

Concetti da testo a video e contenuti social

Demo di prodotto e storyboard cinematografici

Movimento da immagine a video e iterazione creativa

Altri modelli

Confronta altri modelli disponibili tramite CometAPI in base a qualità, latenza, capacità e prezzo.

Apri confronto modelli →

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

Uptime

Controlla i dati di heartbeat in tempo reale, la disponibilità dell'endpoint e i tempi di risposta osservati prima di passare in produzione.

Versioni

Controlla gli identificatori dei modelli disponibili prima di fissare un'integrazione in produzione.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Continua a esplorare