Sådan anvender du Kling API uden direkte Kling-onboarding: 2026 Guide

TL;DR Du kan få adgang til understøttede Kling-videomodeller via CometAPI med en CometAPI-konto og API-nøgle i stedet for at gennemføre en separat Kling-udvikleronboarding. Den aktuelle tekst-til-video-rute er POST /kling/v1/videos/text2video. Den returnerer et task-ID, som din backend poller, indtil tasken når succeed eller failed. Modeltilgængelighed, parametre, priser og kontoberettigelse kan ændre sig, så verificer det aktuelle modelkatalog og API-dokumentationen før produktionsudrulning.

Direkte svar

Den praktiske vej er CometAPIs Kling-modelkatalog. Hvis den Kling-model, du har brug for, er tilgængelig for din CometAPI-konto, kan din server autentificere med en CometAPI API-nøgle og kalde det tilsvarende Kling-kompatible endpoint. For denne vej er en separat Kling API-ansøgning ikke en del af integrationsskridtene.

Denne sondring er vigtig for teams, der allerede bruger CometAPI til andre modeller. Applikationen bevarer én flade til håndtering af legitimationsoplysninger og ét udbyderforhold, samtidig med at der tilføjes en Kling-videoworkflow. Din kode skal stadig bruge Kling’s video-specifikke anmodningsskema og asynkrone task-livscyklus; “én API-nøgle” betyder ikke, at alle udbydere deler en identisk request body.

Denne artikel fokuserer på tekst-til-video, fordi det er den mindste nyttige integration. CometAPI dokumenterer også billede-til-video og andre Kling-workflows, men hver har sit eget endpoint og sine egne parameterbegrænsninger. Start med én verificeret vej, og tilføj først flere kapabiliteter efter at have tjekket den aktuelle dokumentation.

Hvorfor denne vej kan være nyttig for et udviklingsteam

Fordelen er først og fremmest operationel. Et team, der allerede bruger CometAPI, kan tilføje et tilgængeligt Kling-workflow uden at oprette endnu en direkte udbyderintegration, uddele endnu en legitimation eller bygge en separat kontoadministrationssti. Det kan reducere antallet af secrets, betalingsrelationer og udbyderspecifikke klientkonfigurationer, som din platform skal vedligeholde.

Den anden fordel er arkitektonisk. Din applikation kan udstille en lille intern videogenereringskontrakt—prompt, workflow, model, valgmuligheder og jobstatus—mens en udbyderadapter oversætter den kontrakt til den dokumenterede Kling-anmodning. Hvis teamet senere evaluerer en anden videomodel, kan det produktvendte jobmodel forblive stabilt, selvom endpoint-stier, parametre og outputmetadata varierer.

Begrænsningen er lige så vigtig: Et konsolideret adgangslag gør ikke de underliggende modeller udskiftelige. Promptadfærd, accepterede medier, latenstid, pris, sikkerhedspolitikker og resultatskemaer kan variere. Hold disse forskelle synlige i konfiguration og tests i stedet for at skjule dem bag uunderbyggede antagelser.

Hvad denne adgangsvej ændrer—og hvad den ikke ændrer

Hvad ændres. Du opretter og administrerer en CometAPI-nøgle, sender anmodninger til CometAPIs Kling-kompatible API og sporer forbrug fra CometAPI-siden. Dette fjerner et separat direkte Kling-onboardingtrin fra denne specifikke adgangsvej.

Hvad ændres ikke. Kling forbliver den underliggende modelfamilie. Udbyderspecifikke parametre, genereringsadfærd, regler for acceptabel brug, modeltilgængelighed og outputkarakteristika er stadig vigtige. CometAPIs dokumentation bemærker også, at udbyderes request- og responsefelter kan afvige, så behandl den live endpoint-reference som kontrakten for din implementering.

Hvad du bør verificere, før du forpligter dig. Bekræft, at din konto kan få adgang til det nødvendige model-ID, gennemgå den aktuelle pris og ratelimits, og kør en lille autentificeret test. Design ikke en produktionsarbejdsgang omkring et modelnavn fundet i et gammelt blogindlæg eller et cached eksempel.

Før du begynder

Du skal bruge en CometAPI-konto, en API-nøgle, der opbevares på din server, og en backend, der kan køre et asynkront job. Opbevar nøglen i en miljøvariabel som COMETAPI_KEY; eksponer den ikke i browser- eller mobilklientkode.

