API Seedance 2.0: Um Guia Prático para Desenvolvedores

Última atualização: Março de 2026

A API Seedance 2.0 permite que desenvolvedores integrem geração de vídeo com IA diretamente em suas aplicações. Este guia cobre o que a API realmente faz, como ela se compara a alternativas e como começar.

O que a API Seedance 2.0 Faz

A API Seedance 2.0 fornece acesso programático para gerar vídeos a partir de prompts de texto e imagens. Em vez de usar a interface web, você envia trabalhos de geração via requisições HTTP, consulta a conclusão e recupera URLs de vídeo.

Capacidades principais:

• Geração de texto para vídeo (modelo Seedance 2.0)
• Geração de imagem para vídeo (animar uma imagem de referência)
• Envio assíncrono de trabalhos com consulta de status
• Saída em formato MP4, 1080p HD
• Até ~10 segundos por geração

O que não faz:

• Sem saída de streaming em tempo real (a geração leva tempo)
• Sem edição de vídeo integrada
• Sem geração de áudio (ao contrário do Google Veo 3)
• Os tempos de fila de geração variam sob carga

API Seedance vs APIs Concorrentes

Antes de construir, vale a pena comparar suas opções honestamente.

Quando a API Seedance faz sentido:

• Você quer boa qualidade sem a complexidade de configuração do Google Cloud
• Você está construindo um produto que precisa de preços previsíveis baseados em créditos
• Você quer acesso a múltiplos modelos em uma única API (Seedance 1.5 para velocidade, 2.0 para qualidade)

Quando considerar alternativas:

• Precisa da mais alta qualidade possível → Google Veo 3 (Vertex AI)
• Precisa de geração de áudio nativa → Google Veo 3
• Precisa de controles avançados de câmera → Runway API

Primeiros Passos

Passo 1: Obtenha sua Chave de API

Cadastre-se em seedance.tv e navegue até as configurações da sua conta. O acesso à API está disponível em planos pagos a partir de $9,9/mês.

Armazene sua chave de API como uma variável de ambiente — nunca a codifique diretamente nos arquivos fonte:

export SEEDANCE_API_KEY="sua-chave-api-aqui"

Passo 2: Envie um Trabalho de Geração

A API usa um padrão assíncrono: você envia um trabalho e consulta a conclusão.

import requests
import time
import os

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.seedance.tv/v1"

def generate_video(prompt: str, model: str = "seedance-2.0"):
    """Envia um trabalho de geração de texto para vídeo."""
    response = requests.post(
        f"{BASE_URL}/videos",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": model,
            "aspect_ratio": "16:9",
            "resolution": "1080p"
        }
    )
    response.raise_for_status()
    return response.json()["job_id"]

Passo 3: Consulte a Conclusão

def wait_for_completion(job_id: str, poll_interval: int = 5, timeout: int = 300):
    """Consulta até que a geração do vídeo seja concluída."""
    start_time = time.time()
    
    while time.time() - start_time < timeout:
        response = requests.get(
            f"{BASE_URL}/videos/{job_id}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        response.raise_for_status()
        data = response.json()
        
        status = data["status"]
        
        if status == "completed":
            return data["output_url"]
        elif status == "failed":
            raise Exception(f"Falha na geração: {data.get('error', 'Erro desconhecido')}")
        
        # Ainda processando
        print(f"Status: {status} ({int(time.time() - start_time)}s decorridos)")
        time.sleep(poll_interval)
    
    raise TimeoutError(f"A geração não foi concluída em {timeout} segundos")

# Uso
job_id = generate_video("Um movimento lento de dolly por uma rua de Tóquio iluminada por neon à noite, reflexos de chuva no asfalto molhado, 1080p cinematográfico")
video_url = wait_for_completion(job_id)
print(f"Vídeo pronto: {video_url}")

Passo 4: Imagem para Vídeo

Para animar uma imagem de referência:

def generate_from_image(image_url: str, prompt: str):
    """Anima uma imagem de referência."""
    response = requests.post(
        f"{BASE_URL}/videos",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": "seedance-2.0",
            "image_url": image_url,
            "type": "image-to-video",
            "aspect_ratio": "16:9"
        }
    )
    response.raise_for_status()
    return response.json()["job_id"]

Engenharia de Prompt para a API

A qualidade da sua saída depende muito da estrutura do prompt. Aqui estão padrões que funcionam consistentemente:

Boa estrutura de prompt de texto para vídeo:

[Tipo de plano], [Descrição do sujeito], [Ação/movimento], [Ambiente], [Iluminação], [Estilo]

Exemplo:

Plano close-up com travelling, mulher caminhando por um olival banhado de sol, cabelo ao vento, luz quente da tarde através das folhas, profundidade de campo rasa cinematográfica

Erros comuns que desperdiçam créditos da API:

Muito vago:

Um vídeo bonito

Muitos elementos concorrentes:

Um homem e uma mulher e um cachorro na praia e também um pôr do sol e ondas e montanhas ao fundo

Falta descrição de movimento:

Uma xícara de café em uma mesa

Melhor: Uma xícara de café em uma mesa de madeira, vapor subindo lentamente, luz natural suave de janela à esquerda, lente macro

Escolhendo o modelo certo:

Fluxo de trabalho recomendado: Rascunhe com seedance-1.5, refine o prompt, depois gere o final com seedance-2.0. Isso reduz os custos da API durante a iteração.

Proporções de Tela

ASPECT_RATIOS = {
    "landscape": "16:9",   # YouTube, desktop, anúncios
    "portrait": "9:16",    # TikTok, Instagram Reels, Shorts
    "square": "1:1",       # Posts do Instagram
    "cinema": "21:9"       # Widescreen cinematográfico
}

Tratamento de Erros

