Kling API: Leitfaden für offizielle und Aggregator-Integration (2026)

Eine Kling-Videoanfrage ist kein einzelner, universeller API-Aufruf. Kuaishous Videogenerierungsmodell Kling ist über die offizielle Open Platform sowie über Aggregatoren wie WaveSpeedAI, KIE und fal verfügbar. Zugangsdaten, Modell-IDs, Request-Formate und Abrechnung unterscheiden sich dabei jeweils. Konstant bleibt der asynchrone Ablauf: Job absenden, ID speichern, auf einen finalen Status warten und das Ergebnis abrufen – ohne unkontrollierte Wiederholungsversuche.

Erst den Zugang wählen, dann das SDK

Kling betreibt eine offizielle Open Platform. Unter dem Suchbegriff „Kling API“ finden sich jedoch auch unabhängige Gateways. Entscheide daher nicht allein anhand des Modellnamens, sondern nach Anbieterzugang, Integrationsaufwand und Kontrolle über die Abrechnung.

Details zu Preisen nach Auflösung findest du im bestehenden Kling 3 API pricing guide. Preise, Audio-Multiplikatoren, Parallelität und die Abrechnung fehlgeschlagener Tasks sollten hier als anbieterspezifische Konfiguration behandelt werden.

Der offizielle Kling-Ablauf

Nutze die offizielle Open Platform, wenn der Einkauf eine direkte Kuaishou-Beziehung verlangt oder du Zugriff auf Modelle aus erster Hand benötigst. Die aktuelle offizielle Dokumentation trennt Einrichtung der Zugangsdaten, Task-Erstellung, Callbacks, Parallelitätsregeln und Fehlercodes. Folge deshalb diesem Weg, statt ein Aggregator-Payload anzupassen:

1. Erstelle oder rufe die offizielle Zugangsdaten gemäß dem authentication guide ab und bewahre den Token ausschließlich serverseitig auf.
2. Sende den dokumentierten asynchronen Video-Task an den modellspezifischen Endpoint, mit den Request-Feldern aus der offiziellen Referenz.
3. Füge callback_url hinzu, wenn Status-Updates aktiv zugestellt werden sollen. Zu den dokumentierten Callback-Status gehören submitted, processing, succeed und failed; speichere bei Fehlern task_status_msg.
4. Setze die aktuell für den Account zugewiesene Parallelitätsgrenze auch lokal durch. Der offizielle Concurrency-Leitfaden beschreibt Überlastung als HTTP 429 mit Business-Code 1303 – nicht als Arbeit, die Kling zwangsläufig für dich in eine Warteschlange stellt.
5. Nutze die offizielle error-code reference, um ungültige Zugangsdaten, fehlerhafte Parameter, aufgebrauchte Ressourcen, Richtlinienblockaden und wiederholbare Serverfehler auseinanderzuhalten.

Die offizielle Authentifizierungsseite wird in der zugänglichen Dokumentationsversion clientseitig gerendert. Dieser Leitfaden übernimmt deshalb kein nicht verifiziertes Snippet zur Token-Erzeugung. Übernimm das aktuelle Credential-Format direkt von dieser Seite, statt anzunehmen, dass ein WaveSpeed-, KIE- oder fal-Header funktioniert.

Der offizielle Lebenszyklus lässt sich dennoch normalisieren, ohne das exakte Payload zu erraten:

official_credential = get_from_kling_console()
task = POST official_model_endpoint(official_credential, documented_input)
store(task.task_id)
wait_for_callback_or_query_status(task.task_id)
if status == "succeed": save_output(task_result.videos)
else: classify(http_status, business_code, task_status_msg)

Das ist eine Skizze des Ablaufs, kein Endpoint zum Kopieren. Token, Pfad, Request-Felder und Response-Format stehen in der verlinkten offiziellen Referenz.

Wann ein Aggregator besser passt

Für Prototypen sind Aggregatoren oft schneller: nutzungsbasierter Zugang, ein Account für mehrere Modelle oder ein Provider-SDK. Dafür kontrolliert der Anbieter Schlüssel, Schema, Queue, Ausgabe-URL und teils auch die Aufbewahrungsdauer. Ordne den Fehler zunächst der richtigen Ebene zu, bevor du erneut sendest.

Der Kling-API-Vertrag, den du verlässlich vereinheitlichen kannst

Ein produktionsreifer Client sollte anbieterspezifische Unterschiede hinter einer internen Funktion verbergen. Unabhängig vom gewählten Zugang muss deine Anwendung diese Schritte erledigen:

