Kimi Code: Is It Free? Plans, Kimi Code CLI Install, and Using K3 in Claude Code or OpenCode (2026)

Kimi Code is Moonshot AI's coding service for its Kimi models, including the 2.8-trillion-parameter Kimi K3. You can use it through the open-source Kimi Code CLI in your terminal, a desktop app, a VS Code extension, or inside other agents such as Claude Code, Codex and OpenCode. The CLI is free and MIT-licensed. The service is not: Kimi Code comes with Kimi membership, and here is the catch: the cheapest paid tier, Go, includes no coding quota at all. Coding starts at the Plus plan, $19 a month, and K3's full 1-million-token context and the fast HighSpeed model need Pro at $39. Below: what each plan really includes, how to install the Kimi Code CLI on Windows, Mac and Linux, how to use K3 inside Claude Code or OpenCode, the quota traps that quietly double your usage, and every common error explained.

Jake had read that Kimi K3 was one of the best coding models in the world and wanted to try it on his shop's website. He signed up for Kimi, picked the cheapest paid plan, Go, installed the Kimi Code CLI, and typed /login. The login worked. The first request did not; the account had no coding quota. He assumed he had installed something wrong and reinstalled twice before texting Ethan. Ethan checked the plan page for thirty seconds. "Nothing's wrong with your install," he wrote. "Go is the chat plan. Kimi Code starts one tier up, at Plus." Jake upgraded, the remaining days of his Go plan were credited automatically, and his next request worked.

What Kimi Code is, in plain English

Moonshot AI is the Chinese company behind the Kimi chatbot and the Kimi K3 model. Kimi Code is its developer service: a monthly coding allowance, included with certain Kimi membership plans, that you spend through several apps. Every request from every app counts against the same allowance.

• Kimi Code CLI: a coding agent that runs in your terminal. It reads and edits code, runs shell commands, searches files, fetches web pages and decides the next step from the results. It is open source under the MIT license, on GitHub as MoonshotAI/kimi-code, with about 7,800 stars; version 2.1 shipped on September 23, 2026.
• Kimi Code Desktop: a graphical app for macOS (Apple Silicon and Intel) and Windows, released September 17, 2026, built on the same agent core, with a built-in browser for checking web pages.
• Kimi Code for VS Code: an extension that adds a chat panel, file references with @, and diff views with rollback inside the editor.
• Other agents: Kimi Code's API speaks both the OpenAI and Anthropic formats, so you can use your allowance inside Claude Code, Codex, OpenCode and Hermes.

A coding agent, if the term is new, is an AI that does the work rather than describing it: you ask for a feature or a fix, and it reads your files, changes them, runs the tests and reports back. It is powerful, which is why the approval settings later on this page matter.

The four Kimi Code models

Kimi Code offers four model IDs. You type the ID, not the marketing name, wherever a tool asks for a model:

Model ID	What it is	Context	Plan needed
k3	Kimi K3, the flagship (2.8T parameters); images and video	1M on Pro and above; 256K on Plus	Plus
k3-256k	K3 capped at 256K tokens; images only	256K	Plus
kimi-for-coding	K2.8 Preview since September 11: close to K3, more efficient thinking	1M	Plus
kimi-for-coding-highspeed	K2.7 Code HighSpeed: about 6 times faster output	256K	Pro

K3 and K2.8 Preview think before answering, at three effort levels: low, high and max. K3 defaults to high, K2.8 Preview to max. Turning thinking off sends the request to K2.8 Preview without thinking, whichever model you named.

Kimi CLI vs Kimi Code CLI: which one?

If you search "Kimi CLI," you will find two projects. The old kimi-cli was written in Python and installed with the uv tool; it is now archived and no longer maintained. The current Kimi Code CLI was rebuilt on Node.js, installs as a single command, starts faster and has a redesigned interface. Both use the command kimi, which is the main source of confusion.

Moving over is painless: the first time you run the new kimi, it finds the old data in ~/.kimi/ and offers to migrate it, or you can run kimi migrate any time. It copies your config, MCP server settings, input history and the chat sessions you choose, and it never changes the old folder, so both can coexist. Logins are not copied; run /login again afterward. Old plugins do not carry over either.

Is Kimi Code free? Plans and prices

The Kimi Code CLI is free and open source. The Kimi Code service is a paid membership benefit, and it starts at Plus. Moonshot renamed its plans in 2026 with prices unchanged, and the new tiers line up like this:

Plan	Monthly	Billed yearly	Kimi Code includes
Go	Entry tier	—	No coding quota
Plus	$19	$180 ($15 a month)	K3 and K3-256K at 256K context, K2.8 Preview at 1M
Pro	$39	$372 ($31 a month)	Adds K3 at 1M context and the HighSpeed model
Max	$99	$948 ($79 a month)	Same models, larger allowance
Ultra	$199	$1,908 ($159 a month)	Largest allowance

Older subscriptions keep their legacy names and rules: Andante (Kimi Code with K2.8 Preview only), Moderato (adds K3, equivalent to Plus), and Allegretto and above (1M context and HighSpeed, equivalent to Pro). Nobody is forced to switch; legacy plans keep renewing until you change them, and an upgrade credits your remaining days automatically.

How the allowance works

• A rolling five-hour window. Send too much in a short time and you are rate-limited until the window rolls on. It recovers by itself.
• A monthly total, shared with your Kimi membership. If you reach it, Kimi Code freezes until the month resets or you upgrade.
• No weekly limit on the new plans. New members no longer have the seven-day quota that refreshed weekly; legacy plans still do, refreshing every seven days from the subscription date, with no rollover.
• Everything shares one pool: the CLI, Desktop, VS Code, third-party tools and every API key. Devices unused for 30 days are unbound automatically; run /login to bring one back.
• Check it any time with /usage in the CLI, or in the Kimi Code Console.

Extra Usage: the overflow wallet with no cap by default

When your allowance runs out, Kimi offers Extra Usage, a prepaid balance that takes over automatically so tasks keep running instead of stopping with an error. It is useful, and it has one setting to check: a monthly spending cap is optional, and without it there is no cap. Turn on the cap in the Extra Usage settings before you turn on the feature. Other details: Extra Usage is shared between Kimi on the web and Kimi Code, priced close to the Kimi Open Platform's API rates and shown in Chinese yuan, with a minimum top-up of ¥25. The balance never expires but is generally non-refundable, and Moonshot itself says that for heavy use, upgrading the plan is usually better value.

The pay-as-you-go alternative, and other providers

You do not need a membership to use the CLI. At /login, choose a Kimi Platform API key instead of the Kimi Code account, and you pay per token at Moonshot's API prices; K3 costs $3.00 per million input tokens ($0.30 cached) and $15.00 per million output tokens. Note that this is a different service with a different base URL from Kimi Code, a frequent source of login errors. The CLI can also connect to Anthropic, OpenAI, Google Gemini, Vertex AI and OpenAI-compatible services such as DeepSeek, through /provider or ~/.kimi-code/config.toml. So "free Kimi Code" really means the free CLI plus whichever model you pay for.

How good is Kimi Code? K3's coding scores

Kimi Code's appeal rests on Kimi K3, so it is fair to ask how strong K3 really is at coding. The most useful recent snapshot comes from an unexpected place: the comparison chart Reflection AI published on October 5, 2026 for its own Beam model, which gathered results from third-party evaluators. In that chart, K3 led every other open model on most coding and agent tests:

Benchmark	Kimi K3	GLM 5.3	Qwen 3.8 Max	DeepSeek V4.1 Flash
SWE Bench Pro v2-Hard	88.2	84.3	not reported	not reported
Terminal Bench v2.1	88.3	88.2	86.6	90.6
SWE Atlas Codebase QnA	68.0	61.0	not reported	not reported
HLE, no tools (hard reasoning)	46.9	42.3	43.6	39.1
BrowseComp (web research)	91.2	not reported	not reported	not reported
AA-LCR (long context)	88.7	79.7	80.3	84.0

Two caveats keep this honest. DeepSeek V4.1 Flash beat K3 on Terminal Bench and on the DeepSWE test (74.2 against 68.0), at a small fraction of the price. And benchmarks measure average performance on someone else's tasks; your codebase is the only test that settles it. Moonshot describes the default kimi-for-coding model, K2.8 Preview, as "close to K3" with more efficient thinking, which makes it the sensible everyday choice on Plus, with K3 kept for the hardest problems.

So is Kimi Code worth it? If you code most days and want one of the strongest open models at a predictable price, Plus at $19 is a reasonable starting point; step up to Pro only if you need K3's full 1M context for very large codebases or the HighSpeed model. If you code occasionally, pay-as-you-go with a Kimi Platform API key, or OpenCode Go's $10 plan, which also includes K3, may cost less.

Quota traps that quietly double your usage

Most "my Kimi quota vanished" stories come down to four habits, all documented by Moonshot itself:

1. K3 at 1M context costs about twice as much quota as K3-256K. On Pro and above, k3 means the 1M version. If your project fits in 256K tokens, which most do, k3-256k stretches your allowance roughly twice as far.
2. HighSpeed uses three times the quota for about six times the output speed. And it only speeds up the model's writing, not file reads, commands or scripts, so on tool-heavy tasks it can feel barely faster while costing triple.
3. Switching models or effort levels mid-session throws away the cache. Kimi reuses the context it has already processed. Change the model or the thinking effort and that cache no longer applies, so the whole conversation is processed again. Pick a model and effort per task, and start a new session (/new) when you change them.
4. A mistyped HighSpeed model ID fails silently. The ID must be exactly kimi-for-coding-highspeed. Anything else falls back to the standard kimi-for-coding with no error and no speedup, which looks like HighSpeed "not working."

"So it's like a phone plan," Jake said. "The fast lane costs triple, and if you keep switching networks you pay to reconnect."

"Exactly," Ethan said. "Pick your lane at the start of the trip."

How to install the Kimi Code CLI on Windows, Mac and Linux

The official install script downloads the latest release, verifies its checksum and puts the kimi command on your path. No Node.js is required for this route.

Mac and Linux, including Kali and Ubuntu

curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

Open a new terminal window afterward, so it picks up the updated path, and check the install with kimi --version. On a Mac, the very first launch can be slow while macOS Gatekeeper checks the new program; that is normal. Adding your terminal app under System Settings, Privacy & Security, Developer Tools avoids it.

Windows 11 and 10

First install Git for Windows. Kimi Code CLI uses the Git Bash that comes with it as its shell, and it will not work properly without it. Then run this in PowerShell:

irm https://code.kimi.com/kimi-code/install.ps1 | iex

If Git Bash lives somewhere unusual and the CLI cannot find it, set the KIMI_SHELL_PATH environment variable to the full path of bash.exe.

Installing with npm instead

If you prefer npm, you need Node.js 22.19.0 or later:

npm install -g @moonshot-ai/kimi-code

The package name matters: it is @moonshot-ai/kimi-code. Some older guides show a different package name or describe Kimi Code as running on K2.5; both are out of date.

First launch and login

1. Open your project and start the agent:

   cd your-project
   kimi

2. Type /login and choose one of two options:
   • Kimi Code (OAuth), which uses your membership allowance. It shows a link and a code; open the link on any device, sign in, and enter the code.
   • Kimi Platform API key, for pay-as-you-go billing, using a key from the Kimi Open Platform.
3. Start with a safe question, such as: "Take a look at this project and explain its main directories." Reading is automatic, so this costs nothing in approvals and teaches you how the agent works.

Two shortcuts are worth knowing on day one: kimi -p "your instruction" runs a single task without opening the interface, and kimi -c resumes your previous session. To upgrade later, run kimi upgrade; to uninstall a script install, delete the kimi executable, or run npm uninstall -g @moonshot-ai/kimi-code for an npm install. Local data, including settings, sessions and logs, lives in ~/.kimi-code/, or wherever the KIMI_CODE_HOME variable points.

The desktop app and the VS Code extension

Kimi Code Desktop runs on macOS and Windows; from the CLI, /desktop opens the download page. It shows every tool call, thought and file change, and adds a built-in browser where you can point at a page element or annotate a screenshot to tell the agent exactly what to change. Kimi Code for VS Code installs from the VS Code Marketplace and signs in with your Kimi account or an API key; it needs an open folder (workspace) to work, and if it reports that the CLI is missing, install the CLI and set kimi.executablePath in VS Code's settings. Zed and JetBrains editors can drive the CLI directly through the Agent Client Protocol with kimi acp.

Using Kimi Code safely: approvals, Plan mode and the other modes

Here Kimi Code makes a choice we like. By default it runs in "Always Ask" mode: reading files and searching happen automatically, but every file edit and every command waits for you to approve it. When it asks, you can approve once, approve that kind of action for the rest of the session, or reject it with Esc. There are two looser modes:

• Ask When Needed (formerly called YOLO), turned on with /yolo, approves routine edits and commands automatically, but still asks before sensitive actions such as reading .env files or SSH keys and running dangerous commands.
• Never Ask (formerly Auto), turned on with /auto, approves everything, including sensitive files, and never asks you anything. Keep it for throwaway sandboxes.

Permanent allow and deny rules can go in the config file, so you can, for example, always allow your test command and always deny anything touching production.

The other modes are about how the agent works rather than what it may do:

• Plan mode (Shift-Tab or /plan): the agent writes a plan and waits for your approval before touching any file. Use it for anything bigger than a one-line fix. Leaving Plan mode always asks for confirmation, even in Ask When Needed mode.
• Shell mode: type ! in an empty input box to run a terminal command yourself without leaving the conversation; the agent sees the output. !gh auth login is a handy example.
• Goal mode (/goal): give the agent an outcome with a clear finish line, such as "all tests pass," and it keeps working across turns until it gets there, with pause, resume and cancel controls.

A few more commands cover most daily needs: /model to switch models, /compact to shrink a long conversation, /new for a fresh session, /sessions to resume an old one, /fork to branch a session, and /help for everything else. Kimi Code also supports MCP servers (configured conversationally with /mcp-config), reusable skills, lifecycle hooks that can block risky tool calls, and built-in coder, explore and plan subagents that work in separate contexts.

Version 2.1 added a security change worth knowing: file tools can no longer escape the working folder through symbolic links, and project-level config only applies after you mark the folder as trusted.

Your first real task with Kimi Code, step by step

Here is a calm way to run a first real job, using only built-in commands. It works the same in the terminal and in the desktop app.

1. Let it learn the project. Run /init. Kimi Code analyzes the codebase and writes an AGENTS.md file describing its structure and conventions. Read it, fix anything it got wrong, and commit it; every future session starts from it.
2. Switch to Plan mode with Shift-Tab, then describe the task the way you would brief a new teammate: what you want, why, and what "done" looks like. For Jake, it was "Add a page listing our repair prices, using the same layout as the contact page."
3. Review the plan. The agent proposes which files it will touch and how. Ask questions, push back, or ask for a smaller first step. Nothing changes until you approve.
4. Approve and watch. In the default Always Ask mode, each edit and command appears for approval. For a routine run of edits you trust, "approve for this session" saves clicks without giving up control of anything new.
5. Check the result yourself. Use shell mode, typing ! followed by your test or build command, so the agent sees the output too and can fix what failed.
6. Keep the session lean. If the conversation grows long, /compact summarizes it, and you can add an instruction such as /compact keep the pricing table decisions. /usage shows how much context and quota you have used.
7. Save what matters. /export-md saves the whole session as a Markdown file, which is handy for documenting what changed and why.

If a prompt took things in the wrong direction, /undo removes recent prompts from the conversation, so the agent stops building on them. For file changes, work in a Git repository so you can always see and reverse exactly what was edited.

Customizing Kimi Code: skills, rules, hooks and safer defaults

Kimi Code reads its settings from ~/.kimi-code/config.toml. A few entries make it noticeably safer and more useful.

Start every session in Plan mode. Add default_plan_mode = true, and new sessions propose before they act. The related default_permission_mode setting keeps its older names: manual (Always Ask, the default), yolo (Ask When Needed) and auto (Never Ask).

Write permanent permission rules. Rules let routine actions through and block dangerous ones for good:

[[permission.rules]]
decision = "allow"
pattern = "Read"

[[permission.rules]]
decision = "deny"
pattern = "Bash(rm -rf*)"

Add a hook for extra checks. Hooks run your own command at key moments. A PreToolUse hook with matcher = "Bash" can inspect every shell command before it runs and block anything that touches production, log it for an audit, or send a desktop notification.

Teach it your routines with skills. A skill is a Markdown file with a short header (a name, a description and, optionally, a whenToUse hint) followed by instructions, such as your code style or your release checklist. Put it in .kimi-code/skills/ in a project or ~/.kimi-code/skills/ for all projects, either as a folder containing SKILL.md or as a single .md file. Kimi can load a skill on its own when it fits the task, and each skill also becomes a command, /skill:<name>.

Two tips if you use more than one agent. Kimi Code also reads the shared .agents/skills/ folders, which OpenCode reads too, so skills placed there work in both. It does not read .claude/skills/ by default; to reuse skills written for Claude Code, add that folder's full path to extra_skill_dirs in config.toml.

Kimi Code in the browser and from your phone

Two newer features make Kimi Code more flexible than a terminal app.

Kimi Code Web is a browser interface built into the CLI. Run kimi web, or type /web inside a session to hand it over, and a local page opens where you can chat, handle approvals and review file changes with a friendlier view. The address it prints includes a #token= part; that is the password to the session, so do not share it, and stop the server with Ctrl-C when you are done.

Remote Control lets you drive a session on your computer from your phone or another device. Run kimi rc (or /rc inside a session), scan the QR code, and sign in with the same Kimi account. It requires a paid membership, the computer must stay awake and online, and only one Remote Control instance can run per machine. Kimi's own warning is the important part: the Remote Control link is an entry point to your machine, and anyone who has it may control your sessions and files. Treat it like a house key.

For bigger jobs, Kimi Code can also split work: /swarm runs a task with several agents working in parallel, /btw opens a side conversation without interrupting the main one, and /secondary-model chooses a cheaper model for subagents, which is a quiet way to save quota.

How to use Kimi K3 in Claude Code

Because Kimi Code's API speaks Anthropic's format, you can point Claude Code at it and use your Kimi allowance with the Claude Code interface. Kimi documents the setup itself.

1. Check your plan against the table above. Plus gets k3 and k3-256k at 256K context; Pro and above can use k3 at 1M.
2. Create an API key in the Kimi Code Console. You can have up to five, and each is shown only once, so copy it right away.
3. Run Kimi's one-time setup script from its Claude Code guide before starting Claude Code. It skips Anthropic's login flow and clears old endpoint, key and model settings that would otherwise override yours. Also remove any leftover ANTHROPIC_* lines from ~/.bashrc, ~/.zshrc or your Windows user environment variables.
4. Add the settings to the env section of ~/.claude/settings.json (on Windows, C:\Users\<you>\.claude\settings.json). For K3 at 256K:

   {
     "env": {
       "ANTHROPIC_BASE_URL": "https://api.kimi.ai/coding/",
       "ANTHROPIC_API_KEY": "your-kimi-code-api-key",
       "ANTHROPIC_MODEL": "k3-256k",
       "ANTHROPIC_DEFAULT_OPUS_MODEL": "k3-256k",
       "ANTHROPIC_DEFAULT_SONNET_MODEL": "k3-256k",
       "ANTHROPIC_DEFAULT_HAIKU_MODEL": "k3-256k",
       "CLAUDE_CODE_SUBAGENT_MODEL": "k3-256k",
       "CLAUDE_CODE_EFFORT_LEVEL": "high",
       "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "262144",
       "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "262144"
     }
   }

   Kimi's guide also sets the same model for Claude Code's Fable slot. On Pro and above, the 1M version uses the model name k3[1m] with both window settings at 1048576.
5. Restart Claude Code.

Two cautions. The key in settings.json is stored in plain text, so never commit that file or share it with your dotfiles. And settings in that file override variables you export in the terminal; if you choose the terminal method instead, use one method only. Users in mainland China use api.kimi.com in place of api.kimi.ai.

How to use Kimi Code in OpenCode

OpenCode has Kimi built in. Run opencode auth login, choose Kimi For Coding, and paste your Kimi Code API key. Inside OpenCode, pick a Kimi model with /models, and use /variants to choose the thinking effort: Default, low, high (Kimi's recommendation) or max. Our OpenCode guide covers the rest of the setup, including its permission settings. OpenCode Go also includes Kimi K3 and Kimi K2.7 Code as part of its $10 subscription, a separate route to the same models.

Codex and other tools

Codex and other OpenAI-format tools use the OpenAI-compatible base URL, https://api.kimi.ai/coding/v1, with a Kimi Code API key and one of the four model IDs. Tools translate their own effort names: max, xhigh and ultra become Kimi's max; high and medium become high; low, minimum and light become low; and none turns thinking off. Any other value returns an HTTP 400 error.

Kimi Code vs Claude Code vs Codex vs OpenCode

Tool	Agent open source?	Default models	Default safety
Kimi Code CLI	Yes, MIT	Kimi K3 and K2.8 family; others via config	Asks before edits and commands
Claude Code	No	Anthropic's Claude; Kimi via the steps above	Asks before edits and commands
Codex	The command-line tool is	OpenAI's models; Kimi via base URL	Configurable approval modes
OpenCode	Yes, MIT	Almost any provider, Kimi built in	Permissive; most actions allowed until you change it

• Kimi Code vs Claude Code: the real question is the model, not the interface. Kimi K3 costs less per token than Anthropic's top models ($3 and $15 per million input and output tokens, against $4 and $20 for Claude Opus 5.5 and $10 and $50 for Claude Fable 5.1), and since Claude Code can run on Kimi's API, you can keep Claude Code's interface and switch the model underneath. If you want Claude models themselves, use Claude Code with Anthropic.
• Kimi Code CLI vs OpenCode: Kimi's CLI is tuned for Kimi models, with video input, goal mode and cautious defaults. OpenCode is the better choice if you switch between many providers or want local models.
• Kimi Code vs Codex: a similar trade with OpenAI. Codex can call Kimi's API, so try both on your own project before committing to a subscription.

Can you run Kimi Code locally?

The Kimi Code CLI runs locally, but the Kimi models do not, in any practical sense. K3 has 2.8 trillion parameters, and its weights run to well over a terabyte, a size that needs a cluster of data-center GPUs, as our guide to Kimi K3's specs and self-hosting explains. Kimi Code is a cloud service by design. If your code must never leave your machine, a fully local setup with a smaller open model, through Ollama or LM Studio, is the honest alternative; our comparison of local AI tools helps you choose one.

Kimi Code errors and fixes

You see	What it means	Fix
No coding quota on a new account	You are on the Go plan	Upgrade to Plus or above; remaining days are credited
"No models available for the selected platform" at /login	Wrong or expired key, a network problem, or a key from the other platform	Match the key to the service: Kimi Code Console keys for Kimi Code, Open Platform keys for pay-as-you-go
401 "Your current subscription does not have access to k3"	Plan below Plus or Moderato	Upgrade, or use kimi-for-coding on Andante
401 "Your current plan supports only kimi-k3 up to 256K context"	1M context needs Pro or Allegretto	Use k3-256k, or upgrade
401 no access to kimi-for-coding-highspeed	HighSpeed needs Pro or Allegretto	Upgrade, or use kimi-for-coding
401 "Your model id does not exist"	A version name such as "K3" instead of an ID	Use k3, k3-256k, kimi-for-coding or kimi-for-coding-highspeed
402 "unable to verify your membership benefits"	Membership lapsed or not recognized	Check status with /usage; renew, or log in again
403 "You've reached your 5-hour usage limit"	The rolling window is full	Wait for it to roll over, enable Extra Usage with a cap, or upgrade
403 weekly or monthly usage limit	Legacy weekly quota, or the monthly total	Wait for the reset, or upgrade
403 concurrent request limit	Too many sessions or agents at once	Run fewer in parallel
429 "engine is currently overloaded"	Busy servers	Retry after a short wait
400 "Your request exceeded model token limit: 262144"	The conversation is over 256K tokens	Run /compact, or start a new session
HighSpeed is not faster	Mistyped ID silently falls back, or the task is tool-heavy	Use exactly kimi-for-coding-highspeed
"Current model does not support image input"	The model or clipboard has no image	Switch to a vision model; copy the image itself, not its path
kimi: command not found	The terminal has the old path	Open a new terminal; check kimi --version
Shell errors on Windows	Git Bash missing or not found	Install Git for Windows, or set KIMI_SHELL_PATH
Usage jumped after switching models	The context cache does not carry over	Start a new session when you change model or effort
VS Code says no workspace, or CLI not found	No folder open, or the extension cannot find kimi	Open a folder; set kimi.executablePath

For IT admins and team leads

• Know where the data goes. Kimi Code is a cloud service run by Moonshot AI. Prompts and the code the agent reads are sent to its servers; users in mainland China and elsewhere use different endpoints (api.kimi.com and api.kimi.ai). Review your data rules before staff point it at client code.
• Keys are shared quota. Every API key and device draws from the same membership allowance. Up to five keys per account; each is shown once.
• Plain-text keys. The Claude Code method stores the Kimi key in settings.json in plain text. Keep it out of repositories and shared dotfiles.
• Keep the default approval mode. "Always Ask" is the right default for most teams; reserve "Never Ask" for isolated sandboxes, and use deny rules for anything that must never happen.
• Set a cap on Extra Usage if you enable it; otherwise there is no monthly limit on it. Extra Usage was not available for Enterprise accounts at the time of writing.
• Local footprint: config, sessions and logs live in ~/.kimi-code/; set KIMI_CODE_HOME to move them.

Kimi Code: frequently asked questions

Jake's Kimi Code setup has been steady since that first evening. He keeps k3-256k as his default, starts a new session when he changes tasks, and leaves the approval mode exactly where Kimi set it. If you also hit a wall on day one and assumed you had broken something, you hadn't. The plan names simply didn't say which one includes coding, and now you know.

Revision note. Written October 6, 2026, with Kimi Code CLI at version 2.1. If a plan page left you more confused than when you arrived, that was the naming, not you; we hope this one made it simple.