1. Åbn Kling-modelkataloget og bekræft, at modellen, du vil bruge, er listet for din konto.
2. Gennemgå den aktuelle Kling tekst-til-video API-reference. På verifikationstidspunktet bruger det dokumenterede eksempel kling-v3.
3. Opret en server-side API-nøgle i CometAPI-konsollen og sæt den i dit runtime-miljø.
4. Beslut, hvor din service vil lagre task-ID’et og den endelige video. Genereringsanmodningen returnerer en task, ikke den færdige videofil.

Vælg Kling-workflowet, før du designer anmodningen

Start med den ressource, dit produkt allerede har. Hvis brugeren kun har et skriftligt koncept, er tekst-til-video den direkte vej. Hvis brugeren har et stillbillede, der skal forblive det visuelle anker, skal du bruge den separat dokumenterede billede-til-video-vej. Tilføj ikke et billedfelt til en tekst-til-video-anmodning og antag, at API’et vil udlede workflowet.

Den aktuelle billede-til-video-reference accepterer en offentlig billed-URL eller en base64-billedstreng og returnerer en asynkron task. Mere specialiserede Kling-workflows har deres egne sider og anmodningsbegrænsninger. Tilføj dem én ad gangen, kun når produktkravet og den aktuelle dokumentation retfærdiggør den ekstra adapter.

Til et første produktionsbevis: brug ét workflow, ét verificeret model-ID, en kort varighed og et lille sæt repræsentative prompts. Dette isolerer konto-adgang og task-orkestrering fra subjektiv outputevaluering. Når pipelinen er pålidelig, kan du sammenligne tilstande eller modeller med et fast evalueringssæt i stedet for at ændre flere variabler i samme test.

Lav din første Kling tekst-til-video-anmodning

Det aktuelle tekst-til-video-endpoint accepterer JSON og Bearer-autentificering. Begynd med en kort prompt og den mindste understøttede varighed. Den følgende anmodning bruger kun felter, der vises i den aktuelle CometAPI-reference:

curl https://api.cometapi.com/kling/v1/videos/text2video \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A small ceramic cup on a wooden table, steam rising in soft morning light",
    "model_name": "kling-v3",
    "mode": "std",
    "duration": "5",
    "sound": "off"
  }'

En vellykket indsendelse returnerer et objekt, der indeholder data.task_id og en taskstatus. Gem det task-ID sammen med din applikations jobpost. Hold ikke HTTP-forbindelsen åben, mens videoen renderes.

Håndter den asynkrone task sikkert

Kling-generering er asynkron. For tekst-til-video skal du poll’e GET /kling/v1/videos/text2video/{task_id}. CometAPIs task-reference siger, at et svar kan returnere tasken direkte eller inde i en data-indpakning, så eksemplet normaliserer begge former. Det behandler også enhver ikke-terminal tilstand som “vent videre” i stedet for at antage en fast liste over mellemliggende tilstande.

import os
import time
import requests

API_KEY = os.environ["COMETAPI_KEY"]
BASE_URL = "https://api.cometapi.com/kling/v1/videos/text2video"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def submit_video(prompt: str) -> str:
    response = requests.post(
        BASE_URL,
        headers=HEADERS,
        json={
            "prompt": prompt,
            "model_name": "kling-v3",
            "mode": "std",
            "duration": "5",
            "sound": "off",
        },
        timeout=30,
    )
    response.raise_for_status()
    payload = response.json()
    return payload["data"]["task_id"]


def wait_for_video(task_id: str, timeout_seconds: int = 600) -> str:
    deadline = time.monotonic() + timeout_seconds
    poll_url = f"{BASE_URL}/{task_id}"

    while time.monotonic() < deadline:
        response = requests.get(poll_url, headers=HEADERS, timeout=30)
        response.raise_for_status()
        payload = response.json()
        task = payload.get("data") or payload
        status = task.get("task_status")

        if status == "succeed":
            videos = task.get("task_result", {}).get("videos", [])
            if not videos or not videos[0].get("url"):
                raise RuntimeError("Task succeeded without a video URL")
            return videos[0]["url"]

        if status == "failed":
            detail = task.get("task_status_msg") or task.get("task_result")
            raise RuntimeError(f"Kling task failed: {detail}")

        time.sleep(10)

    raise TimeoutError(f"Kling task {task_id} exceeded {timeout_seconds}s")