1. Prompt und Medien-URLs validieren, bevor Credits verbraucht werden.
2. Einen Videogenerierungs-Task mit einer anbieterspezifischen Modell-ID absenden.
3. Die zurückgelieferte Task- oder Prediction-ID sofort persistent speichern.
4. Einen Callback empfangen oder einen Ergebnis-Endpoint abfragen, bis der Job einen finalen Status erreicht.
5. Ausgabe-URL, Anbieter, Modell, Parameter und Kosten-Metadaten speichern.
6. Wiederholungen beenden, wenn der Anbieter Fehler, Abbruch, Timeout oder Löschung meldet.

Die Abstraktion sollte ein eigenes normalisiertes Objekt zurückgeben, zum Beispiel:

{
  "provider": "wavespeed",
  "job_id": "provider-job-id",
  "status": "queued",
  "output_url": null,
  "error": null
}

Parameter, die sich gut übertragen lassen

Die Konzepte lassen sich übertragen, die Feldnamen nicht. generate_audio, sound und generate_audio: true können bei unterschiedlichen Diensten verwandtes Verhalten beschreiben. Behandle jedes Provider-Schema als eigenen Adapter.

Parameter, die nicht übertragbar sind

Modell-IDs sind die erste Falle. kling-3.0, kling-3.0/video, fal-ai/kling-video/v3/standard/text-to-video und kwaivgi/kling-v3.0-std/text-to-video stehen für unterschiedliche API-Routen und sind keine austauschbaren Werte.

Dasselbe gilt für Authentifizierungs-Header, Callback-Namen, Ergebnis-URLs, Task-Statuswerte und Regeln für Datei-Uploads. Ein Client, der einen Status-String eines Anbieters wie completed fest verdrahtet, kann die Antwort succeeded oder failed eines anderen Anbieters falsch einordnen.

Drei reale Request-Formate

Diese anbieterspezifischen Beispiele zeigen, warum es keinen universellen Kling-Endpoint gibt.

WaveSpeedAI: Prediction-ID und Ergebnis-Polling

WaveSpeedAI dokumentiert Kling 3.0 Standard Text-to-Video unter diesem Endpoint:

POST https://api.wavespeed.ai/api/v3/kwaivgi/kling-v3.0-std/text-to-video

Der Request verwendet einen Bearer-Token. Der Endpoint liefert eine Prediction-ID zurück; das Ergebnis wird hier abgerufen:

GET https://api.wavespeed.ai/api/v3/predictions/{prediction_id}/result

Ein minimaler cURL-Ablauf sieht so aus:

export WAVESPEED_API_KEY="replace_me"

submit=$(curl --fail-with-body -s \
  -X POST \
  "https://api.wavespeed.ai/api/v3/kwaivgi/kling-v3.0-std/text-to-video" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cinematic sunrise over a futuristic cityscape",
    "duration": 5,
    "aspect_ratio": "16:9",
    "cfg_scale": 0.5,
    "shot_type": "customize"
  }')

prediction_id=$(printf '%s' "$submit" | jq -r '.data.id // .id')

curl -s \
  "https://api.wavespeed.ai/api/v3/predictions/$prediction_id/result" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY"

In der Modelldokumentation von WaveSpeedAI sind 3–15 Sekunden, die Seitenverhältnisse 16:9, 9:16 und 1:1 sowie ein Standardwert von 0.5 für cfg_scale aufgeführt. Die Standard-Preistabelle nennt $0.42 für einen 5-Sekunden-Clip ohne Ton und $0.63 mit Ton. Betrachte diese Werte als Momentaufnahme dieses Anbieters, nicht als allgemeinen Kling-Preis.

Für den Produktivbetrieb solltest du den Ergebnis-Endpoint mit Backoff abfragen, statt Requests in einer engen Schleife zu senden. Beende das Polling bei completed, failed, cancelled, timeout oder deleted; dies sind die für diesen Endpoint dokumentierten finalen Statuswerte.

KIE: createTask mit Callback oder Task-Abfrage

KIE verwendet einen gemeinsamen Endpoint zur Task-Erstellung:

POST https://api.kie.ai/api/v1/jobs/createTask

Die Kling-3.0-Modellkennung lautet kling-3.0/video; die Authentifizierung erfolgt per Bearer-Token. Ein kompaktes Payload für einen einzelnen Shot sieht so aus:

