Kling 3.0 Text-zu-Video: Kurzvideoclips mit nativem Audio

Die meisten „Text-zu-Video“-Demos enden bei einem stummen Clip. kling-3.0/text-to-video auf hiapi tut das nicht – es rendert natives, lippensynchrones Audio direkt während der Generierung und ist die einzige Kling-3.0-Stufe, die bis zu 4K unterstützt. Für Kurzform-Inhalte (Reels, TikTok, Shorts) erspart diese Kombination – vertikale Bildkomposition, echte Umgebungsgeräusche, kein separater TTS-/Voiceover-Schritt – einen ganzen Postproduktionsschritt.

Dieser Artikel geht den praktischen Workflow durch: zuerst einen einzelnen Clip über die /v1/tasks-API generieren, dann mit asynchronem Code auf Batch-Clips skalieren und schließlich die Preisstufen, mit denen du kalkulieren musst.

Was kling-3.0/text-to-video gegenüber der Turbo-Stufe zusätzlich bietet

hiapi betreibt zwei Kling-3.0-Videoserien parallel: kling-3.0-turbo/text-to-video und das hier behandelte reine kling-3.0/text-to-video. Die Turbo-Stufe ist schneller, auf 1080p begrenzt und bringt immer eigenen Ton mit, ohne Schalter zur Steuerung. Die reine Stufe tauscht etwas Geschwindigkeit gegen:

• Natives synchrones Audio – ein sound-Boolean in der Anfrage. Bei true rendert hiapi.ai Sprache und Umgebungsgeräusche, die zur Bildaktion passen, statt nachträglich aufgeklebter Musik.
• 4K-Obergrenze – resolution akzeptiert 720p, 1080p oder 4K, während Turbo auf 1080p begrenzt ist.
• Gleicher Dauerbereich – beide reichen von 3 bis 15 Sekunden, genau das Fenster, das Kurzform-Plattformen belohnen.

Wenn du eine stumme Hintergrundschleife brauchst, nutze diese Stufe und schalte sound aus: $0.10/Sekunde bei 720p, günstiger als Turbo mit $0.13/Sekunde. Wenn der Clip klingen soll, als würde jemand zur Kamera sprechen – was bei den meisten Kurzform-Inhalten der Fall ist –, erledigt diese Stufe das in einer einzigen Anfrage.

Einen einzelnen Clip generieren

Das Modell liegt auf hiapis asynchronem /v1/tasks-Endpunkt: Aufgabe einreichen, Fertigstellung abfragen, dann die Ausgabe-URL abrufen (sie läuft ab, also sofort herunterladen).

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="Vertikaler 9:16-Kurzform-Videoclip: ein Creator, der mit einem Smartphone einen schnellen Take im Produktbewertungs-Stil aufnimmt, energische Handgesten, natürliches Innenlicht, lockere Talking-Head-Komposition zur Kamera, realistische Bewegung und Lippenbewegung, Raumumgebungston und Sprachaudio synchron zur Aktion",
    duration=6,
    resolution="720p",
    aspect_ratio="9:16",
    sound=True,
)
video_url = wait_for_clip(task_id)

Das ist der exakte Prompt und die Einstellungen hinter dem Clip unten – vertikal, 6 Sekunden, 720p, Audio an ($0.86).

Prompt: „Vertikaler 9:16-Kurzvideoclip: Creator nimmt mit dem Smartphone einen schnellen Take im Produktbewertungs-Stil auf, dynamische Gesten, natürliches Innenlicht, lockere Komposition beim Sprechen zur Kamera, realistische Bewegung und Lippenbewegung, Raumumgebungston und synchron zur Aktion abgestimmtes Sprach-Audio“

Auf Batch skalieren: asynchroner Code statt sequenzieller Schleife

Ein einzelner Clip ist eine Anfrage. Eine Woche Kurzform-Inhalte sind zehn oder zwanzig. Jede Aufgabe einzeln in einer for-Schleife abzufragen funktioniert, serialisiert aber Wartezeiten, die nicht serialisiert werden müssten – die API nimmt gleichzeitige Einreichungen bereitwillig an. Verwende stattdessen asyncio und aiohttp und schicke sie gemeinsam raus:

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 = [
    "Vertikaler 9:16-Clip: Creator packt vor der Kamera ein Paket aus, begeisterte Reaktion, "
    "weiches Fensterlicht, Sprache synchron zur Lippenbewegung",
    "Vertikaler 9:16-Clip: Creator geht durch eine Stadtstraße und spricht zur Kamera, "
    "B-Roll-artige Komposition, Umgebungsgeräusche der Straße",
    "Vertikaler 9:16-Clip: Creator demonstriert eine Skincare-Routine in Nahaufnahme, ruhiges "
    "Narrations-Audio, natürliches Badezimmerlicht",
]
urls = asyncio.run(produce_batch(prompts))

