Como o Seedance 2.0 lida com áudio e sincronização labial?

O modelo gera áudio e vídeo conjuntamente, oferecendo sincronização audiovisual nativa com sincronização labial no nível de fonema, em 8+ idiomas, para fala natural e efeitos sonoros.

O Seedance 2.0 permite edição e extensão de vídeos existentes?

Sim — o modelo suporta extensão de vídeo e edição direcionada, como adicionar cenas, substituir personagens ou alterar segmentos específicos, preservando as partes não editadas.

Que tipos de entradas o Seedance 2.0 suporta para geração de vídeo?

O Seedance 2.0 suporta 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.

Quais resultados e níveis de qualidade posso esperar dos vídeos do Seedance 2.0?

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

Quais são as limitações conhecidas ou as durações típicas de geração com o Seedance 2.0?

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

Como funcionam os recursos de referência (imagens, clipes de vídeo) nos prompts do Seedance 2.0?

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

O Seedance 2.0 pode manter a consistência de personagens e estilo em múltiplos planos de vídeo?

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

O Seedance 2.0 é adequado para projetos criativos profissionais, como marketing ou curtas narrativos?

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

Bytedance

Disponível Popular

doubao-seedance-2-0

Seedance 2-0 API

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

Preço inicial

$0.056 / segundo

Cobrança por uso

Status da API

Disponível

Endpoint de produção

Resposta

Pronto para assíncrono

Tempo de resposta da API observado

Lançado

Apr 19, 2026

Bytedance

Playground

Teste Seedance 2-0 com uma solicitação real, revise os parâmetros e valide a saída antes de integrar a API.

Visão Geral

Uma visão geral prática de Seedance 2-0, incluindo comportamentos importantes e considerações de integração.

Especificações técnicas do Doubao Seedance 2.0

Item	Detalhes
Product family	Família de geração de vídeo Seedance da ByteDance
CometAPI slug	Slug do CometAPI
Provider	Fornecedor
Model type	Tipo de modelo
Input modalities	Modalidades de entrada
Output type	Tipo de saída
Output resolution	Resolução de saída
Aspect ratios	Proporções de aspecto
Output duration	Duração de saída
API style	Estilo de API

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 utiliza uma arquitetura unificada de geração conjunta de áudio e vídeo que permite controle preciso em nível de diretor, referenciando simultaneamente múltiplas imagens, clipes de vídeo e arquivos de áudio. Destaca-se na produção de vídeos cinematográficos, com estabilidade de movimento e sincronização nativa de áudio — ideal para criadores profissionais que precisam de física realista, consistência de personagens 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 de diretor: O modelo foi projetado para seguir instruções sobre atuação, iluminação, sombra, movimento de câmera, ritmo de movimento e características de som.
Edição e extensão de vídeo: O Seedance 2.0 não se limita à geração de primeira passada; ele suporta a edição de clipes, personagens, ações e enredos específicos, além de extensão para frente/para trás.
Sincronização audiovisual robusta: A ByteDance destaca a saída estéreo de dois canais e a 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 ao Seedance 1.5.
Saída orientada à produção: A API oferece configurações ajustáveis 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 utiliza a avaliação interna SeedVideoBench-2.0 e fica entre as primeiras posições 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 com interações complexas e movimento.

Modos Seedance 2.0 API e Seedance 2.0 Fast API no CometAPI

Modelo	Nome do modelo no CometAPI	Melhor para	Principal diferença
Seedance 2.0	doubao-seedance-2-0	Criação multimodal de vídeo de mais alta qualidade	Pilha de referências mais ampla e a maior controlabilidade da família Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Produção mais rápida quando é possível abrir mão de um pouco de qualidade	A ByteDance afirma 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 e vídeo de geração anterior	O Seedance 1.5 Pro é posicionado como um modelo nativo de geração conjunta de áudio e vídeo, enquanto o Seedance 2.0 expande a pilha de referências e de 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 de referência superior e capacidade multi-tomada; duração máxima ligeiramente menor.
vs Veo 3.1: Mais forte em consistência de personagens e aderência às instruções em fluxos de trabalho com muitas 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 à performance.

Experimente o gerador de vídeo com IA Seedance 2.0 no CometAPI

Etapa 1: Etapa 1: Cadastre-se para obter uma chave de API

Comece diretamente no Playground do CometAPI para experimentar o Doubao Seedance 2.0 sem qualquer configuração ou codificação. Basta entrar na sua conta do CometAPI, ir à 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 nativa de áudio.

Etapa 2: Obtenha acesso à API para o Seedance 2.0 no CometAPI

Crie ou use sua chave CometAPI existente para habilitar o 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 ao integrar nos seus projetos.