task_id = submit_video(
    "A small ceramic cup on a wooden table, steam rising in soft morning light"
)
video_url = wait_for_video(task_id)
print(video_url)

Den terminale successtreng er succeed, ikke succeeded. Når en task fuldføres, skal du kopiere den genererede ressource til lager, du kontrollerer, hvis dit produkt kræver retention. Udbyderens leverings-URL’er bør ikke behandles som permanent applikationslager.

For større arbejdsbyrder skal du bruge en kø eller worker i stedet for at poll’e inde i en webanmodning. CometAPI dokumenterer også callback-URL’er for Kling-tasks. Hvis du bruger webhooks, så autentificér og deduplikér callback-hændelser og behold en polling-fallback for missede leverancer.

Design applikationens joblivscyklus, før du skalerer

Behandl udbydertasken som én del af din egen jobpost. Gem et applikations-job-ID, workflow, ønsket model, udbyder-task-ID, query-URL, aktuel status, indsendelsestidspunkt, seneste poll-tid og outputplacering. Det giver dit support- og driftsteam nok kontekst til at undersøge en fejlet eller langsom generering uden at gennemsøge rå anmodningslogs.

Forsøg ikke at gentage create-anmodningen blot fordi klienten ikke modtog et svar. Udbyderen kan allerede have oprettet en task. Persistér dit lokale job før indsendelse, gem det returnerede task-ID med det samme, og adskil create-retries fra status-forespørgsels-retries. Den aktuelle tekst-til-video-reference dokumenterer også external_task_id til applikationssporing; bekræft dens liveadfærd, før du stoler på den som en deduplikeringsmekanisme.

const TERMINAL = new Set(["succeed", "failed"]);

function normalizeKlingTask(payload) {
  const task = payload?.data ?? payload;
  if (!task?.task_id || !task?.task_status) {
    throw new Error("Kling response is missing task identity or status");
  }
  return task;
}

async function refreshVideoJob(job, apiKey) {
  const response = await fetch(job.queryUrl, {
    headers: { Authorization: `Bearer ${apiKey}` },
  });

  if (!response.ok) {
    throw new Error(`Task query failed with HTTP ${response.status}`);
  }

  const task = normalizeKlingTask(await response.json());
  const outputUrl = task.task_result?.videos?.[0]?.url ?? null;

  return {
    ...job,
    providerTaskId: task.task_id,
    providerStatus: task.task_status,
    terminal: TERMINAL.has(task.task_status),
    outputUrl,
    failureDetail: task.task_status_msg ?? null,
    checkedAt: new Date().toISOString(),
  };
}

Dette eksempel oversætter med vilje ikke enhver mulig mellemliggende udbyderstatus til et produktløfte. Din worker holder ikke-terminale tasks aktive, håndterer succeed og failed eksplicit og registrerer rå udbyderstatus til fejlsøgning. Tilføj en separat applikationstimeout, så en fastlåst task ikke forbliver åben for evigt.

Brug polling som baseline, fordi task-ID’et forbliver forespørgbart. Når det valgte endpoint understøtter callback_url, kan en webhook reducere gentagne statusanmodninger, men den bør ikke blive din eneste genopretningsmekanisme. Den officielle vejledning i polling og webhooks bemærker, at callback-payloads kan være udbyderspecifikke. Gem den rå hændelse, gør behandlingen idempotent efter task-ID, returnér hurtigt et vellykket HTTP-svar, og forlig den terminale tilstand via polling.

Produktions-tjekliste for udviklingsteams

• Validér modellen ved køretid. Tjek det aktuelle katalog, og giv en tydelig fejl, når en anmodet model ikke er tilgængelig. Erstat ikke stiltiende med en anden model, hvis outputadfærd er vigtig.
• Adskil indsendelse fra hentning. Gem CometAPI-task-ID, dit eget job-ID, den valgte model og tidsstempler, så retries ikke skaber dobbeltarbejde.
• Begræns polling. Brug en timeout, eksponentiel backoff eller et fornuftigt fast interval og et maksimalt antal retries. Gennemgå CometAPIs ratelimit- og samtidighedsvejledning, før du øger parallellismen.
• Klassificér fejl. Forsøg ikke igen ved ugyldige parametre eller autentificeringsfejl. Anvend backoff på retrybare ratelimit- og platformfejl i henhold til den aktuelle retry-vejledning.
• Beskyt legitimationsoplysninger og input. Hold API-nøgler på serversiden, undgå at logge secrets, og bekræft, at brugere har rettigheder til alle prompts, billeder eller andre kildeaktiver, de indsender.
• Mål hele jobbet. Spor indsendelsessucces, køtid, genereringstid, terminal fejlraten, timeout-raten, output-hentningssucces og omkostninger pr. model og tilstand.
• Gem outputs bevidst. Download fuldførte aktiver til eget kontrolleret lager, når dit produkt kræver vedvarende adgang, og anvend derefter din politik for retention og sletning.

