Kimi K2.7 Code est le modèle agentique de Moonshot AI axé sur le codage, construit sur Kimi K2.6, réglé pour l'ingénierie logicielle réelle et décrit par Moonshot comme son modèle de codage dédié, suivant les instructions de façon plus fiable en contexte long et menant à bien les tâches de codage avec de meilleurs taux de réussite.
- Entrée
- texte image vidéo $0.95/M
- Sortie
- texte $4/M
- Lecture de cache
- $0.19/M
- Contexte
- 256K
- vs GPT-4o
- ~81% moins cher
Benchmarks
Chiffres publiés par les fournisseurs : Alibaba (Qwen) Moonshot OpenAI Z.ai
Le prix en perspective
Position du prix parmi 68 modèles comparables
La barre situe le prix de ce modèle parmi tous les modèles du même type sur Synthorai. Le moins cher et le plus cher sont nommés à chaque extrémité. Ce sont des tarifs de base ; les remises liées au batch, à la région et aux écritures de cache figurent sur la page des tarifs.
Spécifications et limites
Tokens
| Fenêtre de contexte (spécification du fournisseur) | 256 000 |
|---|---|
| Sortie max (spéc. fournisseur) | 32 768 |
Mise en cache
| Mode | automatique |
|---|
Réflexion
| Paramètre du fournisseur | thinking.type + thinking.keep |
|---|---|
| Valeurs acceptées | type accepts only enabled; keep accepts only all |
| Valeur par défaut | réflexion activée avec Preserved Thinking activé appliquée si la requête ne précise rien |
| Désactivable | Non |
| Comportement de la réflexion | Passer type disabled renvoie une erreur ; comme Preserved Thinking est imposé côté serveur, le reasoning_content de chaque message assistant historique doit être renvoyé tel quel. |
| Paramètre | reasoning_effort |
| Valeurs | minimal · low · medium · high paramètres exposés par la passerelle ; la correspondance avec ceux du fournisseur, ci-dessus, s'applique |
Modèle
| Modalités | texte + image + vidéo → texte |
|---|---|
| Paramètres | 1T au total · 32B actifs MoE |
| Licence | Modified-MIT |
- Modèle agentique axé sur le code, construit sur K2.6: MoE de 1T avec 32B actifs, contexte de 256K
- réflexion toujours active avec raisonnement préservé d'un tour à l'autre
- environ 30 % de tokens de réflexion en moins par rapport à K2.6
Un prompt, mesuré via la passerelle
Kimi K2.7 Code réussi · 3 sentences
Enabling reasoning mode causes the model to generate an internal chain-of-thought before producing each answer, and that hidden reasoning text is billed like any other output. Those extra reasoning tokens typically add up to much more than the final response itself, so every API call now costs significantly more than before. Because our overall usage volume did not change, the doubled bill reflects that each query consumes roughly twice as many billable tokens.
sortie 259 tok (+174 réflexion) latence 5.4 s
Le respect de la consigne (exactement trois phrases, ça se compte), l'adaptation au public visé (le registre d'un directeur financier) et l'écart de facturation dû à la réflexion masquée, que révèlent les compteurs de tokens ci-dessous.
Kimi K2.7 Code réussi · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is that the function counts *transitions* between equal neighbors instead of counting the items themselves, so a single-element list never enters the loop and returns `0` instead of `1`. Likewise, resetting `cur` to `0` on a mismatch forgets the current item that starts a new run, which causes runs that end at the last index to be undercounted. Initializing both `best` and `cur` to `1` and resetting `cur` to `1` fixes both issues.
sortie 410 tok (+222 réflexion) latence 9.4 s
La justesse réelle du correctif (il s'exécute), la densité de l'explication et l'économie de tokens sur une tâche bien délimitée.
Kimi K2.7 Code réussi · 5/5 fields, guidance "withheld pending the Q4 close"
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close" } ```
sortie 721 tok (+663 réflexion) latence 13.2 s
Le respect du schéma (aucun champ inventé), la tentation d'halluciner (le texte indique que la guidance n'est pas communiquée) et les différences entre les mécanismes de sortie structurée.
Kimi K2.7 Code réussi · 120 words, 0 banned, 1 question
We're introducing Prompt Cache for our API Gateway, a new capability that stores prompt responses across multiple AI providers. By caching replies, you reduce redundant calls, lower latency, and cut costs without changing how you build. Teams using several model providers can now reuse identical prompt results instantly, keeping traffic consistent and budgets predictable. Responses are keyed by provider, model, and exact prompt, so you always get the right result. Configure TTL, hit thresholds, and eviction rules from a single dashboard. It fits into your existing routing and requires no code changes. Setup takes minutes and works with your current endpoints. Want to see how much latency and spend you can trim? Check the docs to enable Prompt Cache today.
sortie 2375 tok (+2235 réflexion) latence 38.6 s
Le respect des contraintes (nombre de mots, liste de mots interdits, une seule question), l'empreinte stylistique et la maîtrise de la longueur.
Utilisez Kimi K2.7 Code en 30 secondes
Compatible OpenAI : changez la base_url, gardez votre SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="kimi-k2.7-code",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "kimi-k2.7-code",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k2.7-code",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "kimi-k2.7-code",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("kimi-k2.7-code")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));À propos de Kimi K2.7 Code
- Il conserve l'architecture Mixture-of-Experts de 1T de paramètres avec 32B activés par token (384 experts, huit par token plus un partagé) et un contexte de 256K, accepte l'entrée d'images en plus du texte, et fonctionne toujours en mode réflexion avec le contenu de raisonnement conservé d'un tour à l'autre.
- Le mode sans réflexion n'est pas simplement déconseillé, il est rejeté : la documentation indique que le modèle ne le prend pas en charge et que désactiver la réflexion renvoie une erreur, la conservation de la réflexion étant imposée côté serveur.
- Le raisonnement arrive dans reasoning_content avant la réponse, et le guide est explicite : vous devez renvoyer ce champ avec le message assistant sur les tours d'appel d'outils, sans quoi la requête échoue, ce qui constitue l'erreur d'intégration la plus fréquente avec ce modèle.
- Officiellement, il renforce l'exécution de bout en bout des tâches sur des workflows d'ingénierie logicielle complexes tout en consommant environ 30 % de tokens de réflexion en moins que K2.6, et prend en charge l'usage agentique d'outils via l'écosystème MCP avec une réflexion entrelacée sur des appels d'outils multi-étapes.
- Moonshot conseille de laisser une marge généreuse sur max_tokens, car le raisonnement la consomme.
- Les poids sont ouverts sous une licence MIT modifiée.
- Accédez à Kimi K2.7 Code sur Synthorai via l'endpoint compatible OpenAI.
FAQ
Peut-on essayer l'API Kimi K2.7 Code gratuitement ?
Oui : les nouveaux comptes reçoivent 10 appels d'essai et jusqu'à $1 de crédit gratuit, sans carte bancaire. À $0.95/M de tokens en entrée, ce crédit couvre à lui seul environ 131 requêtes de ~8K tokens sur Kimi K2.7 Code.
Quels sont les points forts de Kimi K2.7 Code ?
Environ 30 % de tokens de réflexion en moins ; raisonnement préservé au fil des conversations multi-tours ; réglé pour l'ingénierie logicielle du monde réel. La section À propos en donne un aperçu complet, tiré des notes de version du fournisseur.
Combien coûte Kimi K2.7 Code ?
Sur Synthorai, Kimi K2.7 Code coûte $0.95 par million de tokens en entrée et $4 par million de tokens en sortie, soit le tarif public du fournisseur, sans majoration de plateforme. Les tokens d'entrée en cache sont facturés $0.19/M.
Quelle est la fenêtre de contexte de Kimi K2.7 Code ?
Kimi K2.7 Code dispose d'une fenêtre de contexte de 256K tokens sur Synthorai. Une réponse peut compter jusqu'à 32,768 tokens.
Kimi K2.7 Code prend-il en charge la mise en cache des prompts ?
Oui, automatiquement : les prompts servis par Moonshot sont mis en cache sans modification de code. Les tokens d'entrée en cache sont facturés $0.19/M contre $0.95/M hors cache. Guide de mise en cache des prompts →
Comment obtenir l'accès à Kimi K2.7 Code ?
Dans votre SDK OpenAI actuel, indiquez base_url="https://synthorai.io/v1" et model="kimi-k2.7-code", et c'est tout. Une seule clé API donne accès à tous les modèles de la passerelle.
Kimi K2.7 Code est-il open source ?
Oui : les poids sont publiés sous licence Modified-MIT. Vous pouvez aussi vous passer de GPU : la version hébergée ici est facturée à l'usage, sans infrastructure à gérer. Exécuter des modèles à poids ouverts →
Modèles associés
Comparer
Chaque valeur de cette page est reprise de la documentation du fournisseur (lien ci-dessus) et porte la date de sa vérification. Les prix sont comparés à l'échelle du catalogue. Quand les fournisseurs ne définissent pas une spécification de la même façon, la différence est signalée et la valeur n'est pas mise en graphique. Nous ne mesurons rien ici et nous n'attribuons aucune note.