Doubao-Seedance-2-0

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

Seedance 2.0 oferece suporte a entradas multimodais, incluindo prompts de texto, até 9 imagens, até 3 clipes de vídeo curtos e até 3 arquivos de áudio, que podem ser combinados livremente para uma geração rica e controlável.

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

Sim — o Seedance 2.0 foi projetado para narrativas coerentes em múltiplos planos, com personagens, estilo visual e atmosfera consistentes entre as cenas, reduzindo problemas comuns de deriva em vídeos de IA.

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

O Seedance 2.0 pode gerar vídeos em nível cinematográfico (até 2K de resolução), com áudio nativo, diálogo sincronizado e síntese de movimento natural, normalmente em clipes de 5–60 segundos.

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

O modelo gera áudio e vídeo de forma conjunta, oferecendo sincronização áudio-visual nativa com sincronização labial no nível de fonemas em 8+ idiomas para fala e efeitos sonoros naturais.

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

Sim — o controle multimodal, a continuidade entre múltiplos planos e a saída de alta fidelidade do Seedance 2.0 o tornam adequado para vídeos de marketing, curtas narrativos, anúncios e outras aplicações profissionais.

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

Os usuários podem enviar ativos de referência e, em linguagem natural, descrever como cada um deve influenciar o movimento, o movimento da câmera ou elementos de estilo, oferecendo controle granular sobre o conteúdo gerado.

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

Sim — o modelo oferece suporte à extensão de vídeo e a edições direcionadas, como adicionar cenas, substituir personagens ou alterar segmentos específicos, preservando as partes não editadas.

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

As durações típicas de saída variam de ~5 a ~60 segundos por vídeo, e combinar muitos ativos ou configurações de alta resolução pode aumentar o tempo de geração.

Por Segundo:$0.08

Seedance 2.0 é o modelo de base multimodal de vídeo de próxima geração da ByteDance, focado na geração de vídeos narrativos cinematográficos com múltiplas tomadas. Diferentemente de demos de texto-para-vídeo de tomada única, o Seedance 2.0 enfatiza o controle baseado em referências (imagens, clipes curtos, áudio), a consistência de personagens e de estilo entre tomadas e a sincronização nativa de áudio e vídeo — visando tornar o vídeo com IA útil para fluxos de trabalho criativos profissionais e de pré-visualização.

Novo

Uso comercial

Playground

Visão Geral

Recursos

Preços

API

Versões

Especificações técnicas do Doubao Seedance 2.0

Item	Details
Família de produtos	ByteDance Seedance video generation family
CometAPI slug	doubao-seedance-2-0
Fornecedor	ByteDance / BytePlus ModelArk
Tipo de modelo	Modelo de geração de vídeo
Modalidades de entrada	Texto, imagem, áudio, vídeo
Capacidade de referência	Até 9 imagens, 3 clipes de vídeo e 3 clipes de áudio em uma única solicitação multimodal
Tipo de saída	Vídeo MP4
Resolução de saída	480p, 720p, 1080p
Proporções	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Duração de saída	4–15 segundos
Estilo de API	Geração de vídeo assíncrona baseada em tarefas

O que é o Doubao Seedance 2.0?

O Doubao Seedance 2.0 é o principal modelo multimodal de geração de vídeo da ByteDance (lançado em fevereiro de 2026). Ele usa uma arquitetura unificada de geração conjunta de áudio e vídeo que permite controle preciso em nível de direção ao referenciar simultaneamente várias imagens, clipes de vídeo e arquivos de áudio. Destaca-se na produção de vídeos cinematográficos, com movimento estável e sincronização nativa de áudio — ideal para criadores profissionais que precisam de física realista, personagens consistentes e composição de cenas complexas.

Principais recursos do Doubao Seedance 2.0 no CometAPI

