API‑Dokumentation

Übersicht

kimrel.com stellt eine unabhängige, OpenAI- und Anthropic-kompatible API-Oberfläche für den Zugriff auf Kimi K2 und verwandte Modelle bereit. Kimi K2 wird von Moonshot AI entwickelt, und kimrel.com ist weder mit Moonshot AI verbunden noch von Moonshot AI unterstützt, befürwortet oder gesponsert.

Basis‑URL

https://kimrel.com/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 kimrel.com API in drei Schritten:

1. Konto erstellen und 10 kostenlose Credits erhalten
2. API‑Key generieren im Dashboard
3. Erste Anfrage senden (die Nutzung wird nach Input- und Output-Tokens aus deinem Credit-Guthaben berechnet, mit modellspezifischen Mindestbeträgen)

Beispiel‑Request

curl https://kimrel.com/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"}]
  }'

KI‑Coding‑Tools

kimrel.com stellt OpenAI‑kompatible (chat completions) und Claude‑kompatible (messages) Endpunkte bereit, sodass sich unterstützte Modelle einfach in gängige KI‑Coding‑Tools integrieren lassen.

Modell‑Support: kimi-k2, kimi-k2-0905, kimi-k2.5, kimi-k2.6, kimi-k2.7-code und kimi-k3 werden über kimrel.com bereitgestellt. Diese Modelle werden von Moonshot AI entwickelt; kimrel.com ist eine unabhängige Oberfläche und weder mit Moonshot AI verbunden noch von Moonshot AI unterstützt oder gesponsert. Verwenden Sie kimi-k3 für 1M‑Kontext, Bildverständnis, Long‑Horizon Coding und fortgeschrittene Tool‑Workflows; kimi-k2.7-code bleibt die Coding‑fokussierte K2‑Route.

Claude Code (Empfohlen)

Claude Code liest die Konfiguration aus ~/.claude/settings.json. Ergänzen oder aktualisieren Sie den env‑Abschnitt:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://kimrel.com/api",
    "ANTHROPIC_AUTH_TOKEN": "<KIMREL_API_KEY>",
    "API_TIMEOUT_MS": "3000000",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": 1,
    "ANTHROPIC_MODEL": "kimi-k2.5",
    "ANTHROPIC_SMALL_FAST_MODEL": "kimi-k2",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "kimi-k2.5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "kimi-k2.5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "kimi-k2"
  }
}

Nach dem Speichern Claude Code neu starten. Anfragen werden an https://kimrel.com/api/v1/messages geroutet.

Codex

Codex CLI installieren:

npm i -g @openai/codex

kimrel.com in ~/.codex/config.toml konfigurieren:

[model_providers.kimi-k2]
name = "kimrel.com Chat Completions API"
base_url = "https://kimrel.com/api/v1"
env_key = "KIMREL_API_KEY"
wire_api = "chat"
requires_openai_auth = false
request_max_retries = 4
stream_max_retries = 10
stream_idle_timeout_ms = 300000

[profiles.k2]
model = "kimi-k2"
model_provider = "kimi-k2"

[profiles.k2.5]
model = "kimi-k2.5"
model_provider = "kimi-k2"

API‑Key setzen und Codex starten:

export KIMREL_API_KEY="<YOUR_API_KEY>"

codex --profile k2.5

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.5",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2.5",
      "parent": null
    },
    {
      "id": "kimi-k2.6",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2.6",
      "parent": null
    },
    {
      "id": "kimi-k2.7-code",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2.7-code",
      "parent": null
    },
    {
      "id": "kimi-k3",
      "object": "model",
      "created": 1784160000,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k3",
      "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

Die folgenden Modell-IDs werden von kimrel.com für unterstützte Modellrouten bereitgestellt. Modelle der Kimi-K2-Familie werden von Moonshot AI entwickelt; kimrel.com stellt eine unabhängige Zugriffsschicht bereit und ist nicht die offizielle Produktmarke des Modellentwicklers.

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.5: Native multimodale agentische Modell, optimiert für Tool‑Use und Reasoning mit 256K Kontext
• kimi-k2.6: Empfohlen für die K2.6‑Route auf kimrel.com mit Text‑ und Bildverständnis, Thinking‑Mode und Tool‑Calling. Dieser Dienst unterstützt aktuell Bild‑, aber keine Videoeingaben.
• kimi-k2.7-code: Empfohlen für Long‑Horizon Coding, Coding Agents, Repository‑Arbeit und tool‑gestützte Software‑Engineering‑Workflows. Dieser Dienst unterstützt Text und Bilder für K2.7 Code, aber keine Videos.
• kimi-k3: Empfohlen für anspruchsvolle Long‑Context Agents, Repository‑Engineering, visuelles Reasoning, strukturierte Ausgabe und fortgeschrittene Tool‑Workflows. K3 führt immer Reasoning aus; verwenden Sie reasoning_effort: "max" statt des K2.x‑Objekts thinking. Kimrel unterstützt Text und Bilder, keine Videos.

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

kimi-k2.6 unterstützt den Thinking‑Mode für Workflows, in denen nachvollziehbarere Reasoning‑Spuren und tool‑gestützte Problemlösung hilfreich sind.

Kimi K3 Schnellstart

Verwenden Sie kimi-k3 für das 2,8T‑Flaggschiffmodell von Moonshot AI mit 1M‑Token‑Kontext, nativem Bildverständnis, Long‑Horizon Coding und Tool Calling. K3 führt immer Reasoning aus. Nutzen Sie am OpenAI‑kompatiblen Endpoint das Top‑Level‑Feld reasoning_effort; senden Sie nicht das K2.x‑Objekt thinking.

OpenAI‑kompatible K3 Reasoning‑Anfrage

{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": "Prüfe diesen Migrationsplan, nenne die riskanteste Annahme und schlage eine Verifikationsreihenfolge vor."
    }
  ],
  "reasoning_effort": "max",
  "max_completion_tokens": 4096
}

OpenAI‑kompatible K3 Bildanfrage

{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://example.com/interface.png"
          }
        },
        {
          "type": "text",
          "text": "Beschreibe die Oberfläche und nenne die wahrscheinlichsten Barrierefreiheitsprobleme."
        }
      ]
    }
  ],
  "reasoning_effort": "max",
  "max_completion_tokens": 4096
}

Setzen Sie am Anthropic‑kompatiblen /v1/messages‑Endpoint model auf kimi-k3 und geben Sie wie üblich das erforderliche max_tokens an; K3 nutzt standardmäßig maximales Reasoning. Senden Sie bei mehrstufigen Tool‑Abläufen die vollständige Assistant‑Nachricht in der nächsten Runde zurück.

Kimi K2.6 Schnellstart

kimi-k2.6 ist die neueste K2.6‑Route auf kimrel.com. Sie ist die beste Wahl auf diesem Dienst, wenn Sie stärkeres Reasoning, Bildverständnis und tool‑gestützte Workflows benötigen, ohne Ihre bestehende OpenAI‑kompatible Request‑Struktur zu verändern. Auf kimrel.com unterstützt K2.6 ein 256K‑Kontextfenster, Text‑ und Bildeingaben, Tool‑Calling sowie den Thinking‑Mode auf dem OpenAI‑kompatiblen /v1/chat/completions‑Endpoint. Videoeingaben werden von diesem Dienst derzeit nicht unterstützt.

Wenn Sie Bilder an kimi-k2.6 senden, können Sie entweder direkt eine data:image/...;base64,...‑URL übergeben oder eine entfernte http(s)‑Bild‑URL angeben. kimrel.com lädt das Bild serverseitig, validiert es, wandelt es in Base64 um und sendet erst dann die Anfrage upstream. So können bestehende Screenshot‑ oder Bildpipelines übernommen werden, ohne dass Clients die Kodierung selbst durchführen müssen.

OpenAI‑kompatibel: K2.6 mit Thinking

{
  "model": "kimi-k2.6",
  "messages": [
    {
      "role": "user",
      "content": "Denke gründlich nach und fasse dann den besten Migrationsplan zusammen."
    }
  ],
  "thinking": { "type": "enabled" },
  "max_completion_tokens": 2048
}

OpenAI‑kompatibel: K2.6 Bildverständnis

{
  "model": "kimi-k2.6",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://example.com/demo-ui.png"
          }
        },
        {
          "type": "text",
          "text": "Beschreibe das Bild und liste die wichtigsten UI-Elemente auf."
        }
      ]
    }
  ],
  "max_completion_tokens": 2048
}

Für kimi-k2.6, kimi-k2.7-code und kimi-k3 akzeptiert kimrel.com entfernte http(s)‑Bild‑URLs und wandelt sie vor dem Upstream‑Request serverseitig in Base64 um. Wenn Sie bereits eine data:image/...;base64,...‑URL haben, können Sie diese direkt senden. Video‑URLs werden von diesem Dienst abgelehnt.

Bildlimits auf Kimrel:

• Maximale ursprüngliche Bildgröße: 6 MB
• Maximale kodierte Bildlast nach der Umwandlung: 8 MB
• Unterstützte Bildtypen: PNG, JPEG/JPG, WEBP, GIF
• Entfernte Bild‑URLs müssen http(s) verwenden und werden serverseitig vor dem Upstream‑Request abgerufen
• Videoeingaben werden nicht unterstützt

Anthropic‑kompatibel: K2.6 Bildeingabe

{
  "model": "kimi-k2.6",
  "max_tokens": 2048,
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "url",
            "url": "https://example.com/demo-ui.png"
          }
        },
        {
          "type": "text",
          "text": "Beschreibe den Bildinhalt."
        }
      ]
    }
  ]
}

Der Anthropic‑kompatible /v1/messages‑Endpoint unterstützt weiterhin bestehende Base64‑Bildblöcke. Das automatische Abrufen entfernter Bild‑URLs ist für kimi-k2.6, kimi-k2.7-code und kimi-k3 aktiviert und entspricht damit dem aktuellen Service‑Verhalten.

K2.6 Tool‑Calling Beispiel

{
  "model": "kimi-k2.6",
  "messages": [
    {
      "role": "user",
      "content": "Nutze das Wetter-Tool, um Peking und Shanghai zu vergleichen."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Aktuelles Wetter einer Stadt abrufen",
        "parameters": {
          "type": "object",
          "properties": {
            "city": { "type": "string" }
          },
          "required": ["city"]
        }
      }
    }
  ],
  "tool_choice": "auto",
  "max_completion_tokens": 1024
}

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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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 Credit-Wallet abgerechnet:

• Credits werden dynamisch nach Input- und Output-Token-Nutzung berechnet
• Mindestbetrag: die meisten Modelle starten bei 1 Credit pro erfolgreichem Request
• kimi-k2.5: mindestens 2 Credits pro erfolgreichem Request
• kimi-k2.6: mindestens 3 Credits pro erfolgreichem Request
• kimi-k2.7-code: mindestens 3 Credits pro erfolgreichem Request
• kimi-k3: mindestens 3 Credits pro erfolgreichem Request
• Die finalen Credits werden nach erfolgreichem Abschluss anhand der tatsächlichen Token-Nutzung abgezogen
• Fehlgeschlagene Requests (4xx) werden nicht berechnet
• Serverfehler (5xx) werden nicht berechnet
• Neue Nutzer erhalten 10 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://kimrel.com/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://kimrel.com/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-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