Kimi K3.1 Pro: How to Use It in Kimi Code, Claude Code and Codex, API Key and Pricing ($2/$10, Cheaper Than K3), Is It Free, Highspeed, and the November 4 Open Weights

Kimi K3.1 Pro is Moonshot AI's new flagship model, released October 23, 2026: a post-trained Kimi K3 (a 2.8-trillion-parameter mixture-of-experts model) with a 1-million-token context window, aimed at long coding jobs, agents and finance work. You can use it today in the Kimi app, in Kimi Code (pick it with /model), in Claude Code, OpenCode and Codex, and through the API as kimi-k3.1-pro, and the full weights are due by November 4. Here is what surprises most people. First, the new model is cheaper than the one it replaces: $2.00 per million input tokens and $10.00 per million output, against $3.00 and $15.00 for Kimi K3. Second, there is no free API tier: the API refuses K3.1 Pro until you top up at least $1. And third, thinking is always on and the default effort is max, the most expensive setting, so most bills can be cut by changing one field. This guide covers setup in every tool, the real prices with worked examples, the Highspeed version, caching, the errors you will meet, and what the November 4 weights will take to run.

Ethan uses Kimi Code for the small scripts that run Jake's phone shop, and on Friday Jake came in waving a headline: Kimi's new model "matches the best paid models". "Do we switch?" he asked. "What does it cost us?" Ethan had already burned $6 that morning on a test run, most of it on thinking he had not asked for. "It costs exactly what we let it cost," he said. "Let me show you the setting."

New to Kimi? Moonshot AI is the Beijing lab behind the Kimi chat app, the Kimi Code coding agent and a family of open-weight models. Its K3 model, released this summer, was the largest open-weight model anyone had published, and our Kimi K3 explainer covers what that size means in practice. K3.1 Pro is the next step: the same model, trained much further. If you mostly want to use it for coding, our Kimi Code guide covers the subscription plans; this page focuses on the new model, the API and the tools around it.

What is Kimi K3.1 Pro?

Kimi K3.1 Pro is the first model in Moonshot's K3.1 series. Technically it is a post-trained version of Kimi K3: the same architecture and size, with much more reinforcement learning on top, across hundreds of downstream domains. It is Moonshot's most capable "3T-class" open-weight model so far. The key facts:

Moonshot pitches it at four kinds of work: long-horizon coding (from quick fixes to whole projects, including game engines such as Unity, Unreal and Godot), 3D modeling through CAD code, financial modeling and research, and general agent tasks with web search. It is a big, slow, thorough model by design. "So it's the careful one," Jake said. "The careful one that charges by the word," Ethan said, "including the words it thinks to itself."

Is Kimi K3.1 Pro free?

It depends on where you use it, and the API answer surprises people who used earlier Kimi models for free:

• The API is not free. K3.1 Pro is a "flagship" model on Moonshot's platform, and it is unlocked only after a successful top-up of at least $1. Until then, requests for it are refused. Your total top-ups also set your account tier, which controls how many requests and tokens per minute you may send. When your total top-ups reach $5, Moonshot adds a $5 voucher, so a $5 first top-up is effectively $10 of usage.
• The Kimi app and Kimi Code include K3.1 Pro in Moonshot's products, but which plans get it, and how much use each plan allows, is set per plan and changes often. Paid Kimi plans start at $19 a month. Check the plan page inside the app before you count on free access. Enterprise administrators must switch K3.1 Pro on for their organization; it is off by default at launch.
• OpenRouter lists moonshotai/kimi-k3.1-pro at the same $2.00 / $10.00, so it is a convenience, not a discount.
• The weights will be free to download from November 4, but they are well over a terabyte. See the open weights section for what that means.

The honest summary: K3.1 Pro is cheap, not free. For many people the cheapest route is a $5 top-up, with the voucher, and a sensible effort setting.

Kimi K3.1 Pro pricing (and why it is cheaper than K3)

The Kimi API bills input and output tokens per million (MTok). K3 series models also have automatic context caching, billed with separate prices for cache hits and cache writes. Prices from Moonshot's pricing page on October 24, 2026:

So the newer, stronger model costs a third less than K3 on every line. If you built anything on kimi-k3, switching the model name to kimi-k3.1-pro is the rare upgrade that also lowers the bill. Prices exclude tax, and file upload and extraction endpoints are temporarily free (you still pay for the extracted text when you send it to the model).

Some worked examples at the standard price, before caching:

• A chat question: 2,000 tokens in and 3,000 tokens out (including its reasoning) cost $0.004 + $0.030 = about $0.034.
• A coding-agent step: 80,000 tokens of repository context in and 6,000 out cost $0.16 + $0.06 = $0.22. A session of 40 such steps is about $8.80 without caching, which is how Ethan spent $6 before lunch.
• The same session with caching: if 70,000 of those 80,000 input tokens repeat from step to step, they bill at $0.20 per million after the first write, and each step drops to about $0.094. Forty steps then cost about $3.90.
• A full 1-million-token prompt: $2.00 just to send it once, before any output. Caching matters most here.

To compare these prices with Claude, GPT-6, Gemini, DeepSeek and Qwen, see our AI API pricing comparison.

Thinking is always on: reasoning_effort low, high and max

K3.1 Pro always reasons before it answers; you cannot switch thinking off as you could on some K2 models. What you can set is how hard it thinks, with the top-level reasoning_effort field: low, high or max. The default is max. Moonshot also runs its published benchmarks at max, with temperature 1.0 and top-p 0.95.

That default is the most expensive choice you can make. The reasoning the model writes before answering is generated output, so a higher effort means more output tokens, at $10.00 per million, plus more time before the answer appears. A rule of thumb that works:

• low for chat, summaries, simple edits and anything a human reads straight away.
• high for most coding and analysis, where you want care but not an essay of reasoning.
• max for the hard, long, multi-step tasks where a wrong answer costs more than the tokens.

completion = client.chat.completions.create(
    model="kimi-k3.1-pro",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "Refactor this function to remove the global state."}],
)
print(completion.choices[0].message.content)

If you are migrating code from K2.x, remove the old thinking configuration and use reasoning_effort instead. In the Anthropic-compatible endpoint the same setting lives in output_config as effort, and in Claude Code it is the CLAUDE_CODE_EFFORT_LEVEL variable. Ethan switched his script helper to high and his weekly report summary to low. "The report didn't get worse," he told Jake. "It just stopped arguing with itself before telling me sales were up."

How to get a Kimi API key (and is the Kimi API free?)

The Kimi API is pay-as-you-go with no subscription and no free monthly allowance, so "free API key" searches end at the same place: the key itself is free to create, but K3.1 Pro will not answer until the account holds credit. Here is the whole process, start to finish:

1. Sign in at platform.kimi.ai. This is Moonshot's international API platform. Keys created here work only with its endpoints (api.moonshot.ai), so do not mix them with keys from other regional Kimi platforms.
2. Top up. The minimum is $1, which unlocks K3.1 Pro and the other flagship models. When your total top-ups reach $5 you receive a $5 voucher.
3. Create the key on the API Keys page of the console. Give it a name that says where it will be used ("shop-scripts", "claude-code-laptop"), so you can revoke one without breaking the others.
4. Copy it once and store it safely. Put it in an environment variable or a secrets manager, never in source code or a shared document. If a key leaks, delete it in the console and create a new one.
5. Check your tier. Your cumulative top-up amount sets your account tier, which controls concurrency, requests per minute (RPM), tokens per minute (TPM) and tokens per day (TPD). The current limits for each tier are on the platform's Recharge and Rate Limits page; larger top-ups raise them.

When you exceed a limit, the API returns HTTP 429 with X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset headers, so a well-behaved client waits until the reset time and tries again. Moonshot's web search endpoints have their own per-second quota, separate from chat limits.

Kimi Code keys are different. A Kimi Code subscription comes with its own key and its own coding endpoint, billed by the subscription quota rather than per token. That is the key many guides mean by "Kimi for coding API". It is not interchangeable with a platform.kimi.ai key: use the Kimi Code key with Kimi Code's settings, and the platform key with api.moonshot.ai. Mixing them is the most common cause of a 401 on day one.

Kimi K3.1 Pro API setup in five minutes

1. Create an account and top up. Sign in at platform.kimi.ai and add at least $1 (or $5 for the voucher). Without a top-up, K3.1 Pro stays locked.
2. Create an API key on the API Keys page and store it as an environment variable: export MOONSHOT_API_KEY="sk-..." on Mac or Linux, or $env:MOONSHOT_API_KEY="sk-..." in PowerShell.
3. Install the OpenAI SDK: python3 -m pip install --upgrade "openai>=1.0". The Kimi API is OpenAI-compatible, so no Kimi-specific library is needed.
4. Make a first call (below), with a low effort while you test.
5. Set a spending alert in the console before you hand the key to an agent.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1")

r = client.chat.completions.create(
    model="kimi-k3.1-pro",
    reasoning_effort="low",
    messages=[{"role": "user", "content": "Give me three names for a phone repair shop."}],
)
print(r.choices[0].message.content)

The same call with curl:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" -H "Content-Type: application/json" \
  -d '{"model":"kimi-k3.1-pro","reasoning_effort":"low",
       "messages":[{"role":"user","content":"Give me three names for a phone repair shop."}]}'

The multi-turn rule that breaks tool loops. For conversations and tool calls, append the complete assistant message the API returned to your next request, not just its content. That message carries the reasoning and tool-call fields the model needs to continue. Code that rebuilds the history from content alone works for plain chat and then fails strangely once tools are involved. With streaming, the reasoning arrives as reasoning_content deltas and the answer as content deltas, so collect both.

Keys are tied to their platform. A key created on platform.kimi.ai only works against that platform's endpoints. Mixing it with another regional Kimi platform returns 401. If you also hold a Kimi Code subscription key, that is a separate credential again.

Use Kimi K3.1 Pro in the Kimi app and Kimi Work

The easiest way to try K3.1 Pro needs no key at all. On kimi.com and in the Kimi mobile apps, open the model picker at the top of a chat and choose Kimi K3.1 Pro. If it is missing or grayed out, your plan does not include it; the app's plan page shows which models each plan gets. Long jobs such as building a spreadsheet model or researching a company run better in Kimi Work, Moonshot's desktop app for agent tasks. You need version 3.1.0 or later, for Windows or Apple Silicon Macs, then K3.1 Pro appears in its model list.

Three habits make the app work well with this model. Give it the whole task at once, with the files attached, rather than feeding it step by step, because it is built for long, multi-step jobs. Ask for the output format you want (a table, a workbook, a slide outline) in the first message. And for quick questions, use a lighter model in the picker: a big, thorough model makes you wait for answers a smaller one gives in a second. Companies on Kimi Enterprise should note that K3.1 Pro is off by default; an administrator has to enable it for the organization first.

Use Kimi K3.1 Pro in Kimi Code

Kimi Code CLI is Moonshot's own terminal coding agent, and it can run K3.1 Pro either on a Kimi Code subscription or on your pay-as-you-go API key:

1. Install it. On Mac or Linux: curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash. On Windows, install Git for Windows first, then run irm https://code.kimi.com/kimi-code/install.ps1 | iex in PowerShell. The script verifies its download and puts kimi on your PATH.
2. Start it in your project with kimi, then type /login.
3. Pick how you pay. Choose your Kimi Code subscription, or Kimi Platform (API key · platform.kimi.ai) and paste the API key from the previous section. The CLI checks the key and loads the models your account can use.
4. Select the model with /model and choose Kimi K3.1 Pro.

Which route is cheaper depends on how much you code. A subscription has a monthly price and a usage quota; the API key bills every token. If you code every day, the subscription usually wins; if you use the agent a few times a week, the API key with reasoning_effort set sensibly is often cheaper. Our Kimi Code guide compares the plans and quotas.

In OpenCode, run opencode auth login, choose the Kimi provider that matches your key (Kimi For Coding for a Kimi Code subscription key, Moonshot AI for a platform.kimi.ai key), paste it, then pick the model with /models. Our OpenCode guide covers the install.

Use Kimi K3.1 Pro in Claude Code

The Kimi API has an Anthropic-compatible Messages endpoint at https://api.moonshot.ai/anthropic, and kimi-k3.1-pro is its default model, so Claude Code can run on K3.1 Pro with a few settings. Put them in the env block of ~/.claude/settings.json and restart Claude Code:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.moonshot.ai/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_MOONSHOT_API_KEY",
    "ANTHROPIC_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-highspeed",
    "ANTHROPIC_DEFAULT_FABLE_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"
  }
}

A few details matter here:

• Set every tier. Claude Code uses different model slots for the main chat, background summaries and sub-agents. Leave one out and the tasks on that tier fail quietly. Kimi's own Claude Code example still shows kimi-k2.7-code on the Haiku tier, but the Anthropic endpoint lists only kimi-k3.1-pro, kimi-k3.1-pro-highspeed and kimi-k3, so Highspeed is the safe fast choice there.
• The [1m] suffix tells Claude Code to use the full million-token window, the same pattern Kimi uses for K3. Keep CLAUDE_CODE_AUTO_COMPACT_WINDOW matched to it so conversations are not compacted early.
• Effort: max is the quality ceiling, but high is the better default for everyday coding on a token budget.
• Stale settings win. The env block in settings.json overrides variables exported in your terminal, and old ANTHROPIC_* exports in ~/.zshrc or ~/.bashrc interfere too. If Claude Code keeps talking to the wrong service, clean both.
• No /v1 on the base URL. Use exactly https://api.moonshot.ai/anthropic. Adding /v1 makes Claude Code build the wrong path, and the error it shows looks like a model problem rather than a URL problem.
• The /model menu will not list Kimi. Claude Code's menu shows its own tier names; the environment variables above decide which Kimi model each tier really uses.
• One key variable only. If ANTHROPIC_API_KEY is also set from an earlier setup, remove it, because it conflicts with ANTHROPIC_AUTH_TOKEN.
• The key is in plain text in that file, so never commit ~/.claude/settings.json to git.

Test the endpoint and key with curl before blaming Claude Code:

curl https://api.moonshot.ai/anthropic/v1/messages \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" -H "anthropic-version: 2023-06-01" -H "content-type: application/json" \
  -d '{"model":"kimi-k3.1-pro","max_tokens":512,"messages":[{"role":"user","content":"hi"}]}'

Use Kimi K3.1 Pro in Codex

The Kimi platform supports the Responses API that Codex uses, so Codex can talk to kimi-k3.1-pro directly, with no proxy:

1. Store the key in an environment variable, not in the config file. On Mac or Linux, read -s KIMI_API_KEY && export KIMI_API_KEY keeps it out of your shell history. In PowerShell, $env:KIMI_API_KEY="YOUR_KEY".
2. Add Kimi as a provider in ~/.codex/config.toml (on Windows, %USERPROFILE%\.codex\config.toml):

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

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

wire_api = "responses" is the setting that makes the direct connection work, and model_context_window stops Codex from assuming a smaller default window. Codex reads this file only at startup, so restart it (and Codex Desktop) after editing. In Desktop the model picker may say Custom; requests still go to K3.1 Pro. If nothing changes, check for -c flags or profiles overriding the file.

Streaming and tool calls in Python and JavaScript

Two patterns cover most real applications: streaming, so users see the answer as it is written, and a tool-call loop, so the model can use your functions. Both work with the standard OpenAI SDKs.

Streaming in Python. K3.1 Pro streams its reasoning and its answer separately. Show the answer to users, and log or hide the reasoning:

stream = client.chat.completions.create(
    model="kimi-k3.1-pro",
    reasoning_effort="high",
    stream=True,
    messages=[{"role": "user", "content": "Explain a mixture-of-experts model in three sentences."}],
)
for chunk in stream:
    delta = chunk.choices[0].delta
    if getattr(delta, "reasoning_content", None):
        pass  # the model's thinking: log it, or show it collapsed
    if delta.content:
        print(delta.content, end="", flush=True)

A tool-call loop in Python. The important line is messages.append(msg): it keeps the complete assistant message, with its tool calls and reasoning, exactly as the API returned it:

import json

tools = [{"type": "function", "function": {
    "name": "check_stock", "description": "Count units of a spare part on the shelf",
    "parameters": {"type": "object", "properties": {"part": {"type": "string"}}, "required": ["part"]}}}]

messages = [{"role": "user", "content": "Do we have an iPhone 17 screen in stock?"}]
while True:
    r = client.chat.completions.create(model="kimi-k3.1-pro", reasoning_effort="low",
                                       messages=messages, tools=tools)
    msg = r.choices[0].message
    messages.append(msg)                      # the whole message, not just msg.content
    if not msg.tool_calls:
        print(msg.content); break
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"part": args["part"], "count": 2}   # your real stock lookup goes here
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})

JavaScript or TypeScript. The official openai package works the same way (npm install openai):

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.MOONSHOT_API_KEY, baseURL: "https://api.moonshot.ai/v1" });
const r = await client.chat.completions.create({
  model: "kimi-k3.1-pro",
  reasoning_effort: "low",
  messages: [{ role: "user", content: "Write a one-line SMS telling a customer their repair is ready." }],
});
console.log(r.choices[0].message.content);

Keep the key on the server. A key placed in browser JavaScript can be read by anyone who opens the page, and they can spend your balance with it.

Kimi K3.1 Pro Highspeed: when double the price is worth it

kimi-k3.1-pro-highspeed runs the same model 2 to 3 times faster, by Moonshot's figures, and costs exactly double for input, output and cache writes ($4.00 / $20.00), while cached input stays at $0.20. It is not a smaller or weaker model, just a faster serving tier.

It is worth it when a person is waiting: interactive coding in an editor, a chat assistant with customers on the other end, or agent steps where latency compounds over dozens of calls. It is not worth it for overnight batch jobs, long reports or anything that runs while you do something else. Since cached input costs the same on both, a long, mostly cached context makes Highspeed's premium smaller than the headline suggests. "So pay for speed only when someone is standing at the counter," Jake said. "Exactly," said Ethan.

1M context and caching: 5-minute vs 1-hour cache

Context caching on the Kimi API is automatic. When a request repeats a prefix that is already cached (a long system prompt, a repository, a document), those tokens bill at the cached-input price, $0.20 per million instead of $2.00. You do not create caches by hand. You only choose how long a written cache lives: 5m (the default) or 1h.

The pricing makes the choice simple. A 5-minute cache write costs the same as normal input ($2.00), so caching never costs extra on the first request. A 1-hour write costs double ($4.00), so it pays off only when your requests come more than five minutes apart and you will reuse the prefix at least a couple of times within the hour. Rapid back-and-forth in a coding session: keep 5m. A support bot that answers a question every 20 minutes against the same manual: 1h.

Two habits get the most from it. Put the stable parts first (system prompt, tools, documents) and the changing parts last, because only an identical prefix is reused. And remember the window is big but not free: a 1-million-token prompt costs $2.00 to write and $0.20 for each cached reuse, so trim what the model does not need.

Vision, tool calls, structured output and partial mode

K3.1 Pro handles more than plain chat, through the same endpoints:

• Images: send image parts in the messages content, as with other OpenAI-compatible vision models. It reads screenshots, charts and photos.
• Tool calls: standard tools and tool_choice, plus dynamic tool loading for agents that discover tools as they go. Remember the multi-turn rule: send back the whole assistant message.
• Structured output: JSON that follows your schema, for pipelines that parse the reply.
• Partial mode: start the assistant's reply yourself (for example with an opening { or a fixed sentence) and the model continues from there.
• Web search: Moonshot's separate search endpoints have their own per-second quota that does not count against your chat limits.

Long requests should stream. A non-streaming request that runs past 900 seconds gets a 504 gateway timeout page, and a thorough max-effort answer over a big context can take that long.

Kimi K3.1 Pro benchmarks and what changed from K3

Moonshot reports that K3.1 Pro matches or approaches the strongest proprietary models on coding, agent and knowledge benchmarks, with all results at maximum effort. A few of its headline numbers:

• BenchCAD (3D reconstruction through CAD code): 92.7 percent with tools, against 96.2 percent for Claude Opus 5.5 in Moonshot's comparison.
• OfficeQA Pro v2 (financial data analysis over real document collections): 64.4, which Moonshot calls state of the art.
• Internal finance tests: financial modeling up 7.2 points and financial research up 11.6 points over K3, and about 4.2 times K3's score on a simulated business-operation test.
• Coding: results on Terminal-Bench 4.0, DeepSWE, SWE-Marathon and Moonshot's own Kimi Code Bench, mostly run through a Claude Code harness.

Two points of context. These are the developer's own numbers, and many were run in Claude Code or Kimi Code harnesses, so independent results over the next few weeks will tell you more. And price matters as much as scores. At $2.00 / $10.00, K3.1 Pro costs far more than the budget open models such as DeepSeek V4.1 Flash and MiniMax M3.1 Flash ($0.15 / $0.60 per million tokens), while staying well below the most expensive closed flagships. It is a premium open model, priced like one, so use it where its extra care pays for itself.

Moonshot also describes an unusual safety step. During training it found that vulnerability-research ability rose steadily, traced it to cyber-related training data, and removed that data and filtered related reinforcement-learning environments before release. Its stated aim is not to publish open weights that push the frontier of offensive cyber capability. For defenders that means K3.1 Pro may be less eager on exploit work than K3 was.

Kimi K3.1 Pro vs DeepSeek V4.1 Flash vs MiniMax M3.1 Flash

These three open-weight models from Chinese labs launched within days of each other, and they are easy to confuse. They are not in the same class:

The pattern is simple. DeepSeek and MiniMax's Flash models are budget workhorses, roughly 13 to 17 times cheaper per token, and they are the right default for high-volume work where good enough is good enough. K3.1 Pro is the model you send the hard jobs to: the refactor across a whole repository, the financial model that must tie out, the agent run that goes for hours. Many teams will use both, routing by difficulty. Our guides to DeepSeek V4.1 Flash and MiniMax M3.1 Flash cover their setup.

Kimi K3.1 Pro vs Kimi K3: should you switch?

For almost everyone already on kimi-k3, yes: K3.1 Pro is the same model trained further, a third cheaper on every price, with the same 1-million-token window. The switch is mostly a model name, but check these before you flip production traffic:

1. Change the model ID from kimi-k3 to kimi-k3.1-pro everywhere it appears, including Claude Code's tier variables and Codex's config.toml.
2. Set reasoning_effort on purpose. K3.1 Pro has no way to switch thinking off, while K3 in Claude Code could. Code that relied on thinking being off will now pay for reasoning, so pick low where you want speed.
3. Re-run your own test set. A stronger model can still change tone, length or formatting in ways your parsers notice. Twenty real prompts from your logs are enough to catch it.
4. Check your caching assumptions. Cached input drops from $0.30 to $0.20, so prompt-heavy workloads save even more than the headline prices suggest.
5. Keep K3 as a fallback for a week. The Anthropic-compatible endpoint still accepts kimi-k3, so rolling back is a one-line change if something regresses.

Coming from K2.x is a bigger step: remove the old thinking parameter, move to reasoning_effort, and budget for a model that reasons on every request.

Kimi K3.1 Pro open weights on November 4: can you run it locally?

Moonshot plans to release the full K3.1 Pro weights by November 4, 2026. That is good news for companies that want to host it themselves, and almost irrelevant for home computers. Because K3.1 Pro is a post-trained K3, its size will match K3's, and K3's numbers are already public:

Even the smallest 1-bit conversion needs close to half a terabyte of memory, and 1-bit quality is a real compromise. The official weights are already 4-bit, so there is no "shrink it a little" option that suddenly fits a workstation. People have run K3 on clusters of many GPUs or on multi-node setups of small AI boxes, at single-digit to low-double-digit tokens per second; that is a research project, not a weekend install. Our Kimi K3 explainer walks through the hardware math.

If what you want is a capable model on your own machine, pick one built for it: our guides to Recursive Flint for coding, or the run AI locally series for everything else. And if the files that land on November 4 are smaller than expected, we will add the details here.

Kimi K3.1 Pro API errors and fixes

404: Model not found, or this account does not have permission to access the model

Either the model name is misspelled (it is kimi-k3.1-pro, with the dot), or your account has not been topped up yet. K3.1 Pro unlocks after a top-up of at least $1.

401: Invalid Authentication or Incorrect API key provided

The key is wrong, missing the Bearer prefix, or from a different Kimi platform than the endpoint. Keys from platform.kimi.ai work only with that platform.

429: Account balance is insufficient or Token quota is insufficient

Your prepaid balance ran out. Top up and retry. This is exceeded_current_quota_error, not a rate limit.

429: Organization-level RPM, TPM, TPD or concurrency limit reached

You hit your tier's rate limit. Back off using the X-RateLimit-Reset header, reduce parallel requests, or raise your tier with more total top-ups.

429: The engine is currently overloaded

Moonshot's servers are busy, common on launch days. Wait for the time in Retry-After and reduce concurrency.

504 Gateway Time-out after a long request

A non-streaming request ran past 900 seconds. Use stream: true for long or max-effort requests.

Claude Code still uses the old model or service

Stale values in the env block of ~/.claude/settings.json or old ANTHROPIC_* exports in your shell profile override your new settings. Clean both and restart.

400: Input token length too long

The prompt plus history reached the 1,048,576-token window. Trim old turns or documents, or summarize them, and keep output room for the model's reasoning.

400: The request was rejected because it was considered high risk

This is content_filter: the input or the model's output tripped Moonshot's safety review. Rephrase the request; security work that looks like exploitation is the usual trigger with this model.

Tool calls fail on the second turn

Your code kept only the reply's content. Send the full assistant message, including its tool calls and reasoning, back in the next request.

Kimi K3.1 Pro: frequently asked questions

By Monday, Ethan had his script helper on K3.1 Pro at high effort, the weekly summary at low, and a $5 top-up that had turned into $10 of credit. The morning test run that had cost $6 now cost a little over $2. Jake asked whether that was it. "That's the whole trick," Ethan said. "Big model, small settings." If your numbers or setup steps come out differently, please tell us. Guides like this stay right because readers write in.

Revision note. Written October 24, 2026, the day after Moonshot launched Kimi K3.1 Pro, with the prices and setup steps of that day. "Measure twice, cut once," the carpenter says, and with a model that bills its own thinking, the measuring is the effort setting.