FLUX 3 Max para vídeos curtos: um modo por plano, processamento em lote via API

O FLUX 3 Max oferece três endpoints de vídeo no hiapi, e para trabalhos de vídeo curto a pergunta útil não é "qual é o melhor", mas "qual serve para este plano". Este guia percorre uma pequena campanha vertical (três clipes 9:16 para um post de uma cafeteria de matcha gelado), usando um modo diferente para cada plano, com os três enviados como um único lote paralelo; cada clipe mostrado abaixo é uma saída real e não editada.

Se você precisa da referência completa de parâmetros e das explicações de erros de validação, leia primeiro o guia da API do FLUX 3 Max. Este artigo assume que você já consegue enviar tarefas e foca no fluxo de trabalho de vídeos curtos.

Escolha o modo por plano, não por projeto

Uma edição de vídeo curto normalmente é composta por um gancho, uma batida de produto e um fechamento. Essas batidas têm entradas diferentes, portanto correspondem a ids diferentes do FLUX 3 Max:

Plano na edição	O que você tem em mãos	Use	Entrada principal
Gancho / B-roll	Apenas uma ideia	flux-3-max/text-to-video	prompt
Batida de produto	Uma foto de produto aprovada que não pode ser alterada	flux-3-max/image-to-video	image_url (string única), opcionalmente end_image_url
Transição / fechamento	Duas cenas que você quer conectar	flux-3-max/keyframes-to-video	keyframes: [{image_url, frame_index}]

Os três compartilham duration (5–20 segundos), resolution (720p / 1080p), aspect_ratio (defina 9:16 para vertical) e generate_audio. Como o corpo da requisição é praticamente idêntico, um único script de lote consegue enviar os três. Páginas dos modelos: texto para vídeo, imagem para vídeo, keyframes para vídeo.

Plano 1: o gancho, só com texto

O gancho precisa de movimento já no primeiro segundo e não tem exigência de material específico, então texto para vídeo é a escolha certa.

{
  "model": "flux-3-max/text-to-video",
  "input": {
    "prompt": "Close-up vertical feito à mão: barista despeja leite frio em um matcha gelado num copo de vidro alto e transparente, verde e branco se entrelaçam e giram em câmera lenta, luz da manhã atravessa a janela da cafeteria, profundidade de campo rasa, som nítido de gelo batendo, ambiente suave de cafeteria.",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
    "generate_audio": true
  }
}

Resultado retornado: o despejo começa no primeiro quadro e, ao final, o redemoinho preenche o copo, exatamente o que o gancho precisa. O que texto para vídeo não consegue fazer é corresponder ao seu cenário: pedi uma cafeteria, o modelo escolheu um balcão de madeira, enquanto a minha foto de produto (o próximo plano) usava mármore. Para o gancho isso é aceitável. Para planos que precisam corresponder aos ativos da marca, use um dos modos de imagem.

Plano 2: a batida de produto, ancorada numa imagem estática

Esta é a foto de produto aprovada. Ela foi gerada previamente como uma imagem estática 9:16 e passada ao modelo como primeiro quadro.

{
  "model": "flux-3-max/image-to-video",
  "input": {
    "prompt": "Avanço lento em direção ao copo; o redemoinho de leite se desloca e assenta, o gelo se move levemente, a luz cintila suavemente no balcão de mármore, a folha de hortelã permanece imóvel. Ambiente sonoro tranquilo de cafeteria.",
    "image_url": "https://static.hiapi.ai/blog/flux-3-max-short-form-video/still-a.jpg",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
    "generate_audio": true
  }
}

A composição permanece travada: o mesmo copo, o mesmo ramo de hortelã, o mesmo mármore e a mesma luz da janela do começo ao fim. Porém o movimento é contido. O avanço que pedi mal se percebe em 5 segundos, e a maior parte do movimento está no líquido e na luz. Para uma batida de produto esse é um bom resultado, porque você quer que o plano de produto permaneça fiel. Se quiser um movimento de câmera mais forte, dê mais segundos ou reforce no prompt, e verifique o resultado antes de ampliar o lote.

