Loading page
Kimi
Kimi K2.7 Code
Kimi K2.7 Code is a coding-oriented chat model from Kimi, positioned as the code-focused variant in the K2.7 line and available through inference API providers.
Input from
$0.680 / 1M tokens
across 8 providers
API Pricing
Cheapest on Deep Infra — 26% below avg| Provider | Input / 1M | Output / 1M | Cached / 1M |
|---|---|---|---|
| $0.680 | $3.40 | $0.136 | |
| $0.710 | $3.50 | $0.150 | |
| $0.872 | $3.83 | $0.436 | |
| $0.950 | $4.00 | - | |
| $0.950 | $4.00 | - | |
| $0.950 | $4.00 | - | |
| $0.950 | $4.00 | $0.190 | |
| $1.25 | $4.50 | $0.310 |
Prices updated daily. Last check: Sep 8, 2026
Kimi K2.7 Code pricing by provider
Input, output, and batch rates, plus alternatives, for one provider at a time.
Performance & Benchmarks
Source: Artificial Analysis →Intelligence
32.7 / 100
Coding
60.8 / 100
Output Speed
65.7 t/s
Latency (TTFT)
1.1s
Reasoning & Knowledge
- GPQA Diamond89.6%
- Humanity's Last Exam35.0%
Coding
- SciCode47.8%
Agentic & Tool Use
- Terminal-Bench Hard44.7%
- Terminal-Bench v2.167.4%
- τ²-bench90.1%
- τ-bench Banking20.2%
Instruction & Long Context
- IFBench63.1%
- Long-Context Reasoning79.3%
Benchmarks measured Sep 2026. Scores are independent evaluations, not vendor-reported.
Model Details
General
- Creator
- Kimi
- Modalities
- Text
Capabilities
- Tool Calling
- No
- Open Source
- No
Strengths & Limitations
Strengths
- Code-focused variant within Kimi's K2.7 line, tuned for software development tasks rather than general chat
- Measured output throughput of roughly 39.5 tokens per second, adequate for interactive coding sessions and agent loops
- Time to first token around 1,280 ms, keeping the initial response wait in a usable range for IDE and assistant integrations
- Served through multiple inference API providers, so buyers can compare hosts on throughput, latency, and region
- Independent serving measurements available from Artificial Analysis rather than only vendor-published figures
- Standard chat-completions style access makes it straightforward to drop into existing coding tooling
Limitations
- Published accuracy benchmarks for this specific variant are not tracked in our database, making capability comparison harder
- We do not have a confirmed context window figure, which matters for repository-scale code tasks — verify with your provider
- Output speed near 39.5 tokens per second is mid-range, so very long generations take noticeable wall-clock time
- Code specialization means general-purpose chat, writing, or open-domain reasoning may be better served by a general model
- Performance and availability vary by host provider, so results are not identical across endpoints
Key Features
•Coding-oriented chat model in the Kimi K2.7 family
•Measured output throughput of about 39.5 tokens per second (Artificial Analysis)
•Time to first token of approximately 1,280 ms
•Chat completion API access via multiple inference providers
•Suited to code generation, refactoring, and debugging prompts
•Usable as the backing model for coding agents and editor plugins
•Provider-level choice of region, rate limits, and serving configuration
About Kimi K2.7 Code
Kimi K2.7 Code is a chat model released by Kimi under the K2.7 naming, with the "Code" suffix indicating a variant tuned toward software development work rather than general-purpose conversation. It sits alongside other K2 and K2.7 entries in Kimi's model catalog, and like other models in that catalog it is served through third-party inference API providers as well as Kimi's own endpoints, which is why throughput and latency can differ noticeably from one host to another.
The measurements we track for this model come from Artificial Analysis and describe serving characteristics rather than accuracy: roughly 39.5 output tokens per second and about 1,280 ms to first token. That combination is moderate — fast enough for interactive coding assistance and agent loops, but slower per token than the lightest models in the market, so long multi-file generations will take visible wall-clock time. We do not currently track a confirmed context window, modality list, or published accuracy benchmarks for Kimi K2.7 Code, so those specifics should be checked against the documentation of whichever provider you route to.
In practice, a code-specialized chat model of this kind is used for code generation, refactoring, test writing, debugging assistance, and as the model behind coding agents and IDE integrations. Buyers comparing Kimi K2.7 Code typically weigh it against other coding-tuned options and against general frontier chat models, where the trade-off is usually cost per token and provider availability versus breadth of general reasoning. Because multiple providers host Kimi models, the practical differentiator is often which host offers the throughput, region, and rate limits your workload needs.
Common Use Cases
Kimi K2.7 Code is aimed at development workloads: generating functions and modules from natural-language specifications, refactoring existing files, writing unit tests, explaining unfamiliar code, and diagnosing errors from stack traces. Its measured latency profile — roughly 1.3 seconds to first token with mid-range output speed — fits interactive use in an editor or terminal assistant, and it is workable inside agentic loops where a model reads code, proposes an edit, and reacts to test output, though each turn will feel deliberate rather than instant. For very high-volume, latency-critical tasks such as inline autocomplete, a smaller and faster model is usually the better fit, and for broad non-coding reasoning or writing, a general-purpose chat model is the more natural choice. Because we do not have a confirmed context window for this variant, teams planning whole-repository ingestion should confirm limits with their chosen provider before committing.
Frequently Asked Questions
How much does Kimi K2.7 Code cost to run?
Pricing depends on which inference provider you use and how they bill — separate input and output token rates, cached input discounts, and batch or dedicated-capacity options all differ between hosts. Because those rates change frequently, we do not quote figures in this write-up; check the pricing table on this page for the current per-provider rates for Kimi K2.7 Code.
What is Kimi K2.7 Code best used for?
It is a code-focused variant, so it suits code generation, refactoring, test authoring, code explanation, and debugging assistance, including use as the model behind a coding agent or editor integration. Its moderate first-token latency and mid-range output speed make it more appropriate for deliberate assistant turns than for inline autocomplete.
How fast is Kimi K2.7 Code?
Artificial Analysis measurements for this model show roughly 39.5 output tokens per second and about 1,280 ms to first token. Those are serving characteristics of a specific measured endpoint — actual speed varies by provider, prompt length, and load, so compare hosts if throughput matters to your workload.
How does Kimi K2.7 Code differ from other Kimi models?
The "Code" suffix marks it as the coding-tuned variant within the K2.7 line, as opposed to Kimi's general-purpose chat entries. If your workload is mostly software development, the code variant is the intended target; for mixed conversational, analytical, and writing tasks, a general Kimi model or another general-purpose chat model is usually a closer match.
What context window does Kimi K2.7 Code support?
We do not currently track a confirmed context window for this variant, and a missing value in our database means unverified rather than small. Check the documentation of the provider you plan to use, especially if you intend to feed in large codebases or long diffs.