API Pro do Seedance 1.0: Endpoint de Geração de Vídeos Profissional

Se você está construindo vídeo em um produto, fluxo de trabalho ou pipeline, a interface web eventualmente se torna um gargalo. A API Seedance 1.0 Pro é o mesmo modelo por trás da interface, exposto como um endpoint REST limpo com autenticação por token de portador, preços previsíveis por segundo e polling de trabalho simples. Este guia cobre tudo que você precisa para colocá-lo em produção.

RESUMO

• API REST para geração de vídeo nativo 1080p Seedance 1.0 Pro
• Autenticação: token de portador do seu painel de conta
• Faturamento: por segundo a $0,24/seg ($0,12 base × margem 2x)
• Padrão: enviar trabalho → pesquisar status → baixar MP4
• Melhor para: integrações SaaS, pipelines em lote, automação, produtos white-label

O que a API oferece

Tudo o que a interface web Seedance 1.0 Pro oferece, disponível programaticamente:

• Geração de vídeo a partir de imagem com URL de imagem de origem
• Prompt de movimento para direcionar a animação
• Controle de duração de 2 a 12 segundos
• Controle de quadro final para transições direcionadas
• Bloqueio de câmera ativável
• Polling de trabalho para status e URL de resultado
• Saída MP4 em 1080p nativo

Use-o para produtos SaaS que precisam de geração de vídeo integrada, pipelines internos de agências, fluxos de trabalho de produção em lote ou automação de tarefas de vídeo repetitivas.

Autenticação

Todas as chamadas de API são autenticadas com um token de portador. Gere um no painel da sua conta Arteza em arteza.ai.

Authorization: Bearer YOUR_API_KEY

Regras de segurança:

• Nunca confirme chaves de API no controle de origem
• Reveze as chaves regularmente
• Use variáveis de ambiente ou um gerenciador de segredos
• Restrinja as chaves a origens específicas se possível

Os endpoints principais

Enviar um trabalho de geração

POST /v1/seedance-1-pro/generate

Corpo da solicitação:

{
  "source_image_url": "https://your-cdn.com/source.jpg",
  "prompt": "Slow camera push-in on the subject, warm golden hour light, shallow depth of field",
  "duration_seconds": 6,
  "camera_lock": false,
  "end_frame_url": null
}

Parâmetros:

Resposta:

{
  "job_id": "job_abc123xyz",
  "status": "queued",
  "created_at": "2026-04-10T12:00:00Z",
  "estimated_seconds": 90
}

Verificar o status do trabalho

GET /v1/seedance-1-pro/status/{job_id}

Resposta (em andamento):

{
  "job_id": "job_abc123xyz",
  "status": "processing",
  "progress": 0.45,
  "created_at": "2026-04-10T12:00:00Z"
}

Resposta (completo):

{
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "resolution": "1920x1080",
  "credits_charged": 144
}

Valores de status possíveis: queued, processing, completed, failed

Baixar o resultado

Assim que o status for completed, o video_url aponta para um arquivo MP4 1080p. Baixe-o imediatamente e armazene-o em sua própria infraestrutura - não dependa da URL ser válida indefinidamente.

Um exemplo Python completo

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1/seedance-1-pro"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(source_image_url, prompt, duration=6, camera_lock=False, end_frame=None):
    payload = {
        "source_image_url": source_image_url,
        "prompt": prompt,
        "duration_seconds": duration,
        "camera_lock": camera_lock,
    }
    if end_frame:
        payload["end_frame_url"] = end_frame
    
    response = requests.post(f"{BASE_URL}/generate", headers=HEADERS, json=payload)
    response.raise_for_status()
    return response.json()["job_id"]

def wait_for_completion(job_id, poll_interval=5, timeout=300):
    start = time.time()
    while time.time() - start < timeout:
        r = requests.get(f"{BASE_URL}/status/{job_id}", headers=HEADERS)
        r.raise_for_status()
        data = r.json()
        
        if data["status"] == "completed":
            return data["video_url"]
        if data["status"] == "failed":
            raise RuntimeError(f"Job failed: {data.get('error', 'unknown')}")
        
        time.sleep(poll_interval)
    
    raise TimeoutError(f"Job {job_id} did not complete within {timeout}s")

def download_video(url, output_path):
    response = requests.get(url, stream=True)
    response.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

# Use it
job_id = generate_video(
    source_image_url="https://example.com/product.jpg",
    prompt="Slow camera orbit around the product, studio lighting, 6 seconds",
    duration=6,
    camera_lock=True
)

video_url = wait_for_completion(job_id)
download_video(video_url, "output.mp4")
print(f"Video saved to output.mp4")

Um exemplo Node.js completo

import fs from 'fs';
import fetch from 'node-fetch';

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = 'https://api.arteza.ai/v1/seedance-1-pro';
const HEADERS = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

async function generateVideo(opts) {
  const response = await fetch(`${BASE_URL}/generate`, {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(opts)
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const data = await response.json();
  return data.job_id;
}

async function waitForCompletion(jobId, { pollInterval = 5000, timeout = 300000 } = {}) {
  const start = Date.now();
  while (Date.now() - start < timeout) {
    const r = await fetch(`${BASE_URL}/status/${jobId}`, { headers: HEADERS });
    const data = await r.json();
    if (data.status === 'completed') return data.video_url;
    if (data.status === 'failed') throw new Error(`Job failed: ${data.error}`);
    await new Promise(res => setTimeout(res, pollInterval));
  }
  throw new Error('Timeout');
}

async function downloadVideo(url, path) {
  const response = await fetch(url);
  const buffer = await response.buffer();
  fs.writeFileSync(path, buffer);
}

// Use it
const jobId = await generateVideo({
  source_image_url: 'https://example.com/product.jpg',
  prompt: 'Slow camera orbit around the product, studio lighting, 6 seconds',
  duration_seconds: 6,
  camera_lock: true
});

const videoUrl = await waitForCompletion(jobId);
await downloadVideo(videoUrl, 'output.mp4');
console.log('Saved output.mp4');

Quer qualidade broadcast como esta? Experimente Seedance 1.0 Pro grátis →

Preços e faturamento

Taxa: $0,24 por segundo de vídeo de saída (24 créditos/segundo)

Os créditos são deduzidos apenas em gerações bem-sucedidas. Trabalhos com falha não consomem créditos.

Os pacotes de créditos são os mesmos da interface web: $10 / $25 / $50 / $100. Veja o página de preços.

Limites de taxa e concorrência

Contas padrão têm limites de taxa adequados para cargas de trabalho de integração típicas. Para produção de alto volume, entre em contato com o suporte para limites aumentados.

Orientação geral:

• 5 a 10 trabalhos simultâneos é confiável para a maioria das contas
• Backoff exponencial em respostas HTTP 429
• Tentativas em nível de trabalho em falhas transitórias (até 3 tentativas)
• Callbacks de webhook disponíveis para evitar polling excessivo

Webhooks (opcional)

Em vez de fazer polling, registre uma URL de webhook nas configurações da sua conta ou por solicitação. Quando um trabalho é concluído, a Arteza envia um POST para sua URL:

{
  "event": "job.completed",
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "credits_charged": 144,
  "timestamp": "2026-04-10T12:02:15Z"
}

Os webhooks são assinados com uma assinatura HMAC no cabeçalho X-Seedance-Signature. Verifique antes de confiar na carga útil.

Tratamento de erros

A API retorna códigos de status HTTP padrão:

Os corpos de resposta de erro incluem um campo error com uma mensagem legível por humanos e um campo code para tratamento programático.

{
  "error": "Source image URL could not be fetched",
  "code": "source_image_unreachable"
}

Requisitos de imagem de entrada

• Formatos: PNG, JPEG, WebP
• Tamanho: até 10 MB por imagem
• Resolução: mínimo 512x512, quanto maior melhor (1080p+ recomendado)
• Acesso à URL: deve ser acessível publicamente pelos servidores Arteza (sem localhost, sem autenticação)

Para imagens privadas, carregue-as em uma URL S3 assinada, CloudFront ou similar, e passe a URL assinada na solicitação.

Melhores práticas

1. Armazene saídas em sua própria infraestrutura. Não confie em URLs da Arteza a longo prazo.
2. Registre tudo. IDs de trabalho, prompts, cronogramas, transições de status, erros.
3. Tente novamente erros transitórios. Soluços de rede e respostas 5xx devem tentar novamente com backoff exponencial.
4. Valide entradas cedo. Verifique URLs de imagem e intervalos de parâmetros antes de enviar.
5. Monitore saldo de créditos. Alerte quando cair abaixo de um limite.
6. Use webhooks para produção. Polling é bom para pequenas cargas de trabalho, mas ineficiente em escala.
7. Cache gerações idênticas. Se um usuário enviar a mesma imagem + prompt duas vezes, retorne a URL em cache.

Testes e preparação

Comece cada integração com a camada de crédito de $10 (1.050 créditos). Isso é suficiente para várias dezenas de gerações de teste. Construa e teste sua integração end-to-end antes de se comprometer com camadas de volume mais alto.

Casos de uso

• Plataformas SaaS - deixe seus usuários gerarem vídeo a partir de seus próprios ativos
• E-commerce - gere vídeos de movimento de produtos a partir de imagens do catálogo
• Imóvel - automatize a produção de vídeo de listagem a partir de fotos
• Automação de marketing - vídeo personalizado em escala
• Plataformas de conteúdo - enriqueça artigos, listagens ou postagens sociais com vídeo gerado
• Ferramentas de vídeo white-label - construa seu próprio produto de vídeo AI no backend da Arteza

Leitura relacionada

• Fluxos de processamento em lote
• Guia completo do Seedance 1.0 Pro
• Seedance 1.0 Pro para agências
• Guia da API do Seedance 2.0

Perguntas frequentes

Posso usar a API para aplicações comerciais? Sim, toda a saída é liberada para uso comercial.

O que acontece se a geração falhar? Nenhum crédito é cobrado em gerações com falha.

Por quanto tempo os vídeos gerados são hospedados? Os vídeos estão disponíveis para download por um período de tempo após a geração. Baixe e armazene prontamente.

Vocês suportam bibliotecas SDK? SDKs comunitários para Python e Node estão disponíveis. Veja a documentação do desenvolvedor em arteza.ai.

Posso cancelar um trabalho em andamento? Sim, envie DELETE /v1/seedance-1-pro/jobs/{job_id}. Os créditos não são cobrados em trabalhos cancelados.

Como obtenho suporte? Envie um email para o suporte através do painel da sua conta para problemas específicos da API.

---

A API Seedance 1.0 Pro é o caminho pronto para produção para incorporar geração de vídeo AI 1080p em seu produto ou pipeline.

Obtenha sua chave de API e comece a construir → com 50 créditos grátis inclusos no registro.