Observe o nome do campo: image-to-video aceita uma única string image_url. Passar um array image_urls (como alguns outros modelos de vídeo do hiapi esperam) será rejeitado no envio.

Plano 3: o fechamento, com dois keyframes

O fechamento conecta a cafeteria e a rua. Eu tenho uma segunda imagem estática da mesma bebida erguida ao ar livre e usei as duas como keyframes.

{
  "model": "flux-3-max/keyframes-to-video",
  "input": {
    "prompt": "Plano contínuo: uma mão pega o matcha gelado no balcão da cafeteria e o leva para fora, terminando erguido em direção ao céu azul claro numa rua ensolarada. Câmera na mão suave, luz natural transitando do interior quente para a luz do dia intensa.",
    "keyframes": [
      {"image_url": "https://static.hiapi.ai/blog/flux-3-max-short-form-video/still-a.jpg", "frame_index": 0},
      {"image_url": "https://static.hiapi.ai/blog/flux-3-max-short-form-video/still-b.jpg", "frame_index": 120}
    ],
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
    "generate_audio": true
  }
}

frame_index conta quadros a 24 fps, então um clipe de 5 segundos vai de 0 a 120. Colocando as âncoras em 0 e 120, o clipe começa exatamente no plano do balcão e termina exatamente no plano da rua. Entre os dois, o modelo inventou sozinho uma transição: no meio do clipe, a mão segura o copo na porta, e então a rua aparece. Esse é o trade-off dos keyframes. Você controla os momentos ancorados, e o modelo preenche o resto. Se o meio precisa ser de um jeito específico, adicione um terceiro keyframe (até 10 são permitidos).

Processamento em lote: um script, três modos, em paralelo

Trabalho com vídeos curtos significa muitas variantes, então envie tudo primeiro e faça polling depois. Este é o script que usei, enxugado:

import json, os, time, requests
from concurrent.futures import ThreadPoolExecutor

API = "https://api.hiapi.ai/v1/tasks"
HEAD = {"Authorization": f"Bearer {os.environ['HIAPI_KEY']}"}
BASE = {"duration": 5, "resolution": "720p", "aspect_ratio": "9:16", "generate_audio": True}

jobs = {
    "hook":    ("flux-3-max/text-to-video",      {"prompt": HOOK_PROMPT}),
    "product": ("flux-3-max/image-to-video",     {"prompt": PRODUCT_PROMPT, "image_url": STILL_A}),
    "payoff":  ("flux-3-max/keyframes-to-video", {"prompt": PAYOFF_PROMPT, "keyframes": [
                    {"image_url": STILL_A, "frame_index": 0},
                    {"image_url": STILL_B, "frame_index": 120}]}),
}

def run(name):
    model, extra = jobs[name]
    r = requests.post(API, headers=HEAD, json={"model": model, "input": {**BASE, **extra}}).json()
    task_id = r["data"]["taskId"]          # save this before polling
    deadline = time.time() + 900
    while time.time() < deadline:
        time.sleep(10)
        d = requests.get(f"{API}/{task_id}", headers=HEAD).json()["data"]
        if d["status"] == "success":
            url = d["output"][0]["url"]
            open(f"{name}.mp4", "wb").write(requests.get(url).content)  # download now
            return name, "success"
        if d["status"] == "fail":
            return name, d.get("error")
    return name, f"timeout {task_id}"

with ThreadPoolExecutor(len(jobs)) as pool:
    for result in pool.map(run, jobs):
        print(result)

Em 3 de novembro de 2026, o que vi quando enviei os três de uma vez:

