Blog

Kimi K2.6 API Nutzung: Eine Anleitung

Ashley Innocent

Ashley Innocent

21 April 2026

Kimi K2.6 API Nutzung: Eine Anleitung

Apidog für Unternehmen

On-Premises-Bereitstellung

SSO & RBAC

SOC 2 konform

Apidog Enterprise entdecken

Die Ankündigung von Kimi K2.6 von Moonshot AI positioniert es als den neuen Open-Source-Stand der Technik für Codierung, Langzeit-Ausführung und Agentenschwärme. Die API, die es antreibt, ist OpenAI-kompatibel, wird unter https://api.moonshot.ai/v1 gehostet und ist auf der Plattform dokumentiert. Wenn Sie das OpenAI SDK installiert haben, können Sie innerhalb von etwa fünf Minuten echte Anfragen senden.

Dieser Leitfaden führt Sie durch die Authentifizierung, Ihre erste Anfrage, Streaming, Tool-Aufrufe, Bild- und Videoeingabe, den Denkmodus und wie Sie Agent Swarm mit 300 Sub-Agenten steuern, und zeigt, wie Sie jeden Endpunkt mit Apidog testen, bevor Sie Integrationscode schreiben.

💡
Schnellstart: Testen Sie die Kimi K2.6 API visuell in Apidog, bevor Sie Integrationscode committen. Ein Import, ein Bearer-Token, und Sie stellen echte gestreamte Anfragen mit vollständiger Historie und Schema-Validierung. Laden Sie Apidog kostenlos herunter.

Button

TL;DR: Kimi K2.6 API in 60 Sekunden

Minimaler Curl-Befehl:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'

Das ist alles. Der Rest dieses Leitfadens erläutert die Details, einschließlich Agent Swarm und die von Moonshot genannte Ausführungsgrenze von 4.000 Schritten.

Bild

Was Sie tatsächlich mit dieser API tun können

Laut der Kimi K2.6-Ankündigung ermöglicht die API all dies in der Produktion:

Wenn Sie Tools in derselben Kategorie wie Claude Code Computernutzung, eigenes Claude Code erstellen oder Cursor Composer 2 entwickeln, ist die K2.6 API ein direkter Austausch auf der Modellebene.

Schritt 1: API-Schlüssel erhalten

  1. Gehen Sie zu platform.moonshot.ai (oder platform.kimi.ai) und registrieren Sie sich. E-Mail oder Google OAuth funktioniert.
  2. Verifizieren Sie Ihr Konto. Internationale Benutzer benötigen möglicherweise eine SMS-Verifizierung.
  3. Fügen Sie Abrechnungsinformationen hinzu. Moonshot schreibt neuen Konten typischerweise ein kleines kostenloses Guthaben gut.
  4. Öffnen Sie API-Schlüssel im Dashboard und klicken Sie auf Schlüssel erstellen.
  5. Kopieren Sie den Schlüssel sofort (er wird nur einmal angezeigt).
  6. Exportieren Sie ihn:
export KIMI_API_KEY="sk-..."

Fügen Sie ihn zu .zshrc, .bashrc oder einem Secret Manager für die Produktion hinzu. Committen Sie ihn niemals.

Möchten Sie während der Entwicklung keine Kosten verursachen? Kimi K2.6 kostenlos nutzen behandelt Cloudflare Workers AI, selbst gehostete Gewichte und kostenlose Guthabenprogramme.

Schritt 2: Wählen Sie Ihr SDK

Die API ist OpenAI-kompatibel, daher funktionieren die offiziellen OpenAI SDKs, nachdem Sie die Basis-URL geändert haben.

Option Installation Am besten geeignet für
curl integriert Schnelle Tests, CI
OpenAI Python pip install openai Python-Dienste
OpenAI Node npm install openai JS/TS-Anwendungen

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

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

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

Curl

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'

Alle drei geben dieselbe Antwortstruktur zurück.

Schritt 3: Den Request Body verstehen

Dieselbe Felder wie OpenAI Chat Completions:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}

Zwei Moonshot-spezifische Hinweise:

Schritt 4: Streaming

Streaming ist die richtige Standardeinstellung für jede Benutzeroberfläche oder lange Generierung. Die maximale Ausgabe für Aufgaben, die Argumentation erfordern, kann 98.304 Tokens erreichen; Sie möchten nicht auf alles gleichzeitig warten.

Python

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

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

Node.js

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

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

Streaming funktioniert auch mit Tool-Aufrufen; die Argumente kommen als JSON-Deltas an, die Sie verketten.

Schritt 5: Tool-Aufrufe

Moonshot meldet einen Toolathlon-Score von 50,0 % und eine 96,60 %ige Erfolgsquote bei Tool-Aufrufen in Partnertests. Das Format entspricht dem Standard-OpenAI-Funktionsaufruf-Schema, sodass bestehende API-Test-Workflows für QA-Ingenieure anwendbar sind.

Tools definieren

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

Erster Aufruf (Modell entscheidet)

import json

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

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })

Zweiter Aufruf (endgültige Antwort)

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

K2.6 ist stark in mehrstufigen Tool-Ketten, was langlaufende Code-Agenten wie Kimi Code realisierbar macht. Für einen Framework-Vergleich behandelt Claude Code Workflows denselben Loop mit einem anderen Backend.

Schritt 6: Vision-Eingabe

K2.6 erreicht 79,4 % bei MMMU-Pro und 96,9 % bei V* (mit Python). Bilder werden in der Benutzernachricht im image_url-Inhaltsformat von OpenAI übermittelt:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)

Für lokale Dateien kodieren Sie diese in Base64:

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/jpeg;base64,{b64}"

