Kling 3.0 text-to-video: clip brevi con audio nativo

La maggior parte delle demo di "text-to-video" si ferma a una clip muta. kling-3.0/text-to-video su hiapi non è così: esegue il rendering di audio nativo e sincronizzato con il labiale direttamente durante la generazione, ed è l'unica fascia di Kling 3.0 che supporta fino al 4K. Per i contenuti short-form (Reels, TikTok, Shorts), questa combinazione — inquadratura verticale, suono ambientale reale, nessuna fase separata di TTS/doppiaggio — elimina un intero passaggio di post-produzione.

Questo articolo percorre il flusso di lavoro reale: prima la generazione di una singola clip tramite l'API /v1/tasks, poi l'estensione a clip in batch con codice asincrono, e infine le fasce di prezzo su cui basare il budget.

Cosa offre kling-3.0/text-to-video in più rispetto alla fascia turbo

hiapi gestisce in parallelo due serie video di Kling 3.0: kling-3.0-turbo/text-to-video e il semplice kling-3.0/text-to-video descritto in questo articolo. La fascia turbo è più veloce, ha un limite massimo di 1080p e include sempre l'audio, senza alcun interruttore per controllarlo. La fascia semplice scambia un po' di velocità per:

• Audio nativo sincronizzato — un booleano sound nella richiesta. Quando è true, hiapi.ai/ esegue il rendering di voce e suoni ambientali che corrispondono all'azione visiva, invece di una colonna sonora applicata a forza.
• Limite 4K — resolution accetta 720p, 1080p o 4K, mentre turbo si ferma a 1080p.
• Stessa gamma di durata — entrambe da 3 a 15 secondi, esattamente la finestra premiata dalle piattaforme short-form.

Se ti serve un loop di sfondo muto, usa questa fascia e disattiva sound: a 720p costa $0.10/secondo, meno dei $0.13/secondo di Turbo. Se la clip deve suonare come qualcuno che parla davanti alla camera — il caso della maggior parte dei contenuti short-form — questa fascia lo fa in un'unica richiesta.

Generare una singola clip

Il modello risiede sull'endpoint asincrono /v1/tasks di hiapi: invii il task, ne controlli lo stato di completamento e poi recuperi l'URL di output (scade, quindi scaricalo subito).

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)

Questi sono esattamente il prompt e le impostazioni dietro la clip qui sotto: verticale, 6 secondi, 720p, audio attivo ($0.86).

Prompt: "Clip video verticale 9:16 in formato breve: un creator riprende con uno smartphone una rapida ripresa in stile recensione prodotto, gesti energici delle mani, illuminazione naturale da interni, inquadratura informale mentre parla alla camera, movimento e movimento labiale realistici, suono ambientale della stanza e audio del parlato sincronizzati all'azione"

Scalare al batch: con codice asincrono, non con un ciclo sequenziale

Una singola clip è una richiesta. Una settimana di contenuti short-form sono dieci o venti clip. Controllare ogni task uno alla volta in un ciclo for funziona, ma serializza attese che non hanno bisogno di essere seriali: l'API accetta volentieri invii concorrenti. Invia tutto insieme con 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))

Ogni task viene eseguito in modo indipendente lato server, quindi il tempo effettivo per tre clip è vicino a quello di una sola clip, non il triplo. Per batch più grandi, limita la concorrenza con asyncio.Semaphore per non saturare i tuoi stessi limiti di frequenza.

Quanto costa

Il prezzo di kling-3.0/text-to-video è suddiviso per risoluzione e interruttore sound, non è una tariffa fissa unica: non applicare il prezzo fisso al secondo della fascia turbo, queste due rotte hanno prezzi distinti:

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

Una clip 1080p da 6 secondi con audio costa circa $1.16; la clip 720p con audio qui sopra costa $0.86. Un batch di 10 clip con le stesse impostazioni costa circa $11.60: vale la pena verificarlo rispetto alla tua dashboard dei prezzi prima di mettere in coda esecuzioni su larga scala, perché ogni campo (risoluzione, durata, audio) influisce sul totale in modo indipendente. Se stai confrontando con altre fasce di Kling, consulta il dettaglio completo nella pagina dei prezzi di Kling 3.0.

Note per la produzione short-form

Oltre ad "attivare l'audio", alcune cose influenzano davvero la retention:

• Mantieni duration tra 6 e 10 secondi. Il modello supporta fino a 15 secondi, ma la maggior parte degli hook short-form cattura o perde lo spettatore nei primi secondi: clip più compatte ti costringono a scrivere prompt più compatti.
• Includi l'audio nel prompt, non darlo per scontato. Testo come "audio del parlato sincronizzato all'azione" o "rumore ambientale della strada" nel prompt guida ciò che sound:true renderizza effettivamente: un prompt senza indizi audio può comunque restituire una clip insolitamente silenziosa.
• Usa aspect_ratio: "9:16" dall'inizio alla fine. Non generare in 16:9 per poi ritagliare; quando chiedi direttamente il verticale, il modello compone le inquadrature diversamente per il formato verticale (posizione delle mani, spazio sopra la testa, profondità dello sfondo).
• Genera in batch varianti dello stesso hook, non clip non correlate. La generazione asincrona rende economico provare 3-4 varianti di formulazione di un concetto di hook e scegliere la migliore, invece di inviare un solo prompt per idea.

Domande frequenti

kling-3.0/text-to-video supporta nativamente il 9:16 o devo ritagliare un render 16:9? Supporto nativo: aspect_ratio accetta direttamente 9:16 nella richiesta e il modello compone le inquadrature per il verticale fin dall'inizio.

L'audio è vero parlato/suono ambientale o una traccia di sottofondo generica? Viene generato in base alla scena: quando il prompt descrive qualcuno che parla, la voce è sincronizzata con il movimento labiale; i suoni ambientali (stanza, strada, ecc.) seguono la scena descritta nel prompt. Non è una base musicale di stock.

Per l'uso short-form, in cosa differisce da kling-3.0-turbo? Turbo è più veloce e ha un limite di 1080p. Non ha il campo sound, ma le clip includono sempre l'audio. Usa turbo quando ti serve b-roll rapido e il suo audio integrato è abbastanza buono; usa questa fascia quando ti serve un output muto o quando la clip deve suonare come qualcosa di specifico (soprattutto parlato alla camera).

Posso generare una settimana di clip senza attendere una per una in sequenza? Sì: invia tutte le richieste di creazione task in modo concorrente (vedi l'esempio batch asincrono sopra), poi controllale anch'esse in concorrenza. L'API non richiede di inviare un task alla volta.

Cosa succede se non scarico subito l'URL di output? Gli URL di output hanno una scadenza (expireAt). Appena il task riporta success, scarica subito i byte e archiviali tu stesso: non inserire URL hotlink in nessuna posizione persistente.

Per il riferimento completo dei campi e i prezzi aggiornati, consulta la pagina del modello kling-3.0/text-to-video.