Doubao-Seedance-2-0

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

Seedance 2.0 supporta input multimodali, tra cui 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.

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

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

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

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.

Q: How does Seedance 2.0 handle audio and lip synchronization?

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

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

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

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

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

Q: Does Seedance 2.0 allow editing and extension of existing videos?

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.

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

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

Al Secondo:$0.08

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.

Nuovo

Uso commerciale

Panoramica

Caratteristiche

Prezzi

API

Versioni

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, audio, video
Capacità di riferimento	Fino a 9 immagini, 3 clip video e 3 clip audio in una singola richiesta multimodale
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 dell'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 generazione video multimodale di punta di ByteDance (rilasciato a febbraio 2026). Utilizza un'architettura unificata di generazione congiunta audio‑video che consente un controllo preciso a livello di regia facendo riferimento contemporaneamente a più immagini, clip video e file audio. Eccelle nella produzione di video cinematografici, stabili nel movimento, con sincronizzazione audio nativa — ideale per creator professionali 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 workflow, così gli utenti possono dirigere una scena con materiale di riferimento più ricco rispetto a un generatore solo testuale.
Controllo in stile regia: il modello è progettato per seguire prompt relativi a performance, illuminazione, ombre, movimenti di camera, ritmo del movimento e caratteristiche sonore.
Montaggio ed estensione video: Seedance 2.0 non è limitato alla generazione al primo passaggio; supporta l'editing di clip, personaggi, azioni e linee narrative specifiche, oltre all'estensione in avanti/indietro.
Sincronizzazione audiovisiva avanzata: ByteDance evidenzia output stereo a due canali e la sincronizzazione di musica di sottofondo, suoni ambientali e comportamento del voiceover per risultati più immersivi.
Elevata controllabilità per scene complesse: presenta miglioramenti nella gestione di interazioni complesse, scene di movimento e plausibilità fisica rispetto a Seedance 1.5.
Output orientato alla produzione: l'API supporta impostazioni configurabili di rapporto, durata e watermark, 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 ai vertici nelle dimensioni dei task text-to-video, image-to-video e multimodali. Il modello migliora la qualità di generazione, l'accuratezza fisica, il realismo e la controllabilità rispetto a Seedance 1.5, soprattutto in interazioni complesse e scene dinamiche.

Modalità Seedance 2.0 API e Seedance 2.0 Fast API su CometAPI

Modello	Nome del modello in CometAPI	Ideale per	Differenza principale
Seedance 2.0	doubao-seedance-2-0	Creazione video multimodale della 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ò sacrificare leggermente la qualità	ByteDance afferma che mantiene le stesse capacità 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 un modello nativo di generazione congiunta audio‑video, mentre Seedance 2.0 amplia 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: Più forte nella coerenza dei personaggi e nell'aderenza ai prompt per workflow ricchi di riferimenti; Veo è in vantaggio nel grading cinematografico e in clip più lunghe.

Eccelle in video incentrati sulle persone e guidati dalla performance.

Prova il generatore video AI Seedance 2.0 su CometAPI

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

Inizia direttamente nel CometAPI Playground per provare Doubao Seedance 2.0 senza configurazioni o codice. Accedi semplicemente al tuo account CometAPI, vai alla pagina del modello doubao-seedance-2-0, carica le 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.

Passaggio 2: Ottieni l'accesso all'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 aver effettuato l'accesso, vai alla sezione API Token nella tua console, genera una nuova chiave e copiala. Quindi visita la pagina del modello Seedance 2.0 e la Documentazione API su CometAPI per rivedere i parametri supportati da integrare nei tuoi progetti.

Passaggio 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à il task in modo asincrono, restituirà un ID attività e fornirà un video MP4 scaricabile una volta completato. Potrai quindi affinare i prompt, regolare le impostazioni ed effettuare il scaling per video di marketing, contenuti social, pipeline video automatizzate o applicazioni creative basate su Seedance 2.0.

Questo flusso di lavoro ti offre una sperimentazione rapida nel playground e una transizione fluida all'uso 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 workflow sia text‑to‑video sia image‑to‑video
Gestione dei job 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 familiari o endpoint dedicati ai task video. Ottieni creazione dei task, polling e download MP4 in modo lineare, senza dover gestire l'autenticazione complessa o le limitazioni regionali di Volcengine.

Prezzi convenienti

CometAPI offre in genere tariffe al 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 rapidi con il Playground

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