Für OCR oder das Lesen von Diagrammen kombinieren Sie eine klare Textanweisung mit dem Bild. Für mathematische Probleme fügen Sie ein Python-Interpreter-Tool hinzu; der MathVision-Score von 93,2 % wurde mit aktiviertem Python-Zugriff gemessen.

Schritt 7: Video-Eingabe

Geben Sie eine Video-URL oder eine Bildsequenz an:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)

Kurze Clips (<30s) funktionieren in einem einzigen Aufruf. Längere Videos profitieren vom Streaming, da die Frame-für-Frame-Inferenz viele Tokens produziert.

Schritt 8: Denkmodus

kimi-k2.6-thinking erzeugt eine sichtbare Denkspur (ähnlich den o1-Modellen von OpenAI). Moonshot meldet 96,4 % bei AIME 2026 und 90,5 % bei GPQA-Diamond mit aktiviertem Denkmodus.

Denkmodus an (Standard für das Denkmodell):

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)

Denkmodus aus:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)

Die Denkspur wird in einem reasoning-Feld der Antwort zurückgegeben. Sie können sie vor Endbenutzern verbergen und nur die endgültige Antwort anzeigen oder sie in ein Debug-Log leiten.

Schritt 9: Agenten-Schwarm

Agenten-Schwarm ist die Funktion, die am meisten Beachtung verdient. Aus dem Kimi K2.6 Blog: bis zu 300 Sub-Agenten, über 4.000 koordinierte Schritte, 3x die Kapazität von K2.5.

Rufen Sie es über den Agent-Parameter der Plattform auf:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)

Schwarm-Aufrufe laufen Minuten oder Stunden. Drei praktische Tipps:

  1. Streaming verwenden. Sie werden den Fortschritt sehen und fehlerhafte Läufe frühzeitig beenden wollen.
  2. Begrenzen Sie max_agents. 300 ist das Maximum; 10 bis 30 ist für die meisten Aufgaben vorhersehbarer.
  3. Legen Sie ein Budget fest. Lange Schwarm-Aufgaben können schnell Tokens verbrauchen; protokollieren Sie die usage bei jeder Antwort und leiten Sie sie in Ihre Metriken.

Der Kimi-Blog beschreibt Demo-Läufe, die über 4.000 Codezeilen in 13 Stunden geändert haben. Die Architektur macht dies möglich; das API-Flag schaltet es lediglich ein.

Schritt 10: Alles mit Apidog testen

Jeder oben genannte Abschnitt führt eine andere Body-Struktur, Header-Anforderung oder ein anderes Antwortformat ein. Apidog verwandelt den Debugging-Loop in einen visuellen Workflow.

Bild

Kimi K2.6 Einrichtung in Apidog

  1. Laden Sie Apidog herunter und erstellen Sie ein Projekt.
  2. Erstellen Sie eine kimi-prod Umgebung mit zwei Variablen: BASE_URL = https://api.moonshot.ai/v1 und KIMI_API_KEY = sk-....
  3. Neue API-Anfrage: POST {{BASE_URL}}/chat/completions.
  4. Header: Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json.
  5. Body (Streaming-Beispiel):
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
  1. Klicken Sie auf Senden. Tokens strömen in Echtzeit in das Antwortpanel.

Was Apidog zusätzlich bietet

Für Tests im Editor ist Apidog auch als VS Code Erweiterung verfügbar. Wenn Sie derzeit an Postman gebunden sind, beschreibt wie man API-Tests ohne Postman durchführt den Umstieg.

Fehlerbehandlung, die Sie nicht bekämpft

Moonshot verwendet Standard-HTTP-Statuscodes:

Retry-Wrapper:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")

Bei Verbindungsabbrüchen während des Streams verfolgen Sie die empfangenen Tokens und starten Sie mit einer "hier fortfahren"-Anweisung neu, falls die Verbindung abbricht. Die Obergrenze von 98.304 Tokens für die Denk-Ausgabe bedeutet, dass lange Streams normal sind und kein Fehler.

Kostenkontrolle

Moonshot veröffentlicht die Preise unter kimi.com/membership/pricing. Drei praxiserprobte Tipps, um die Kosten vorhersehbar zu halten:

Produktionsmuster: Ein GitHub-Issue-Fixer

Hier ist ein Agent, der ein GitHub-Issue liest, den relevanten Code findet, eine Korrektur vorschlägt und Tests ausführt, strukturiert um die Kimi K2.6 Tool-Calling-Schleife:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })

Dies skaliert mit Agenten-Schwarm durch Hinzufügen der extra_body Schwarm-Konfiguration. Es funktioniert auch gut mit dem Hermes Multi-Agenten-Stack, wenn Sie menschliche Kontrollpunkte im Loop wünschen.

FAQ

Zusammenfassung

Die Kimi K2.6 API lässt sich mit zwei Änderungen in jede OpenAI-kompatible Toolchain integrieren: die Basis-URL und Ihr API-Schlüssel. Von dort erhalten Sie ein 262K-Kontextfenster, Agenten-Schwarm mit 300 Sub-Agenten, Tool-Aufrufe, die auf 96,60 % Aufruferfolg abgestimmt sind, und die Open-Source-Gewichte als Fallback, falls Sie jemals von der gehosteten API wegwechseln möchten.

Wenn Sie eine neue Integration erstellen, verwenden Sie Apidog, um jeden Endpunkt zuerst zu konstruieren und zu verifizieren. Sie werden Schemafehler, Streaming-Bugs und Authentifizierungsprobleme abfangen, bevor sie in Ihre Codebasis gelangen. Anschließend portieren Sie die funktionierenden Anfragen mit Zuversicht in Ihren Python- oder Node-Dienst.

Referenzen und weiterführende Lektüre

Praktizieren Sie API Design-First in Apidog

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

Kostenlos registrierenDownload