Kling 3.0 texto para vídeo: clipes curtos com áudio nativo

A maioria das demonstrações de "texto para vídeo" para por aí, num clipe sem som. O kling-3.0/text-to-video no hiapi não é assim — ele renderiza áudio nativo e com sincronia labial diretamente durante a geração, e é a única variante do Kling 3.0 que suporta até 4K. Para conteúdo de formato curto (Reels, TikTok, Shorts), essa combinação — enquadramento vertical, som ambiente real, sem etapa separada de TTS/dublagem — elimina uma etapa inteira de pós-produção.

Este artigo percorre o fluxo de trabalho real: primeiro gerar um clipe único via API /v1/tasks, depois escalar para clipes em lote com código assíncrono, e por fim as faixas de preço com as quais você precisa fazer seu orçamento.

O que kling-3.0/text-to-video adiciona em relação à variante turbo

O hiapi executa duas séries de vídeo Kling 3.0 em paralelo: kling-3.0-turbo/text-to-video, e a variante base kling-3.0/text-to-video descrita neste artigo. A variante turbo é mais rápida, tem limite de 1080p e sempre inclui som, sem opção para controlar. A variante base troca parte da velocidade por:

• Áudio nativo sincronizado — o booleano sound na requisição. Quando é true, o hiapi.ai/ renderiza fala e som ambiente compatíveis com a ação da imagem, em vez de uma trilha sonora colada artificialmente.
• Limite de 4K — resolution aceita 720p, 1080p ou 4K, enquanto a turbo tem limite de 1080p.
• Mesma faixa de duração — ambas vão de 3 a 15 segundos, que é exatamente a janela que as plataformas de formato curto valorizam.

Se você precisa de um loop de fundo sem som, use esta variante e desligue sound: $0.10/segundo em 720p, abaixo dos $0.13/segundo da Turbo. Se o clipe precisa soar como alguém falando para a câmera — o que vale para a maior parte do conteúdo de formato curto — esta variante faz isso em uma única requisição.

Gerar um único clipe

O modelo fica no endpoint assíncrono /v1/tasks do hiapi: envie a tarefa, faça polling do status de conclusão e então busque a URL de saída (ela expira, então baixe imediatamente).

import os
import time
import requests

API_BASE = "https://api.hiapi.ai/v1/tasks"
TOKEN = os.environ["HIAPI_API_KEY"]
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}


def create_clip(prompt: str, duration: int, resolution: str, aspect_ratio: str, sound: bool) -> str:
    body = {
        "model": "kling-3.0/text-to-video",
        "input": {
            "prompt": prompt,
            "duration": duration,
            "resolution": resolution,
            "aspect_ratio": aspect_ratio,
            "sound": sound,
        },
    }
    resp = requests.post(API_BASE, headers=HEADERS, json=body, timeout=30)
    resp.raise_for_status()
    return resp.json()["data"]["taskId"]


def wait_for_clip(task_id: str, poll_every: int = 5, timeout: int = 600) -> str:
    deadline = time.time() + timeout
    while time.time() < deadline:
        resp = requests.get(f"{API_BASE}/{task_id}", headers=HEADERS, timeout=30)
        resp.raise_for_status()
        data = resp.json()["data"]
        if data["status"] == "success":
            return data["output"][0]["url"]
        if data["status"] == "fail":
            raise RuntimeError(data.get("error"))
        time.sleep(poll_every)
    raise TimeoutError(f"task {task_id} did not finish in {timeout}s")


task_id = create_clip(
    prompt="Vertical 9:16 short-form video clip: a creator filming a quick "
           "product-review style take with a smartphone, energetic hand gestures, "
           "natural indoor lighting, casual talking-to-camera framing, realistic "
           "motion and lip movement, ambient room tone and speech audio synced to "
           "the action",
    duration=6,
    resolution="720p",
    aspect_ratio="9:16",
    sound=True,
)
video_url = wait_for_clip(task_id)

Este é o prompt e as configurações exatas por trás do clipe abaixo — vertical, 6 segundos, 720p, áudio ativado ($0.86).

Prompt: "Vertical 9:16 short-form video clip: a creator filming a quick product-review style take with a smartphone, energetic hand gestures, natural indoor lighting, casual talking-to-camera framing, realistic motion and lip movement, ambient room tone and speech audio synced to the action"

Escalar para lote: com código assíncrono, não laço sequencial

Um único clipe é uma requisição. Uma semana de conteúdo de formato curto são dez ou vinte. Fazer polling de cada tarefa uma após a outra num laço for funciona, mas serializa esperas que não precisam ser serializadas — a API aceita envios concorrentes com prazer. Em vez disso, dispare tudo junto com asyncio e aiohttp:

import asyncio
import os
import aiohttp

API_BASE = "https://api.hiapi.ai/v1/tasks"
TOKEN = os.environ["HIAPI_API_KEY"]
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}


async def create_task(session, prompt, duration=6, resolution="1080p",
                       aspect_ratio="9:16", sound=True):
    body = {
        "model": "kling-3.0/text-to-video",
        "input": {"prompt": prompt, "duration": duration, "resolution": resolution,
                   "aspect_ratio": aspect_ratio, "sound": sound},
    }
    async with session.post(API_BASE, json=body) as resp:
        resp.raise_for_status()
        data = await resp.json()
        return data["data"]["taskId"]


async def poll_task(session, task_id, poll_every=5, timeout=600):
    loop = asyncio.get_event_loop()
    deadline = loop.time() + timeout
    while loop.time() < deadline:
        async with session.get(f"{API_BASE}/{task_id}") as resp:
            resp.raise_for_status()
            data = (await resp.json())["data"]
        if data["status"] == "success":
            return data["output"][0]["url"]
        if data["status"] == "fail":
            raise RuntimeError(data.get("error"))
        await asyncio.sleep(poll_every)
    raise TimeoutError(f"task {task_id} timed out")


async def produce_batch(prompts: list[str]) -> list[str]:
    async with aiohttp.ClientSession(headers=HEADERS) as session:
        task_ids = await asyncio.gather(*(create_task(session, p) for p in prompts))
        return await asyncio.gather(*(poll_task(session, tid) for tid in task_ids))


prompts = [
    "Vertical 9:16 clip: creator unboxing a package on camera, excited reaction, "
    "soft window light, speech synced to lip movement",
    "Vertical 9:16 clip: creator walking through a city street talking to camera, "
    "b-roll style framing, ambient street audio",
    "Vertical 9:16 clip: creator demoing a skincare routine close-up, calm "
    "narration audio, natural bathroom lighting",
]
urls = asyncio.run(produce_batch(prompts))

Cada tarefa roda de forma independente no servidor, então o tempo real de três clipes fica próximo ao de um clipe, em vez de três vezes mais longo. Para lotes maiores, limite a concorrência com asyncio.Semaphore para não estourar seus próprios limites de taxa.

Quanto custa

O preço do kling-3.0/text-to-video é dividido por resolução e pelo interruptor sound, e não é uma tarifa fixa única — não reaproveite o preço fixo por segundo da variante turbo, essas duas rotas têm preços separados:

• 720p, sem áudio: $0.10/segundo
• 720p + sound:true: $0.143/segundo
• 1080p, sem áudio: $0.129/segundo
• 1080p + sound:true: $0.193/segundo
• 4K: $0.479/segundo

Um clipe de 6 segundos em 1080p com áudio custa cerca de $1.16; o clipe em 720p com áudio acima custa $0.86. Um lote de 10 clipes com as mesmas configurações fica em torno de $11.60 — vale a pena conferir no seu próprio painel de preços antes de enfileirar uma execução em larga escala, porque cada campo (resolução, duração, áudio) afeta o total de forma independente. Se você quiser comparar com outras variantes do Kling, veja o detalhamento completo na página de preços do Kling 3.0.

Observações para produção de formato curto

Além de "ligar o áudio", algumas coisas realmente afetam a retenção:

• Mantenha duration entre 6 e 10 segundos. O modelo suporta até 15 segundos, mas a maioria dos ganchos de formato curto prende ou perde o espectador nos primeiros segundos — clipes mais enxutos forçam você a escrever prompts mais enxutos.
• Escreva o áudio no prompt, não presuma. "Áudio de fala sincronizado com a ação" ou "ruído ambiente de rua" no texto do prompt orientam o que sound:true realmente renderiza — prompts sem pistas de áudio ainda podem retornar clipes estranhamente silenciosos.
• Use aspect_ratio: "9:16" de ponta a ponta. Não gere em 16:9 e depois corte; quando você pede vertical diretamente, o modelo faz um enquadramento diferente para a composição vertical (posição das mãos, espaço acima da cabeça, profundidade do fundo).
• Gere variações do mesmo gancho em lote, em vez de clipes não relacionados. A geração assíncrona torna barato testar 3-4 variações de redação de um conceito de gancho e escolher a melhor versão, em vez de enviar um único prompt por ideia.

Perguntas frequentes

O kling-3.0/text-to-video suporta 9:16 nativamente, ou preciso cortar uma renderização em 16:9? Suporta nativamente — aspect_ratio aceita 9:16 diretamente na requisição, e o modelo enquadra para composição vertical desde o início.

O áudio é fala/som ambiente real, ou uma trilha de fundo genérica? Ele é gerado de acordo com a cena: quando o prompt descreve alguém falando, a fala sincroniza com o movimento labial; sons ambientes (sala, rua etc.) acompanham a cena descrita no prompt. Não é uma trilha de música de banco de áudio.

Para uso em formato curto, como isso difere do kling-3.0-turbo? A Turbo é mais rápida e tem limite de 1080p. Ela não tem o campo sound, mas os clipes sempre incluem som. Use a turbo quando precisar de b-roll rápido e o som embutido dela for suficiente; use esta variante quando precisar de saída sem som ou quando o clipe precisar soar como algo específico (especialmente conteúdo falado para a câmera).

Consigo gerar uma semana de clipes sem esperar um por um na ordem? Sim — envie concorrentemente todas as requisições de criação de tarefa (veja o exemplo de lote assíncrono acima) e depois faça polling delas também em concorrência. A API não exige enviar uma por vez.

O que acontece se eu não baixar a URL de saída imediatamente? As URLs de saída têm prazo de validade (expireAt). Assim que a tarefa reportar success, baixe os bytes imediatamente e armazene por conta própria — não coloque URLs de hotlink em nenhum local persistente.

Veja a referência completa de campos e o preço em tempo real na página do modelo kling-3.0/text-to-video.