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

Por Segundo:$0.056

Publicado:Apr 19, 2026

Seedance 2.0 es el modelo fundacional multimodal de video de próxima generación de ByteDance, centrado en la generación de videos narrativos cinematográficos de múltiples tomas. A diferencia de las demostraciones de texto a video de una sola toma, Seedance 2.0 pone énfasis en el control basado en referencias (imágenes, clips cortos y audio), la coherencia de personajes y de estilo a lo largo de las tomas y la sincronización nativa de audio y video, con el objetivo de hacer que el video de IA sea útil para flujos de trabajo profesionales de creación y previsualización.

Nuevo

Popular

Uso comercial

Playground para Seedance 2-0

Explora el Playground de Seedance 2-0 — un entorno interactivo para probar modelos y ejecutar consultas en tiempo real. Prueba prompts, ajusta parámetros e itera instantáneamente para acelerar el desarrollo y validar casos de uso.

Especificaciones técnicas de Doubao Seedance 2.0

Ítem	Detalles
Familia de producto	ByteDance Seedance video generation family
CometAPI slug	doubao-seedance-2-0
Proveedor	ByteDance / BytePlus ModelArk
Tipo de modelo	Modelo de generación de video
Modalidades de entrada	Texto, imagen
Tipo de salida	Video MP4
Resolución de salida	480p, 720p, 1080p
Relaciones de aspecto	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Duración de salida	4–15 segundos
Estilo de API	Generación de video asíncrona basada en tareas

¿Qué es Doubao Seedance 2.0?

Doubao Seedance 2.0 es el modelo insignia multimodal de generación de video de ByteDance (lanzado en febrero de 2026). Utiliza una arquitectura de generación conjunta de audio y video unificada que permite un control preciso a nivel de director al referenciar simultáneamente múltiples imágenes, clips de video y archivos de audio. Sobresale en producir videos cinematográficos con estabilidad de movimiento y sincronización de audio nativa, ideal para creadores profesionales que necesitan física realista, personajes consistentes y composición de escenas complejas.

Funciones principales de Doubao Seedance 2.0 en CometAPI

Generación multimodal unificada: Acepta entradas de texto, imagen, audio y video en un solo flujo de trabajo, de modo que los usuarios pueden dirigir una escena con material de referencia más rico que un generador solo de texto.
Control al estilo director: El modelo está diseñado para seguir prompts sobre interpretación, iluminación, sombras, movimiento de cámara, ritmo del movimiento y características del sonido.
Edición y extensión de video: Seedance 2.0 no se limita a la generación en un primer pase; admite editar clips, personajes, acciones y tramas específicos, además de extensión hacia adelante/atrás.
Sólida sincronización audiovisual: ByteDance destaca la salida estéreo de doble canal y la sincronización de música de fondo, sonido ambiental y comportamiento de la voz en off para resultados más inmersivos.
Alto grado de control para escenas complejas: Enfatiza el manejo mejorado de interacciones complejas, escenas de movimiento y plausibilidad física en comparación con Seedance 1.5.
Salida orientada a producción: La API admite configuración de relación, duración y marcas de agua, lo que hace que el modelo sea práctico para flujos de trabajo repetibles.

Rendimiento en benchmarks

ByteDance afirma que Seedance 2.0 utiliza la evaluación interna SeedVideoBench-2.0 y se sitúa en una posición líder en las dimensiones de tareas de texto a video, imagen a video y multimodales. El modelo mejora la calidad de generación, la precisión física, el realismo y el control frente a Seedance 1.5, especialmente en escenas de interacción compleja y movimiento.

Modos Seedance 2.0 API y Seedance 2.0 Fast API en CometAPI

Modelo	Nombre del modelo en CometAPI	Mejor para	Diferencia principal
Seedance 2.0	doubao-seedance-2-0	Creación de video multimodal de la más alta calidad	La pila de referencias más amplia y el mayor control dentro de la familia Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Producción más rápida cuando se puede sacrificar un poco la calidad	ByteDance dice que mantiene las mismas capacidades del modelo que Seedance 2.0, pero genera más rápido.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Creación de audio y video de generaciones anteriores	Seedance 1.5 Pro se posiciona como un modelo nativo de generación conjunta de audio y video, mientras que Seedance 2.0 amplía la pila de referencias y edición multimodal.

Fortalezas frente a la competencia:

vs Kling 3.0: Mejor control de referencia multimodal y audio nativo.
vs Sora 2: Precisión de referencia superior y capacidad de múltiples tomas; duración máxima ligeramente menor.
vs Veo 3.1: Más fuerte en consistencia de personajes y fidelidad a los prompts en flujos de trabajo con muchas referencias; Veo lidera en gradación cinematográfica pura y clips más largos.

Sobresale en videos centrados en personas y orientados a la actuación.

Pruebe el generador de video con IA Seedance 2.0 en CometAPI

Paso 1: Paso 1: Regístrese para obtener la clave de API

Comience directamente en el Playground de CometAPI para experimentar Doubao Seedance 2.0 sin configuración ni código. Simplemente inicie sesión en su cuenta de CometAPI, vaya a la página del modelo para doubao-seedance-2-0, cargue sus imágenes de referencia, clips de video cortos o archivos de audio, agregue un prompt descriptivo y genere videos de vista previa al instante. Esta es la forma más rápida de entender cómo Seedance 2.0 maneja la consistencia del movimiento, la apariencia de los personajes, los movimientos de cámara y la sincronización de audio nativa.

Paso 2: Obtenga acceso a la API para Seedance 2.0 en CometAPI

Cree o use su clave de CometAPI existente para habilitar el acceso completo a Doubao Seedance 2.0. Después de iniciar sesión, vaya a la sección API Token en su consola, genere una nueva clave y cópiela. Luego visite la página de detalle del modelo Seedance 2.0 y la documentación de API en CometAPI para revisar los parámetros compatibles e integrarlos en sus proyectos.

Paso 3: Envíe su primera solicitud con la API de Seedance 2.0

Use el endpoint de CometAPI para enviar su primera solicitud de generación de video con un prompt de texto claro y archivos de referencia opcionales (imágenes, video o audio). El sistema procesará la tarea de forma asíncrona, devolverá un ID de tarea y proporcionará un video MP4 descargable una vez completado. Luego podrá refinar sus prompts, ajustar configuraciones y escalar para videos de marketing, contenido para redes sociales, flujos de video automatizados o aplicaciones creativas impulsadas por Seedance 2.0.

Este flujo de trabajo le ofrece experimentación rápida en el Playground y una transición fluida al uso en producción a través de CometAPI.

Principales razones para elegir Seedance 2.0 en CometAPI

Por qué usar CometAPI para Seedance 2.0

Acceso directo vía API o Playground
Control sencillo de parámetros (duración, resolución, formato)
Compatible con flujos de texto a video e imagen a video
Gestión de trabajos integrada para generación de video asíncrona

API unificada y amigable para desarrolladores

CometAPI ofrece un endpoint limpio y estandarizado que funciona sin fricciones con formatos de estilo OpenAI o endpoints de tareas de video dedicados. Obtendrá creación de tareas sencilla, polling y descargas MP4 sin tener que lidiar con la autenticación compleja de Volcengine ni con limitaciones regionales.

Precios rentables

CometAPI suele ofrecer tarifas por segundo más competitivas en comparación con proveedores directos, lo que le permite generar videos de alta calidad a escala para marketing, redes sociales o flujos automatizados sin exceder su presupuesto.

Pruebas rápidas con Playground

Experimente de inmediato en el Playground de CometAPI. Cargue imágenes, videos y archivos de audio de referencia, ajuste prompts y obtenga vistas previas en minutos: perfecto para iterar en estilo, movimiento y sincronización de audio antes de entrar en producción.

En pocas palabras, si desea el poder creativo de Seedance 2.0 — control de referencia líder en su clase, movimiento natural y audio nativo — sin las complicaciones del acceso directo a ByteDance, CometAPI es actualmente una de las mejores plataformas para usarlo.

Preguntas frecuentes

Precios para Seedance 2-0

Explora precios competitivos para Seedance 2-0, diseñado para adaptarse a diversos presupuestos y necesidades de uso. Nuestros planes flexibles garantizan que solo pagues por lo que uses, facilitando el escalado a medida que crecen tus requisitos. Descubre cómo Seedance 2-0 puede mejorar tus proyectos mientras mantienes los costos manejables.

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.

Código de ejemplo y API para Seedance 2-0

Accede a código de muestra completo y recursos de API para Seedance 2-0 para agilizar tu proceso de integración. Nuestra documentación detallada proporciona orientación paso a paso, ayudándote a aprovechar todo el potencial de Seedance 2-0 en tus proyectos.

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

Versiones de Seedance 2-0

La razón por la cual Seedance 2-0 tiene múltiples instantáneas puede incluir factores potenciales como variaciones en la salida tras actualizaciones que requieren instantáneas anteriores para mantener la coherencia, ofrecer a los desarrolladores un período de transición para adaptación y migración, y diferentes instantáneas que corresponden a endpoints globales o regionales para optimizar la experiencia del usuario. Para conocer las diferencias detalladas entre versiones, consulte la documentación oficial.

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