Blog

Wie benutzt man die Kimi K3 API?

Rufen Sie die Kimi K3 API mit dem OpenAI SDK auf: Python-, JavaScript- und cURL-Schnellstarts, sowie Streaming, Tool-Aufrufe, JSON-Modus, Denkaufwand und Caching.

Ashley Innocent

Ashley Innocent

17 July 2026

Wie benutzt man die Kimi K3 API?

Apidog fĂĽr Unternehmen

On-Premises Bereitstellung

SSO & RBAC

SOC 2 konform

Apidog Enterprise entdecken

Moonshot AI hat Kimi K3 am 16. Juli 2026 ausgeliefert und es als ihr bisher leistungsfähigstes Modell bezeichnet: das weltweit erste offene Modell der 3T-Klasse mit einem 2.8T-Parameter Mixture-of-Experts-Design und einem 1.048.576-Token-Kontextfenster. Das Interessante für Entwickler ist nicht die Größe, sondern die API. Kimi K3 spricht den OpenAI SDK-Dialekt, wenn Sie also bereits GPT oder einen anderen OpenAI-kompatiblen Endpunkt nutzen, können Sie denselben Client auf kimi-k3 verweisen und innerhalb weniger Minuten mit dem Streaming von Antworten beginnen. Dieser Leitfaden führt Sie durch die Beschaffung eines Schlüssels, den Schnellstart in Python, JavaScript und cURL, Streaming, Tool-Aufrufe, den JSON-Modus, den konfigurierbaren reasoning-effort-Parameter und das Kontext-Caching, das Cache-Hit-Eingaben etwa zehnmal günstiger macht als Cache-Miss. Anschließend testen und debuggen Sie diese Aufrufe in Apidog, damit Sie die Rohanfrage und die Server-Sent Events sehen können, anstatt nur zu raten.

TL;DR

Welches Kimi-Modell sollten Sie aufrufen

Bevor Sie Code schreiben, wählen Sie das richtige Ziel. Kimi K3 ist das führende Modell der Familie: ein großes MoE, das auf komplexe Codierung, langfristige Agentenarbeit und Wissensaufgaben über lange Kontexte abzielt. Es verursacht die höchsten Pro-Token-Ausgabekosten in der Modellreihe, und Moonshots eigener Launch-Beitrag gibt offen zu, dass K3 in ihren internen Vergleichen hinter Claude Fable 5 und GPT-5.6 Sol zurückliegt. Es ist stark, aber kein klarer Spitzenreiter, und es ist entsprechend bepreist.

Wenn Ihr Workload ein hochvolumiger Codierungsassistent, ein CI-Test-Autor oder etwas anderes ist, bei dem Sie pro Aufruf im großen Maßstab bezahlen, ist die ältere K2.7 Code-Linie oft die bessere Wahl hinsichtlich der Kosten. Beginnen Sie mit dem Kimi K2.7 Code API-Leitfaden und der Kimi K2.7 Code-Übersicht, um zu sehen, ob diese Stufe Ihren Anwendungsfall abdeckt. Für einen direkten Vergleich von Fähigkeiten und Preis zeigt der Vergleich Kimi K3 vs. Kimi K2.7 Code, wo jedes Modell seine Stärken hat. Greifen Sie zu kimi-k3, wenn Sie die zusätzliche Argumentationstiefe, den vollständigen 1M Kontext oder die agentische Tool-Orchestrierung benötigen; wechseln Sie zu K2.7, wenn die Aufgabe Routine ist und das Volumen hoch ist. Wenn Sie zuerst eine vollständige Übersicht über die Fähigkeiten wünschen, erläutert der Kimi K3-Erklärer die Architektur und die Positionierung des Modells.

API-SchlĂĽssel auf der Kimi-Plattform erhalten

Gehen Sie zu platform.kimi.ai und melden Sie sich an. In der neuen Konsole erstellen Sie Schlüssel, überwachen die Nutzung und bestätigen die Basis-URL für Ihr Konto.

  1. Ă–ffnen Sie den Bereich API-SchlĂĽssel der Konsole und erstellen Sie einen neuen SchlĂĽssel.
  2. Kopieren Sie ihn einmal und speichern Sie ihn an einem sicheren Ort. Sie werden den vollständigen Wert nicht wieder sehen.
  3. Fügen Sie Guthaben hinzu oder bestätigen Sie Ihre Abrechnungsstufe, damit Anrufe an kimi-k3 nicht wegen unzureichenden Guthabens abgelehnt werden.
  4. Beachten Sie die in der Konsole angezeigte Basis-URL. Kimi hat historisch https://api.moonshot.ai/v1 verwendet; die Konsole ist die Quelle der Wahrheit fĂĽr Ihr Konto.

