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

Seedance 2.0 supports multimodal inputs including text prompts, up to 9 images, up to 3 short video clips, and up to 3 audio files, which can be freely combined for rich, controllable generation.

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

Yes — Seedance 2.0 is designed for coherent multi-shot storytelling with consistent characters, visual style, and atmosphere across scenes, reducing common AI video drift issues.

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

Seedance 2.0 can generate cinematic-grade videos (up to 2K resolution) with native audio, synchronized dialogue, and natural motion synthesis, typically in clips of 5–60 seconds.

How does Seedance 2.0 handle audio and lip synchronization?

The model generates audio and video jointly, offering native audio-visual sync with phoneme-level lip sync in 8+ languages for natural speech and sound effects.

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

Yes — Seedance 2.0’s multimodal control, multi-shot continuity, and high fidelity output make it suitable for marketing videos, narrative shorts, ads, and other professional applications.

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

Users can upload reference assets and then describe in natural language how each should influence motion, camera movement, or stylistic elements, giving fine-grained control over the generated content.

Does Seedance 2.0 allow editing and extension of existing videos?

Yes — the model supports video extension and targeted editing like adding scenes, replacing characters, or altering specific segments while preserving unedited portions.

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

Typical output lengths range from ~5 to ~60 seconds per video, and combining many assets or high-resolution settings can increase generation time.

Kimi K3 is now live on CometAPI →

Seedance 2-0

Al Secondo:$0.056

Rilasciato:Apr 19, 2026

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

Popolare

Uso commerciale

Playground per Seedance 2-0

Esplora il Playground di Seedance 2-0 — un ambiente interattivo per testare modelli ed eseguire query in tempo reale. Prova prompt, regola parametri e itera istantaneamente per accelerare lo sviluppo e convalidare i casi d'uso.

Specifiche tecniche di Doubao Seedance 2.0

Elemento	Dettagli
Famiglia di prodotto	ByteDance Seedance video generation family
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
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 a livello di regia facendo riferimento contemporaneamente a più immagini, clip video e file audio. Eccelle nella produzione di video cinematografici e stabili nei movimenti con sincronizzazione audio nativa — ideale per creatori professionali che necessitano di 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 workflow, 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 è costruito per seguire prompt relativi a interpretazione, illuminazione, ombre, movimento di camera, ritmo del movimento e caratteristiche del suono.
Editing ed estensione video: Seedance 2.0 non si limita a una prima generazione; supporta l'editing di clip, personaggi, azioni e storyline specifiche, oltre all'estensione avanti/indietro.
Forte sincronizzazione audiovisiva: ByteDance evidenzia un'uscita stereo a doppio canale e la sincronizzazione di musica di sottofondo, suoni ambientali e voce fuori campo per risultati più immersivi.
Alta controllabilità per scene complesse: Sottolinea un miglioramento nella gestione di interazioni complesse, scene in movimento e plausibilità fisica rispetto a Seedance 1.5.
Output orientato alla produzione: L'API supporta impostazioni configurabili di rapporto d'aspetto, durata e filigrana, rendendo il modello pratico per workflow di contenuti ripetibili.

Prestazioni benchmark

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

Modalità API Seedance 2.0 e Seedance 2.0 Fast su CometAPI

Modello	Nome modello in CometAPI	Ideale per	Differenza principale
Seedance 2.0	doubao-seedance-2-0	Creazione video multimodale della massima qualità	Il set di riferimenti più ampio e la massima controllabilità nella famiglia Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Produzione più rapida quando si può cedere qualcosa in qualità	ByteDance afferma che mantiene le stesse capacità del modello 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 congiunto audio‑video, mentre Seedance 2.0 amplia lo stack di riferimento multimodale e di editing.

Punti di forza rispetto ai concorrenti:

vs Kling 3.0: Miglior controllo dei riferimenti multimodali e audio nativo.
vs Sora 2: Precisione dei riferimenti superiore e capacità multi‑shot; durata massima leggermente inferiore.
vs Veo 3.1: Più forte in coerenza dei personaggi e aderenza ai prompt per flussi di lavoro ricchi di riferimenti; Veo primeggia nel grading cinematografico "raw" e in clip più lunghe.

Eccelle nei video incentrati sulle persone e guidati dall'interpretazione.

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 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 all'istante video di anteprima. È il modo più veloce per capire come Seedance 2.0 gestisce coerenza del movimento, aspetto dei personaggi, movimenti di camera e sincronizzazione audio nativa.

Passaggio 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 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 e scalare per video marketing, contenuti social, pipeline video automatizzate o applicazioni creative basate su 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 tramite API o Playground
Controllo semplice dei parametri (durata, risoluzione, formato)
Supporta sia workflow text‑to‑video che image‑to‑video
Gestione integrata delle attività per la generazione video asincrona

API unificata e pensata per gli sviluppatori

CometAPI offre un endpoint pulito e standardizzato che funziona senza attriti con formati in stile OpenAI 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, consentendoti 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 immediatamente nel CometAPI Playground. 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 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 utilizzarlo.

FAQ

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 available for all models except doubao-seedance-2-0-fast

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-1-5-pro`	$0.0192	$0.0416	$0.0928	—
`doubao-seedance-1-0-pro`	$0.0192	$0.0416	$0.0976	—
`doubao-seedance-1-0-pro-fast`	$0.008	$0.016	$0.0384	—

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

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

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)

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

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"')

    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 Seedance 2-0

Il motivo per cui 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