Etapa 3: Envie sua primeira solicitação com a API do Seedance 2.0

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 de tarefa e fornecerá um vídeo MP4 para download quando concluído. Em seguida, você pode refinar seus prompts, ajustar configurações e escalar para vídeos de marketing, conteúdo de mídia social, pipelines de vídeo automatizados ou aplicações criativas com o 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)
Suporta fluxos de trabalho de texto para vídeo e de imagem para vídeo
Gerenciamento de tarefas 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 com endpoints dedicados a tarefas de vídeo. Você obtém criação de tarefas simples, polling e downloads em 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 o orçamento.

Testes rápidos com o Playground

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

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

FAQ

Preços

Use a estimativa rápida acima para uma única execução e depois veja a comparação completa entre CometAPI e preço oficial.

Teste de 5 segundos

$0.28

Custo estimado de uso da CometAPI

Teste de 10 segundos

$0.56

Custo estimado de uso da CometAPI

Teste de 15 segundos

$0.84

Custo estimado de uso da CometAPI

Preços para Seedance 2-0

Explore preços competitivos para 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 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
size	Refer to documentation

*1080p is unavailable for doubao-seedance-2-0-fast and doubao-seedance-2-0-mini.

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-2-0-mini`	$0.032	$0.064	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—

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

API

Copie um endpoint funcional e um exemplo de código, e abra a referência completa da API quando precisar de todos os parâmetros.

Uma API, acesso a modelos pronto para produção

Autentique-se uma vez, chame o endpoint do modelo e mantenha o mesmo fluxo de cobrança e observabilidade entre provedores.

POST/v1/videos

Código de exemplo e API para Seedance 2-0

Acesse código de exemplo abrangente e recursos de API para 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 Seedance 2-0 em seus projetos.

POST

/v1/videos

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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 $'
%{http_code}' "https://api.cometapi.com/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 $'
%{http_code}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

cURL Code Example

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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}' "https://api.cometapi.com/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}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

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

Capacidades

Veja os principais dados do modelo antes de escolher uma arquitetura ou estimar a carga em produção.

Capacidades suportadas

Recursos retornados pela API do modelo existente.

text-to-video

image-to-video

Entrada e saída

Entradas

text

Saídas

video

Perfil de produção

Provedor: Bytedance
Contexto: Depende do modelo
Uso comercial: Suportado

Casos de uso

Use Seedance 2-0 em fluxos de produção compatíveis com suas capacidades de video, e compare alternativas antes de um compromisso de integração de longo prazo.

Conceitos de texto para vídeo e conteúdo social

Demos de produto e storyboards cinematográficos

Movimento de imagem para vídeo e iteração criativa

Outros modelos

Compare outros modelos disponíveis na CometAPI considerando qualidade, latência, capacidades e preço.

Abrir comparação de modelos →

Aliyun

Wan3.0

From fast verification to cinematic output, billing is based on the generated video duration, selecting the appropriate resolution, and turning every generation into a planned creative investment activity rule

Ver modelo

Flux

Flux 3

FLUX 3 - Real World Models: Towards Multimodal Flow Models as the Backbone of Visual Intelligence.

Ver modelo

Aliyun

Happy Horse 1.1

HappyHorse 1.1 é um modelo multimodal de geração de vídeo projetado para criação de conteúdo profissional, publicidade, curtas-metragens, produção para redes sociais e narrativa. Ele amplia as capacidades do HappyHorse 1.0 — que recebeu grande atenção após ficar bem classificado em avaliações independentes de geração de vídeo — com maior coerência entre cenas e fidelidade visual aprimorada.

Ver modelo

Google

Gemini omni fast

Gemini Omni Fast is a lightweight multimodal video generation model designed for fast and flexible content creation. It enables efficient video generation with support for multiple input types, making it suitable for interactive and iterative workflows.

Ver modelo

OpenAI

Sora 2 Pro

Sora 2 Pro é nosso modelo de geração de mídia mais avançado e poderoso, capaz de gerar vídeos com áudio sincronizado. Ele pode criar clipes de vídeo detalhados e dinâmicos a partir de linguagem natural ou imagens.

Ver modelo

Aliyun

Happy Horse 1.0

Happy Horse 1.0 — A high-quality audio-video generation model that supports text-to-video and image-to-video creation. It can generate synchronized visuals, audio, and lip movements, making it suitable for short films, advertising creatives, and product showcases.

Ver modelo

Uptime

Veja dados de heartbeat em tempo real, disponibilidade do endpoint e tempos de resposta observados antes de ir para produção.

Versões

Veja os identificadores de modelo disponíveis antes de fixar uma integração de produção.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Continue explorando

Compare modelos e continue sua pesquisa

Bytedance

Disponível Popular

doubao-seedance-2-0

Seedance 2-0 API

Preço inicial

$0.056 / segundo

Cobrança por uso

Status da API

Disponível

Endpoint de produção

Resposta

Pronto para assíncrono

Tempo de resposta da API observado

Lançado

Apr 19, 2026

Bytedance

Playground

Teste Seedance 2-0 com uma solicitação real, revise os parâmetros e valide a saída antes de integrar a API.

Visão Geral

Uma visão geral prática de Seedance 2-0, incluindo comportamentos importantes e considerações de integração.

Especificações técnicas do Doubao Seedance 2.0

Item	Detalhes
Product family	Família de geração de vídeo Seedance da ByteDance
CometAPI slug	Slug do CometAPI
Provider	Fornecedor
Model type	Tipo de modelo
Input modalities	Modalidades de entrada
Output type	Tipo de saída
Output resolution	Resolução de saída
Aspect ratios	Proporções de aspecto
Output duration	Duração de saída
API style	Estilo de API

O que é o Doubao Seedance 2.0?

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 de diretor: O modelo foi projetado para seguir instruções sobre atuação, iluminação, sombra, movimento de câmera, ritmo de movimento e características de som.
Edição e extensão de vídeo: O Seedance 2.0 não se limita à geração de primeira passada; ele suporta a edição de clipes, personagens, ações e enredos específicos, além de extensão para frente/para trás.
Sincronização audiovisual robusta: A ByteDance destaca a saída estéreo de dois canais e a 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 ao Seedance 1.5.
Saída orientada à produção: A API oferece configurações ajustáveis 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

Modos Seedance 2.0 API e Seedance 2.0 Fast API no CometAPI

Modelo	Nome do modelo no CometAPI	Melhor para	Principal diferença
Seedance 2.0	doubao-seedance-2-0	Criação multimodal de vídeo de mais alta qualidade	Pilha de referências mais ampla e a maior controlabilidade da família Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Produção mais rápida quando é possível abrir mão de um pouco de qualidade	A ByteDance afirma 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 e vídeo de geração anterior	O Seedance 1.5 Pro é posicionado como um modelo nativo de geração conjunta de áudio e vídeo, enquanto o Seedance 2.0 expande a pilha de referências e de 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 de referência superior e capacidade multi-tomada; duração máxima ligeiramente menor.
vs Veo 3.1: Mais forte em consistência de personagens e aderência às instruções em fluxos de trabalho com muitas 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 à performance.

Experimente o gerador de vídeo com IA Seedance 2.0 no CometAPI

Etapa 1: Etapa 1: Cadastre-se para obter uma chave de API

Etapa 2: Obtenha acesso à API para o Seedance 2.0 no CometAPI

Etapa 3: Envie sua primeira solicitação com a API 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)
Suporta fluxos de trabalho de texto para vídeo e de imagem para vídeo
Gerenciamento de tarefas integrado para geração de vídeo assíncrona

API unificada e amigável para desenvolvedores

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

Testes rápidos com o Playground

FAQ

Preços

Use a estimativa rápida acima para uma única execução e depois veja a comparação completa entre CometAPI e preço oficial.

Teste de 5 segundos

$0.28

Custo estimado de uso da CometAPI

Teste de 10 segundos

$0.56

Custo estimado de uso da CometAPI

Teste de 15 segundos

$0.84

Custo estimado de uso da CometAPI

Preços para Seedance 2-0

doubao-seedance Video Generation Pricing

Parameters

Parameter	Description
Duration (seconds)	4–15 seconds, default 5 seconds
size	Refer to documentation

*1080p is unavailable for doubao-seedance-2-0-fast and doubao-seedance-2-0-mini.

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-2-0-mini`	$0.032	$0.064	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—

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