Exportieren Sie den SchlĂĽssel als Umgebungsvariable, damit er niemals in Ihrem Quellcode landet:

export KIMI_API_KEY="sk-your-key-here"

Diese eine Gewohnheit hält Geheimnisse aus der Git-Historie und aus Screenshots fern. Später, wenn Sie in Apidog testen, speichern Sie denselben Wert auch dort als Umgebungsvariable, sodass der Schlüssel an genau zwei Orten liegt, die Sie kontrollieren.

Für eine vollständige Aufschlüsselung der Cache-Hit- versus Cache-Miss-Berechnung und deren Auswirkungen auf die tatsächlichen Monatsrechnungen, siehe den Kimi K3-Preisleitfaden.

Schnellstart: Ihr erster kimi-k3-Aufruf

Kimis API folgt dem OpenAI Chat-Completions-Vertrag, daher funktionieren die offiziellen OpenAI SDKs mit zwei Ă„nderungen: der base_url und dem model. Installieren Sie das bevorzugte SDK und fĂĽhren Sie dann einen der folgenden Snippets aus.

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["KIMI_API_KEY"],
    # Kimi ist OpenAI-SDK-kompatibel. Bestätigen Sie die genaue Basis-URL in der
    # Konsole unter platform.kimi.ai; Kimi hat historisch den untenstehenden Wert verwendet.
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a precise coding assistant."},
        {"role": "user", "content": "Explain what a token bucket rate limiter does in one paragraph."},
    ],
)

print(response.choices[0].message.content)

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  // Bestätigen Sie die Basis-URL in der platform.kimi.ai-Konsole.
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "system", content: "You are a precise coding assistant." },
    { role: "user", content: "Explain what a token bucket rate limiter does in one paragraph." },
  ],
});

console.log(response.choices[0].message.content);

cURL

curl "$KIMI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "user", "content": "Explain what a token bucket rate limiter does in one paragraph."}
    ]
  }'

