API‑Dokumentation

Übersicht

Die Kimi K2 API bietet programmgesteuerten Zugriff auf das Kimi K2 Sprachmodell. Sie unterstützt sowohl OpenAI‑ als auch Anthropic‑Nachrichtenformate und ermöglicht eine nahtlose Integration in bestehende Anwendungen.

Basis‑URL

https://kimi-k2.ai/api

Unterstützte Protokolle

• REST API über HTTPS
• JSON Request‑ und Response‑Bodies
• UTF-8 Zeichenkodierung
• CORS‑Support für Browser‑Anwendungen

Schnellstart

Starten Sie mit der Kimi K2 API in drei Schritten:

1. Konto erstellen und 100 kostenlose Credits erhalten
2. API‑Key generieren im Dashboard
3. Erste Anfrage senden (die meisten Modelle kosten 1 Credit pro Anfrage; kimi-k2.5 kostet 2 Credits)

Beispiel‑Request

curl https://kimi-k2.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2-0905",
    "messages": [{"role": "user", "content": "Hallo"}]
  }'

Authentifizierung

API‑Schlüssel

Die Authentifizierung erfolgt über API‑Keys. Fügen Sie Ihren API‑Key im Request‑Header hinzu:

Authorization: Bearer YOUR_API_KEY

Oder für Anthropic‑kompatible Endpoints:

X-API-Key: YOUR_API_KEY

Authentifizierungsmethoden

API‑Referenz

Modelle auflisten

Listet alle verfügbaren Modelle auf, die über die API genutzt werden können.

Verfügbare Modelle auflisten

GET /v1/models

Gibt eine Liste der verfügbaren Modelle zurück.

Antwortformat

{
  "object": "list",
  "data": [
    {
      "id": "kimi-k2",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2",
      "parent": null
    },
    {
      "id": "kimi-k2-0905",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2-0905",
      "parent": null
    },
    {
      "id": "kimi-k2-thinking",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2-thinking",
      "parent": null
    }
  ]
}

Antwortfelder

Chat‑Completions

Die Chat‑Completions‑API generiert Modellantworten für Dialoge und ist mit dem OpenAI‑Format kompatibel.

Completion erstellen

POST /v1/chat/completions

Erzeugt eine Modellantwort für den angegebenen Dialog.

Anfrageformat

{
  "model": "kimi-k2-0905",
  "messages": [
    {
      "role": "system",
      "content": "Du bist ein hilfreicher Assistent."
    },
    {
      "role": "user", 
      "content": "Erkläre Quantencomputing"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 2048,
  "top_p": 1.0,
  "frequency_penalty": 0,
  "presence_penalty": 0,
  "stream": false,
  "n": 1
}

Parameter

Nachrichtenobjekt

Antwortformat

{
  "id": "chatcmpl-9d4c2f68-5e3a-4b2f-a3c9-7d8e6f5c4b3a",
  "object": "chat.completion",
  "created": 1709125200,
  "model": "kimi-k2-0905",
  "system_fingerprint": "fp_a7c4d3e2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Quantencomputing nutzt quantenmechanische Effekte..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 25,
    "completion_tokens": 189,
    "total_tokens": 214
  }
}

Antwortfelder

Finish Reasons

Streaming

Server‑Sent‑Events‑Format bei stream: true:

data: {"id":"chatcmpl-...","choices":[{"delta":{"content":"Hallo"},"index":0}]}

data: {"id":"chatcmpl-...","choices":[{"delta":{"content":" zusammen"},"index":0}]}

data: [DONE]

Nachrichten

Die Messages‑API liefert Anthropic‑kompatible Message‑Generierung.

Nachricht erstellen

POST /v1/messages

Erstellt eine Modellantwort im Messages‑Format.

Anfrageformat

{
  "model": "kimi-k2-0905",
  "messages": [
    {
      "role": "user",
      "content": "Was ist die Hauptstadt von Frankreich?"
    }
  ],
  "max_tokens": 1024,
  "system": "Du bist ein wissender Geografie‑Assistent.",
  "temperature": 0.7,
  "top_p": 1.0,
  "stop_sequences": ["\n\nHuman:"]
}

Parameter

Antwortformat

{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Die Hauptstadt von Frankreich ist Paris."
    }
  ],
  "model": "kimi-k2-0905",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 15,
    "output_tokens": 9
  }
}