In breve, se desideri la potenza creativa di Seedance 2.0 — controllo dei riferimenti best‑in‑class, movimento naturale e audio nativo — senza le complicazioni dell'accesso diretto a ByteDance, CometAPI è attualmente una delle migliori piattaforme per usarlo.

FAQ

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

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

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

How does Seedance 2.0 handle audio and lip synchronization?

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

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

Does Seedance 2.0 allow editing and extension of existing videos?

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

Prezzi per Doubao-Seedance-2-0

Esplora i prezzi competitivi per Doubao-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 Doubao-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
Aspect Ratio (size)	`21:9` / `16:9` / `4:3` / `1:1` / `3:4` / `9:16`, default `16:9`
Resolution	`480p` / `720p` / `1080p`*, default `720p`

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

Pricing (Per Second)

Model	480p	720p	1080p
`doubao-seedance-2-0`	$0.08	$0.24	—
`doubao-seedance-2-0-fast`	$0.064	$0.192	—
`doubao-seedance-1-5-pro`	$0.018	$0.04147	$0.09331
`doubao-seedance-1-0-pro`	$0.01875	$0.0432	$0.0972

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

Codice di esempio e API per Doubao-Seedance-2-0

Accedi a codice di esempio completo e risorse API per Doubao-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 Doubao-Seedance-2-0 nei tuoi progetti.

POST

/v1/videos

Python
JavaScript
Curl

import json
import os
import time

import requests

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

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

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

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

    raise SystemExit("Failed to create task.")

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

    raise SystemExit("Failed to query task.")

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

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

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

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

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

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

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

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

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

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

    time.sleep(POLL_INTERVAL_SECONDS)

Python Code Example

import json
import os
import time

import requests

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


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


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


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

    raise SystemExit("Failed to create task.")


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

    raise SystemExit("Failed to query task.")

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

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

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

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

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

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

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

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

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

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

    time.sleep(POLL_INTERVAL_SECONDS)

JavaScript Code Example

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

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

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

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

  return false;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Curl Code Example

#!/bin/bash

set -euo pipefail

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

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

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

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

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

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

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

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

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

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

    echo "$CREATE_RESPONSE"
    return 1
  done
}

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

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

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

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

    echo "$TASK_RESPONSE"
    return 1
  done
}

create_task

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

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

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

while true; do
  get_task "$TASK_ID"

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

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

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

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

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

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

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

  sleep "$POLL_INTERVAL_SECONDS"
done

Versioni di Doubao-Seedance-2-0

Il motivo per cui Doubao-Seedance-2-0 dispone di più snapshot può includere fattori potenziali come variazioni nell'output dopo aggiornamenti che richiedono snapshot precedenti per coerenza, offrire agli sviluppatori un periodo di transizione per l'adattamento e la migrazione, e diversi snapshot corrispondenti a endpoint globali o regionali per ottimizzare l'esperienza utente. Per le differenze dettagliate tra le versioni, si prega di fare riferimento alla documentazione ufficiale.

version
doubao-seedance-2-0
doubao-seedance-2-0-fast

Altri modelli

Blog correlati

Apr 17, 2026

Come utilizzare l'API di Seedance 2.0

Seedance 2.0 API è l’ultimo modello multimodale di generazione video basato su IA di ByteDance (lanciato il 9 aprile 2026). Accetta testo, immagini, clip video e audio in un’unica richiesta per produrre video MP4 cinematografici da 4–15 secondi con sincronizzazione audio nativa, controllo della camera a livello di regia ed eccezionale coerenza del movimento. Per usarlo: registrati su CometAPI.com, ottieni una chiave API, invia un task asincrono via REST, effettua il polling per il completamento e scarica l’URL del video.

Apr 11, 2026

Che cos'è HappyHorse-1.0? Come confrontare Seedance 2.0?

Scopri che cos’è HappyHorse-1.0, perché ha raggiunto la vetta della classifica video di Artificial Analysis, come si confronta con Seedance 2.0 e che cosa significano le classifiche più recenti per la generazione di video con IA.

Mar 24, 2026

Che cos'è Seedance 2.0? Un'analisi completa

Seedance 2.0 è un modello multimodale di generazione video basato sull’IA di nuova generazione, sviluppato da ByteDance, in grado di generare video cinematografici di alta qualità a partire da testo, immagini, audio e video di riferimento. Offre generazione congiunta audio-video, stabilità del movimento ed editing basato su riferimenti, e ha rapidamente scalato benchmark globali come l’Artificial Analysis Leaderboard, posizionandosi tra i migliori modelli di generazione video basati su IA nel 2026.