Setzen Sie KIMI_BASE_URL auf den in der Konsole angezeigten Wert (zum Beispiel https://api.moonshot.ai/v1). Wenn eine dieser Anfragen einen 401-Fehler zurĂĽckgibt, ist der SchlĂĽssel falsch oder nicht gesetzt. Ein 404-Fehler auf dem Pfad bedeutet normalerweise, dass die Basis-URL falsch ist und nicht, dass das Modell fehlt. Die OpenAI Python SDK-Dokumentation behandelt die Client-Optionen detaillierter, und jede dortige Option gilt auch hier, da das Ăśbertragungsformat dasselbe ist.

Streaming-Antworten

Für Chat-UIs und lange Agenten-Durchläufe möchten Sie Tokens erhalten, sobald sie eintreffen, anstatt auf die vollständige Vervollständigung zu warten. Setzen Sie stream=True und iterieren Sie über die Deltas.

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Write a 6-line poem about flaky tests."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

Im Hintergrund handelt es sich um einen Server-Sent Events (SSE)-Stream: Jede Zeile ist ein data:-Frame, der ein kleines JSON-Chunk enthält, und der Stream endet mit data: [DONE]. Das SDK verbirgt diese Struktur vor Ihnen, was praktisch ist, bis etwas mitten im Stream bricht und Sie die Roh-Frames sehen müssen. Dies ist ein Punkt, an dem der Apidog-Abschnitt unten seinen Wert beweist.

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [{ role: "user", content: "Write a 6-line poem about flaky tests." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Tool-Aufrufe (Funktionsaufrufe)

Kimi K3 unterstützt Tool-Aufrufe, Tool-Auswahl-Beschränkungen und dynamisches Tool-Laden, sodass Sie es in Agenten integrieren können, die Dateien lesen, APIs aufrufen oder Terminalbefehle ausführen. Sie beschreiben Ihre Funktionen mit JSON Schema, das Modell entscheidet, wann eine Funktion aufgerufen werden soll, und Sie geben das Ergebnis in einer tool-Nachricht zurück.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name, e.g. Singapore"},
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the weather in Singapore right now?"}]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

tool_call = first.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_weather
print(tool_call.function.arguments)  # {"city": "Singapore"}

Das Modell fĂĽhrt Ihre Funktion nicht aus; es gibt Ihnen einen Namen und JSON-Argumente. Sie fĂĽhren die eigentliche Arbeit aus und speisen dann die Ausgabe zurĂĽck, damit das Modell eine endgĂĽltige Antwort schreiben kann:

import json

# Append the assistant turn that asked for the tool, then the tool result.
messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps({"city": "Singapore", "temp_c": 31, "sky": "humid"}),
})

final = client.chat.completions.create(model="kimi-k3", messages=messages, tools=tools)
print(final.choices[0].message.content)

Setzen Sie tool_choice="required", um einen Tool-Aufruf zu erzwingen, oder übergeben Sie ein spezifisches {"type": "function", "function": {"name": "get_weather"}}-Objekt, um eine Funktion festzulegen. Diese Beschränkungen halten einen Agenten auf Kurs, wenn Sie bereits wissen, welches Tool ausgelöst werden soll.

Eine K3-spezifische Besonderheit, die man früh kennen sollte: Das Modell wurde im Modus "preserved-thinking-history" trainiert. Wenn Ihr Agenten-Framework das frühere Denken des Modells zwischen den Gesprächsrunden verwirft, kann die Generierungsqualität instabil werden. Wenn Sie eine Agenten-Schleife mit mehreren Runden erstellen, geben Sie die gesamte Nachrichtenhistorie zurück, anstatt die internen Gesprächsrunden des Assistenten zu kürzen.

JSON-Modus und strukturierte Ausgabe

Wenn Sie maschinenlesbare Ausgaben benötigen, fordern Sie JSON direkt an, anstatt Prosa zu parsen. Setzen Sie response_format auf json_object und weisen Sie das Modell an, JSON zurückzugeben.

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "Return only valid JSON. No prose, no markdown."},
        {"role": "user", "content": "Extract name and role from: 'Ada Lovelace, mathematician'."},
    ],
    response_format={"type": "json_object"},
)

print(response.choices[0].message.content)  # {"name": "Ada Lovelace", "role": "mathematician"}

FĂĽr strengere Garantien unterstĂĽtzt Kimi strukturierte Ausgabe gegen ein Schema. Wenn Ihre SDK-Version dies akzeptiert, ĂĽbergeben Sie ein json_schema-Antwortformat, damit das Modell Ihrer Form entspricht:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Extract name and role from: 'Ada Lovelace, mathematician'."}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "role": {"type": "string"},
                },
                "required": ["name", "role"],
            },
        },
    },
)

Bestätigen Sie die json_schema-Unterstützung für Ihr Konto in der Konsole, bevor Sie es veröffentlichen; im Zweifelsfall ist json_object plus ein Validierungsschritt auf Ihrer Seite der sichere Ausweg. Kimi bietet auch einen Teillmodus und Internetrecherche, die hilfreich sind, wenn Sie eine Assistentenantwort vorab ausfüllen oder Antworten auf neuen Daten basieren möchten.

Konfigurierbarer Argumentationsaufwand

Kimi K3 bietet einen reasoning_effort-Parameter, der steuert, wie stark das Modell nachdenkt, bevor es antwortet. Heute ist der verfügbare Wert max, was auch der Standard ist; Moonshot hat angekündigt, dass niedrigere und höhere Stufen geplant sind. Tieferes Nachdenken kostet mehr Ausgabe-Tokens und erhöht die Latenz, daher ist es ein Hebel, den Sie pro Aufgabe einstellen können.

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Plan a migration from REST to GraphQL for a 40-endpoint API."}],
    reasoning_effort="max",
)

Wenn Ihre OpenAI SDK-Version das Feld als unbekannt ablehnt, ĂĽbergeben Sie es stattdessen ĂĽber den "Escape Hatch":

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Plan a migration from REST to GraphQL."}],
    extra_body={"reasoning_effort": "max"},
)

Das extra_body-Muster ist die Art und Weise, wie Sie anbieterspezifische Felder senden, die das Basis-SDK noch nicht modelliert, was häufig vorkommt, wenn ein kompatibler Endpunkt schneller ist als die Client-Bibliothek.

