Kimi K3.1 Pro : Claude Code, Codex, modèles et tarifs

Pour un premier essai de Kimi K3.1 Pro en développement, utilisez le modèle API standard kimi-k3.1-pro, réglez explicitement le niveau de raisonnement et vérifiez une petite requête avant de connecter Claude Code ou Codex. Si vous avez déjà un abonnement Kimi Code, commencez par son entrée distincte k3.1-pro avec /model. Choisissez Highspeed après avoir mesuré si la réduction du temps d’attente justifie son tarif plus élevé.

Les tarifs et les conditions de disponibilité ci-dessous sont ceux du 2026-10-24. Les configurations de Claude Code et Codex utilisent l’API Kimi facturée à l’usage ; l’accès par abonnement Kimi Code est traité séparément.

Qu’est-ce qui change par rapport à Kimi K3 ?

K3.1 Pro est une version de K3 ayant bénéficié de davantage de calcul au stade du post-entraînement, avec des améliorations visant les tâches qui exigent un raisonnement prolongé et l’utilisation d’outils. Moonshot annonce 61.2%, contre 55.95% pour K3, dans son évaluation interne Kimi Code Bench 3.0 Long-horizon. Considérez ce chiffre comme un résultat du fournisseur pour choisir les tâches à essayer, par exemple un débogage portant sur plusieurs fichiers ou une fonctionnalité nécessitant plusieurs cycles de modification et de test.

La fenêtre de contexte de 1,048,576 tokens n’est pas une nouveauté de cette version : K3 proposait déjà cette capacité. Pour les utilisateurs de l’API K3, la différence réside dans l’association du nouveau modèle, de tarifs par token réduits et du comportement de raisonnement décrit dans la documentation. La capacité du contexte est également distincte des limites de débit du compte et du solde acheté, comme l’explique la documentation tarifaire de Kimi.

L’accès au modèle hébergé est déjà disponible. L’annonce de lancement de Moonshot prévoit la publication des poids complets au plus tard le 2026-11-04. Vous pouvez essayer le service hébergé dès maintenant ; évaluez l’hébergement sur votre propre infrastructure lorsque les poids et les conditions de licence propres au modèle seront disponibles.

Quel identifiant de modèle utiliser ?

Choisissez l’identifiant correspondant au service qui a émis votre clé API. L’API payante de Kimi, l’abonnement Kimi Code et OpenRouter utilisent des espaces de noms et des modes de facturation différents.

Mode d’accès	Identifiant du modèle ou réglage du client	Facturation
API Kimi, y compris Codex connecté à cette API	`kimi-k3.1-pro` ou `kimi-k3.1-pro-highspeed`	Utilisation de l’API Kimi
Claude Code via l’API Kimi, avec la configuration ci-dessous	`kimi-k3.1-pro[1m]`	Utilisation de l’API Kimi
Abonnement Kimi Code	`k3.1-pro` ou `k3.1-pro-highspeed`	Quota de l’abonnement
OpenRouter	`moonshotai/kimi-k3.1-pro`	Facturation de l’API OpenRouter

Ces identifiants proviennent de la référence de l’API Kimi, de la configuration des modèles de Kimi Code et de la fiche du modèle sur OpenRouter.

Attention à un décalage dans le guide actuel de Kimi pour Claude Code : ses réglages utilisent encore kimi-k3[1m], alors que sa requête de vérification utilise kimi-k3.1-pro.

La documentation de configuration des modèles d’Anthropic explique que [1m] indique à Claude Code d’utiliser une fenêtre de contexte de 1M. Ce suffixe est retiré avant que l’identifiant du modèle soit envoyé au fournisseur. Il ne transforme pas kimi-k3 en kimi-k3.1-pro. La configuration ci-dessous désigne donc explicitement K3.1 Pro.

Quels sont les tarifs actuels de l’API ?

Les tarifs publiés pour l’entrée, la sortie et le cache de K3.1 Pro standard sont inférieurs d’un tiers à ceux de K3. Le coût d’une tâche terminée dépend toujours du nombre de tokens consommés par l’agent.

Les montants suivants sont exprimés en USD par 1,000,000 tokens, avec le tarif d’écriture en cache 5m par défaut, selon les prix actuels des modèles sur la plateforme Kimi. Ils n’incluent pas les taxes applicables.