Geração multimodal unificada: Aceita entradas de texto, imagem, áudio e vídeo em um único fluxo de trabalho, permitindo que os usuários dirijam uma cena com material de referência mais rico do que um gerador apenas de texto.
Controle em estilo diretor: O modelo é construído para seguir prompts sobre performance, iluminação, sombra, movimento de câmera, ritmo de movimento e características do som.
Edição e extensão de vídeo: O Seedance 2.0 não se limita à geração de primeira passagem; ele suporta a edição de clipes, personagens, ações e linhas narrativas específicos, além de extensão para frente/para trás.
Forte sincronização audiovisual: A ByteDance destaca saída estéreo de dois canais e sincronização de música de fundo, som ambiente e comportamento de narração para resultados mais imersivos.
Alta controlabilidade para cenas complexas: Enfatiza o manuseio aprimorado de interações complexas, cenas de movimento e plausibilidade física em comparação com o Seedance 1.5.
Saída voltada à produção: A API oferece configurações de proporção, duração e marca d’água, o que torna o modelo prático para fluxos de trabalho de conteúdo repetíveis.

Desempenho em benchmarks

A ByteDance afirma que o Seedance 2.0 usa a avaliação interna SeedVideoBench-2.0 e ocupa posição de liderança nas dimensões de tarefas de texto para vídeo, imagem para vídeo e multimodal. O modelo melhora a qualidade de geração, a precisão física, o realismo e a controlabilidade em relação ao Seedance 1.5, especialmente em cenas de interação complexa e movimento.

Seedance 2.0 API e modos Seedance 2.0 Fast API no CometAPI

Modelo	Nome do modelo no CometAPI	Ideal para	Principal diferença
Seedance 2.0	doubao-seedance-2-0	Criação de vídeo multimodal de mais alta qualidade	Pilha de referências mais ampla e maior controlabilidade na família Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Produção mais rápida quando é possível ceder um pouco na qualidade	A ByteDance diz que mantém as mesmas capacidades do Seedance 2.0, mas gera mais rápido.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Criação de áudio-vídeo de geração anterior	O Seedance 1.5 Pro é posicionado como um modelo nativo conjunto de áudio e vídeo, enquanto o Seedance 2.0 expande a pilha de referência e edição multimodal.

Pontos fortes vs. concorrentes:

vs Kling 3.0: Melhor controle de referências multimodais e áudio nativo.
vs Sora 2: Precisão superior de referência e capacidade multi-shot; duração máxima ligeiramente menor.
vs Veo 3.1: Mais forte em consistência de personagens e aderência ao prompt para fluxos de trabalho ricos em referências; o Veo lidera em gradação cinematográfica bruta e clipes mais longos.

Destaca-se em vídeos centrados em pessoas e orientados à atuação.

Experimente o Seedance 2.0 AI Video Generator no CometAPI

Comece diretamente no CometAPI Playground para experimentar o Doubao Seedance 2.0 sem qualquer configuração ou código. Basta fazer login na sua conta do CometAPI, acessar a página do modelo doubao-seedance-2-0, enviar suas imagens de referência, clipes de vídeo curtos ou arquivos de áudio, adicionar um prompt descritivo e gerar vídeos de prévia instantaneamente. Esta é a maneira mais rápida de entender como o Seedance 2.0 lida com consistência de movimento, aparência de personagens, movimentos de câmera e sincronização de áudio nativa.

Step 2: Get API Access for Seedance 2.0 on CometAPI

Crie ou use sua chave CometAPI existente para habilitar acesso completo ao Doubao Seedance 2.0. Após fazer login, navegue até a seção API Token no seu console, gere uma nova chave e copie-a. Em seguida, visite a página de detalhes do modelo Seedance 2.0 e a Documentação da API no CometAPI para revisar os parâmetros suportados e integrá-los aos seus projetos.

Step 3: Send Your First Request with Seedance 2.0 API

Use o endpoint do CometAPI para enviar sua primeira solicitação de geração de vídeo com um prompt de texto claro e arquivos de referência opcionais (imagens, vídeo ou áudio). O sistema processará a tarefa de forma assíncrona, retornará um ID da tarefa e fornecerá um vídeo MP4 para download quando concluído. Você poderá então refinar seus prompts, ajustar as configurações e escalar para vídeos de marketing, conteúdo para redes sociais, pipelines de vídeo automatizados ou aplicações criativas com tecnologia do Seedance 2.0.

Esse fluxo de trabalho oferece experimentação rápida no playground e uma transição suave para uso em produção via CometAPI.

Principais motivos para escolher o Seedance 2.0 no CometAPI

Por que usar o CometAPI para o Seedance 2.0