kimi-k3 in Apidog testen und debuggen

SDK-Code verbirgt das Übertragungsformat, was in Ordnung ist, bis ein Tool-Aufruf die falsche Form zurückgibt oder ein Stream abbricht und Sie nicht erkennen können, ob der Fehler bei Ihnen oder dem Endpunkt liegt. Hier zahlt sich ein API-Client aus, der reines HTTP spricht. Apidog ermöglicht es Ihnen, die exakte kimi-k3-Anfrage zu senden, den SSE-Stream Frame für Frame zu beobachten und Ihren Schlüssel außerhalb des Anfragetextes zu halten. Wenn Sie API-Aufrufe lieber testen möchten, ohne in einem Terminal zu leben, ist dies ein saubererer Workflow als "curl-and-squint"; der Leitfaden APIs testen ohne Postman behandelt den allgemeinen Arbeitsablauf.

Hier ist ein fokussierter Ablauf fĂĽr kimi-k3:

  1. Erstellen Sie eine neue HTTP-Anfrage in Apidog. Setzen Sie die Methode auf POST und die URL auf Ihre Basis-URL plus /chat/completions.
  2. Speichern Sie Ihren Schlüssel als Umgebungsvariable. Fügen Sie in den Umgebungseinstellungen von Apidog KIMI_API_KEY hinzu und setzen Sie dann den Authorization-Header auf Bearer {{KIMI_API_KEY}}. Nun wird das Geheimnis referenziert, nicht eingefügt, und Sie können zwischen Test- und Produktionsschlüsseln wechseln, indem Sie die Umgebungen ändern.
  3. Fügen Sie einen JSON-Body mit "model": "kimi-k3" und Ihr messages-Array ein. Senden Sie die Anfrage und lesen Sie die vollständige Antwort, einschließlich der Token-Nutzung, damit Sie Cache-Hit- versus Cache-Miss-Anzahlen bei tatsächlichen Aufrufen sehen können.
  4. Schalten Sie "stream": true um und beobachten Sie, wie die Server-Sent Events als diskrete Frames eintreffen. Das Sehen der rohen data:-Chunks macht Streaming-Fehler auf eine Weise offensichtlich, die der saubere Iterator des SDK nicht bietet.
  5. Debuggen Sie Tool-Aufrufe, indem Sie das tool_calls-Array in der Antwort überprüfen. Wenn Argumente fehlerhaft zurückkommen, können Sie sehen, ob das Modell schlechtes JSON produziert hat oder Ihr Schema mehrdeutig war, und die Beschreibung direkt dort korrigieren.
  6. A/B-Test gegen kimi-k2-7-code. Duplizieren Sie die Anfrage, ändern Sie nur das Feld model und vergleichen Sie Latenz, Ausgabequalität und Kosten für denselben Prompt. Das ist der schnellste und ehrlichste Weg, um zu entscheiden, ob die zusätzliche Argumentationsfähigkeit von K3 den Preissprung für Ihre Aufgabe wert ist.

Da Apidog OpenAI-kompatible Anfragen direkt importiert, können Sie einen cURL-Befehl einfügen und eine gespeicherte, wiederholbare Anfrage mit bereits ausgefüllten Headern und Body erhalten. Von dort aus wird es zu einem geteilten Testfall, den Ihr Team jedes Mal ausführen kann, wenn Kimi ein Update veröffentlicht. Wenn Ihr Agent über MCP mit dem Modell kommuniziert, zeigt der Leitfaden visuelles Debugging mit dem Apidog MCP-Client, wie Sie diese Aufrufe ebenfalls verfolgen können. Laden Sie Apidog herunter, wenn Sie diesen Ablauf mit Ihrem eigenen Schlüssel verfolgen möchten.

Anwendungsfälle in der Praxis

Einige Muster passen genau zu dem, wofĂĽr kimi-k3 entwickelt wurde:

Bei jedem dieser Fälle ist der Workflow derselbe: Erstellen Sie die Anfrage mit dem SDK, überprüfen Sie das Rohverhalten in Apidog und integrieren Sie es dann in Ihre App, sobald Sie der Form vertrauen.

Zusammenfassung

