In che modo Seedance 2.0 gestisce 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 8+ lingue, per un parlato naturale ed effetti sonori.

Seedance 2.0 consente la modifica e l'estensione di video esistenti?

Sì — il modello supporta l'estensione dei video e modifiche mirate, come aggiungere scene, sostituire personaggi o alterare 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–60 secondi.

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

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

Come funzionano le risorse di riferimento (immagini, clip video) nei prompt di Seedance 2.0?

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

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

Sì — Seedance 2.0 è progettato per una narrazione coerente su più riprese, con personaggi, stile visivo e atmosfera consistenti tra le scene, riducendo i comuni problemi di deriva nei video AI.

Seedance 2.0 è adatto a progetti creativi professionali come video di marketing o corti narrativi?

Sì — il controllo multimodale, la continuità su più riprese e l'output ad alta fedeltà di Seedance 2.0 lo rendono adatto a video di marketing, corti narrativi, annunci pubblicitari e altre applicazioni professionali.

Bytedance

Disponibile Popolare

doubao-seedance-2-0

Seedance 2-0 API

Seedance 2.0 è il modello multimodale di base per il video di nuova generazione di ByteDance, incentrato sulla generazione di video narrativi cinematografici a più inquadrature. A differenza delle demo da testo a video a singola inquadratura, Seedance 2.0 enfatizza il controllo basato su riferimenti (immagini, clip brevi, audio), la coerenza di personaggi/stile tra le inquadrature e la sincronizzazione audio/video nativa — con l’obiettivo di rendere i video generati dall’IA utili per i flussi di lavoro creativi professionali 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

Elemento	Dettagli
Famiglia di prodotti	Famiglia di generazione video ByteDance Seedance
CometAPI slug	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
Rapporti d’aspetto	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 attività

Che cos’è Doubao Seedance 2.0?

Doubao Seedance 2.0 è il modello di punta di ByteDance per la generazione video multimodale (rilasciato a febbraio 2026). Utilizza un’architettura unificata di generazione congiunta audio-video che consente un controllo preciso 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 professionali che richiedono fisica realistica, coerenza dei personaggi e composizione di scene complesse.

Caratteristiche 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, movimento della camera, ritmo del movimento e caratteristiche sonore.
Montaggio ed estensione video: Seedance 2.0 non è limitato alla generazione in prima passata; supporta la modifica di clip specifici, personaggi, azioni e linee narrative, oltre all’estensione in avanti/indietro.
Solida sincronizzazione audiovisiva: ByteDance evidenzia output stereo a doppio canale e sincronizzazione di musica di sottofondo, suoni ambientali e comportamento della voce fuori campo per risultati più immersivi.
Elevata controllabilità per scene complesse: Sottolinea una gestione migliorata delle interazioni complesse, delle scene in movimento e della verosimiglianza fisica rispetto a Seedance 1.5.
Output orientato alla produzione: L’API supporta impostazioni configurabili di rapporto, durata e filigrana, rendendo il modello pratico per workflow di contenuti ripetibili.

Prestazioni nei benchmark

ByteDance afferma che Seedance 2.0 utilizza la valutazione interna SeedVideoBench-2.0 e si colloca in posizione di vertice su compiti da testo a video, da immagine a video e multimodali. Il modello migliora la qualità di generazione, l’accuratezza fisica, il realismo e la controllabilità rispetto a Seedance 1.5, specialmente in scene di interazione complessa e di 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ù veloce quando si può sacrificare leggermente la qualità	ByteDance afferma che mantiene le stesse capacità del modello Seedance 2.0, ma genera più rapidamente.
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 amplia lo stack di riferimento e di editing multimodale.

Punti di forza rispetto ai concorrenti:

vs Kling 3.0: Miglior controllo dei riferimenti multimodali e audio nativo.
vs Sora 2: Precisione superiore dei riferimenti e capacità multi-shot; durata massima leggermente inferiore.
vs Veo 3.1: Più forte nella coerenza dei personaggi e nell’aderenza ai prompt per flussi di lavoro con molti riferimenti; Veo eccelle nel grading cinematografico puro e nelle clip più lunghe.

Eccelle in video incentrati sull’essere umano e guidati dall’interpretazione.

Prova il Generatore Video AI Seedance 2.0 su CometAPI

Passo 1: Passo 1: Registrati per la chiave API

Inizia direttamente nel Playground di CometAPI per provare Doubao Seedance 2.0 senza alcuna configurazione o scrivere codice. Accedi semplicemente al tuo account CometAPI, vai alla pagina del modello per doubao-seedance-2-0, carica le tue immagini di riferimento, brevi clip video o file audio, aggiungi un prompt descrittivo e genera immediatamente video di anteprima. Questo è il modo più veloce 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 tua console, genera una nuova chiave e copiala. Quindi visita la pagina di dettaglio del modello Seedance 2.0 e la documentazione API su CometAPI per esaminare i parametri supportati da integrare nei tuoi progetti.

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

Usa l’endpoint 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à l’attività in modo asincrono, restituirà un ID attività e fornirà un video MP4 scaricabile una volta completato. Puoi quindi affinare i tuoi prompt, regolare le impostazioni e scalare per video di marketing, contenuti per i social media, pipeline video automatizzate o applicazioni creative alimentate da Seedance 2.0.