Acesso direto via API ou Playground
Controle fácil de parâmetros (duração, resolução, formato)
Suporte a fluxos de texto para vídeo e imagem para vídeo
Gerenciamento de jobs integrado para geração de vídeo assíncrona

API unificada e amigável para desenvolvedores

O CometAPI oferece um endpoint limpo e padronizado que funciona perfeitamente com formatos ao estilo OpenAI ou endpoints dedicados a tarefas de vídeo. Você obtém criação de tarefas simples, polling e downloads de MP4 sem lidar com a autenticação complexa da Volcengine ou limitações regionais.

Preços com boa relação custo-benefício

O CometAPI normalmente oferece tarifas por segundo mais competitivas em comparação com provedores diretos, permitindo gerar vídeos de alta qualidade em escala para marketing, redes sociais ou pipelines automatizados sem estourar seu orçamento.

Teste rápido com o Playground

Experimente imediatamente no CometAPI Playground. Envie imagens, vídeos e áudios de referência, ajuste prompts e visualize resultados em minutos — perfeito para iterar sobre estilo, movimento e sincronização de áudio antes de entrar em produção.

Em resumo, se você quer o poder criativo do Seedance 2.0 — controle de referência líder de classe, movimento natural e áudio nativo — sem o incômodo do acesso direto à ByteDance, o CometAPI é atualmente uma das melhores plataformas para usá-lo.

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?

Preços para Doubao-Seedance-2-0

Explore preços competitivos para Doubao-Seedance-2-0, projetado para atender diversos orçamentos e necessidades de uso. Nossos planos flexíveis garantem que você pague apenas pelo que usar, facilitando o dimensionamento conforme suas necessidades crescem. Descubra como Doubao-Seedance-2-0 pode aprimorar seus projetos mantendo os custos gerenciáveis.

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 exemplo e API para Doubao-Seedance-2-0

Acesse código de exemplo abrangente e recursos de API para Doubao-Seedance-2-0 para otimizar seu processo de integração. Nossa documentação detalhada fornece orientação passo a passo, ajudando você a aproveitar todo o potencial do Doubao-Seedance-2-0 em seus projetos.

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

Versões do Doubao-Seedance-2-0

O motivo pelo qual Doubao-Seedance-2-0 possui múltiplas versões instantâneas pode incluir fatores como variações na saída após atualizações que exigem versões antigas para consistência, fornecendo aos desenvolvedores um período de transição para adaptação e migração, e diferentes versões correspondentes a endpoints globais ou regionais para otimizar a experiência do usuário. Para diferenças detalhadas entre versões, consulte a documentação oficial.

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

Mais modelos

Blogs relacionados

Apr 17, 2026

Como usar a API do Seedance 2.0

Seedance 2.0 API é o mais recente modelo multimodal de geração de vídeo por IA da ByteDance (lançado em 9 de abril de 2026). Aceita texto, imagens, clipes de vídeo e áudio em uma única solicitação para produzir vídeos MP4 cinematográficos de 4–15 segundos com sincronização de áudio nativa, controle de câmera em nível de diretor e consistência de movimento excepcional. Para usá-la: inscreva-se em CometAPI.com, obtenha uma chave de API, envie uma tarefa assíncrona via REST, verifique periodicamente até a conclusão e faça o download da URL do vídeo.

Apr 11, 2026

O que é o HappyHorse-1.0? Como comparar o Seedance 2.0?

Saiba o que é a HappyHorse-1.0, por que ela chegou ao topo do ranking de vídeos da Artificial Analysis, como ela se compara à Seedance 2.0 e o que os rankings mais recentes significam para a geração de vídeo por IA.

Mar 24, 2026

O que é o Seedance 2.0? Uma análise abrangente

Seedance 2.0 é um modelo de geração de vídeo multimodal de IA de próxima geração, desenvolvido pela ByteDance, capaz de gerar vídeos cinematográficos de alta qualidade a partir de texto, imagens, áudio e vídeos de referência. Ele apresenta geração conjunta de áudio e vídeo, estabilidade de movimento e edição baseada em referências, e tem subido rapidamente em benchmarks globais como o Artificial Analysis leaderboard, posicionando-se entre os principais modelos de vídeo por IA em 2026.