Criando vídeos curtos com seedance-2.0-mini: fluxo de trabalho ponta a ponta na API hiapi

TL;DR

• O que é: um fluxo de trabalho ponta a ponta para produzir vídeos curtos verticais no estilo TikTok/Reels com seedance-2.0-mini na API hiapi — desde a primeira chamada curl até um script que renderiza uma semana inteira de conteúdo em lote. O clipe de demonstração desta página foi gerado exatamente com as requisições mostradas no texto.
• Por que escolher este modelo para vídeos curtos: suporte nativo a 9:16, áudio sincronizado integrado (sem necessidade de tratamento de som separado), duração flexível entre 4 e 15 segundos, e rascunho em 480p custa apenas $0,0272 por segundo — um rascunho vertical de 4 segundos sai por cerca de $0,11 (preços).
• Fatos da API verificados: prompt, duration (inteiro de 4 a 15) e resolution (480p | 720p) são obrigatórios; aspect_ratio aceita 1:1, 4:3, 3:4, 16:9, 9:16, 21:9, adaptive. Para imagem-para-vídeo, use first_frame_url / last_frame_url. O esquema é estrito — campos desconhecidos como seed são rejeitados com 400.
• Fluxo de trabalho: gere em 480p para iterar prompts, re-renderize os clipes aprovados em 720p e envie tarefas em lote e em paralelo — a fila assíncrona /v1/tasks faz o fan-out por você.

Por que seedance-2.0-mini é ideal para o ciclo de vídeos curtos

A produção de vídeos curtos é um trabalho quantitativo: você rascunha muitos clipes, mantém poucos e publica diariamente. Esse fluxo de trabalho exige que uma API de vídeo faça três coisas — iteração de baixo custo, saída vertical e som — e o seedance-2.0-mini atende exatamente às três:

• Custo por rascunho baixo o suficiente para iterar repetidamente. Em 480p, o modelo cobra $0,0272 por segundo de saída, então um rascunho de 4 segundos custa cerca de $0,11, e mesmo um clipe completo de 15 segundos sai por apenas cerca de $0,41. A faixa de 720p é $0,0586/s. (Preços verificados na página de preços ao vivo; vídeos são cobrados por segundo, então duration é sua alavanca de custo.)
• 9:16 nativo. Renderiza vertical diretamente, em vez de cortar um clipe horizontal e perder a composição.
• Áudio sincronizado nativo. O MP4 de saída já vem com uma faixa AAC gerada junto com a cena — som ambiente, foley, ruído de fundo da sala. Para conteúdo de feed que toca com som automaticamente, isso elimina uma etapa inteira de edição.

Se você quiser um modelo irmão maior para conteúdo de destaque, o mesmo fluxo de trabalho se aplica ao seedance-2-0 — apenas com faixas de preço diferentes.

Configuração

Você só precisa de uma chave de API da hiapi, nada mais — sem SDK. Guarde a chave em uma variável de ambiente:

export HIAPI_API_KEY="sk-..."

Todos os modelos de vídeo da hiapi rodam pelo endpoint unificado de tarefas assíncronas: POST https://api.hiapi.ai/v1/tasks retorna um taskId imediatamente, e então você faz polling em GET /v1/tasks/{taskId} até concluir. Detalhes na documentação.

Seu primeiro clipe vertical (T2V)

A requisição mínima válida exige prompt, duration e resolution. Para vídeo curto, adicione aspect_ratio: "9:16":

curl -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-mini",
    "input": {
      "prompt": "Vídeo curto vertical. Sobre o balcão de um café banhado de sol, um matcha latte fresco é lentamente despejado em um copo de vidro transparente, redemoinhos verdes florescem entre o leite, luz suave de janela, profundidade de campo rasa. Áudio nativo: ambiente suave de café, som de líquido sendo despejado. Nítido, apetitoso, fotorrealista.",
      "duration": 4,
      "resolution": "480p",
      "aspect_ratio": "9:16"
    }
  }'

A resposta retorna imediatamente:

{"code": 200, "data": {"taskId": "tk-hiapi-01KWTTFDPHSDWZ0FP1QAS5J79Q"}, "message": "success"}

Faça polling da tarefa até que status seja success e então baixe imediatamente output[0].url — as URLs de saída são temporárias e expiram. Segue o clipe real gerado por essa requisição (4 segundos, 480p, 9:16, com áudio nativo de despejo e ambiente — ative o som para ouvir):

Duas dicas práticas desta renderização: a saída vertical "480p" mediu 496×864 pixels na prática, e o áudio entra no MP4 como faixa AAC padrão — sem necessidade de composição de arquivo separado.

Modos de entrada, verificados contra a API ao vivo

O esquema é estrito. Seguem as respostas reais de validação, reproduzidas literalmente para que você possa reconhecê-las nos logs:

Campo	Tipo	Obrigatório	Valores
prompt	string	✅ (comprimento mínimo 3)	Descrição do seu plano
duration	integer	✅	4–15 (segundos)
resolution	string	✅	480p, 720p
aspect_ratio	string	Opcional	1:1, 4:3, 3:4, 16:9, 9:16, 21:9, adaptive
first_frame_url	string	Opcional	URL da imagem do quadro inicial para I2V
last_frame_url	string	Opcional	URL da imagem para controle do quadro final
image_input	array	Opcional	Referência de imagem multimodal
reference_video_urls	array	Opcional	Vídeo de referência de estilo/movimento (tarifa por segundo menor)

Omitir um campo obrigatório faz com que a tarefa seja rejeitada antes da criação (sem cobrança):

{"code": 400, "error_code": "INVALID_REQUEST", "message": "invalid input: resolution: missing required field \"resolution\"; duration: missing required field \"duration\""}

Valores fora dos limites indicam o limite exato — duration: maximum: got 16, want 15 — e campos desconhecidos são rejeitados em vez de ignorados:

{"code": 400, "error_code": "INVALID_REQUEST", "message": "invalid input: <root>: additional properties 'seed' not allowed"}

Vale internalizar esse último comportamento: se você reaproveitar a estrutura de requisição de outro modelo (um seed, um size, uma flag audio), o seedance-2.0-mini retorna 400 em vez de descartar silenciosamente o campo.

Função Python reutilizável

Tudo o que você precisa para produção cabe em cerca de 40 linhas — envio, polling, download:

import os, time, requests

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"}

def submit(prompt: str, duration: int = 4, resolution: str = "480p",
           aspect_ratio: str = "9:16", **extra) -> str:
    r = requests.post(API, headers=HEADERS, json={
        "model": "seedance-2.0-mini",
        "input": {"prompt": prompt, "duration": duration,
                  "resolution": resolution, "aspect_ratio": aspect_ratio, **extra},
    }, timeout=60)
    data = r.json()
    task_id = (data.get("data") or {}).get("taskId")
    if not task_id:
        raise RuntimeError(f"submit failed: {data}")
    return task_id

def wait(task_id: str, timeout_s: int = 900) -> dict:
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        task = requests.get(f"{API}/{task_id}", headers=HEADERS, timeout=30).json()["data"]
        if task["status"] == "success":
            return task
        if task["status"] == "fail":
            raise RuntimeError(f"task failed: {task.get('error')}")
        time.sleep(8)
    raise TimeoutError(task_id)

def make_clip(prompt: str, out_path: str, **kw):
    task = wait(submit(prompt, **kw))
    url = task["output"][0]["url"]          # URL temporária — baixe imediatamente
    with open(out_path, "wb") as f:
        f.write(requests.get(url, timeout=120).content)

Um clipe de 4 segundos em 480p costuma ficar pronto em poucos minutos; em horários de pico, reserve até cerca de 10 minutos antes de considerar timeout.

Imagem-para-vídeo: travando o primeiro quadro

Para clipes orientados a produto, a deriva do prompt é o inimigo — você quer o seu produto no quadro, não a imaginação do modelo sobre ele. A solução é I2V com first_frame_url: gere (ou fotografe) um quadro estático e então anime-o. Um quadro de referência vertical como este, produzido com gpt-image-2 pelo mesmo endpoint /v1/tasks, é ótimo como quadro inicial:

A requisição só precisa adicionar um campo:

task_id = submit(
    "Água quente despejada lentamente em círculos por cima, vapor começa a subir do porta-filtro de café coado, "
    "gotas caem no jarro de vidro abaixo, luz do sol realçando o vapor. Movimento lento e suave de aproximação. "
    "Áudio nativo: som delicado de fluxo de água, ruído de fundo de manhã silenciosa.",
    duration=4, resolution="480p", aspect_ratio="9:16",
    first_frame_url="https://your-cdn.example/pourover-ref.jpg",
)

A seguir, o efeito real da animação do primeiro quadro — um quadro estático da nossa biblioteca de receitas seedance-2.0-mini e o clipe gerado a partir dele, mesmo modelo e estrutura de requisição (neste caso, 16:9):

A composição, a paleta e o sujeito ficam travados no seu quadro estático; o prompt só precisa descrever o movimento. Se você precisar que o clipe termine em um quadro final específico, há também last_frame_url — útil para loops que voltam ao card de produto.

Produzindo uma semana de conteúdo em lote

Como /v1/tasks é assíncrono, produzir em lote é simplesmente: enviar todas as tarefas e depois fazer polling. Sem fila no cliente.

briefs = [
    ("mon-hook",  "Clipe vertical. Café expresso extraindo lentamente, ……"),
    ("tue-loop",  "Clipe vertical em loop contínuo. Vapor subindo da xícara, ……"),
    ("wed-recipe","Clipe vertical. Sequência de preparo de café coado vista de cima, ……"),
    # …… um por dia de publicação
]

tasks = {name: submit(p, duration=6) for name, p in briefs}   # fan-out
for name, tid in tasks.items():                                 # coleta
    make = wait(tid)
    url = make["output"][0]["url"]
    open(f"{name}.mp4", "wb").write(requests.get(url, timeout=120).content)

O cálculo de custo permanece previsível porque a cobrança é por segundo de saída:

Cenário	Especificação	Custo
1 iteração de rascunho	4 s · 480p	≈ $0,11
1 clipe pronto para publicar	6 s · 480p	≈ $0,16
7 clipes (uma semana, um por dia)	7 × 6 s · 480p	≈ $1,14
Re-renderização do destaque	6 s · 720p	≈ $0,35

Um fluxo de trabalho que funciona bem: rascunhe cada ideia primeiro em 480p, mantenha as vencedoras e re-renderize apenas essas em 720p. Para mais alavancas (faixas de resolução, corte de duração, agendamento em lote), consulte nosso guia sobre como controlar os custos de APIs de imagem e vídeo com IA.

Dicas de prompt para o feed

O que funcionou nas nossas renderizações de teste, ajustado para vídeos curtos:

• Diga "vertical" e componha para isso. Comece com "Vídeo curto vertical." e adicione aspect_ratio: "9:16", fazendo o sujeito centralizar no quadro alto em vez de enquadrar uma cena horizontal que será cortada.
• Coloque o gancho no primeiro segundo. O feed decide no primeiro segundo — faça da ação inicial a própria recompensa (o despejo já em andamento, o vapor já subindo), não um plano de estabelecimento lento.
• Escreva o roteiro de áudio. Uma frase "Áudio nativo: ……" listando 2–3 sons concretos (despejo de líquido, ambiente de café) molda a faixa de áudio de forma confiável. Sem esse prompt, você só terá o ruído genérico de fundo da sala.
• Para clipes em loop, minimize a variação entre início e fim. Partículas à deriva, brilho pulsante, vapor ondulante — descreva um movimento em estado estacionário, e os quadros inicial e final ficarão próximos o suficiente para fazer o loop.

Resumo

Produzir vídeos curtos com seedance-2.0-mini se resume a um endpoint assíncrono, três campos obrigatórios e uma cobrança por segundo que torna a iteração barata: rascunhe clipes verticais em 480p por cerca de vinte e cinco centavos cada, trave tomadas de produto com first_frame_url, envie seu calendário de publicação em lote e re-renderize os mantidos em 720p. Obtenha uma chave de API e comece pela requisição curl de 4 segundos acima — a página do modelo seedance-2.0-mini tem a referência de parâmetros e preços ao vivo para continuar a partir daí.