Questo workflow ti offre sperimentazione rapida nel playground e una transizione fluida in produzione tramite la CometAPI.

Motivi principali per scegliere Seedance 2.0 su CometAPI

Perché usare CometAPI per Seedance 2.0

Accesso diretto via API o Playground
Controllo semplice dei parametri (durata, risoluzione, formato)
Supporta sia i flussi di lavoro da testo a video che da immagine a video
Gestione delle attività integrata per la generazione video asincrona

API unificata e adatta agli sviluppatori

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

Prezzi convenienti

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

Test rapido con Playground

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

In breve, se vuoi la potenza creativa di Seedance 2.0 — controllo dei riferimenti best-in-class, movimento naturale e audio nativo — senza la complessità dell’accesso diretto a ByteDance, CometAPI è attualmente una delle migliori piattaforme per usarlo.

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

Dalla verifica rapida all'output cinematografico, la fatturazione si basa sulla durata del video generato, sulla selezione della risoluzione appropriata e sulla trasformazione di ogni generazione in una regola per un'attività di investimento creativo pianificata.

Visualizza modello

MiniMax

MiniMax H3

minimax-h3 è un nuovo modello di generazione video progettato per una produzione creativa di alta qualità. Offre una migliore comprensione dei prompt, una maggiore coerenza visiva, movimenti più fluidi e un controllo più flessibile delle immagini di riferimento, per flussi di lavoro cinematografici di generazione video.

Visualizza modello

Bytedance

Seedance 2.5

seedance-2-5 è un modello generativo congiunto audio-video di nuova generazione, progettato per narrazioni da 30 secondi, con controllo preciso dei riferimenti e potenti funzionalità di editing.

Visualizza modello

Flux

Flux 3

FLUX 3 - Modelli del mondo reale: verso modelli di flusso multimodali come spina dorsale dell'intelligenza visiva.

Visualizza modello

Aliyun

Happy Horse 1.1

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

Visualizza modello

Aliyun

Happy Horse 1.0

Happy Horse 1.0 — un modello di generazione audio-video di alta qualità che supporta la creazione da testo a video e da immagine a video. Può generare contenuti visivi, audio e movimenti labiali sincronizzati, rendendolo adatto a cortometraggi, creatività pubblicitarie e presentazioni di prodotto.

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

Elemento	Dettagli
Famiglia di prodotti	Famiglia di generazione video ByteDance Seedance
CometAPI slug	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
Rapporti d’aspetto	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 attività

Che cos’è Doubao Seedance 2.0?

Caratteristiche 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, movimento della camera, ritmo del movimento e caratteristiche sonore.
Montaggio ed estensione video: Seedance 2.0 non è limitato alla generazione in prima passata; supporta la modifica di clip specifici, personaggi, azioni e linee narrative, oltre all’estensione in avanti/indietro.
Solida sincronizzazione audiovisiva: ByteDance evidenzia output stereo a doppio canale e sincronizzazione di musica di sottofondo, suoni ambientali e comportamento della voce fuori campo per risultati più immersivi.
Elevata controllabilità per scene complesse: Sottolinea una gestione migliorata delle interazioni complesse, delle scene in movimento e della verosimiglianza fisica rispetto a Seedance 1.5.
Output orientato alla produzione: L’API supporta impostazioni configurabili di rapporto, durata e filigrana, rendendo il modello pratico per workflow di contenuti 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ù veloce quando si può sacrificare leggermente la qualità	ByteDance afferma che mantiene le stesse capacità del modello Seedance 2.0, ma genera più rapidamente.
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 amplia lo stack di riferimento e di editing multimodale.

Punti di forza rispetto ai concorrenti:

vs Kling 3.0: Miglior controllo dei riferimenti multimodali e audio nativo.
vs Sora 2: Precisione superiore dei riferimenti e capacità multi-shot; durata massima leggermente inferiore.
vs Veo 3.1: Più forte nella coerenza dei personaggi e nell’aderenza ai prompt per flussi di lavoro con molti riferimenti; Veo eccelle nel grading cinematografico puro e nelle clip più lunghe.

Eccelle in video incentrati sull’essere umano e guidati dall’interpretazione.

Prova il Generatore Video AI Seedance 2.0 su CometAPI

Passo 1: Passo 1: Registrati per la 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 workflow ti offre sperimentazione rapida nel playground e una transizione fluida in produzione tramite la CometAPI.

Motivi principali per scegliere Seedance 2.0 su CometAPI

Perché usare CometAPI per Seedance 2.0

Accesso diretto via API o Playground
Controllo semplice dei parametri (durata, risoluzione, formato)
Supporta sia i flussi di lavoro da testo a video che da immagine a video
Gestione delle attività integrata per la generazione video asincrona

API unificata e adatta agli sviluppatori

Prezzi convenienti

Test rapido con 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 →

seedance-2-5 è un modello generativo congiunto audio-video di nuova generazione, progettato per narrazioni da 30 secondi, con controllo preciso dei riferimenti e potenti funzionalità di editing.

Visualizza modello

Flux

Flux 3

FLUX 3 - Modelli del mondo reale: verso modelli di flusso multimodali come spina dorsale dell'intelligenza visiva.

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