Jede Aufgabe läuft serverseitig unabhängig, sodass drei Clips ungefähr so lange dauern wie einer statt dreimal so lang. Bei größeren Batches begrenze die Nebenläufigkeit mit asyncio.Semaphore, damit du deine eigenen Rate-Limits nicht überrennst.

Was kostet es

Die Preisgestaltung von kling-3.0/text-to-video ist nach Auflösung und sound-Schalter gestaffelt, nicht ein einziger Festpreis – übernimm nicht den festen Sekundenpreis der Turbo-Stufe, diese beiden Routen werden getrennt bepreist:

• 720p, ohne Audio: $0.10/Sekunde
• 720p + sound:true: $0.143/Sekunde
• 1080p, ohne Audio: $0.129/Sekunde
• 1080p + sound:true: $0.193/Sekunde
• 4K: $0.479/Sekunde

Ein 6-Sekunden-1080p-Clip mit Audio kostet etwa $1.16; der 720p-Clip mit Audio oben kostet $0.86. Ein Batch von 10 Clips mit denselben Einstellungen liegt bei etwa $11.60 – das lohnt sich, vor dem Start großer Läufe gegen dein eigenes Preis-Dashboard zu prüfen, denn jedes Feld (Auflösung, Dauer, Audio) wirkt unabhängig auf den Gesamtpreis. Wenn du mit anderen Kling-Stufen vergleichen willst, schau dir die vollständige Aufschlüsselung auf der Kling-3.0-Preisseite an.

Hinweise zur Kurzform-Produktion

Neben „Audio einschalten“ gibt es ein paar Dinge, die die Retention wirklich beeinflussen:

• Halte duration bei 6-10 Sekunden. Das Modell unterstützt bis zu 15 Sekunden, aber die meisten Kurzform-Hooks fangen oder verlieren Zuschauer in den ersten Sekunden – kompaktere Clips zwingen dich zu kompakteren Prompts.
• Schreibe Audio in den Prompt, verlasse dich nicht darauf. „Sprachaudio synchron zur Aktion“ oder „Umgebungsgeräusche der Straße“ im Prompt-Text lenken, was sound:true tatsächlich rendert – Prompts ohne Audio-Hinweise können trotzdem ungewöhnlich stille Clips zurückgeben.
• aspect_ratio: "9:16" durchgängig verwenden. Generiere nicht 16:9 und schneide dann zu; wenn du direkt vertikal anforderst, inszeniert das Modell die Aufnahme anders für vertikale Komposition (Handpositionen, Kopfraum, Hintergrundtiefe).
• Generiere Varianten desselben Hooks im Batch, nicht unzusammenhängende Clips. Asynchrone Generierung macht es günstig, 3-4 Formulierungsvarianten eines Hook-Konzepts auszuprobieren und die beste auszuwählen, statt pro Idee nur einen Prompt einzureichen.

Häufige Fragen

Unterstützt kling-3.0/text-to-video 9:16 nativ, oder muss ich ein 16:9-Render zuschneiden? Nativ – aspect_ratio akzeptiert 9:16 direkt in der Anfrage, und das Modell inszeniert von Anfang an für vertikale Komposition.

Ist das Audio echte Sprache/Umgebungsgeräusche oder eine generische Hintergrundspur? Es wird szenengeneriert: Wenn der Prompt beschreibt, dass jemand spricht, ist die Sprache mit der Lippenbewegung synchron; Umgebungsgeräusche (Raum, Straße usw.) folgen der im Prompt beschriebenen Szene. Es ist keine Stock-Musikbett.

Worin unterscheidet sich das für Kurzform-Zwecke von kling-3.0-turbo? Turbo ist schneller und auf 1080p begrenzt. Es hat kein sound-Feld, aber Clips bringen immer eigenen Ton mit. Nutze Turbo, wenn du schnelles B-Roll brauchst und dessen eingebauter Ton gut genug ist; nutze diese Stufe, wenn du stumme Ausgabe brauchst oder der Clip nach etwas Bestimmtem klingen soll (besonders Inhalte, die zur Kamera sprechen).

Kann ich eine Woche voller Clips generieren, ohne sequenziell auf jeden zu warten? Ja – reiche alle Create-Task-Anfragen gleichzeitig ein (siehe asynchrones Batch-Beispiel oben) und frage sie dann ebenfalls gleichzeitig ab. Die API verlangt nicht, dass du nur eine auf einmal einreichst.

Was passiert, wenn ich die Ausgabe-URL nicht sofort herunterlade? Ausgabe-URLs sind zeitlich begrenzt (expireAt). Sobald eine Aufgabe success meldet, lade die Bytes sofort herunter und speichere sie selbst – setze Hotlink-URLs nirgendwo dauerhaft ein.

Die vollständige Feldreferenz und Live-Preise findest du auf der kling-3.0/text-to-video-Modellseite.