Slik bruker du Kling API uten direkte Kling-onboarding: 2026-guide

TL;DR Du kan få tilgang til støttede Kling-videomodeller via CometAPI med en CometAPI-konto og API-nøkkel, i stedet for å fullføre en separat Kling-utvikleronboarding. Den nåværende tekst-til-video-ruten er POST /kling/v1/videos/text2video. Den returnerer en oppgave-ID som backend-en din poller til oppgaven blir succeed eller failed. Modelltilgjengelighet, parametere, priser og kontoberettigelse kan endre seg, så verifiser den live modellkatalogen og API-dokumentasjonen før produksjonsutrulling.

Direkte svar

Den praktiske veien er CometAPIs Kling-modellkatalog. Hvis Kling-modellen du trenger er tilgjengelig for CometAPI-kontoen din, kan serveren din autentisere med en CometAPI API-nøkkel og kalle det tilsvarende Kling-kompatible endepunktet. For denne veien inngår ikke en separat Kling API-søknad i integrasjonsstegene.

Dette skillet er viktig for team som allerede bruker CometAPI til andre modeller. Applikasjonen beholder ett grensesnitt for legitimasjonshåndtering og ett leverandørforhold, samtidig som den legger til en Kling-videoflyt. Koden din må fortsatt bruke Kling-spesifikt forespørselsskjema for video og asynkron oppgavelivssyklus; “én API-nøkkel” betyr ikke at alle leverandører deler ett identisk request-body-format.

Denne artikkelen fokuserer på tekst-til-video fordi det er den minste nyttige integrasjonen. CometAPI dokumenterer også bilde-til-video og andre Kling-arbeidsflyter, men hver har sitt eget endepunkt og parameterbegrensninger. Start med én verifisert vei, og legg først til flere funksjoner etter å ha sjekket gjeldende dokumentasjon.

Hvorfor denne veien kan være nyttig for et utviklingsteam

Den umiddelbare fordelen er operasjonell, ikke magisk. Et team som allerede bruker CometAPI kan legge til en tilgjengelig Kling-arbeidsflyt uten å opprette en ny direkte leverandørintegrasjon, distribuere en ny legitimasjon eller bygge en separat kontoadministrasjonssti. Det kan redusere antall hemmeligheter, faktureringsforhold og leverandørspesifikke klientkonfigurasjoner plattformen din må vedlikeholde.

Den andre fordelen er arkitektonisk. Applikasjonen din kan eksponere en liten intern kontrakt for videogenerering—prompt, arbeidsflyt, modell, alternativer og jobbstatus—mens en leverandøradapter oversetter den kontrakten til den dokumenterte Kling-forespørselen. Hvis teamet senere evaluerer en annen videomodell, kan den produktvendte jobbmodellen forbli stabil selv om endepunkter, parametere og utdata-metadata er ulike.

Begrensningen er like viktig: et konsolidert tilgangslag gjør ikke underliggende modeller utskiftbare. Promptatferd, tillatt media, latens, priser, sikkerhetspolicyer og resultatskjemaer kan variere. Hold disse forskjellene synlige i konfigurasjon og tester i stedet for å skjule dem bak antakelser som ikke støttes.

Hva denne tilgangsveien endrer—og hva den ikke endrer

Hva som endres. Du oppretter og administrerer en CometAPI-nøkkel, sender forespørsler til CometAPIs Kling-kompatible API og sporer bruken fra CometAPI-siden. Dette fjerner et separat direkte Kling-onboardingsteg fra akkurat denne tilgangsveien.

Hva som ikke endres. Kling er fortsatt den underliggende modelfamilien. Leverandørspesifikke parametere, genereringsatferd, regler for akseptabel bruk, modelltilgjengelighet og utgangsegenskaper er fortsatt viktige. CometAPIs dokumentasjon påpeker også at forespørsels- og responsfelt kan avvike mellom leverandører, så behandle live endepunktsreferanse som kontrakten for implementeringen din.

Hva du bør verifisere før du forplikter deg. Bekreft at kontoen din kan få tilgang til nødvendig modell-ID, gjennomgå gjeldende pris og rategrenser, og kjør en liten autentisert test. Ikke design en produksjonsflyt rundt et modellnavn funnet i et gammelt blogginnlegg eller hurtigbufret eksempel.

Før du starter

Du trenger en CometAPI-konto, en API-nøkkel lagret på serveren din, og en backend som kan kjøre en asynkron jobb. Oppbevar nøkkelen i en miljøvariabel som COMETAPI_KEY; eksponer den ikke i nettleser- eller mobilklientkode.

1. Åpne Kling-modellkatalogen og bekreft at modellen du vil bruke er oppført for kontoen din.
2. Les gjeldende Kling text-to-video API-referanse. Ved verifiseringstidspunktet bruker det dokumenterte eksemplet kling-v3.
3. Opprett en server-side API-nøkkel i CometAPI-konsollen og sett den i kjøremiljøet ditt.
4. Bestem hvor tjenesten din skal lagre oppgave-ID-en og ferdig video. Genereringsforespørselen returnerer en oppgave, ikke den ferdige videofilen.

Velg Kling-arbeidsflyt før du designer forespørselen

Start fra ressursen produktet ditt allerede har. Hvis brukeren kun har et skriftlig konsept, er tekst-til-video den direkte veien. Hvis brukeren har et stillbilde som bør forbli visuelt anker, bruk den separat dokumenterte bilde-til-video-ruten. Ikke legg til et bildefelt i en tekst-til-video-forespørsel og anta at API-et vil utlede arbeidsflyten.

Den nåværende bilde-til-video-referansen aksepterer en offentlig bilde-URL eller en base64-bildestreng og returnerer en asynkron oppgave. Mer spesialiserte Kling-arbeidsflyter har egne sider og forespørselsbegrensninger. Legg dem til én om gangen, kun når produktbehovet og gjeldende dokumentasjon rettferdiggjør ekstra adapter.

For et første produksjonsbevis, bruk én arbeidsflyt, én verifisert modell-ID, kort varighet og et lite sett representative prompt. Dette isolerer konto-tilgang og oppgaveorkestrering fra subjektiv vurdering av utdata. Når pipelinen er pålitelig, sammenlign moduser eller modeller med et fast evalueringssett i stedet for å endre flere variabler i samme test.

Gjør din første Kling tekst-til-video-forespørsel

Det nåværende tekst-til-video-endepunktet aksepterer JSON og Bearer-autentisering. Start med en kort prompt og den minste støttede varigheten. Følgende forespørsel bruker kun felter som vises i gjeldende CometAPI-referanse:

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 innsending returnerer et objekt som inneholder data.task_id og en oppgavestatus. Lagre denne oppgave-ID-en sammen med applikasjonens jobbreferanse. Ikke hold HTTP-tilkoblingen åpen mens videoen rendres.

Håndter den asynkrone oppgaven trygt

Kling-generering er asynkron. For tekst-til-video, poll GET /kling/v1/videos/text2video/{task_id}. CometAPIs oppgavereferanse sier at et svar kan returnere oppgaven direkte eller inne i en data-konvolutt, så eksempelet normaliserer begge former. Det behandler også enhver ikke-terminal tilstand som “fortsett å vente” i stedet for å anta en fast liste over mellomtilstander.

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("Oppgaven ble vellykket uten en video-URL")
            return videos[0]["url"]

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

        time.sleep(10)

    raise TimeoutError(f"Kling-oppgave {task_id} overskred {timeout_seconds}s")

Den terminale suksess-strengen er succeed, ikke succeeded. Når en oppgave fullfører, kopier den genererte ressursen til lagring du kontrollerer hvis produktet ditt krever varig lagring. Leverandørens leverings-URL-er bør ikke behandles som permanent applikasjonslagring.