Der Aufruf von Kimi K3 läuft auf drei Einstellungen bei einem OpenAI-kompatiblen Client hinaus: die Basis-URL aus Ihrer Konsole, Ihr API-Schlüssel und model="kimi-k3". Von dort aus folgen Streaming, Tool-Aufrufe, JSON-Modus, strukturierte Ausgabe und reasoning_effort alle dem Chat-Completions-Vertrag, den Sie bereits kennen. Die zwei Dinge, die es zu verinnerlichen gilt, sind die Cache-Ökonomie, bei der das Beibehalten eines stabilen Präfixes 3,00 $ Input in 0,30 $ Input verwandelt, und der ehrliche Kompromiss, dass K3 Argumentationstiefe zu einem echten Preis erkauft, leiten Sie also routinemäßige Hochvolumen-Arbeit an die K2.7-Linie weiter. Erstellen Sie die Anfrage im Code, testen Sie sie in Apidog, und Sie werden kimi-k3 ohne Überraschungen einsetzen.

FAQ

Wie lautet die API-Modell-ID fĂĽr Kimi K3? Auf Kimis eigener Plattform ist es kimi-k3. Wenn Sie es ĂĽber OpenRouter aufrufen, ist der Slug moonshotai/kimi-k3. Die OpenRouter-Listung des Modells finden Sie unter openrouter.ai/moonshotai/kimi-k3.

Welche Basis-URL verwende ich? Bestätigen Sie diese in der Konsole unter platform.kimi.ai, da dies die zuverlässigste Quelle für Ihr Konto ist. Kimi hat historisch https://api.moonshot.ai/v1 verwendet. Halten Sie es im Code als base_url-Variable, die Sie aus der Konsole festlegen, anstatt es fest zu codieren.

Ist Kimi K3 mit dem OpenAI SDK kompatibel? Ja. Die API folgt dem OpenAI Chat-Completions-Format, sodass die offiziellen OpenAI Python- und JavaScript-SDKs funktionieren, nachdem Sie base_url und model geändert haben. Anbieterspezifische Felder werden über extra_body übergeben.

Wie viel kostet die Kimi K3 API? $0.30 pro Million Cache-Hit-Input-Tokens, $3.00 pro Million Cache-Miss-Input-Tokens und $15.00 pro Million Output-Tokens. Die Strukturierung von Prompts für die Cache-Wiederverwendung ist der größte Hebel, um Ihre Kosten zu beeinflussen. Der Kimi K3-Preisleitfaden erklärt die Zahlen.

Was bewirkt Kontext-Caching eigentlich? Wenn die fĂĽhrenden Tokens Ihrer Anfrage mit einer frĂĽheren ĂĽbereinstimmen, verwendet der Endpunkt den berechneten Zustand wieder, anstatt ihn neu zu berechnen, was die Input-Kosten fĂĽr diesen Teil von $3.00 auf $0.30 pro Million senkt. Halten Sie Ihren System-Prompt und den gemeinsamen Kontext vorne und identisch ĂĽber alle Aufrufe hinweg, um die Treffer zu maximieren.

Kann ich steuern, wie stark das Modell nachdenkt? Ja, über reasoning_effort. Der heute verfügbare Wert ist max, was auch der Standard ist; Moonshot hat angekündigt, dass weitere Stufen geplant sind. Höherer Aufwand kostet mehr Ausgabe-Tokens und erhöht die Latenz.

Sollte ich Kimi K3 oder Kimi K2.7 Code verwenden? Verwenden Sie kimi-k3, wenn Sie tiefe Argumentation, den vollständigen 1M Kontext oder agentische Tool-Orchestrierung benötigen. Für hochvolumige, routinemäßige Codierungsarbeiten ist die günstigere K2.7-Linie oft die bessere Wahl. Der Vergleich Kimi K3 vs. Kimi K2.7 Code und der Kimi K2.7 Code API-Leitfaden helfen Ihnen bei der Entscheidung.

Wie debugge ich eine fehlerhafte Streaming- oder Tool-Call-Antwort? Senden Sie die Rohanfrage in Apidog mit "stream": true und lesen Sie die Server-Sent Events Frame für Frame, oder überprüfen Sie das tool_calls-Array, um festzustellen, ob das Modell fehlerhaftes JSON zurückgegeben hat. Das Speichern Ihres Schlüssels als Umgebungsvariable hält ihn während des Tests aus dem Anfragetext fern.

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenHerunterladen