Kling 3.0 texto a video: clips cortos con audio nativo

La mayoría de las demostraciones de "texto a video" se quedan en un clip sin sonido. Con kling-3.0/text-to-video en hiapi no es así: renderiza audio nativo y con sincronización labial directamente durante la generación, y es el único nivel de Kling 3.0 que admite hasta 4K. Para contenido de formato corto (Reels, TikTok, Shorts), esta combinación —composición vertical, sonido ambiente real y ningún paso separado de TTS o doblaje— elimina todo un paso de postproducción.

Este artículo recorre el flujo de trabajo real: primero genera un solo clip mediante la API /v1/tasks, luego escala a lotes de clips con código asíncrono y, por último, los niveles de precios con los que debes presupuestar.

Qué añade kling-3.0/text-to-video frente al nivel turbo

hiapi ejecuta en paralelo dos series de video de Kling 3.0: kling-3.0-turbo/text-to-video y el kling-3.0/text-to-video simple que trata este artículo. El nivel turbo es más rápido, tiene un límite de 1080p y siempre incluye sonido, sin interruptor que lo controle. El nivel simple cambia parte de esa velocidad por:

• Audio nativo sincronizado: el booleano sound en la solicitud. Cuando es true, hiapi.ai renderiza voz y sonido ambiente que coinciden con la acción de la imagen, no una pista musical pegada a la fuerza.
• Límite de 4K: resolution acepta 720p, 1080p o 4K, mientras que turbo se limita a 1080p.
• El mismo rango de duración: ambos van de 3 a 15 segundos, justo la ventana que premian las plataformas de formato corto.

Si necesitas un bucle de fondo sin sonido, usa este nivel y desactiva sound: $0.10/segundo en 720p, por debajo de los $0.13/segundo de Turbo. Si el clip debe sonar como si alguien hablara a cámara —como ocurre en la mayoría del contenido de formato corto—, este nivel lo consigue en una sola solicitud.

Generar un solo clip

El modelo está en el endpoint asíncrono /v1/tasks de hiapi: envía la tarea, consulta el estado de finalización y luego obtén la URL de salida (caduca, así que descárgala de inmediato).

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 es el prompt y la configuración exactos detrás del clip de abajo: vertical, 6 segundos, 720p, audio activado ($0.86).

Prompt: "Clip de video vertical 9:16 de formato corto: una creadora graba con su smartphone una toma rápida al estilo de reseña de producto, gestos enérgicos con las manos, iluminación interior natural, encuadre informal hablando a cámara, movimiento realista y movimiento de labios, tono ambiental de la habitación y audio de voz sincronizado con la acción"

Escalar a lotes: con código asíncrono, no con un bucle secuencial

Un solo clip es una solicitud. Una semana de contenido de formato corto son diez o veinte. Consultar cada tarea una por una en un bucle for funciona, pero serializa tiempos de espera que no necesitan ser seriales: la API acepta encantada envíos concurrentes. Usa asyncio y aiohttp para lanzarlas juntas:

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 tarea se ejecuta de forma independiente en el servidor, así que el tiempo real de tres clips se acerca al de uno solo, en lugar de triplicarse. Para lotes más grandes, limita la concurrencia con asyncio.Semaphore para no desbordar tus propios límites de velocidad.

Cuánto cuesta

El precio de kling-3.0/text-to-video se escalona por resolución y por el interruptor sound, no es una tarifa fija única: no apliques el precio fijo por segundo del nivel turbo, estas dos rutas se tarifican por separado:

• 720p, sin audio: $0.10/segundo
• 720p + sound:true: $0.143/segundo
• 1080p, sin audio: $0.129/segundo
• 1080p + sound:true: $0.193/segundo
• 4K: $0.479/segundo

Un clip de 6 segundos en 1080p con audio cuesta aproximadamente $1.16; el clip de 720p con audio de arriba cuesta $0.86. Un lote de 10 clips con la misma configuración ronda los $11.60, algo que conviene contrastar con tu propio panel de precios antes de poner en cola una ejecución a gran escala, porque cada campo (resolución, duración, audio) afecta al total de forma independiente. Si vas a comparar con otros niveles de Kling, consulta el desglose completo en la página de precios de Kling 3.0.

Consideraciones para producir formato corto

Más allá de "activar el audio", hay varias cosas que realmente afectan a la retención:

• Mantén duration entre 6 y 10 segundos. El modelo admite hasta 15 segundos, pero la mayoría de los ganchos de formato corto atrapan o pierden al espectador en los primeros segundos: clips más ajustados te obligan a escribir prompts más ajustados.
• Escribe el audio en el prompt, no lo des por sentado. Textos como "audio de voz sincronizado con la acción" o "ruido ambiental de calle" en el prompt guían lo que sound:true renderiza realmente: un prompt sin pistas de audio puede devolver un clip anormalmente silencioso.
• Usa aspect_ratio: "9:16" de principio a fin. No generes en 16:9 y recortes después; cuando pides vertical directamente, el modelo compone los planos de forma distinta para el encuadre vertical (posición de las manos, espacio sobre la cabeza, profundidad del fondo).
• Genera en lote variantes del mismo gancho, no clips inconexos. La generación asíncrona abarata probar 3 o 4 variantes de redacción de un concepto de gancho y elegir la mejor, en lugar de enviar un solo prompt por idea.

Preguntas frecuentes

¿kling-3.0/text-to-video admite 9:16 de forma nativa o tengo que recortar un render en 16:9? De forma nativa: aspect_ratio acepta 9:16 directamente en la solicitud, y el modelo compone los planos para vertical desde el principio.

¿El audio es diálogo o sonido ambiente real, o una pista de fondo genérica? Se genera según la escena: cuando el prompt describe a alguien hablando, la voz se sincroniza con el movimiento de los labios; el sonido ambiente (habitación, calle, etc.) sigue la escena descrita en el prompt. No es una cama de música de stock.

Para uso en formato corto, ¿en qué se diferencia de kling-3.0-turbo? Turbo es más rápido y se limita a 1080p. No tiene campo sound, pero los clips siempre incluyen sonido. Usa turbo cuando necesites b-roll rápido y su sonido integrado sea suficiente; usa este nivel cuando necesites salida sin sonido o cuando el clip deba sonar como algo concreto (sobre todo, contenido hablando a cámara).

¿Puedo generar una semana de clips sin esperar uno por uno de forma secuencial? Sí: envía todas las solicitudes de creación de tareas de forma concurrente (véase el ejemplo de lote asíncrono de arriba) y luego consúltalas también de forma concurrente. La API no exige enviar de una en una.

¿Qué pasa si no descargo la URL de salida de inmediato? La URL de salida tiene caducidad (expireAt). En cuanto la tarea informe success, descarga los bytes de inmediato y guárdalos por tu cuenta: no pongas la URL de enlace directo en ningún lugar persistente.

Consulta la referencia completa de campos y los precios en tiempo real en la página del modelo kling-3.0/text-to-video.