Blog

Comment utiliser l'API Kimi K2.6 ?

Ashley Innocent

Ashley Innocent

21 April 2026

Comment utiliser l'API Kimi K2.6 ?

Apidog pour les entreprises

Déploiement sur site

SSO & RBAC

Conforme SOC 2

Explorer Apidog Enterprise

L'annonce du Kimi K2.6 de Moonshot AI le positionne comme le nouvel état de l'art open-source pour le codage, l'exécution à long terme et les essaims d'agents. L'API qui l'alimente est compatible OpenAI, hébergée à https://api.moonshot.ai/v1, et documentée sur la plateforme. Si vous avez le SDK OpenAI installé, vous pouvez envoyer de vraies requêtes en environ cinq minutes.

Ce guide vous expliquera l'authentification, votre première requête, le streaming, l'appel d'outils, l'entrée visuelle et vidéo, le mode de réflexion, et comment piloter un Essaim d'Agents avec 300 sous-agents, et vous montrera comment tester chaque endpoint avec Apidog avant d'écrire le code d'intégration.

💡
Accès rapide : Testez visuellement l'API Kimi K2.6 dans Apidog avant de vous engager dans un code d'intégration. Une seule importation, un seul jeton Bearer, et vous effectuez de vraies requêtes en streaming avec un historique complet et une validation de schéma. Téléchargez Apidog gratuitement.

télécharger l'application

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

Curl minimal :

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."}]
  }'

C'est tout. Le reste de ce guide fournit les détails, y compris l'Essaim d'Agents et la limite d'exécution de 4 000 étapes que Moonshot mentionne.

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

Ce que vous pouvez réellement faire avec cette API

D'après l'annonce de Kimi K2.6, l'API débloque tout ceci en production :

Si vous construisez des outils dans la même catégorie que l'utilisation d'ordinateur de Claude Code, construisez votre propre Claude Code, ou Cursor Composer 2, l'API K2.6 est un remplacement direct au niveau de la couche de modèle.

Étape 1 : Obtenir une clé API

  1. Allez sur platform.moonshot.ai (ou platform.kimi.ai) et inscrivez-vous. L'e-mail ou l'authentification Google OAuth fonctionnent.
  2. Vérifiez votre compte. Les utilisateurs internationaux peuvent avoir besoin d'une vérification par SMS.
  3. Ajoutez la facturation. Moonshot crédite généralement les nouveaux comptes d'un petit solde gratuit.
  4. Ouvrez API Keys dans le tableau de bord et cliquez sur Create Key.
  5. Copiez la clé immédiatement (elle n'est affichée qu'une seule fois).
  6. Exportez-la :
export KIMI_API_KEY="sk-..."

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

Vous voulez éviter de payer pendant le développement ? Comment utiliser Kimi K2.6 gratuitement couvre Cloudflare Workers AI, les poids auto-hébergés et les programmes de crédit gratuit.

Étape 2 : Choisissez votre SDK

L'API est compatible OpenAI, donc les SDK OpenAI officiels fonctionnent après avoir changé l'URL de base.

Option Installation Idéal pour
curl intégré Tests rapides, CI
OpenAI Python pip install openai Services Python
OpenAI Node npm install openai Applications 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)

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?"}]
  }'

Les trois renvoient la même forme de réponse.

Étape 3 : Comprendre le corps de la requête

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" }
}

Deux remarques spécifiques à Moonshot :

Étape 4 : Streaming

Le streaming est la bonne valeur par défaut pour toute interface utilisateur ou génération longue. La sortie maximale pour les tâches de raisonnement peut atteindre 98 304 jetons ; vous ne voulez pas attendre tout cela en une seule fois.

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

Le streaming fonctionne également avec les appels d'outils ; les arguments arrivent sous forme de deltas JSON que vous concaténez.

Étape 5 : Appel d'outils

Moonshot rapporte un score Toolathlon de 50.0% et un taux de réussite d'invocation d'outils de 96.60% lors des tests partenaires. Le format est le schéma standard d'appel de fonction OpenAI, de sorte que les workflows de test d'API existants pour les ingénieurs QA 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"]
            }
        }
    }
]

Premier appel (le modèle décide)

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

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)

K2.6 est performant pour les chaînes d'outils multi-étapes, ce qui rend possibles les agents de codage à long terme comme Kimi Code. Pour une comparaison de frameworks, les workflows de Claude Code couvrent la même boucle avec un backend différent.

Étape 6 : Entrée visuelle

K2.6 obtient 79,4 % sur MMMU-Pro et 96,9 % sur V* (avec Python). Les images sont insérées dans le message de l'utilisateur en utilisant le format de contenu `image_url` d'OpenAI :

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

Pour les fichiers locaux, encodez-les en 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}"

Pour la reconnaissance optique de caractères (OCR) ou la lecture de diagrammes, combinez une instruction textuelle claire avec l'image. Pour les problèmes de mathématiques, incluez un outil d'interprète Python ; le score de 93,2 % de MathVision a été mesuré avec l'accès Python activé.

Étape 7 : Entrée vidéo

Passez une URL vidéo 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"}}
            ]
        }
    ],
)

Les clips courts (<30s) fonctionnent en un seul appel. Les vidéos plus longues bénéficient du streaming car l'inférence image par image produit beaucoup de jetons.

Étape 8 : Mode de réflexion

kimi-k2.6-thinking produit une trace de raisonnement visible (similaire aux modèles de style o1 d'OpenAI). Moonshot rapporte 96,4 % sur AIME 2026 et 90,5 % sur GPQA-Diamond avec le mode de réflexion activé.

Réflexion activée (par défaut pour le modèle de réflexion) :

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

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

La trace de raisonnement est renvoyée dans un champ `reasoning` de la réponse. Vous pouvez la masquer aux utilisateurs finaux et n'afficher que la réponse finale, ou l'intégrer à un journal de débogage.

Étape 9 : Essaim d'Agents

L'Essaim d'Agents est la fonctionnalité la plus intéressante à apprendre. D'après le blog de Kimi K2.6 : jusqu'à 300 sous-agents, plus de 4 000 étapes coordonnées, 3x la capacité de K2.5.

Invoquez-le via le paramètre d'agent de la plateforme :

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

Les appels de l'essaim peuvent durer des minutes ou des heures. Trois conseils pratiques :

  1. Utilisez le streaming. Vous voudrez voir la progression et interrompre les mauvaises exécutions rapidement.
  2. Limitez max_agents. 300 est le plafond ; 10 à 30 est plus prévisible pour la plupart des tâches.
  3. Définissez un budget. Les tâches d'essaim longues peuvent consommer des jetons rapidement ; enregistrez l'usage sur chaque réponse et transmettez-le à votre pile de métriques.

Le blog de Kimi décrit des démonstrations qui ont modifié plus de 4 000 lignes de code sur 13 heures. L'architecture est ce qui rend cela possible ; le flag de l'API l'active simplement.

Étape 10 : Tout tester avec Apidog

Chaque section ci-dessus introduit une forme de corps différente, une exigence d'en-tête ou un format de réponse différent. Apidog transforme la boucle de débogage en un 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 deux variables : `BASE_URL = https://api.moonshot.ai/v1` et `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. Corps (exemple de streaming) :
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
  1. Cliquez sur Send. Les jetons sont diffusés en temps réel dans le panneau de réponse.

Ce qu'Apidog ajoute en plus

Pour les tests directement dans l'éditeur, Apidog est également disponible en tant qu'extension VS Code. Si vous êtes actuellement bloqué sur Postman, comment effectuer des tests API sans Postman explique comment effectuer la transition.

Gestion des erreurs qui ne vous posera pas de problèmes

Moonshot utilise les codes de statut HTTP standard :

Enveloppe de réessai :

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")

En cas de déconnexion en cours de streaming, suivez les jetons reçus et redémarrez avec une instruction "continuer à partir d'ici" si la connexion est interrompue. Le plafond de sortie de raisonnement de 98 304 jetons signifie que les longs flux sont normaux, et non une erreur.

Contrôle des coûts

Moonshot publie ses tarifs sur kimi.com/membership/pricing. Trois conseils de niveau production pour des factures prévisibles :

Modèle de production : un correcteur de problèmes GitHub

Voici un agent qui lit un problème GitHub, localise le code pertinent, propose une correction et exécute des tests, structuré autour de la boucle d'appel d'outils Kimi K2.6 :

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

Ceci s'adapte à l'Essaim d'Agents en ajoutant la configuration d'essaim `extra_body`. Cela fonctionne également bien avec la pile multi-agents Hermes si vous souhaitez des points de contrôle avec intervention humaine.

FAQ

Ai-je besoin d'un SDK spécifique à Moonshot ?Non. Les SDK Python et Node d'OpenAI fonctionnent après avoir modifié l'URL de base (`base_url`).

L'API est-elle soumise à des limites de débit ?Oui. Les limites dépendent de votre niveau et de l'historique de votre utilisation. Vérifiez le tableau de bord.

Kimi K2.6 fonctionne-t-il avec LangChain, LlamaIndex, Vercel AI SDK ?Oui. Tout framework acceptant une URL de base compatible OpenAI fonctionne.

Kimi K2.6 prend-il en charge le mode JSON ?Oui. Passez `response_format: {"type": "json_object"}` pour une sortie JSON valide, ou `{"type": "json_schema", "json_schema": {...}}` pour des schémas stricts.

Quelle est la taille exacte de la fenêtre contextuelle ?262 144 jetons d'entrée, 98 304 jetons de sortie maximum pour les tâches de raisonnement, selon le blog officiel.

Puis-je affiner Kimi K2.6 via l'API ?Pas encore. Pour l'instant, l'affinement signifie l'exécution des poids open-source sur votre propre matériel.

Quelle est la différence entre kimi-k2.6 et kimi-k2.6-thinking ?`kimi-k2.6` est le modèle d'agent rapide. `kimi-k2.6-thinking` expose ses étapes de raisonnement et est réglé pour les mathématiques, la logique et la planification complexe (AIME 2026 : 96,4 %, GPQA-Diamond : 90,5 %).

Existe-t-il un niveau gratuit ?Consultez notre guide d'accès gratuit à Kimi K2.6 pour Cloudflare Workers AI, le chat kimi.com et les options auto-hébergées.

Résumé

L'API Kimi K2.6 s'intègre à toute chaîne d'outils compatible OpenAI avec deux changements : l'URL de base et votre clé API. À partir de là, vous obtenez une fenêtre de contexte de 262K, un Essaim d'Agents avec 300 sous-agents, un appel d'outils réglé à 96,60 % de succès d'invocation, et les poids open-source comme solution de repli si jamais vous souhaitez vous passer de l'API hébergée.

Si vous construisez une nouvelle intégration, utilisez Apidog pour construire et vérifier chaque endpoint en premier. Vous détecterez les erreurs de schéma, les bugs de streaming et les problèmes d'authentification avant qu'ils n'atteignent votre base de code. Ensuite, portez les requêtes fonctionnelles dans votre service Python ou Node en toute confiance.

Références et lectures complémentaires

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger