Doubao-Seedance-2-0

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

Seedance 2.0 admite entradas multimodales, incluidas indicaciones de texto, hasta 9 imágenes, hasta 3 videoclips cortos y hasta 3 archivos de audio, que pueden combinarse libremente para una generación rica y controlable.

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

Sí — Seedance 2.0 está diseñado para una narración coherente de múltiples tomas, con personajes, estilo visual y atmósfera consistentes a lo largo de las escenas, lo que reduce los problemas comunes de deriva en videos de IA.

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

Seedance 2.0 puede generar videos de calidad cinematográfica (hasta 2K de resolución) con audio nativo, diálogo sincronizado y síntesis de movimiento natural, normalmente en clips de 5–60 segundos.

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

El modelo genera audio y video de forma conjunta, ofreciendo sincronización audiovisual nativa con sincronización labial a nivel de fonema en más de 8 idiomas para un habla y efectos de sonido naturales.

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

Sí — el control multimodal, la continuidad entre múltiples tomas y la alta fidelidad de salida de Seedance 2.0 lo hacen adecuado para videos de marketing, cortometrajes narrativos, anuncios y otras aplicaciones profesionales.

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

Los usuarios pueden cargar recursos de referencia y luego describir en lenguaje natural cómo cada uno debe influir en el movimiento, el movimiento de cámara o los elementos estilísticos, otorgando un control detallado sobre el contenido generado.

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

Sí — el modelo admite la extensión de video y la edición dirigida, como agregar escenas, reemplazar personajes o alterar segmentos específicos, preservando las partes no editadas.

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

Las longitudes típicas de salida van de ~5 a ~60 segundos por video, y combinar muchos recursos o configuraciones de alta resolución puede aumentar el tiempo de generación.

Por Segundo:$0.08

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

Uso comercial

Resumen

Características

Precios

API

Versiones

Especificaciones técnicas de Doubao Seedance 2.0

Item	Details
Product family	ByteDance Seedance video generation family
CometAPI slug	doubao-seedance-2-0
Provider	ByteDance / BytePlus ModelArk
Model type	Video generation model
Input modalities	Text, image, audio, video
Reference capacity	Up to 9 images, 3 video clips, and 3 audio clips in a single multimodal request
Output type	MP4 video
Output resolution	480p, 720p, 1080p
Aspect ratios	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Output duration	4–15 seconds
API style	Asynchronous task-based video generation

¿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 unificada de generación conjunta de audio y video que permite un control preciso a nivel de director al referenciar simultáneamente múltiples imágenes, clips de video y archivos de audio. Destaca por producir videos cinematográficos y estables en movimiento con sincronización de audio nativa, ideal para creadores profesionales que necesitan física realista, consistencia de personajes y composición de escenas complejas.

Principales características 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, por lo que los usuarios pueden dirigir una escena con material de referencia más rico que el de un generador solo de texto.
Control al estilo director: El modelo está diseñado para seguir indicaciones 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 de primer pase; admite la edición de clips, personajes, acciones y líneas narrativas específicas, además de extensión hacia adelante/atrás.
Sincronización audiovisual sólida: 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.
Alta controlabilidad en escenas complejas: Hace hincapié en un mejor manejo 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 de aspecto, duración y marcas de agua, lo que hace que el modelo sea práctico para flujos de trabajo de contenido repetibles.

Rendimiento en benchmarks

ByteDance señala que Seedance 2.0 utiliza la evaluación interna SeedVideoBench-2.0 y se sitúa en una posición de liderazgo en las dimensiones de texto a video, imagen a video y tareas multimodales. El modelo mejora la calidad de generación, la precisión física, el realismo y la controlabilidad frente a Seedance 1.5, especialmente en interacciones complejas y escenas de movimiento.

Modos Seedance 2.0 API y Seedance 2.0 Fast API en CometAPI

Modelo	Nombre del modelo en CometAPI	Ideal para	Diferencia principal
Seedance 2.0	doubao-seedance-2-0	Creación de video multimodal de máxima calidad	Conjunto de referencias más amplio y la mayor controlabilidad de la familia Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Producción más rápida cuando se puede ceder calidad	ByteDance afirma 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-video de generación anterior	Seedance 1.5 Pro se posiciona como un modelo nativo conjunto de audio y video, mientras que Seedance 2.0 amplía el conjunto de referencia y edición multimodal.

Fortalezas frente a competidores:

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

Sobresale en videos centrados en personas y dirigidos por la actuación.

Prueba el generador de video con IA Seedance 2.0 en CometAPI

Paso 1: Paso 1: Regístrate para obtener una clave de API

Comienza directamente en CometAPI Playground para experimentar Doubao Seedance 2.0 sin configuración ni código. Simplemente inicia sesión en tu cuenta de CometAPI, ve a la página del modelo doubao-seedance-2-0, sube tus imágenes de referencia, clips de video cortos o archivos de audio, añade un prompt descriptivo y genera 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 personajes, los movimientos de cámara y la sincronización de audio nativa.

Paso 2: Obtén acceso a la API para Seedance 2.0 en CometAPI

Crea o utiliza tu clave existente de CometAPI para habilitar el acceso completo a Doubao Seedance 2.0. Tras iniciar sesión, navega a la sección API Token en tu consola, genera una nueva clave y cópiala. Luego visita la página de detalles del modelo Seedance 2.0 y la documentación de la API en CometAPI para revisar los parámetros compatibles que se integran en tus proyectos.

Paso 3: Envía tu primera solicitud con la API de Seedance 2.0

Utiliza el endpoint de CometAPI para enviar tu 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. A continuación, puedes refinar tus prompts, ajustar la configuración y escalar para videos de marketing, contenido para redes sociales, pipelines de video automatizados o aplicaciones creativas impulsadas por Seedance 2.0.

Este flujo de trabajo te brinda 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 fácil de parámetros (duración, resolución, formato)
Compatible con flujos de trabajo de texto a video e imagen a video
Gestión integrada de tareas para generación de video asíncrona

API unificada y amigable para desarrolladores

CometAPI ofrece un endpoint limpio y estandarizado que funciona sin problemas con formatos familiares al estilo OpenAI o endpoints dedicados de tareas de video. Obtienes creación de tareas, sondeo y descargas de MP4 de forma directa, sin tener que lidiar con la autenticación compleja o las limitaciones regionales de Volcengine.

Precios rentables

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

Pruebas rápidas con Playground

Experimenta de inmediato en CometAPI Playground. Sube imágenes, videos y audio de referencia, ajusta prompts y previsualiza resultados en minutos, perfecto para iterar en estilo, movimiento y sincronización de audio antes de pasar a producción.

En resumen, si quieres 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

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?

Precios para Doubao-Seedance-2-0

Explora precios competitivos para Doubao-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 Doubao-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
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.

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

Accede a código de muestra completo y recursos de API para Doubao-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 Doubao-Seedance-2-0 en tus proyectos.

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

Versiones de Doubao-Seedance-2-0

La razón por la cual Doubao-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

Más modelos

Blog relacionado

Apr 17, 2026

Cómo usar la API de Seedance 2.0

Seedance 2.0 API es el último modelo multimodal de IA de generación de video de ByteDance (lanzado el 9 de abril de 2026). Acepta texto, imágenes, clips de video y audio en una sola solicitud para producir videos MP4 cinematográficos de 4 a 15 segundos con sincronización de audio nativa, control de cámara a nivel de director y una consistencia de movimiento excepcional. Para usarlo: regístrate en CometAPI.com, obtén una clave de API, envía una tarea asíncrona mediante REST, consulta periódicamente hasta que se complete y descarga el video desde la URL.

Apr 11, 2026

¿Qué es HappyHorse-1.0? ¿Cómo comparar Seedance 2.0?

Descubre qué es HappyHorse-1.0, por qué alcanzó la cima de la tabla de clasificación de videos de Artificial Analysis, cómo se compara con Seedance 2.0 y qué significan las últimas clasificaciones para la generación de video con IA.

Mar 24, 2026

¿Qué es Seedance 2.0? Un análisis exhaustivo

Seedance 2.0 es un modelo de IA multimodal de próxima generación para la generación de video, desarrollado por ByteDance, que puede generar videos cinematográficos de alta calidad a partir de texto, imágenes, audio y videos de referencia. Cuenta con generación conjunta de audio y video, estabilidad de movimiento y edición basada en referencias, y ha ascendido rápidamente en clasificaciones globales como la tabla de Artificial Analysis, posicionándose entre los principales modelos de video con IA en 2026.