Kurzvideos mit Kling 3.0 Image-to-Video über die HiAPI-API erstellen

Kurzvideos sind ein Format, das jede Content-Pipeline irgendwann unterstützen muss, und der günstigste Weg, sie zuverlässig in großem Umfang zu produzieren, ist Image-to-Video: Man nimmt ein Standbild, das man bereits unter Kontrolle hat – ein Produktfoto, ein Charakterdesign, ein generiertes Keyframe – und lässt ein Videomodell es in Bewegung setzen. Der Image-to-Video-Endpunkt von Kling 3.0 auf HiAPI glänzt hierbei und bietet eine Funktion, die die meisten i2v-Modelle überspringen: Man kann sowohl ein Start- als auch ein Endbild angeben, sodass das Modell die Animation zwischen zwei Zuständen erzeugt und nicht nur aus einem einzelnen Frame Bewegung extrapoliert.

Dieses Tutorial baut einen vollständigen, skriptfähigen Workflow: ein Startbild generieren, es an die asynchrone Task-API von Kling 3.0 übermitteln, bis zur Fertigstellung pollen und einen fertigen Clip mit nativem, synchronem Audio herunterladen – alles über gewöhnliche HTTP-Aufrufe, die sich direkt in Batch-Jobs einfügen lassen.

Warum Image-to-Video statt Text-to-Video

Text-to-Video liefert jedes Mal eine Überraschung. Image-to-Video gibt dir einen Ausgangspunkt, den du bereits abgesegnet hast – und das zählt, wenn dieser Frame ein Produktfoto, eine Markenfigur oder irgendetwas ist, das vor der Bewegung auf eine bestimmte Weise aussehen muss. Das Image-to-Video-Modell von Kling 3.0 treibt das mit Start- und Endbild-Steuerung noch weiter: Übergibst du ein Referenzbild, behandelt das Modell es nur als Ausgangspunkt; übergibst du zwei, wird das zweite zum angestrebten Endzustand, und das Modell interpoliert die Bewegung dazwischen. Das ist praktisch programmierbare Keyframe-Animation über einen einzigen API-Aufruf, ganz ohne Timeline-Editor.

Aufbau der Anfrage

Kling 3.0 Image-to-Video läuft auf dem einheitlichen asynchronen Task-Endpunkt von HiAPI – POST /v1/tasks, dann GET /v1/tasks/{id} pollen, bis der Task abgeschlossen ist. Das Eingabe-Schema des Modells ist bewusst schlank gehalten:

{
  "model": "kling-3.0/image-to-video",
  "input": {
    "prompt": "a lantern slowly lighting up as the camera pushes in, warm cinematic glow",
    "image_urls": ["https://static.hiapi.ai/blog/kling-3-0-image-to-video-short-form-workflow/first-frame-v2.jpg"],
    "duration": 3,
    "resolution": "720p",
    "sound": true
  }
}

Bevor du darauf aufbaust, lohnt es sich, ein paar Dinge zu wissen:

• image_urls akzeptiert 1 oder 2 Einträge. Ein Bild bedeutet „animiere ab diesem Frame“. Zwei Bilder bedeuten „animiere vom ersten zum zweiten“ – das ist die oben erwähnte Start- und Endbild-Steuerung. Es gibt kein separates Feld tail_image_url; alles wird über die Position im Array ausgedrückt.
• duration ist eine ganze Zahl von 3 bis 15 Sekunden. Kurzvideo-Plattformen wollen Clips meist im Bereich von 3–8 Sekunden, daher willst du für eine einzelne Szene in der Regel das untere Ende dieses Bereichs.
• resolution geht bis zu 4K und liegt damit über dem Schwestermodell kling-3.0-turbo (maximal 1080p). Der Preis dafür sind die Kosten – siehe Preisgestaltung unten –, deshalb decken 720p oder 1080p die meisten Kurzvideo-Anwendungsfälle ab, ohne für eine Auflösung zu zahlen, die niemand auf einem Handybildschirm bemerkt.
• sound ist ein Boolescher Wert, und es handelt sich um echte synchrone Audiogenerierung, nicht um einen stummen Clip mit nachträglich unterlegter Musik. Aktiviere es, wenn die Bewegung in deiner Szene plausibel Geräusche erzeugt (eine zufallende Tür, Wind, Schritte) – das Ergebnis wirkt dann deutlich glaubwürdiger als ein stummer Render.
• Es gibt kein Feld aspect_ratio – die Ausgabe übernimmt das Seitenverhältnis deines Eingabebilds.

Das End-to-End-Skript

Hier der vollständige Ablauf in Python: Task erstellen, bis zur Fertigstellung pollen, Ergebnis herunterladen.

import requests
import time

API_KEY = "YOUR_HIAPI_KEY"
BASE = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

def submit_i2v(image_url, prompt, duration=3, resolution="720p", sound=True):
    payload = {
        "model": "kling-3.0/image-to-video",
        "input": {
            "prompt": prompt,
            "image_urls": [image_url],
            "duration": duration,
            "resolution": resolution,
            "sound": sound,
        },
    }
    resp = requests.post(BASE, headers=HEADERS, json=payload, timeout=60)
    resp.raise_for_status()
    return resp.json()["data"]["taskId"]

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