API

Copie um endpoint funcional e um exemplo de código, e abra a referência completa da API quando precisar de todos os parâmetros.

Uma API, acesso a modelos pronto para produção

Autentique-se uma vez, chame o endpoint do modelo e mantenha o mesmo fluxo de cobrança e observabilidade entre provedores.

POST/v1/videos

Código de exemplo e API para Seedance 2-0

POST

/v1/videos

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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 $'
%{http_code}' "https://api.cometapi.com/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 $'
%{http_code}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

cURL Code Example

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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}' "https://api.cometapi.com/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}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

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

Capacidades

Veja os principais dados do modelo antes de escolher uma arquitetura ou estimar a carga em produção.

Capacidades suportadas

Recursos retornados pela API do modelo existente.

text-to-video

image-to-video

Entrada e saída

Entradas

text

Saídas

video

Perfil de produção

Provedor: Bytedance
Contexto: Depende do modelo
Uso comercial: Suportado

Casos de uso

Use Seedance 2-0 em fluxos de produção compatíveis com suas capacidades de video, e compare alternativas antes de um compromisso de integração de longo prazo.

Conceitos de texto para vídeo e conteúdo social

Demos de produto e storyboards cinematográficos

Movimento de imagem para vídeo e iteração criativa

Outros modelos

Compare outros modelos disponíveis na CometAPI considerando qualidade, latência, capacidades e preço.

Abrir comparação de modelos →

FLUX 3 - Real World Models: Towards Multimodal Flow Models as the Backbone of Visual Intelligence.

Uptime

Veja dados de heartbeat em tempo real, disponibilidade do endpoint e tempos de resposta observados antes de ir para produção.

Versões

Veja os identificadores de modelo disponíveis antes de fixar uma integração de produção.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Continue explorando