DEV Community

Cover image for Comment utiliser l'API Kimi K2.6 ?
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Comment utiliser l'API Kimi K2.6 ?

L'annonce du Kimi K2.6 de Moonshot AI positionne ce modèle comme la nouvelle référence open-source pour le codage, l'exécution à long terme et les essaims d'agents. L’API, compatible OpenAI, est accessible à l’URL https://api.moonshot.ai/v1 et documentée sur la plateforme. Si vous disposez déjà du SDK OpenAI, vous pouvez envoyer des requêtes en quelques minutes.

Essayez Apidog dès aujourd'hui

Ce guide explique comment s’authentifier, effectuer une première requête, utiliser le streaming, appeler des outils, intégrer des entrées visuelles et vidéo, activer le mode de réflexion, piloter un Essaim d’Agents (jusqu’à 300 sous-agents), et tester chaque endpoint avec Apidog avant de coder votre intégration.

💡 Accès rapide : Testez visuellement l'API Kimi K2.6 dans Apidog avant d'écrire une ligne de code. Importez le schéma, ajoutez un jeton Bearer, et envoyez des requêtes en streaming avec historique et validation de schéma.

TL;DR : API Kimi K2.6 en 60 secondes

  • URL de base : https://api.moonshot.ai/v1
  • Endpoint : POST /chat/completions
  • ID de modèle : kimi-k2.6, kimi-k2.6-thinking
  • Authentification : Authorization: Bearer $KIMI_API_KEY
  • Format : Schéma de complétions de chat OpenAI (messages, outils, stream, etc.)
  • Contexte : 262 144 jetons d'entrée, jusqu'à 98 304 jetons de sortie pour le raisonnement
  • Paramètres par défaut : température 1.0, top-p 1.0 (voir les directives Moonshot)

Exemple minimal en 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": "Write a Python function that reverses a string."}]
  }'
Enter fullscreen mode Exit fullscreen mode

C’est tout. La suite détaille chaque fonctionnalité, l’Essaim d’Agents et la limite d’exécution de 4 000 étapes.

Test Apidog de l'API Kimi K2.6 avec un appel de complétion de chat

Ce que vous pouvez vraiment faire avec cette API

D'après l'annonce de Kimi K2.6, l’API permet en production :

  • Agents de codage capables de travailler 12h+ sur une tâche (plus de 4 000 appels d’outils, débit 15→193 jetons/sec).
  • Gestion autonome d’infrastructure sur plusieurs jours.
  • Fiabilité sur Rust, Go, Python, Zig.
  • Essaims d’agents : jusqu’à 300 sous-agents, 4 000+ étapes coordonnées.
  • Développement full-stack : apps avec auth, DB, transactions générées en une seule invite.
  • Pipelines Vision + outils Python (MathVision avec Python : 93,2 % de réussite).

Si vous développez des outils comme l’utilisation d’ordinateur de Claude Code, votre propre Claude Code, ou Cursor Composer 2, K2.6 est un drop-in replacement au niveau modèle.

Étape 1 : Obtenir une clé API

  1. Rendez-vous sur platform.moonshot.ai (ou platform.kimi.ai) et inscrivez-vous.
  2. Vérifiez votre compte (SMS requis pour l’international).
  3. Ajoutez une méthode de paiement. Un crédit gratuit est souvent offert.
  4. Allez dans API Keys et cliquez sur Create Key.
  5. Copiez la clé (n’apparaît qu’une fois).
  6. Exportez-la : 
export KIMI_API_KEY="sk-..."
Enter fullscreen mode Exit fullscreen mode

Ajoutez-la à .zshrc, .bashrc ou à un gestionnaire de secrets. Ne la commettez jamais.

Besoin d’éviter les coûts en dev ? Comment utiliser Kimi K2.6 gratuitement couvre Workers AI, poids open-source, crédits.

Étape 2 : Choisissez votre SDK

L’API est compatible OpenAI : changez seulement l’URL de base dans les SDK officiels.

Option Installation Idéal pour
curl intégré Tests rapides, CI
OpenAI Python pip install openai Services Python
OpenAI Node npm install openai Apps JS/TS

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)
Enter fullscreen mode Exit fullscreen mode

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);
Enter fullscreen mode Exit fullscreen mode

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?"}]
  }'
Enter fullscreen mode Exit fullscreen mode

Les trois méthodes retournent la même structure de réponse.

Étape 3 : Structure du corps de la requête

Utilisez les mêmes champs que les complétions de chat OpenAI :

{
  "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" }
}
Enter fullscreen mode Exit fullscreen mode

Spécificités Moonshot :

  • Valeurs par défaut élevées : blog officiel recommande température 1.0 et top-p 1.0.
  • thinking active la trace de raisonnement sur kimi-k2.6-thinking. {"type": "disabled"} = réponses rapides.

Étape 4 : Streaming

Le streaming est recommandé pour les interfaces utilisateur ou les générations longues (jusqu’à 98 304 jetons).

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)
Enter fullscreen mode Exit fullscreen mode

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);
}
Enter fullscreen mode Exit fullscreen mode

Le streaming fonctionne aussi pour les outils : concaténez les deltas JSON reçus.

Étape 5 : Appel d’outils

Moonshot annonce un Toolathlon 50 % et 96,60 % de réussite d’appel d’outils. Le format est celui d’OpenAI : vos workflows de test d’API QA existants s’appliquent.

Définir les outils 

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"]
            }
        }
    }
]
Enter fullscreen mode Exit fullscreen mode

Premier appel (décision modèle) 

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),
        })
Enter fullscreen mode Exit fullscreen mode

Deuxième appel (réponse finale) 

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

K2.6 gère les chaînes d’outils multi-étapes : agents de codage à long terme comme Kimi Code. Workflows Claude Code pour comparaison.

Étape 6 : Entrée visuelle

K2.6 : 79,4 % MMMU-Pro, 96,9 % V* (avec Python). Ajoutez des images dans les messages via le format OpenAI image_url :

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"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Pour un fichier local :

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}"
Enter fullscreen mode Exit fullscreen mode

Pour OCR ou lecture de diagrammes : donnez une instruction claire + image. Pour mathématiques : activez l’outil Python (score MathVision 93,2 %).

Étape 7 : Entrée vidéo

Envoyez une URL ou une séquence d’images :

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"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Clips <30s : un appel suffit. Pour plus long, utilisez le streaming.

Étape 8 : Mode de réflexion

kimi-k2.6-thinking expose la trace de raisonnement (similaire OpenAI o1). Scores : 96,4 % AIME 2026, 90,5 % GPQA-Diamond.

Réflexion activée (par défaut) :

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

Réflexion désactivée :

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

La trace est dans reasoning. Affichez-la ou non selon le contexte.

Étape 9 : Essaim d’Agents

Fonction avancée : jusqu’à 300 sous-agents, 4 000+ étapes coordonnées.

Paramètre à passer :

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
        }
    },
)
Enter fullscreen mode Exit fullscreen mode

Conseils pratiques :

  1. Utilisez le streaming pour suivre la progression.
  2. Limitez max_agents (10-30 pour la plupart des tâches).
  3. Définissez un budget : surveillez le champ usage et alertez.

Des démonstrations montrent 4 000+ lignes modifiées en 13h.

Étape 10 : Tester chaque endpoint avec Apidog

Chaque cas d’usage implique des variations de corps ou d’en-tête. Apidog simplifie le débogage en workflow visuel.

Capture d'écran d'Apidog

Configuration de Kimi K2.6 dans Apidog

  1. Téléchargez Apidog et créez un projet.
  2. Créez un environnement kimi-prod avec : BASE_URL = https://api.moonshot.ai/v1, KIMI_API_KEY = sk-....
  3. Nouvelle requête API : POST {{BASE_URL}}/chat/completions.
  4. En-têtes : Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json.
  5. Exemple de corps (streaming) : 
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
Enter fullscreen mode Exit fullscreen mode
  1. Cliquez sur Send. Les jetons arrivent en temps réel.

Ce qu’Apidog ajoute

  • Validation de schéma OpenAI : erreurs immédiates.
  • Historique des requêtes : rejouez chaque appel.
  • Changement d’environnement rapide (dev/staging/prod).
  • Partage d’équipe (export de projet) : 50+ ingénieurs.
  • Mock servers pour tester hors-ligne.
  • Support SSE (streaming Kimi natif).

Pour usage dans l’éditeur : extension VS Code. Migrer depuis Postman : guide détaillé.

Gestion des erreurs

Codes HTTP standard :

  • 400 : requête invalide (corps mal formé, modèle erroné).
  • 401 : authentification échouée (clé manquante/incorrecte).
  • 429 : quota ou débit dépassé.
  • 500 : erreur serveur (réessayer avec back-off).
  • 529 : surchargé (réessayer plus tard).

Exemple de retry Python :

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")
Enter fullscreen mode Exit fullscreen mode

En cas de coupure streaming, relancez avec une instruction "continuer ici". Des flux de 98 304 jetons sont normaux sur des tâches longues.

Contrôle des coûts

Tarifs sur kimi.com/membership/pricing. Pour des coûts prévisibles :

  • Limitez max_tokens (2048 suffit pour du chat).
  • Mettez en cache les prompts système.
  • Enregistrez usage (prompt_tokens, completion_tokens, total_tokens) → monitoring Prometheus ou autre.

Exemple production : correcteur de problèmes GitHub

Agent qui lit un issue GitHub, localise le code, propose une correction, exécute les tests :

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,
        })
Enter fullscreen mode Exit fullscreen mode

Pour une version Essaim d’Agents, ajoutez la config extra_body. Fonctionne aussi avec Hermes multi-agents pour checkpoints humains.

FAQ

SDK Moonshot obligatoire ?

Non. Les SDK OpenAI Python/Node fonctionnent avec l’URL de base personnalisée.

Limites de débit ?

Oui, dépend de votre niveau et historique. Voir dashboard.

Compatibilité LangChain, LlamaIndex, Vercel AI SDK ?

Oui, tout framework acceptant une URL OpenAI custom.

Mode JSON ?

Oui. Passez response_format: {"type": "json_object"} ou avec schéma strict.

Taille contextuelle exacte ?

262 144 jetons d’entrée, 98 304 de sortie (source officielle).

Affinage via API ?

Pas encore. Pour l’instant : poids open-source à auto-héberger.

Différence kimi-k2.6 vs kimi-k2.6-thinking ?

kimi-k2.6 = rapide. kimi-k2.6-thinking = expose raisonnement, réglé pour maths, logique, planification.

Niveau gratuit ?

Voir le guide gratuit, Workers AI, chat kimi.com, auto-hébergé.

Résumé

L’API Kimi K2.6 s’intègre via deux changements : URL de base et clé API. Vous obtenez une fenêtre de 262K, Essaim d’Agents 300 sous-agents, appel d’outils performant, et les poids open-source comme plan B.

Pour toute nouvelle intégration, utilisez Apidog pour valider chaque endpoint dès le départ : validation de schéma, bugs de streaming, auth, tout est vérifié avant d’entrer en prod.

Références et lectures complémentaires

Top comments (0)