Modèle	Entrée hors cache	Écriture en cache, `5m`	Lecture du cache	Sortie
Kimi K3.1 Pro	$2.00	$2.00	$0.20	$10.00
Kimi K3.1 Pro Highspeed	$4.00	$4.00	$0.20	$20.00
Kimi K3	$3.00	$3.00	$0.30	$15.00

Les lectures du cache, les écritures en cache et le reste de l’entrée hors cache sont des catégories de tokens mutuellement exclusives. Ne comptabilisez pas les mêmes tokens d’entrée à la fois au tarif ordinaire et au tarif d’écriture en cache. Le guide de facturation du cache de Kimi décrit la mise en cache automatique, la durée de conservation de cinq minutes par défaut et une option d’écriture 1h facturée séparément.

Pour une estimation illustrative, supposons qu’une tâche cumule :

100,000 nouveaux tokens d’entrée, facturés comme entrée ordinaire ou comme écritures en cache 5m.
500,000 tokens d’entrée lus depuis le cache.
20,000 tokens de sortie au total, raisonnement compris.

Avec K3.1 Pro standard, le coût serait :

(100,000 × $2.00 + 500,000 × $0.20 + 20,000 × $10.00) / 1,000,000 = $0.50

À nombre de tokens identique, le coût serait de $0.75 avec K3 et de $0.90 avec Highspeed. Ces estimations excluent les taxes et les frais supplémentaires liés aux outils, et supposent l’absence d’écritures en cache 1h. Highspeed ne double pas cette facture précise, car son tarif de lecture du cache reste à $0.20.

Des données indépendantes sur le coût par tâche sont déjà disponibles. L’évaluation de lancement d’Artificial Analysis indique environ 55K tokens de sortie par tâche de l’Intelligence Index, contre 48K pour K3, et $1.98 par tâche, soit à peu près le même coût que K3 dans cette évaluation. Sa méthodologie pondère les coûts des différentes épreuves du benchmark. Ce chiffre renseigne sur la consommation de tokens ; il ne prédit pas le coût de correction d’un bug dans votre dépôt.

Vérifiez l’accès à l’API et réglez le raisonnement

Vérifiez votre compte API avant de chercher un problème dans la configuration de votre outil de programmation. Le guide de démarrage de K3.1 Pro précise que l’accès est débloqué après une recharge réussie d’au moins $1. Cette condition concerne l’accès à l’API et reste distincte de l’abonnement Kimi Code.

Les commandes suivantes utilisent Bash sur macOS ou Linux, avec curl et jq installés. Lorsque read attend une saisie, collez votre clé de la plateforme API Kimi, puis appuyez sur Entrée ; la clé ne s’affiche pas.

set -o pipefail
read -rs MOONSHOT_API_KEY && export MOONSHOT_API_KEY

curl --silent --show-error --fail-with-body \
  https://api.moonshot.ai/v1/chat/completions \
  --header "Authorization: Bearer $MOONSHOT_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "kimi-k3.1-pro",
    "reasoning_effort": "low",
    "max_completion_tokens": 2048,
    "messages": [{"role": "user", "content": "Reply with exactly: KIMI_API_OK"}]
  }' | jq -e '
    if .error then error(.error | tostring)
    else {model, answer: .choices[0].message.content,
          finish_reason: .choices[0].finish_reason, usage}
    end
  '

Une vérification réussie doit renvoyer kimi-k3.1-pro dans model, la réponse demandée, stop dans finish_reason et la consommation réelle. La référence de Chat Completions décrit ces champs de réponse.

Si finish_reason vaut length, la génération a atteint son plafond : augmentez max_completion_tokens et réessayez avant de conclure à un problème d’authentification. Une erreur 401 demande de vérifier que la clé correspond au point de terminaison utilisé. Si le modèle n’est pas accessible depuis un nouveau compte, vérifiez d’abord que la recharge a réussi et que l’identifiant est exact.

Le raisonnement est toujours actif sur K3.1 Pro. Le guide du raisonnement de l’API directe accepte low, high et max, avec max par défaut. Le test de connexion utilise volontairement low ; les exemples d’outils de programmation ci-dessous choisissent high comme réglage de départ.

Pour vos propres intégrations, le schéma officiel de l’API place ce réglage dans un champ différent selon le protocole : Chat Completions utilise reasoning_effort, Responses utilise reasoning.effort et Messages utilise output_config.effort. Ne recopiez pas le champ de Chat Completions dans tous les formats de requête.

Configurez Claude Code avec l’identifiant explicite de K3.1 Pro

Affectez K3.1 Pro à la conversation principale, aux modèles utilisés en arrière-plan et aux sous-agents pour que l’essai sollicite ce modèle de manière cohérente. Cette configuration adapte la structure d’intégration de Kimi avec l’identifiant canonique accepté par son API Messages et le comportement de [1m] documenté par Anthropic.

Utilisez une installation à jour de Claude Code. Intégrez les réglages suivants à ~/.claude/settings.json, en conservant les paramètres sans rapport avec cette configuration :

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.moonshot.ai/anthropic",
    "ANTHROPIC_MODEL": "kimi-k3.1-pro[1m]",
    "ANTHROPIC_DEFAULT_FABLE_MODEL": "kimi-k3.1-pro[1m]",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "kimi-k3.1-pro[1m]",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "kimi-k3.1-pro[1m]",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "kimi-k3.1-pro[1m]",
    "CLAUDE_CODE_SUBAGENT_MODEL": "kimi-k3.1-pro[1m]",
    "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "1000000",
    "CLAUDE_CODE_EFFORT_LEVEL": "high"
  }
}

Toutes ces affectations utilisent désormais les tarifs de K3.1 Pro, y compris les tâches en arrière-plan associées à l’emplacement Haiku. Le réglage de compactage définit un seuil côté client ; il n’achète ni contexte ni tokens supplémentaires.

N’ajoutez pas d’identifiants d’authentification à cet exemple JSON. Avant d’utiliser la clé exportée dans le shell ci-dessous, supprimez les anciennes entrées ANTHROPIC_API_KEY ou ANTHROPIC_AUTH_TOKEN de l’objet env existant : Kimi précise que les variables d’environnement du fichier de configuration prennent le pas sur celles exportées dans le terminal.

Depuis la même session Bash que celle utilisée pour vérifier l’API, lancez :

unset ANTHROPIC_API_KEY
export ANTHROPIC_AUTH_TOKEN="$MOONSHOT_API_KEY"
claude

Dans la nouvelle session, exécutez /status. Vérifiez que l’URL de base est https://api.moonshot.ai/anthropic et que le modèle sélectionné indique K3.1 Pro, éventuellement avec l’annotation [1m]. Laissez le raisonnement activé.

Utilisez le test de lecture du dépôt présenté dans la section suivante pour vérifier les appels d’outils. /status confirme la configuration sélectionnée ; la réponse de l’assistant à « Quel modèle es-tu ? » ne permet pas de vérifier de manière fiable le routage des requêtes.

Si l’ancien modèle apparaît encore, recherchez les paramètres qui remplacent la sélection du modèle et redémarrez le client. Si seules les tâches en arrière-plan échouent, vérifiez toutes les affectations de familles de modèles et de sous-agents, plutôt que de modifier uniquement le modèle principal.

Connectez Codex à l’API Responses native

Utilisez le point de terminaison Responses natif de Kimi pour Codex. L’intégration officielle de Kimi prend directement en charge kimi-k3.1-pro, avec wire_api = "responses" et une fenêtre de contexte de 1048576.

Avec Codex 0.134.0 ou une version ultérieure, utilisez un fichier de profil séparé pour sélectionner explicitement cette configuration. Vérifiez votre version avec codex --version. Selon les règles actuelles des profils Codex, --profile kimi-k31 charge ~/.codex/kimi-k31.config.toml par-dessus la configuration de base.

Créez ce fichier avec le contenu suivant :

model = "kimi-k3.1-pro"
model_provider = "kimi"
model_context_window = 1048576
model_reasoning_effort = "high"

[model_providers.kimi]
name = "Kimi"
base_url = "https://api.moonshot.ai/v1"
env_key = "KIMI_API_KEY"
wire_api = "responses"

Les paramètres du fournisseur suivent le guide de Kimi. Le niveau explicite high associe le champ de configuration du raisonnement de Codex à une valeur acceptée par le schéma Responses de Kimi.

Depuis le terminal où votre clé API est disponible, exécutez :

export KIMI_API_KEY="$MOONSHOT_API_KEY"
codex --profile kimi-k31

Ouvrez /status et confirmez le fournisseur kimi ainsi que le modèle kimi-k3.1-pro. Codex envoie ses requêtes à https://api.moonshot.ai/v1/responses ; son URL de base inclut donc /v1, contrairement à celle de Claude Code.