def safe_generate(prompt: str, max_retries: int = 3):
    """Gera com lógica de repetição para falhas transitórias."""
    for attempt in range(max_retries):
        try:
            job_id = generate_video(prompt)
            return wait_for_completion(job_id)
        except requests.HTTPError as e:
            if e.response.status_code == 429:
                # Limite de taxa atingido — aguardar
                wait = 30 * (attempt + 1)
                print(f"Limite de taxa atingido. Aguardando {wait}s...")
                time.sleep(wait)
            elif e.response.status_code == 402:
                raise Exception("Créditos insuficientes. Recarregue sua conta em seedance.tv")
            else:
                raise
        except TimeoutError:
            if attempt < max_retries - 1:
                print(f"Tempo limite excedido na tentativa {attempt + 1}, tentando novamente...")
            else:
                raise
    raise Exception("Máximo de tentativas excedido")

Limites de Taxa e Uso de Créditos

• Limite de taxa: Varia conforme o plano. Verifique seu painel para limites atuais.
• Créditos por geração: Depende do modelo, duração e resolução. O painel mostra o saldo de créditos em tempo real.
• Melhor prática para produção: Implemente uma fila de trabalhos em vez de enviar muitas requisições simultâneas. Envios escalonados evitam erros de limite de taxa e são mais econômicos.

Casos de Uso para os Quais Esta API é Adequada

Automação de vídeos de produto: Plataformas de e-commerce gerando vídeos a partir de imagens de produto em escala. Alimente uma imagem de produto + prompt de voz da marca → clipes de vídeo automatizados para cada SKU.

Pipelines de mídia social: Sistemas de conteúdo agendado que geram uma semana de conteúdo de vídeo a partir de uma lista de prompts aprovados. Combine com uma ferramenta de fila de vídeos para publicação sem intervenção.

Testes de criativos de anúncios: Ferramentas de marketing que geram múltiplas interpretações visuais do mesmo conceito para testes A/B. Gere 5 variações de um conceito de anúncio em um lote.

Geração de protótipos: Equipes de design e produto gerando vídeos conceituais antes de se comprometer com a produção. Muito mais barato que a produção tradicional para visualização em estágio inicial.

Construindo um Pipeline Simples de Geração de Vídeos

import json
from pathlib import Path

def batch_generate(prompts: list[dict], output_dir: str = "./videos"):
    """Gera múltiplos vídeos a partir de uma lista de configurações de prompt."""
    Path(output_dir).mkdir(exist_ok=True)
    results = []
    
    for i, config in enumerate(prompts):
        print(f"Gerando {i+1}/{len(prompts)}: {config['name']}")
        
        try:
            # Use modelo rápido para rascunhos, premium para finais
            model = "seedance-2.0" if config.get("final") else "seedance-1.5"
            job_id = generate_video(config["prompt"], model=model)
            url = wait_for_completion(job_id)
            
            results.append({
                "name": config["name"],
                "url": url,
                "status": "success"
            })
            print(f"  ✓ {url}")
            
        except Exception as e:
            results.append({
                "name": config["name"],
                "error": str(e),
                "status": "failed"
            })
            print(f"  ✗ Falhou: {e}")
        
        # Pequeno atraso entre envios
        time.sleep(2)
    
    # Salvar resultados
    with open(f"{output_dir}/results.json", "w") as f:
        json.dump(results, f, indent=2)
    
    return results

# Exemplo de uso
prompts = [
    {"name": "hero-shot", "prompt": "...", "final": True},
    {"name": "product-demo", "prompt": "...", "final": False},
]
results = batch_generate(prompts)

Perguntas Frequentes

A Seedance 2.0 tem uma API pública oficial?

A Seedance oferece acesso à API como parte dos planos pagos. Verifique a documentação do desenvolvedor em seedance.tv para obter detalhes atuais de acesso e especificações de endpoints.

Como funciona o preço?

O uso da API consome seu saldo de créditos. Diferentes modelos custam diferentes quantidades de créditos por geração. Verifique seu painel para as taxas de crédito atuais por modelo.

Qual é o tempo de geração por vídeo?

Normalmente de 30 segundos a 3 minutos, dependendo da complexidade do modelo e da carga da fila. Seedance 1.5 é mais rápido; Seedance 2.0 leva mais tempo, mas produz maior qualidade.

Posso gerar vídeos com mais de 10 segundos?

Atualmente não com uma única chamada de API. Para conteúdo mais longo, gere múltiplos clipes e junte-os em sua aplicação usando uma biblioteca de processamento de vídeo como moviepy ou ffmpeg.

A saída é adequada para uso comercial?

Verifique os termos de serviço atuais em seedance.tv para detalhes de licenciamento comercial. Geralmente, o conteúdo gerado em planos pagos é licenciado para uso comercial.

Como a API Seedance se compara à API da Runway?

A API da Runway ($0,05-0,10/segundo) oferece controles de câmera mais avançados e o modelo Gen-3 Alpha. A API Seedance usa preços baseados em créditos, que são mais previsíveis para planejamento de orçamento. A Runway vence em polimento cinematográfico e controle de câmera; a Seedance vence em variedade de modelos e clareza de preços. Para a maioria dos desenvolvedores, experimente ambas no seu caso de uso específico — os resultados variam significativamente por tipo de conteúdo.

---

Comece a Construir

Pronto para integrar vídeo com IA na sua aplicação?

Cadastre-se na Seedance → — obtenha créditos gratuitos para testar a API, planos pagos a partir de $9,9/mês.

• Playground de Texto para Vídeo — teste prompts antes de construir
• Playground de Imagem para Vídeo — teste animação de imagem
• Detalhes do modelo Seedance 2.0 — benchmarks de qualidade e especificações