task_id = submit_i2v(
    image_url="https://static.hiapi.ai/blog/kling-3-0-image-to-video-short-form-workflow/first-frame-v2.jpg",
    prompt="a lantern slowly lighting up as the camera pushes in, warm cinematic glow",
)
video_url = wait_for_result(task_id)
print(video_url)  # temporary signed URL — download immediately, don't store it as a permanent link

Ein Detail, über das man beim Einbau in eine echte Pipeline leicht stolpert: Die output[0].url, die du zurückbekommst, ist ein temporärer, ablaufender Link. Lade die Bytes sofort herunter und verschiebe sie in deinen eigenen Speicher, statt die Ausgabe-URL des Tasks irgendwo dauerhaft zu speichern.

Hier das in diesem Beispiel verwendete Startbild und der daraus von Kling 3.0 mit sound: true erzeugte Clip:

Ein Clip wie der obige – 3 Sekunden, 720p, mit Audio – kostet etwas über $0,40, günstig genug, um den Prompt ein paar Mal zu iterieren, bevor man sich auf die Version festlegt, die man ausliefern möchte.

Preisgestaltung: Auflösung und Audio beeinflussen die Kosten

Kling 3.0 Image-to-Video wird pro Sekunde Ausgabedauer abgerechnet, wobei Auflösung und Audio-Schalter den Tarif beeinflussen:

Auflösung	Ohne Audio	Mit Audio
720p	$0.10/s	$0.143/s
1080p	$0.129/s	$0.193/s
4K	$0.479/s	—

Rechenbeispiel: Ein 3-sekündiger Clip in 720p mit Ton kostet etwa $0,43. Ein 5-sekündiger Clip in 1080p ohne Audio kostet $0,645; derselbe Clip mit Audio kostet $0,965. Für Kurzvideo-Inhalte, deren fertige Clips meist im Bereich von 3–8 Sekunden liegen, sind 720p oder 1080p fast immer die richtige Wahl – der 4K-Preis lohnt sich nur, wenn du in etwas hineinkomponierst, das von der zusätzlichen Auflösung wirklich profitiert. Bevor du irgendetwas in großem Umfang startest, schau dir die aktuelle Preisgestaltung an, denn Details wie Sekundentarife sollte man gegen die Live-Seite prüfen und nicht aus dem Gedächtnis zwischenspeichern.

Batch-Verarbeitung zu einem echten Workflow

Für Kurzvideo-Inhalte jeder Größenordnung willst du nicht einen Task absenden und ihn dann ununterbrochen beobachten – du willst eine ganze Charge von Tasks auf einmal absenden und die Ergebnisse einsammeln, wenn sie eintreffen. Da jeder Task unabhängig ist und durch seine eigene taskId identifiziert wird, ist das Muster einfach: erst alle Image-to-Video-Anfragen absenden, die zurückgegebenen Task-IDs speichern, dann in einer Schleife pollen und erst dann handeln, wenn ein Task success oder fail erreicht. So läuft deine Pipeline mit dem tatsächlichen Durchsatz der Plattform, statt sich an der langsamsten einzelnen Generierung zu serialisieren.

Ein paar Gewohnheiten, die man sich von Anfang an aneignen sollte:

• Prüfe vor dem Absenden, ob das Quellbild erreichbar ist. Die Task-API nimmt eine URL bereitwillig an und lässt den Task später scheitern, wenn das Bild nicht abrufbar ist – eine vorherige HEAD-Anfrage erspart dir eine verschwendete Generierung.
• Behandle den Status fail als normales Ergebnis, nicht als Ausnahme. Die Modellausgabe lehnt gelegentlich eine bestimmte Prompt/Bild-Kombination ab; protokolliere den Fehler und mach mit dem nächsten Eintrag weiter, statt die ganze Charge abzubrechen.
• Wiederverwende Clips nach Möglichkeit über verschiedene Varianten hinweg. Wenn du mehrere Untertitel oder Musikstücke auf derselben generierten Animation testest, ist es nicht nötig, das Video selbst neu zu generieren – das ist ein reiner nachgelagerter Bearbeitungsschritt.

Wenn du zum ersten Mal API-Schlüssel und Authentifizierung einrichtest, deckt der Schnellstart-Leitfaden von HiAPI die Grundlagen ab – Schlüssel beziehen und den ersten authentifizierten Aufruf machen –, danach kannst du darauf eine vollständige Batch-Pipeline aufbauen.

Zusammenfassung

Das Image-to-Video-Modell von Kling 3.0 verwandelt ein einzelnes Standbild – oder zwei, wenn du Start- und Endbild-Steuerung willst – mit einem einzigen HTTP-Aufruf in einen Kurzvideo-Clip mit synchronem Audio, wobei die Preisgestaltung je nach Dauer, Auflösung und der Entscheidung für Ton vorhersehbar skaliert. Für Kurzvideo-Pipelines bietet die Kombination aus dieser Steuerung, den niedrigen Kosten pro Clip bei 720p/1080p und der unkomplizierten asynchronen Task-API einen einfachen Weg von „einem Standbild“ zu „einer Charge fertiger Clips“, ohne einen Video-Editor anzufassen.