For større arbeidsmengder, bruk en kø eller arbeidsprosess i stedet for å polle inne i en web-forespørsel. CometAPI dokumenterer også callback-URL-er for Kling-oppgaver. Hvis du tar i bruk webhooks, autentiser og dedupliser callback-hendelser, og behold en fallback med polling for uteblitte leveranser.

Design jobbens livssyklus i applikasjonen før du skalerer

Behandle leverandørens oppgave som én del av din egen jobbpost. Lagre en applikasjonsjobb-ID, arbeidsflyt, ønsket modell, leverandørens oppgave-ID, spørrings-URL, gjeldende status, innsendingstidspunkt, siste poll-tid og utdata-plassering. Dette gir support- og driftsteamene dine nok kontekst til å undersøke en mislykket eller treg generering uten å lete i rå forespørselslogger.

Ikke forsøk å opprette på nytt bare fordi klienten ikke mottok svar. Leverandøren kan allerede ha opprettet en oppgave. Persistér din lokale jobb før innsending, lagre returnert oppgave-ID umiddelbart, og skill mellom re-forsøk på opprettelse og re-forsøk på statusforespørsler. Den nåværende tekst-til-video-referansen dokumenterer også external_task_id for applikasjonssporing; bekreft live-oppførselen før du stoler på den som dedupliseringsmekanisme.

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-respons mangler oppgaveidentitet eller status");
  }
  return task;
}

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

  if (!response.ok) {
    throw new Error(`Oppgavespørring feilet med 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 eksempelet oversetter bevisst ikke hver mulig mellomliggende leverandørstatus til et produktløfte. Arbeideren din holder ikke-terminale oppgaver aktive, håndterer succeed og failed eksplisitt, og registrerer rå leverandørstatus for feilsøking. Legg til en separat applikasjonstimeout slik at en fastlåst oppgave ikke forblir åpen for alltid.

Bruk polling som baseline fordi oppgave-ID-en forblir søkbar. Når valgt endepunkt støtter callback_url, kan en webhook redusere gjentatte statusforespørsler, men den bør ikke være din eneste gjenopprettingsmekanisme. Den offisielle veiledningen for polling og webhooks påpeker at callback-payload kan være leverandørspesifikk. Lagre råhendelsen, gjør prosesseringen idempotent per oppgave-ID, returner et vellykket HTTP-svar raskt, og avklar terminal tilstand via polling.

Sjekkliste for produksjon for utviklerteam

• Valider modellen ved runtime. Sjekk gjeldende katalog og feile tydelig når en forespurt modell ikke er tilgjengelig. Ikke erstatt stille med en annen modell hvis utdataatferd er viktig.
• Skill innsending fra henting. Lagre CometAPI-oppgave-ID, din egen jobb-ID, valgt modell og tidsstempler slik at re-forsøk ikke skaper duplisert arbeid.
• Avgrens polling. Bruk en timeout, eksponentiell backoff eller et rimelig fast intervall, og et maksimum antall forsøk. Les CometAPIs veiledning om rategrenser og samtidighet før du øker parallelliseringen.
• Klassifiser feil. Ikke prøv igjen ved ugyldige parametere eller autentiseringsfeil. Bruk backoff for re-forsøk ved rategrenser og plattformfeil, i tråd med gjeldende retry-veiledning.
• Beskytt legitimasjon og inndata. Hold API-nøkler på serversiden, unngå å logge hemmeligheter, og bekreft at brukerne har rettigheter til eventuelle prompt, bilder eller andre kilder de sender inn.
• Mål hele jobben. Spor innsending, køtid, genereringstid, terminal feilrate, timeout-rate, suksess for uthenting av utdata og kostnad per modell og modus.
• Persistér utdata bevisst. Last ned fullførte ressurser til egen kontrollert lagring når produktet ditt trenger varig tilgang, og anvend din policy for oppbevaring og sletting.

Praktiske vanlige spørsmål

Trenger jeg en egen Kling-utviklerkonto for denne veien?

Nei, ingen separat Kling-utvikleronboarding ser ut til å inngå i CometAPIs integrasjonsflyt. Du bruker en CometAPI-konto og API-nøkkel. Tilgang avhenger fortsatt av at modellen er tilgjengelig for CometAPI-kontoen og regionen din, så bekreft det før du forplikter deg til produksjon.

Er Kling API-et fullt ut OpenAI-kompatibelt?

Ikke for videoflyten som vises her. Den bruker Kling-spesifikke ruter som /kling/v1/videos/text2video og Kling-spesifikke felter. Du kan håndtere legitimasjon via CometAPI, men adapteren din bør bevare leverandørspesifikt skjema.

Hvilken Kling-modell-ID bør jeg bruke?

Den gjeldende CometAPI tekst-til-video-referansen bruker kling-v3 i sitt første fungerende eksempel og lister flere tidligere modellspor. Bruk en modell-ID fra den live endepunkt-enumen og verifiser at den er aktivert for kontoen din. Ikke anta at den nyeste modellen er tilgjengelig overalt.

Hvorfor inneholder ikke første respons en video?

Videogenerering kjøres som en asynkron oppgave. Den første responsen returnerer en oppgave-ID. Poll den matchende spørringsruten til task_status blir succeed eller failed, og les deretter resultatmetadata.

Bør jeg polle eller bruke en callback-URL?

Polling er enklest for en første integrasjon. Callbacks reduserer gjentatte forespørsler i skala, men krever en autentisert, idempotent mottaker og gjenopprettingslogikk. Mange produksjonssystemer bruker callbacks som primærvei og polling som fallback.

Kan jeg bruke bilde-til-video via samme endepunkt?

Nei. CometAPI dokumenterer bilde-til-video under en separat rute, /kling/v1/videos/image2video. Følg dette endepunktets gjeldende forespørselsskjema i stedet for å legge til et bildefelt i tekst-til-video-eksemplet.

Bør jeg starte med standard eller profesjonell modus?

Bruk std for å validere autentisering, forespørselsskjema, oppgavelagring, polling og uthenting av utdata. Den nåværende referansen beskriver pro som en modus med høyere kvalitet og høyere kostnad. Evaluer den med representative prompt først etter at basisflyten fungerer, og sammenlign utdatakvalitet sammen med genereringstid og faktisk kostnad.

Hvordan unngår jeg dupliserte genereringer under re-forsøk?

Opprett en applikasjonsjobbpost før API-kallet og lagre returnert leverandør-oppgave-ID umiddelbart. Forsøk statusforespørsler uavhengig av opprettelsesforespørselen. Ikke anta at det å gjenta samme POST er idempotent. Endepunktet dokumenterer for tiden external_task_id for sporing, men verifiser gjeldende semantikk før du behandler det som en dedupliseringsgaranti.

Konklusjon

For et utviklingsteam i USA som vil teste Kling-videogenerering uten å fullføre en separat direkte Kling-utviklersøknad, tilbyr CometAPI en dokumentert vei: verifiser at nødvendig Kling-modell er tilgjengelig for kontoen, autentiser med en CometAPI-nøkkel, kall arbeidsflytspesifikt endepunkt og spor den asynkrone oppgaven til en terminal tilstand.

Den praktiske ingeniørverdien er sentralisert tilgang og en gjenbrukbar jobbmodell i applikasjonen—ikke antakelsen om at alle videoleverandører oppfører seg likt. Behold en tynn adapter for hver arbeidsflyt, persister oppgaveidentitet og utdata bevisst, og behold polling som gjenopprettingsvei selv når callbacks er aktivert.

En trygg utrulling er liten og målbar: valider én modell og én arbeidsflyt, send korte lavkostjobber, registrer terminale suksess- og feilrater, verifiser uthenting av utdata, og sammenlign faktisk kostnad og latens med produktkravene dine. Utvid til bilde-til-video eller flere Kling-arbeidsflyter først etter at gjeldende dokumentasjon og mål-kontoen din er kontrollert.