Antwortfelder

Systemprompts

Systemprompts werden in der Messages‑API separat angegeben:

{
  "system": "Du bist Claude, ein von Anthropic entwickelter KI‑Assistent.",
  "messages": [
    {"role": "user", "content": "Hallo"}
  ],
  "max_tokens": 1024
}

Modelle

Verfügbare Modelle

Modellauswahl

Wählen Sie das passende Modell für Ihren Anwendungsfall:

• kimi-k2: am besten für allgemeine Konversation, Content‑Erstellung und Standardaufgaben
• kimi-k2-0905: ideal für lange Kontexte (bis 256K), z. B. ganze Dokumente oder lange Gespräche
• kimi-k2-thinking: optimiert für komplexe Reasoning‑Aufgaben:
  • mathematische Beweise und Wettbewerbs‑Mathe
  • Research‑Analyse und Literature Review
  • Mehrschritt‑Problemlösung mit logischem Reasoning
  • Advanced Tool‑Orchestrierung (200–300 sequentielle Tool Calls)
  • Frontend‑Entwicklung mit komplexen UI‑Anforderungen
  • Agentic Search Tasks mit autonomer Navigation
• kimi-k2.5: Native multimodale agentische Modell, optimiert für Tool‑Use und Reasoning mit 256K Kontext

Kimi‑K2.5 Schlüssel‑Specs: MoE‑Architektur (1T total parameters, 32B active), 256K Kontext und ein MoonViT Vision Encoder.

Das Thinking‑Modell zeigt seinen Denkprozess Schritt für Schritt und eignet sich ideal für Bildungskontexte und Anwendungen, bei denen Transparenz wichtig ist.

Anfragelimits

Ratenlimits

Ratenlimits gelten pro API‑Key basierend auf dem Credit‑Stand:

Rate‑Limit‑Header:

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 59
X-RateLimit-Reset: 1709125800

Token‑Limits

Timeout‑Einstellungen

Fehlercodes

HTTP‑Statuscodes

Fehlertypen

OpenAI‑Format‑Fehler

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}

Anthropic‑Format‑Fehler

{
  "type": "error",
  "error": {
    "type": "authentication_error",
    "message": "Invalid API key"
  }
}

Fehlerbehandlung

Implementieren Sie exponential backoff mit jitter:

import time
import random

def retry_with_backoff(
    func, 
    max_retries=3,
    base_delay=1,
    max_delay=60
):
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError:
            if attempt == max_retries - 1:
                raise
            
            delay = min(
                base_delay * (2 ** attempt) + random.uniform(0, 1),
                max_delay
            )
            time.sleep(delay)

Client‑Bibliotheken

Python

Installation

pip install openai
# oder
pip install anthropic

OpenAI‑Client

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://kimi-k2.ai/api/v1"
)

# Verfügbare Modelle auflisten
models = client.models.list()
for model in models.data:
    print(f"Model ID: {model.id}")

# Chat Completion erstellen
response = client.chat.completions.create(
    model="kimi-k2-0905",
    messages=[
        {"role": "user", "content": "Hallo"}
    ]
)

Anthropic‑Client

from anthropic import Anthropic

client = Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://kimi-k2.ai/api/v1"
)

response = client.messages.create(
    model="kimi-k2-0905",
    messages=[
        {"role": "user", "content": "Hallo"}
    ],
    max_tokens=1024
)

Node.js

Installation

npm install openai
# oder
npm install @anthropic-ai/sdk

OpenAI‑Client

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: 'https://kimi-k2.ai/api/v1',
});

// Verfügbare Modelle auflisten
const models = await openai.models.list();
for (const model of models.data) {
  console.log(`Model ID: ${model.id}`);
}

// Chat Completion erstellen
const response = await openai.chat.completions.create({
  model: 'kimi-k2-0905',
  messages: [{ role: 'user', content: 'Hallo' }],
});

Anthropic‑Client

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: 'https://kimi-k2.ai/api/v1',
});

const response = await anthropic.messages.create({
  model: 'kimi-k2-0905',
  messages: [{ role: 'user', content: 'Hallo' }],
  max_tokens: 1024,
});

Go

Installation

go get github.com/sashabaranov/go-openai

Beispiel

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://kimi-k2.ai/api/v1"
    
    client := openai.NewClientWithConfig(config)
    
    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "kimi-k2",
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: "Hallo",
                },
            },
        },
    )
    
    if err != nil {
        panic(err)
    }
    
    fmt.Println(resp.Choices[0].Message.Content)
}

REST API

Direkte HTTP‑Requests ohne Client‑Libraries:

cURL

curl -X POST https://kimi-k2.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2",
    "messages": [
      {"role": "user", "content": "Hallo"}
    ]
  }'

Python (requests)

import requests

response = requests.post(
    "https://kimi-k2.ai/api/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "kimi-k2",
        "messages": [{"role": "user", "content": "Hallo"}]
    }
)

Node.js (fetch)

const response = await fetch('https://kimi-k2.ai/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'kimi-k2-0905',
    messages: [{ role: 'user', content: 'Hallo' }],
  }),
});

Abrechnung

Creditsystem

API‑Nutzung wird über ein Creditsystem abgerechnet:

• Die meisten Modelle: 1 Credit pro API‑Request
• kimi-k2.5: 2 Credits pro API‑Request
• Credits werden bei erfolgreichem Abschluss abgezogen
• Fehlgeschlagene Requests (4xx) werden nicht berechnet
• Serverfehler (5xx) werden nicht berechnet
• Neue Nutzer erhalten 100 kostenlose Credits bei Registrierung
• Einladungs‑Rewards:
  • 50 Credits bei Registrierung über deinen Invite‑Code
  • 500 Credits wenn der eingeladene Nutzer erstmals zahlt

Credit‑Pakete

Nutzungstracking

Überwachen Sie die Nutzung:

1. Response‑Header: X-Credits-Remaining: 4523
2. Dashboard: Echtzeit‑Statistiken unter /my-credits
3. API‑Endpoint: GET /api/user/credits

Nutzungsdaten umfassen:

• Gesamtverbrauchte Credits
• Verbleibende Credits
• Nutzung nach Tag/Stunde
• Durchschnittliche Token pro Request

Migrationsleitfaden

Von OpenAI

Die Migration von OpenAI erfordert nur minimale Änderungen:

1. Base URL aktualisieren:

   # Von
   client = OpenAI(api_key="sk-...")
   
   # Zu
   client = OpenAI(
       api_key="sk-...",
       base_url="https://kimi-k2.ai/api/v1"
   )
   

2. Modellnamen aktualisieren:

   # Von
   model="gpt-4"
   
   # Zu
   model="kimi-k2-0905"
   

3. Keine weiteren Änderungen erforderlich — API ist vollständig kompatibel

Von Anthropic

Migration von Anthropic API:

1. Base URL aktualisieren:

   # Von
   client = Anthropic(api_key="sk-ant-...")
   
   # Zu
   client = Anthropic(
       api_key="sk-...",
       base_url="https://kimi-k2.ai/api/v1"
   )
   

2. Authentifizierung aktualisieren:

   • API‑Key im Kimi‑K2‑Dashboard generieren
   • Anthropic‑API‑Key ersetzen

3. Modellkompatibilität:

   • Kimi K2 wird unterstützt

Änderungsprotokoll

2025-11-10

• Modell kimi-k2-thinking hinzugefügt
• Spezialmodell für komplexe Reasoning‑Aufgaben
• Schritt‑für‑Schritt‑Reasoning‑Anzeige
• Unterstützung für mathematische Beweise, Research‑Analyse und multi‑step Problemlösung
• Erweiterte Tool‑Orchestrierung (200–300 sequentielle Tool Calls)

2025-09-05

• Unterstützung für 256K Kontextfenster
• Support für das Modell kimi-k2-0905

2025-01-30

• Anthropic Messages API‑Kompatibilität hinzugefügt
• X-API-Key‑Authentifizierung eingeführt