Dans l’un ou l’autre des clients, ouvrez un petit dépôt et envoyez la demande suivante :

Read the repository's top-level files and its test configuration.
Explain the entry point and the command for running its tests.
Cite the relevant file paths. Do not edit files or run the tests.

Cette demande invite le client à lire les fichiers à la racine et la configuration des tests, puis à expliquer le point d’entrée et la commande de test en citant les chemins pertinents, sans modifier les fichiers ni exécuter les tests. Vérifiez qu’il lit les fichiers et fournit une réponse finale après le retour des résultats des outils. Ce test couvre davantage d’aspects de l’intégration qu’un simple message de salutation.

Si Codex renvoie 404 sur /v1/responses, vérifiez l’URL de base exacte et toute configuration existante de routeur local. Kimi indique également qu’un avertissement sur les métadonnées du modèle peut apparaître, car le modèle est absent du catalogue intégré de Codex ; le réglage explicite de la fenêtre de contexte fournit l’information de capacité manquante.

Vous utilisez déjà un abonnement Kimi Code ?

Utilisez /model dans la CLI officielle de Kimi Code, sélectionnez K3.1 Pro et démarrez une nouvelle session pour l’essai. Les notes de version du 23 octobre recommandent une nouvelle session lors du passage depuis un modèle antérieur.

Dans les offres actuelles, K3.1 Pro standard est accessible avec Plus et les formules supérieures ; Pro et les formules supérieures donnent accès au contexte complet de 1M et à Highspeed. Les niveaux correspondants des anciennes offres sont Moderato et Allegretto. D’après le guide des modèles, Highspeed applique un multiplicateur d’environ 2× à la consommation du quota d’abonnement. Ce multiplicateur est distinct des tarifs de l’API.

Choisissez explicitement le niveau de raisonnement au lieu de supposer que la valeur par défaut de l’API directe s’applique aussi à votre client. Laissez le raisonnement activé : la référence des erreurs de Kimi Code documente une erreur HTTP 400 avec le message “K3.1 Pro does not support disabled thinking mode.”

Copiez soigneusement les identifiants de modèle. Kimi Code avertit qu’une faute de frappe peut provoquer un repli vers K2.8 Preview sans raisonnement ; sa référence des erreurs décrit également des identifiants invalides qui renvoient 400. Traitez une faute de frappe comme un risque de routage vers un autre modèle, plutôt que comme une erreur qui sera nécessairement détectée automatiquement.

Une clé Kimi Code doit être utilisée avec son propre service. Par exemple, ses instructions distinctes pour Claude Code utilisent https://api.kimi.ai/coding/. Insérer cette clé dans la configuration Moonshot facturée à l’usage présentée plus haut ne fait pas basculer les requêtes sur le quota de votre abonnement.

Faut-il remplacer Claude Opus 5.5 ?

Testez K3.1 Pro sur une tâche représentative de votre dépôt avant de migrer un processus de travail déjà établi avec Opus. Les résultats publiés justifient un essai, mais ils ne définissent pas un classement universel de qualité ou de coût par tâche terminée.

Moonshot annonce 65.7% sur Terminal-Bench 4.0, contre 66.4% pour Claude Opus 5.5 et 58.2% pour GPT-6 Astra. Ses notes méthodologiques précisent que K3.1 Pro a utilisé Claude Code comme environnement d’exécution de l’évaluation, tandis que les scores de comparaison proviennent de rapports de fournisseurs ou du classement public. Il ne s’agit pas d’une seule évaluation contrôlée de tous les modèles dans des conditions identiques.

Le rapport indépendant de lancement d’Artificial Analysis indique séparément environ 67% sur Terminal-Bench 4.0 et 55 à son Intelligence Index. Gardez ces résultats associés à leur propre évaluation ; ne les mélangez pas à la comparaison de Moonshot comme si les conditions étaient identiques.

Pour votre essai, conservez le même état du dépôt, la même tâche, les mêmes permissions et les mêmes tests d’acceptation. Notez le niveau de raisonnement, le montant total facturé, le temps écoulé, les nouvelles tentatives et l’acceptation ou non de la modification finale en revue. Adoptez K3.1 Pro standard lorsqu’il atteint votre niveau de qualité à un coût intéressant ; essayez Highspeed lorsque l’attente de génération domine. Conservez Opus pour les tâches où un nombre réduit de cycles de correction ou une fonction indispensable du client rend le processus existant plus efficace.