Kimi K2.6 API Nutzung: Eine Anleitung

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.

Teste Apidog noch heute

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.

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

• Basis-URL: https://api.moonshot.ai/v1
• Endpunkt: POST /chat/completions
• Modell-IDs: kimi-k2.6, kimi-k2.6-thinking
• Authentifizierung: Authorization: Bearer $KIMI_API_KEY
• Format: OpenAI Chat Completions Schema (Nachrichten, Tools, Stream, etc.)
• Kontext: 262.144 Eingabe-Tokens, bis zu 98.304 Ausgabe-Tokens für Argumentation
• Standardwerte: Temperatur 1.0, Top-P 1.0 (Moonshots offizielle Anleitung)

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.

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

Laut der Kimi K2.6-Ankündigung ermöglicht die API produktiv:

• Code-Agenten, die über 12 Stunden an einer einzigen Aufgabe arbeiten (siehe Qwen3.5-0.8B Mac-Inferenz-Demo: über 4.000 Tool-Aufrufe, Durchsatz von 15 auf 193 Tokens/Sek. erhöht).
• Autonomes Infrastrukturmanagement über mehrtägige Sitzungen mit automatischer Vorfallreaktion.
• Langfristige Zuverlässigkeit über Rust, Go, Python und Zig hinweg.
• Agentenschwärme von bis zu 300 Sub-Agenten, die über 4.000 koordinierte Schritte ausführen.
• Designgetriebene Entwicklung, die Full-Stack-Anwendungen mit Authentifizierung, Datenbanken und Transaktionen aus einem einzigen Prompt generiert.
• Vision + Python Tool-Nutzung-Pipelines (MathVision mit Python: 93,2 %).

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 ggf. 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. Niemals committen.

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 nach Änderung der Basis-URL.

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

Das Schema ist identisch zu 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" }
}

Moonshot-spezifische Hinweise:

• Standardwerte sind hoch: Offizieller Blog empfiehlt Temperatur 1.0, Top-P 1.0. Nicht wie bei OpenAI auf 0.2 reduzieren.
• thinking schaltet die Denkspur bei kimi-k2.6-thinking um. {"type": "disabled"} unterdrückt sie für schnelle Antworten.

Schritt 4: Streaming

Streaming ist für jede UI oder lange Generierung zu empfehlen. Die maximale Ausgabe kann 98.304 Tokens erreichen; per Streaming erhalten Sie früh Ergebnisse.

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; JSON-Deltas werden verknüpft.

Schritt 5: Tool-Aufrufe

Moonshot meldet Toolathlon-Score: 50,0 % und 96,60 % Tool-Aufruf-Erfolg. Das Format entspricht dem OpenAI-Funktionsaufruf-Schema. Vorhandene API-Test-Workflows für QA-Ingenieure sind direkt nutzbar.

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. Für Framework-Vergleich siehe Claude Code Workflows.

Schritt 6: Vision-Eingabe

K2.6 erreicht 79,4 % bei MMMU-Pro und 96,9 % bei V* (mit Python). Bilder werden im OpenAI-image_url-Format übergeben:

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"}}
            ]
        }
    ],
)

Lokale Dateien als 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 Diagramme Textanweisung plus Bild kombinieren. Für Mathematik: Python-Tool aktivieren (93,2 % MathVision-Score mit Python).

Schritt 7: Video-Eingabe

Video-URL oder Bildsequenz angeben:

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 Aufruf. Längere Videos per Streaming, da viele Tokens erzeugt werden.

Schritt 8: Denkmodus

kimi-k2.6-thinking erzeugt eine sichtbare Denkspur. Moonshot meldet 96,4 % bei AIME 2026 und 90,5 % bei GPQA-Diamond mit aktiviertem Denkmodus.

Denkmodus an (Standard):

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 im reasoning-Feld der Antwort zurückgegeben. Nach Bedarf an Nutzer weitergeben oder loggen.

Schritt 9: Agenten-Schwarm

Agenten-Schwarm: bis zu 300 Sub-Agenten, >4.000 Schritte, 3x K2.5-Kapazität (Kimi K2.6 Blog).

Aufruf per Agent-Parameter:

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
        }
    },
)

Praktische Tipps:

1. Streaming verwenden: Fortschritt sehen und notfalls abbrechen.
2. max_agents begrenzen: 10–30 ist für die meisten Aufgaben sinnvoll.
3. Budget setzen: Lange Schwarm-Aufgaben verbrauchen viele Tokens; protokollieren Sie usage bei jeder Antwort.

Kimi-Blog beschreibt Demo-Läufe mit 4.000+ Codezeilen in 13 Stunden.

Schritt 10: Alles mit Apidog testen

Jede Funktionalität führt zu neuen Body- oder Response-Formaten. Apidog verwandelt Debugging in einen visuellen Workflow.

Kimi K2.6 Einrichtung in Apidog

1. Apidog herunterladen und Projekt anlegen.
2. Umgebung kimi-prod mit BASE_URL = https://api.moonshot.ai/v1 und KIMI_API_KEY = sk-....
3. Neue Anfrage: POST {{BASE_URL}}/chat/completions
4. Header: Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json
5. Beispiel-Body für Streaming:

{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}

1. Senden klicken – Tokens erscheinen in Echtzeit.

Was Apidog zusätzlich bietet

• Schema-Validierung nach OpenAI Chat Completions, Fehler werden sofort sichtbar.
• Anfragehistorie für reproduzierbare Tests.
• Umgebungsumschaltung für verschiedene Keys.
• Team-Sharing via Projektexport, siehe API-Tests für Teams >50 Ingenieure.
• Mock-Server für Offline- oder Ausfall-Szenarien.
• SSE-Stream-Unterstützung, verarbeitet Kimis Streaming sauber (viele Tools tun dies nicht).

Apidog gibt es auch als VS Code Erweiterung. Der Umstieg von Postman wird in API-Tests ohne Postman beschrieben.

Fehlerbehandlung, die Sie nicht bekämpft

Moonshot verwendet Standard-HTTP-Statuscodes:

• 400: Fehlerhafter Body oder Modellname.
• 401: Authentifizierungsfehler (Key fehlt/falsch/abgelaufen).
• 429: Ratenlimit oder Kontingent erschöpft.
• 500: Serverfehler, mit Backoff wiederholen.
• 529: Überlastung, wenige Sekunden warten und neu versuchen.

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 Stream-Abbrüchen empfangene Tokens speichern und mit "hier fortfahren"-Prompt erneut starten. Lange Streams (bis 98.304 Tokens) sind erwartbar.

Kostenkontrolle

Preise: kimi.com/membership/pricing.

Drei praxiserprobte Tipps:

• max_tokens begrenzen: Nur so viele wie nötig, z.B. 2.048 für Chat.
• System-Prompts cachen: Statische Anweisungen zuerst platzieren.
• usage loggen: prompt_tokens, completion_tokens und total_tokens aus Antwort in Ihre Metriken leiten.

Produktionsmuster: Ein GitHub-Issue-Fixer

Agent, der ein GitHub-Issue liest, relevanten Code findet, Fix vorschlägt und Tests ausführt – alles in der Kimi Tool-Call-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,
        })

Mit Agenten-Schwarm einfach erweiterbar (per extra_body). Funktioniert auch im Hermes Multi-Agenten-Stack für menschliche Kontrollpunkte.

FAQ

• Benötige ich ein Moonshot-spezifisches SDK?
  
  Nein. OpenAI Python- und Node-SDKs funktionieren nach Anpassung der base_url.

• Ist die API ratenbegrenzt?
  
  Ja, Limits skalieren mit Tarif und Nutzungshistorie. Dashboard prüfen.

• Funktioniert Kimi K2.6 mit LangChain, LlamaIndex, Vercel AI SDK?
  
  Ja, jede OpenAI-kompatible Basis-URL wird unterstützt.

• Unterstützt Kimi K2.6 den JSON-Modus?
  
  Ja, response_format: {"type": "json_object"} für JSON-Ausgabe oder {"type": "json_schema", "json_schema": {...}} für strikte Schemas.

• Wie groß ist das Kontextfenster?
  
  262.144 Eingabe-Tokens, max. 98.304 Ausgabe-Tokens (offizieller Blog).

• Kann ich Kimi K2.6 über die API feinabstimmen?
  
  Noch nicht. Feinabstimmung aktuell nur über offene Gewichte.

• Was ist der Unterschied zwischen kimi-k2.6 und kimi-k2.6-thinking?
  
  kimi-k2.6 ist das schnelle Agentenmodell. kimi-k2.6-thinking legt Denk-Schritte offen, optimiert für Mathematik, Logik, Planung.

• Gibt es einen kostenlosen Tarif?
  
  Siehe unseren Leitfaden zum kostenlosen Zugriff auf Kimi K2.6 für Cloudflare Workers AI, kimi.com, selbst gehostete Optionen.

Zusammenfassung

Die Kimi K2.6 API integriert sich mit zwei Änderungen in jede OpenAI-kompatible Toolchain: Basis-URL und API-Key. Sie erhalten ein 262K-Kontextfenster, Agenten-Schwarm mit 300 Sub-Agenten, Tool-Aufrufe mit 96,60 % Erfolgsquote und Open-Source-Gewichte als Fallback.

Für neue Integrationen verwenden Sie Apidog, um Endpunkte zu testen und Schemafehler, Streaming-Bugs und Auth-Fehler frühzeitig zu erkennen. Dann portieren Sie funktionierende Anfragen in Ihre Dienste.

Referenzen und weiterführende Lektüre

• Offizielle Ankündigung: Kimi K2.6 – Moonshot AI Blog
• API-Schnellstart: platform.kimi.ai/docs/guide/kimi-k2-6-quickstart
• API-Plattform: platform.moonshot.ai
• Kimi Code Terminal-Agent: kimi.com/code
• Preise: kimi.com/membership/pricing
• Offene Gewichte: huggingface.co/moonshotai/Kimi-K2.6
• Verwandte Apidog-Anleitungen: Was ist Kimi K2.6, Kimi K2.6 kostenlos nutzen, Qwen 3.6 kostenlos auf OpenRouter, Qwen3.5-Omni API, Apidog in VS Code, API-Tests ohne Postman, API-Tests für über 50 Ingenieure, Claude Code Workflows, Cursor Composer 2.