• Cada POST /v1/tasks retornou um taskId em menos de 2 segundos.
• O polling mostrou cada tarefa passando pela mesma sequência: handling, depois archiving, depois success.
• Os registros das tarefas mostraram os três clipes levando 20 segundos de created a completed. Executá-los em paralelo não levou mais tempo do que executar um.
• Cada saída é um arquivo H.264 de 5,04 segundos, 704 × 1280, 24 fps, com faixa de áudio AAC. Atenção à largura: 9:16 em 720p dá 704 px, não 720. Se o seu template de editor exige exatamente 720 × 1280, redimensione ou preencha ao importar.
• As URLs de saída ficam num domínio temporário, com expireAt de 7 dias após a conclusão. Baixe e armazene os arquivos por conta própria imediatamente.

Para lotes maiores (dezenas de variantes de gancho), use o callback da API de tarefas com when: "final", assim você dispensa o polling, e registre cada taskId para não perder trabalho já pago em caso de queda.

Custo do lote

O FLUX 3 Max cobra por segundo de saída, por resolução, com a mesma tarifa nos três modos. Em novembro de 2026, a página de preços lista 720p a $0.0608/segundo e 1080p a $0.1036/segundo. A página do modelo indica que o áudio e a quantidade de keyframes não afetam o preço.

Cenário	Por clipe	Lote de três clipes
5 segundos, 720p (o que executei)	$0.304	$0.912
5 segundos, 1080p	$0.518	$1.554
15 segundos, 1080p	$1.554	$4.662

Ciclo prático: teste prompts em 5 segundos e 720p, guarde os vencedores e renderize apenas eles em 1080p ou mais longos. Para detalhes de tarifas, consulte preços da API do FLUX 3 Max.

Checklist para vídeos curtos

1. Primeiro escreva a edição em planos, depois atribua um modo a cada plano usando a tabela acima.
2. Faça as imagens estáticas também em 9:16. Os modos de imagem animam o quadro que você fornece, então uma imagem estática horizontal já é um problema de composição desde o início.
3. Defina aspect_ratio: "9:16" explicitamente em cada requisição, em vez de depender de auto.
4. Mantenha as imagens de keyframe visualmente consistentes (mesmo produto, mesma família de iluminação) e valide frame_index ≤ duration × 24 antes de enviar. Uma linha do tempo errada é aceita no envio e falha instantes depois.
5. Envie em paralelo, faça polling ou use callback, e baixe imediatamente.
6. Mantenha o áudio ligado na fase de rascunho. Não custa extra, e você pode silenciar na edição.

Para ideias de prompts além desta campanha, consulte o guia de prompts de vídeo do FLUX 3 Max. Para usar o mesmo fluxo de trabalho em outro modelo, compare o fluxo de trabalho de vídeos curtos de imagem para vídeo do Kling 3.0.

Perguntas frequentes

O FLUX 3 Max consegue criar vídeos verticais 9:16? Consegue. Os três endpoints aceitam aspect_ratio: "9:16". Em 720p, a saída que obtive foi 704 × 1280.

Qual modo do FLUX 3 Max devo usar para vídeos de produto? Use imagem para vídeo quando a foto do produto precisar permanecer exatamente como aprovada. No meu teste, o copo, a decoração e o fundo permaneceram idênticos durante todo o clipe. Use keyframes quando o produto precisar se mover entre duas cenas.

Quanto tempo leva para gerar um clipe do FLUX 3 Max? Na minha execução, três clipes de 5 segundos em 720p enviados juntos levaram 20 segundos cada, de created a completed. Clipes mais longos ou em 1080p podem levar mais tempo; não cronometrei esses.

É possível misturar texto para vídeo, imagem para vídeo e keyframes no mesmo lote? É possível. São ids de modelo independentes no mesmo endpoint /v1/tasks, que compartilham os mesmos campos, então um único script consegue enviá-los lado a lado.

Qual é a duração máxima de um clipe curto do FLUX 3 Max? Entre 5 e 20 segundos, em segundos inteiros. O custo cresce linearmente com a duração.

Comece a construir

Escolha o plano de que você mais precisa, abra a página do modelo correspondente (texto para vídeo, imagem para vídeo ou keyframes para vídeo), e execute um teste de 5 segundos em 720p antes de processar o restante da edição em lote.