Kling 3.0 texte-vers-vidéo : clips courts avec audio natif

La plupart des démonstrations de « texte-vers-vidéo » s'arrêtent à un clip muet. Sur hiapi, kling-3.0/text-to-video ne fonctionne pas ainsi : il restitue directement un audio natif et synchronisé sur les lèvres pendant la génération, et c'est le seul palier Kling 3.0 qui prend en charge jusqu'à la 4K. Pour le contenu court (Reels, TikTok, Shorts), cette combinaison — cadrage vertical, son d'ambiance réel, aucune étape TTS/doublage séparée — élimine toute une étape de post-production.

Cet article parcourt le flux de travail réel : d'abord générer un seul clip via l'API /v1/tasks, puis passer à l'échelle avec du code asynchrone pour des lots de clips, et enfin les paliers tarifaires sur lesquels baser votre budget.

Ce que kling-3.0/text-to-video apporte de plus que le palier turbo

hiapi exploite deux séries de vidéos Kling 3.0 en parallèle : kling-3.0-turbo/text-to-video, et le kling-3.0/text-to-video brut présenté ici. Le palier turbo est plus rapide, plafonne à 1080p et inclut toujours le son, sans interrupteur pour le contrôler. Le palier brut échange une partie de la vitesse contre :

• Audio natif synchronisé — le booléen sound dans la requête. Lorsqu'il vaut true, hiapi.ai/ restitue la parole et les sons d'ambiance correspondant à l'action à l'écran, et non une musique plaquée.
• Plafond 4K — resolution accepte 720p, 1080p ou 4K, tandis que turbo plafonne à 1080p.
• Plage de durée identique — les deux vont de 3 à 15 secondes, exactement la fenêtre que récompensent les plateformes de contenu court.

Si vous avez besoin d'une boucle d'arrière-plan muette, utilisez ce palier en désactivant sound : 0,10 $/seconde en 720p, moins que les 0,13 $/seconde de Turbo. Si le clip doit donner l'impression que quelqu'un parle face caméra — ce qui est le cas de la plupart des contenus courts — ce palier le fait en une seule requête.

Générer un seul clip

Le modèle se trouve sur le point de terminaison asynchrone /v1/tasks de hiapi : soumettez la tâche, interrogez l'état d'achèvement, puis récupérez l'URL de sortie (elle expire, donc téléchargez immédiatement).

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)

Voici exactement le prompt et les réglages derrière le clip ci-dessous — vertical, 6 secondes, 720p, audio activé (0,86 $).

Prompt : « Clip vidéo court vertical 9:16 : un créateur filme avec un smartphone une prise rapide de type avis produit, gestes énergiques, éclairage intérieur naturel, cadrage décontracté face caméra, mouvements et mouvements des lèvres réalistes, son d'ambiance de la pièce et audio de parole synchronisés avec l'action »

Passer à l'échelle : code asynchrone plutôt qu'une boucle séquentielle

Un seul clip, c'est une requête. Le contenu court d'une semaine, c'est dix ou vingt clips. Interroger chaque tâche une par une dans une boucle for fonctionne, mais sérialise un temps d'attente qui n'a pas besoin de l'être — l'API accepte volontiers les soumissions concurrentes. Utilisez plutôt asyncio et aiohttp pour tout envoyer en même temps :

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))

Chaque tâche s'exécute indépendamment côté serveur, donc le temps réel de trois clips est proche de celui d'un seul clip, et non trois fois plus long. Pour des lots plus importants, limitez la concurrence avec asyncio.Semaphore afin de ne pas saturer vos propres limites de débit.

Combien cela coûte

La tarification de kling-3.0/text-to-video dépend de la résolution et de l'interrupteur sound, et non d'un tarif fixe unique — n'appliquez pas le prix fixe par seconde du palier turbo, ces deux routes sont tarifées séparément :

• 720p, sans audio : 0,10 $/seconde
• 720p + sound:true : 0,143 $/seconde
• 1080p, sans audio : 0,129 $/seconde
• 1080p + sound:true : 0,193 $/seconde
• 4K : 0,479 $/seconde

Un clip de 6 secondes en 1080p avec audio coûte environ 1,16 $ ; le clip 720p avec audio ci-dessus coûte 0,86 $. Un lot de 10 clips avec les mêmes réglages revient à environ 11,60 $ — cela vaut la peine de le vérifier par rapport à votre propre tableau de bord de tarification avant de lancer des exécutions à grande échelle, car chaque champ (résolution, durée, audio) influence indépendamment le prix total. Si vous voulez comparer avec d'autres paliers Kling, consultez le détail complet sur la page de tarification Kling 3.0.

Points d'attention pour la production de contenu court

Au-delà de « activer l'audio », plusieurs choses influencent réellement la rétention :

• Gardez duration entre 6 et 10 secondes. Le modèle prend en charge jusqu'à 15 secondes, mais la plupart des accroches de contenu court gagnent ou perdent le spectateur dans les premières secondes — un clip plus serré vous oblige à écrire des prompts plus serrés.
• Écrivez l'audio dans le prompt, ne le supposez pas. Des expressions comme « audio de parole synchronisé avec l'action » ou « bruits de rue ambiants » dans le texte du prompt orientent ce que sound:true restitue réellement — un prompt sans indication audio peut tout de même renvoyer un clip anormalement silencieux.
• Utilisez aspect_ratio: "9:16" de bout en bout. Ne générez pas en 16:9 puis recadrez ; lorsque vous demandez directement du vertical, le modèle compose différemment pour un cadrage vertical (position des mains, espace au-dessus de la tête, profondeur de l'arrière-plan).
• Générez en lot des variantes de la même accroche, plutôt que des clips sans rapport. La génération asynchrone permet de tester 3 à 4 formulations d'un même concept d'accroche et de choisir la meilleure à moindre coût, au lieu de soumettre un seul prompt par idée.

Questions fréquentes

kling-3.0/text-to-video prend-il en charge le 9:16 nativement, ou dois-je recadrer un rendu 16:9 ? Nativement — aspect_ratio accepte directement 9:16 dans la requête, et le modèle compose dès le départ pour un cadrage vertical.

L'audio est-il de la vraie parole/son d'ambiance, ou une piste de fond générique ? Il est généré en fonction de la scène : lorsque le prompt décrit quelqu'un en train de parler, la parole est synchronisée avec les mouvements des lèvres ; les sons d'ambiance (pièce, rue, etc.) suivent la scène décrite dans le prompt. Ce n'est pas une nappe musicale de stock.

Pour un usage en contenu court, en quoi cela diffère-t-il de kling-3.0-turbo ? Turbo est plus rapide et plafonne à 1080p. Il n'a pas de champ sound, mais les clips incluent toujours le son. Utilisez turbo lorsque vous avez besoin de b-roll rapide et que son son intégré suffit ; utilisez ce palier lorsque vous avez besoin d'une sortie muette, ou que le clip doit sonner comme un contenu précis (surtout quelqu'un qui parle face caméra).

Puis-je générer une semaine de clips sans attendre un par un ? Oui — soumettez toutes les requêtes de création de tâches en concurrence (voir l'exemple de lot asynchrone ci-dessus), puis interrogez-les également en concurrence. L'API n'exige pas une soumission à la fois.

Que se passe-t-il si je ne télécharge pas immédiatement l'URL de sortie ? L'URL de sortie a une durée de validité limitée (expireAt). Dès que la tâche indique success, téléchargez immédiatement les octets et stockez-les vous-même — ne placez pas une URL de lien direct dans un emplacement persistant.

Référence complète des champs et tarification en temps réel sur la page du modèle kling-3.0/text-to-video.