As of November 8, 2026, Kimi K3.1 Pro (kimi-k3.1-pro) is a reasonable starting point for evaluating Moonshot’s managed API for complex tasks such as coding and long-context work. Consider K3.1 Pro Highspeed if responsiveness is important, but measure its performance on your workload rather than relying on Moonshot’s speed claim. For repository-level code repair you want to run yourself, Kimi-Dev-72B is a separate, specialized option—not a hosted API model. Moonshot’s K3.1 Pro API guide describes a one-million-token context window for Pro. Check each API model’s live metadata before relying on the same limit for Highspeed or assuming it is available to your account. (K3.1 Pro API guide; API model list)
“Moonshot Kimi” can mean Kimi products, the models behind them, or the developer API. Those are different selection questions: an app subscription or local model setup does not establish API access, API pricing, or production limits. This guide focuses on model selection and evaluating the managed API.
Shortlist a Kimi model by workload
| If your workload is… | Shortlist | Why—and what to validate |
|---|---|---|
| Complex API tasks, such as coding or long-context reasoning | Kimi K3.1 Pro (kimi-k3.1-pro) |
Moonshot’s API guide describes a one-million-token context window and covers coding and other API capabilities. Check the live model metadata and test your workload. (K3.1 Pro API guide; API model list) |
| Similar API tasks where responsiveness matters | Kimi K3.1 Pro Highspeed (kimi-k3.1-pro-highspeed) |
Moonshot claims 2–3× the speed of K3.1 Pro. Treat that as a vendor claim, not a latency guarantee. The API reference says these models share K3 parameter constraints; compare both on the same prompts. (Moonshot announcement; API parameter reference) |
| Repository issue resolution and test writing, with self-hosting | Kimi-Dev-72B | Moonshot’s repository describes a workflow that locates relevant files, then edits them for fixes or test insertions. It reports 60.4% on SWE-bench Verified; treat that as a repository-reported result, not an independent or apples-to-apples comparison. The documented path is local vLLM serving, not Moonshot’s hosted API. (MoonshotAI repository) |
API fit: what is and isn’t established
Moonshot’s K3.1 Pro API guide describes a one-million-token context window for K3.1 Pro and covers reasoning effort, streaming, vision input, and tool calling. That guide does not establish that Highspeed has the same context limit. The API model-list endpoint is the recommended way to check which IDs are currently available and inspect each model’s context_length and capability flags. Query it before relying on a context figure or capability; account-specific access still depends on what the endpoint returns for your key. (K3.1 Pro API guide; model list)
For example, with your API key set as MOONSHOT_API_KEY, list the two model records and inspect their IDs, context lengths, and capability fields:
curl --fail --silent --show-error \
https://api.moonshot.ai/v1/models \
-H "Authorization: Bearer $MOONSHOT_API_KEY" \
| jq '.data[] | select(.id == "kimi-k3.1-pro" or .id == "kimi-k3.1-pro-highspeed")'
The API reference lists both model IDs and says they share K3 parameter constraints. The public references used here do not establish a numeric, Highspeed-specific Chat Completions output limit; check the live model record and current endpoint documentation rather than transferring a limit from another API surface. (Model list endpoint; model parameter reference)
Production API: a minimal starting point
Moonshot documents Chat Completions calls with the OpenAI Python SDK. Create an API key in the Kimi API Platform, store it outside your source code, and use a model ID shown by the current model-list response. The example uses the documented OpenAI-compatible client setup and Chat Completions request pattern. (Quickstart; Chat Completions reference; API model list)
Set the key in your shell, then install the SDK and run a small smoke test:
export MOONSHOT_API_KEY="your_api_key"
pip install openai
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["MOONSHOT_API_KEY"],
base_url="https://api.moonshot.ai/v1",
)
response = client.chat.completions.create(
model="kimi-k3.1-pro",
messages=[{"role": "user", "content": "Reply with: API connection works."}],
)
print(response.choices[0].message.content)
Expected outcome: the script prints the model’s reply. This is an example based on the documented SDK and Chat Completions interface, not a test performed for this article. For deployment, also handle timeouts, retries, logging, and errors; do not expose the API key in client-side code. Check the current API reference for model-specific parameter support before adding optional request settings. (Chat Completions quickstart; model parameter reference)
API pricing and a worked estimate
OpenRouter’s listing shows a Moonshot AI provider route for K3.1 Pro at $2 per million input tokens and $10 per million output tokens; it lists cache reads separately at $0.20 per million tokens. These are OpenRouter’s displayed rates for that route—not a confirmed quote for direct billing through Moonshot. The listing does not establish that the $2 input rate specifically means uncached input, so this example does not label it that way. Check Moonshot’s official inference-pricing page for direct-platform billing and current terms before purchasing. (OpenRouter K3.1 Pro listing)
Illustrative OpenRouter-route estimate: suppose a request uses 100,000 input tokens billed at the displayed input rate and generates 10,000 output tokens:
- Input: 100,000 ÷ 1,000,000 × $2 = $0.20
- Output: 10,000 ÷ 1,000,000 × $10 = $0.10
- Estimated total: $0.30
This is arithmetic based on the provider listing, not a measured bill or a direct Moonshot quote. It does not apply the separately listed cache-read rate. Actual cost depends on the route selected, token use, current rates, and applicable billing rules. For agent workflows, estimate from the full run: repeated context and tool-result text can make cumulative input usage much larger than one request suggests.
Before committing to production
Confirm these details in the current API documentation and your own account:
- Model access and capability flags: Query the available-model list and verify that your key can call the intended ID and that its returned capability flags match your requirements. (Model list endpoint)
- Context and output limits: Check the live context length for each model ID and the relevant endpoint’s output-token settings. For the Responses API, Moonshot documents a default
max_output_tokensof 131,072 for K3-series models, configurable up to 1,048,576; this is an output budget, not the total input-plus-output context. Do not assume this Responses API setting applies unchanged to Chat Completions. (Responses API reference) - Availability and operating limits: Verify account access, rate limits, and service availability for your planned traffic. The cited public references do not establish the limits that will apply to every account.
- Cost: Recheck the direct-platform price and estimate with representative input/output usage. Keep API charges separate from consumer-app subscriptions. Treat OpenRouter’s route price as a separate provider listing, not proof of Moonshot direct billing. (Moonshot pricing; OpenRouter listing)
- Task fit: Run a small evaluation set drawn from your own workload. Compare task success, factual or code correctness, latency, and cost—not model descriptions alone.
- Deployment type: Don’t confuse local serving with a hosted API integration. Kimi-Dev’s repository documents vLLM deployment for that specific coding model; it does not provide hosted API instructions. (Kimi-Dev repository)
Bottom line: shortlist K3.1 Pro for a managed-API evaluation, test Highspeed if responsiveness matters, and consider Kimi-Dev-72B only for the separate self-hosted coding-model use case. Verify live model access, API limits, and direct-platform prices before production rollout.
Sources
Kimi K3.1 Pro - Kimi API Platform
List Models - Kimi API Platform
Quickstart - Kimi API Platform
Chat Completions API - Kimi API Platform
Model Parameter Reference - Kimi API Platform
Responses API - Kimi API Platform
Kimi API Platform - API key documentation
Model Inference Pricing - Kimi API Platform
Kimi K3.1 Pro has launched! Start exploring now!