{
  "model": "kling-3.0/video",
  "callBackUrl": "https://example.com/webhooks/kie",
  "input": {
    "prompt": "A paper boat moving across a sunlit stream, gentle camera push-in",
    "duration": "5",
    "aspect_ratio": "16:9",
    "mode": "std",
    "sound": false,
    "multi_shots": false
  }
}

KIE dokumentiert Videos mit 3–15 Sekunden Länge, Ausgabeformate in 16:9, 9:16 und 1:1 sowie bis zu fünf Shots im Multi-Shot-Modus. Multi-Shot-Einträge können jeweils 1–12 Sekunden festlegen. Bildelemente verwenden 2–4 JPG- oder PNG-URLs, bei einer dokumentierten Maximalgröße von 10 MB pro Bild; Videoelemente verwenden eine MP4- oder MOV-URL bis 50 MB.

Der Callback ist optional, wird von KIE für den Produktivbetrieb aber empfohlen. Dein Webhook sollte die Signatur prüfen, wenn verfügbar, schnell bestätigen und das Task-Ergebnis in eine Queue legen. Polling über die Task-Abfrage bleibt der Rückfallweg für verpasste Callbacks.

KIE dokumentiert eigene Response-Codes für häufige Fehler, darunter 401 für ungültige Authentifizierung, 402 für unzureichende Credits, 422 für Validierungsfehler und 429 für Rate Limits. Protokolliere Code und Nachricht gemeinsam: Eine allgemeine Meldung wie „Kling fehlgeschlagen“ reicht nicht aus, um sicher über einen erneuten Versuch zu entscheiden.

fal: Modell-Endpoint mit Queue-Client

fal stellt Kling 3.0 über modellspezifische Endpoint-IDs bereit. Für Standard Text-to-Video lautet die dokumentierte ID:

fal-ai/kling-video/v3/standard/text-to-video

Die Raw API verwendet einen Header Authorization: Key $FAL_KEY. Die Python- und JavaScript-Beispiele nutzen den Queue-fähigen Client von fal, was meist einfacher ist, als die Polling-Schleife selbst zu schreiben.

import { fal } from "@fal-ai/client";

fal.config({ credentials: process.env.FAL_KEY });

const result = await fal.subscribe(
  "fal-ai/kling-video/v3/standard/text-to-video",
  {
    input: {
      prompt: "A paper boat moving across a sunlit stream, gentle camera push-in",
      duration: 5,
      aspect_ratio: "16:9",
      generate_audio: false,
      negative_prompt: "blur, distort, low quality",
      cfg_scale: 0.5
    },
    logs: true
  }
);

console.log(result.data.video.url);

fal dokumentiert eine Dauer von 3–15 Sekunden, drei Text-to-Video-Seitenverhältnisse sowie einen Bereich von 0–1 für cfg_scale mit einem Standardwert von 0.5. Laut Standard-Schema sind prompt und multi_prompt Alternativen: Übergib eines von beiden, nicht beide. Der dokumentierte Standardwert für generate_audio ist true; setze ihn daher explizit, wenn dein Budget oder die Postproduktion von einer stummen Ausgabe ausgeht.

fal dokumentiert zudem separate IDs für Image-to-Video und Motion Control. Leite diese IDs nicht ab, indem du text-to-video in einem String ersetzt, ohne zuvor die aktuelle Modellreferenz zu prüfen.

Kontingente, Queue-Zeit und Schutz der Credits

Es gibt kein einheitliches öffentliches Kling-Kontingent, das für die offizielle Plattform, WaveSpeedAI, KIE und fal gilt. Parallelität, Rate Limits, Credit-Guthaben, Abrechnung fehlgeschlagener Tasks und Aufbewahrung der Ergebnisse hängen vom gewählten Zugang ab. Speichere diese Werte als Provider-Konfiguration, nicht als Konstanten namens KLING_LIMIT.

Ein Nutzer fasste das operative Risiko präziser zusammen als eine allgemeine Retry-Empfehlung:

„Kling rechnet pro Generierung ab und hat echte Queue-Latenz. Als Erstes würde ich eine Kosten-/Parallelitätsgrenze einbauen, sonst verbrennt ein Agent, der bei einem schlechten Frame erneut versucht, unbemerkt über Nacht deine Credits.“ — @ukrroot on X

Leitplanken für Budget und Parallelität

Implementiere diese Kontrollen, bevor ein Agent oder Batch-Worker Kling aufrufen darf:

1. Maximale Zahl paralleler Jobs: Setze eine anbieterspezifische Obergrenze, statt pro Prompt einen Job zu starten.
2. Budget je Job: Schätze Dauer, Tarifstufe, Audio und Anzahl der Ausgaben vor dem Absenden.
3. Retry-Budget: Wiederhole Transportfehler gezielt; Validierungs-, Authentifizierungs- und Fehler wegen unzureichender Credits dürfen nicht wiederholt werden.
4. Job-Ledger: Speichere die Job-ID des Anbieters vor jedem Folge-Request, damit ein Worker-Neustart keine doppelte Generierung absendet.
5. Regel für finale Status: Markiere fehlgeschlagene, abgebrochene, zeitüberschrittene oder gelöschte Jobs als abgeschlossen, sofern der Anbieter nicht ausdrücklich bestätigt, dass ein erneutes Absenden sicher ist.
6. Credit-Alarm: Stoppe die Queue, wenn Guthaben oder prognostizierte Ausgaben einen Schwellenwert überschreiten.
7. Schutz von Schlüsseln und Ausgaben: Halte Schlüssel serverseitig, rotiere offengelegte Schlüssel sofort und kopiere fertige Videos in einen dauerhaften Speicher.

Ein Standard-Test mit fünf Sekunden kann im Vergleich zu einem 15-Sekunden-Pro-Job oder einem Job mit aktiviertem Audio günstig sein. Was „günstig“ bedeutet, ist jedoch anbieterspezifisch. Lies die aktuelle Modellseite, bevor du eine Standardstufe auswählst.

Was vor dem Produktivstart gemessen werden sollte

Erfasse für jeden Request diese Felder:

Behandle Latenz und Kontingente als Endpoint-spezifisch; die öffentlichen Quellen nennen kein einheitliches SLA über mehrere Anbieter hinweg.

Kling API: Häufige Fragen

Gibt es eine offizielle Kling API?

Ja. Kling unterhält einen Bereich mit Entwicklerdokumentation für die offizielle Open Platform. Der offizielle Zugang und Gateways von Drittanbietern sind getrennte Dienste. Prüfe aktuelle Zugangsdaten, Kontingente und Preise daher in der Kling Open Platform documentation.

Gibt es einen universellen Kling-API-Endpoint?

Nein. Die offizielle Plattform, WaveSpeedAI, KIE und fal verwenden unterschiedliche Endpoint-Pfade, Modell-IDs, Authentifizierungs-Header und Response-Formate. Baue einen Provider-Adapter, statt anzunehmen, dass kling-3.0 überall gültig ist.

Sollte ich Polling oder Webhooks verwenden?

Verwende im Produktivbetrieb einen Callback oder Webhook, wenn der Anbieter ihn unterstützt. Behalte Polling jedoch für lokale Tests und zur Wiederherstellung bei verpassten Callbacks. Ergänze exponentielles Backoff, ein maximales Wartefenster und Idempotenz, damit ein verspäteter Callback keinen doppelten Datensatz erzeugt.

Welche Dauer und Seitenverhältnisse werden unterstützt?

Mehrere aktuelle Aggregator-Dokumentationen für Kling 3.0 nennen Clips mit 3–15 Sekunden sowie die Formate 16:9, 9:16 und 1:1. Einzelne Endpoints können abweichen. Prüfe daher die Seite des gewählten Modells, statt diese Werte als universellen First-Party-Vertrag zu behandeln.

Ändert aktiviertes Audio die Kosten?

In der Regel kann es das. WaveSpeedAI dokumentiert für seinen Kling-3.0-Standard-Endpoint einen Sound-Multiplikator von 1.5×, während fal und KIE Audio oder Sound als Request-Parameter anbieten. Prüfe die aktuelle Abrechnungsseite des gewählten Endpoints und setze das Flag explizit.

Warum hat ein Retry zusätzliche Kosten verursacht?

Ein erneuter Versuch kann eine zweite Generierung auslösen, obwohl der erste Job noch in der Queue steht. Speichere die Job-ID, setze eine Parallelitätsgrenze, wiederhole nur temporäre Fehler und gleiche die Provider-Abrechnung ab, bevor du einen unklaren Request erneut sendest.

Für den ersten produktionsnahen Test: Starte einen einzelnen stummen Standard-Job mit 5 Sekunden, protokolliere den gesamten Ablauf und ergänze Pro, Audio, Multi-Shot oder Parallelität erst, wenn der Umgang mit doppelten Workern funktioniert.