Praktiske ofte stillede spørgsmål

Skal jeg have en separat Kling-udviklerkonto for denne vej?

Ingen separat Kling-udvikleronboarding indgår i CometAPIs integrationsforløb. Du bruger en CometAPI-konto og API-nøgle. Adgang afhænger stadig af, at modellen er tilgængelig for din CometAPI-konto og region, så bekræft det, før du forpligter dig til produktion.

Er Kling API fuldt OpenAI-kompatibel?

Ikke for den videoworkflow, der vises her. Den bruger Kling-specifikke ruter som /kling/v1/videos/text2video og Kling-specifikke felter. Du kan administrere legitimationsoplysninger gennem CometAPI, men din adapter bør bevare det udbyderspecifikke skema.

Hvilket Kling model-ID skal jeg bruge?

Den aktuelle CometAPI tekst-til-video-reference bruger kling-v3 i sit første fungerende eksempel og oplister flere tidligere modelspor. Brug et model-ID fra den live endpoint-enum, og verificér, at det er aktiveret til din konto. Antag ikke, at den nyeste model er tilgængelig overalt.

Hvorfor indeholder det første svar ikke en video?

Videogenerering kører som en asynkron task. Det første svar returnerer et task-ID. Poll den matchende query-rute, indtil task_status bliver succeed eller failed, og læs derefter resultatmetadata.

Skal jeg poll’e eller bruge en callback-URL?

Polling er lettere til en første integration. Callbacks reducerer gentagne anmodninger i skala, men kræver en autentificeret, idempotent modtager og genopretningslogik. Mange produktionssystemer bruger callbacks som primær vej og polling som fallback.

Kan jeg bruge billede-til-video via det samme endpoint?

Nej. CometAPI dokumenterer billede-til-video under en separat rute, /kling/v1/videos/image2video. Følg det endpoints aktuelle anmodningsskema i stedet for at tilføje et billedfelt til tekst-til-video-eksemplet.

Skal jeg starte med standard- eller professionel tilstand?

Brug std for at validere autentificering, anmodningsform, task-lagring, polling og output-hentning. Den aktuelle reference beskriver pro som en tilstand med højere kvalitet og højere omkostning. Evaluer den med repræsentative prompts først, når den grundlæggende arbejdsgang fungerer, og sammenlign outputkvalitet sammen med genereringstid og faktisk omkostning.

Hvordan undgår jeg duplikerede genereringer under retries?

Opret en applikations-jobpost, før du kalder API’et, og gem det returnerede udbyder-task-ID med det samme. Forsøg statusforespørgsler igen uafhængigt af create-anmodninger. Antag ikke, at det er idempotent at gentage den samme POST. Endpoints dokumenterer i øjeblikket external_task_id til tracking, men verificér dets aktuelle semantik, før du behandler det som en deduplikeringsgaranti.

Konklusion

For et amerikansk udviklingsteam, der vil teste Kling-videogenerering uden at gennemføre en separat direkte Kling-udvikleransøgning, giver CometAPI en dokumenteret vej: verificér, at den krævede Kling-model er tilgængelig for kontoen, autentificér med en CometAPI-nøgle, kald det workflow-specifikke endpoint, og spor den asynkrone task til en terminal tilstand.

Den praktiske ingeniørmæssige værdi er centraliseret adgang og en genbrugelig applikations-jobmodel—ikke antagelsen om, at alle videoudbydere opfører sig ens. Bevar en tynd adapter for hvert workflow, persistér task-identitet og output bevidst, og behold polling som en genopretningsvej, selv når callbacks er aktiveret.

En sikker udrulning er lille og målbar: Validér én model og ét workflow, indsend korte lavomkostningsjobs, registrér terminal succes- og fejlrater, verificér output-hentning, og sammenlign faktisk omkostning og latenstid med dine produktkrav. Udvid til billede-til-video eller yderligere Kling-workflows først efter, at den aktuelle dokumentation og din mål-konto er tjekket.