I pay for Claude and I pay for Kimi Code, and I want both available from the same terminal without choosing one in the morning. Kimi publishes a guide for pointing Claude Code at their endpoint. It tells you to export a handful of environment variables in your shell profile, which works, and which also routes every Claude Code session on the machine to Kimi from then on. Your Anthropic subscription sits there unused while you wonder why Opus got worse.
The fix is boring: a second settings file and a shell function that loads it. Ten minutes. The part worth writing down is that the headline model ID in Kimi's guide is rejected by Kimi's own endpoint, and it's rejected with a 401
that says your credentials are bad. I lost time auditing a key that was never the problem. Then I found a second version of the same lie living in ~/.claude.json
, and that one is better disguised.
TL;DR.Put the Kimi config in~/.claude/kimi-settings.json
rather than~/.claude/settings.json
, then add aclaude-kimi()
function that runsclaude --settings "$HOME/.claude/kimi-settings.json" "$@"
. Base URL ishttps://api.kimi.com/coding/
with the key inANTHROPIC_API_KEY
. The model isk3
, notk3[1m]
, whatever the docs say. SetCLAUDE_CODE_MAX_CONTEXT_TOKENS
to1048576
because a barek3
gives Claude Code no window to infer. If interactive mode 401s whilecurl
andclaude -p
both work, your key is in the rejected list in~/.claude.json
and no amount of key rotation will fix it.
This is the distinction that decides whether anything else in this post works, so get it straight first.
A Kimi Code subscription authenticates against https://api.kimi.com/coding/
, using ANTHROPIC_API_KEY
, which is sent as an x-api-key
header. Model IDs are short: k3
, k3-256k
, kimi-for-coding
.
The Moonshot platform is a different thing. It lives at https://api.moonshot.ai/anthropic
, uses ANTHROPIC_AUTH_TOKEN
as a bearer token, and wants model IDs with a kimi-
prefix. That is the surface you pay for by the token. It's also what most of the search results describe.
They are different products. Your subscription key will not authenticate against the platform host, and the failure is a flat 401
that tells you nothing about why. If you follow the popular guide with a subscription key, this is where you stop.
Go to kimi.com/code/console and create one.
Two things worth knowing before you click. You get at most five keys, and each is shown exactly once, at creation. There is no reveal button later, only delete and make a new one. Copy it somewhere before you close the dialog.
Create it empty and lock it down before the key goes anywhere near it, so it's never briefly readable by anything else on the machine:
touch ~/.claude/kimi-settings.json
chmod 600 ~/.claude/kimi-settings.json
Then paste this in, replacing the placeholder:
{
"env": {
"ANTHROPIC_BASE_URL": "https://api.kimi.com/coding/",
"ANTHROPIC_API_KEY": "PASTE_YOUR_KIMI_CODE_KEY_HERE",
"ANTHROPIC_MODEL": "k3",
"ANTHROPIC_DEFAULT_OPUS_MODEL": "k3",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "k3",
"ANTHROPIC_DEFAULT_FABLE_MODEL": "k3",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "kimi-for-coding",
"CLAUDE_CODE_SUBAGENT_MODEL": "k3",
"ANTHROPIC_DEFAULT_OPUS_MODEL_NAME": "Kimi K3",
"ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION": "Kimi Code K3 (1M context)",
"ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME": "Kimi K2.7 Code",
"CLAUDE_CODE_MAX_CONTEXT_TOKENS": "1048576",
"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "950000",
"CLAUDE_CODE_EFFORT_LEVEL": "high"
}
}
Check the permissions again after you save. Some editors write a temp file and rename it into place, which lands at your umask and quietly undoes the chmod
you just ran:
ls -l ~/.claude/kimi-settings.json # want -rw-------
There are six model slots, not one, and that's deliberate. Claude Code uses the haiku slot for background chores like naming your conversation, and pointing those at K3 spends your quota on titles. kimi-for-coding
is ungated on every tier, so it's the safe floor for throwaway work.
The two window numbers are the part people get wrong. CLAUDE_CODE_AUTO_COMPACT_WINDOW
is a trigger threshold, not a statement of how much context you have, so it needs headroom underneath the real window. Kimi's guide sets it to 1048576
, which is out of range anyway: Claude Code accepts 100000
to 1000000
. It also has to be a plain integer. Write 500k
and it parses as 500
and clamps to the floor, and you'll be wondering why compaction fires roughly immediately.
Kimi's own Claude Code guide tells you to set ANTHROPIC_MODEL
to k3[1m]
. Their endpoint rejects it. I sent each ID at api.kimi.com/coding/
with curl, and here's what came back:
| Model ID | HTTP | What comes back |
|---|---|---|
k3 |
||
| 200 | Works. Main conversation model | |
k3-256k |
||
| 200 | Works. Smaller window variant | |
kimi-for-coding |
||
| 200 | Works. Ungated on all tiers | |
k3[1m] |
||
| 401 | Your model id does not exist, recognized as other:k3[1m]. Please set model id as k3. |
Read that 401
again. It's an authentication_error
, and the message body is about a model ID. Nothing in the status code suggests you should go looking at your model configuration, so you go and audit your key instead, and your key is fine. It cost me more time than anything else in this setup.
Use the bare k3
. It is natively a 1M context model and the suffix was never what unlocked that.
There is a consequence though, and it's why CLAUDE_CODE_MAX_CONTEXT_TOKENS
is in the config above rather than being decorative. With a [1m]
style ID, Claude Code can read the window size out of the name. A bare k3
tells it nothing, so it falls back to a conservative guess and starts compacting your session far earlier than it needs to. Declaring the real number fixes that.
If you're on k3-256k instead, change
ANTHROPIC_MODEL
, ANTHROPIC_DEFAULT_OPUS_MODEL
, ANTHROPIC_DEFAULT_SONNET_MODEL
, ANTHROPIC_DEFAULT_FABLE_MODEL
and CLAUDE_CODE_SUBAGENT_MODEL
to k3-256k
, leave the haiku slot alone, and set CLAUDE_CODE_MAX_CONTEXT_TOKENS
to 262144
with the compact window at 240000
. I'm listing all five by name on purpose. Forget CLAUDE_CODE_SUBAGENT_MODEL
and your subagents keep running on the 1M model while you believe you moved everything down.
cat >> ~/.zshrc <<'EOF'
claude-kimi() {
command claude --settings "$HOME/.claude/kimi-settings.json" "$@"
}
EOF
exec zsh
Use $HOME
rather than ~
so the path resolves however the function gets called. The --settings
flag layers that file on top of your normal user config, and because ~/.claude/settings.json
has no env
block on my machine, there's nothing for it to collide with. Check yours before you assume the same:
python3 -c "import json,os;print('env' in json.load(open(os.path.expanduser('~/.claude/settings.json'))))"
If that prints True
, whatever is in there will fight with the Kimi config, and you should move it out first.
Confirm the key, host and model at the HTTP layer while there's only one thing that can be wrong. Then any failure in the next step is a Claude Code problem, and you already know it isn't credentials.
read -rs "KEY?Kimi Code key: "; echo
curl -sS https://api.kimi.com/coding/v1/messages \
-H "x-api-key: $KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{"model":"k3","max_tokens":16,
"messages":[{"role":"user","content":"Say OK."}]}'
You want JSON with a content
array in it. read -rs
keeps the key out of your shell history, and note the header is x-api-key
rather than a bearer token, which is the practical tell that you're on the subscription surface and not the platform one. Run unset KEY
when you're finished with it.
Two notes on this. If you get a 404
on everything, your base URL includes the full path and Claude Code is appending v1/messages
to something that already ends in it. Set the base, keep the trailing slash, nothing more.
And k3
needs the Moderato tier or above. If it comes back with a 401
naming the model and linking an upgrade page, that's tier gating rather than a bad ID, and you want every slot on kimi-for-coding
instead. Both failures arrive as authentication_error
, so the status code can't tell them apart and the message body is the only thing that can.
A curl probe here is fine, by the way. Kimi's terms require tools to identify themselves honestly, and curl does. Forging a User-Agent
to make one client look like another is the thing they take issue with.
In one tab:
claude-kimi
/status
/status
should show https://api.kimi.com/coding/
and a Kimi model. Send it a real message so you've exercised the round trip rather than just the startup path.
Then open a separate tab and run plain claude
, and check /status
there too. This is the whole point of the exercise, so actually do it. Verifying that the isolation held is more important after a Claude Code upgrade than it is today: model variable precedence changed in v2.1.195, and the next release that touches settings layering is not going to send you a note.
Expect one prompt on the first interactive claude-kimi
, asking whether to use the detected API key. Say yes.
Answer no to that prompt, deliberately or with a stray keypress on a dialog you weren't expecting, and Claude Code writes the key's last 20 characters into a rejected list in ~/.claude.json
. From then on, interactive sessions refuse it and tell you this:
Please run /login · API Error: 401
Here is why this one is genuinely nasty. None of the obvious diagnostics consult that list, so every one of them clears the key. I had curl
returning 200, claude -p "hello"
returning 200, a config file that was correct, an endpoint that was up, and a key that was valid. Only interactive mode failed, and it failed with a message pointing at my credentials.
Do not run /login here. The error asks you to, and it's wrong, and running it inside the Kimi lane is the one action in this whole setup that can disturb the Anthropic credential you were trying to protect.
Check for it instead:
python3 -c "
import json,os
d=json.load(open(os.path.expanduser('~/.claude.json')))
print(json.dumps(d.get('customApiKeyResponses',{}),indent=2))"
If your key's tail is sitting under rejected
, move it across:
python3 - <<'PY'
import json, os, shutil
p = os.path.expanduser('~/.claude.json')
shutil.copy(p, p + '.bak-apikey')
d = json.load(open(p))
key = json.load(open(os.path.expanduser(
'~/.claude/kimi-settings.json')))['env']['ANTHROPIC_API_KEY']
tail = key[-20:]
r = d.setdefault('customApiKeyResponses', {'approved': [], 'rejected': []})
r['rejected'] = [x for x in r.get('rejected', []) if x != tail]
if tail not in r.setdefault('approved', []):
r['approved'].append(tail)
json.dump(d, open(p, 'w'), indent=2)
print('approved:', r['approved'])
PY
Close every Claude Code session before you run that, since ~/.claude.json
is live state and you don't want two writers. Then start fresh, because the list is read at launch. If the prompt appears again, accept it this time.
While we're on things read at launch: settings are too. Editing kimi-settings.json
does nothing to a session that's already open, and a session started before your last edit will keep sending the old model ID and keep 401ing on every turn, with an error that once again blames the key. To find stale ones:
ps -eo pid,lstart,command | grep kimi-settings
stat -f '%Sm' ~/.claude/kimi-settings.json
Compare the two and kill anything older than the file.
This is the part that changes how you work, and it isn't the setup. Your plan is metered in requests per rolling five hour window, somewhere around 300 to 1,200 depending on tier, with up to 30 running at once. Tokens are not the constraint. Round trips are.
Claude Code burns through that faster than a chat client does, because one instruction can fan out into a lot of requests. Subagents are the big one, since each agent runs its own request loop and several can run concurrently, so a single "go investigate this" can cost dozens. Workflows and ultracode fan out hard enough to approach the 30 concurrent ceiling on their own, which is reason enough to keep them off this lane. Raising the effort level means more tool calls per turn, and every tool call is a request. Background chores are small but constant, which is exactly why the haiku slot points at kimi-for-coding
rather than K3.
One quirk on effort. Kimi Code collapses Claude Code's five effort levels onto K3's three, so medium
and xhigh
land in the same place as their neighbors. Tune between low
, high
and max
and don't expect the in between settings to do anything.
Plain claude also goes to Kimi. The variables reached your global environment. Run
env | grep ANTHROPIC
, and check you didn't paste the config into ~/.claude/settings.json
out of habit.A warning that claude.ai connectors are disabled. Expected, and actually a good sign. An API key outranks your claude.ai login for that session, which is the isolation working. The other tab is unaffected.
WebFetch says it's temporarily unavailable. The endpoint doesn't implement it. Paste the content in, or use an MCP scraping server. WebSearch still works on K3.
** /model shows unhelpful names.** That's what the
_NAME
and _DESCRIPTION
keys in the config are for. You can also set CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
and let the picker populate itself from the endpoint's model list.Timestamps in the console request log are UTC+8, and a request that failed on a bad model ID logs the model as -
. A row with a dash in the model column is a rejected ID, not a credential fault, whatever the status column says.
** 400 invalid thinking: only type=enabled is allowed.** The K2.7 Code models used to reject requests that arrived without thinking enabled. I retested on 12 August 2026 and it no longer reproduces, with
kimi-for-coding
returning 200 to a request carrying no thinking
block at all. I'm leaving it here because my retest used a minimal raw HTTP body rather than Claude Code's real request shape, and I'd rather you recognize it than rediscover it. If you do hit it, stay on K3.| Variable | Value | What it does |
|---|---|---|
ANTHROPIC_BASE_URL |
https://api.kimi.com/coding/ |
Where requests go. Base only, keep the trailing slash |
ANTHROPIC_API_KEY |
your Kimi Code key | Sent as x-api-key . Outranks the claude.ai login for this session |
ANTHROPIC_MODEL |
k3 |
Main conversation. No [1m] suffix |
ANTHROPIC_DEFAULT_OPUS_MODEL |
k3 |
What the opus alias resolves to |
ANTHROPIC_DEFAULT_SONNET_MODEL |
k3 |
What the sonnet alias resolves to |
ANTHROPIC_DEFAULT_FABLE_MODEL |
k3 |
What the fable alias resolves to |
ANTHROPIC_DEFAULT_HAIKU_MODEL |
kimi-for-coding |
Background chores. Ungated on every tier |
CLAUDE_CODE_SUBAGENT_MODEL |
k3 |
Subagents and workflow agents. Your main quota burn |
CLAUDE_CODE_MAX_CONTEXT_TOKENS |
1048576 |
Required. A bare k3 gives Claude Code nothing to infer from |
CLAUDE_CODE_AUTO_COMPACT_WINDOW |
950000 |
Compaction trigger. 100000 to 1000000 , plain integer |
CLAUDE_CODE_EFFORT_LEVEL |
high |
Kimi collapses five levels onto three |
rm ~/.claude/kimi-settings.json
exec zsh
Your claude.ai login was never touched, so claude
keeps working the whole time. To Kimi without uninstalling anything, just stop typing claude-kimi
.
One honest caveat on the cleanup. If you accepted that API key prompt, the last 20 characters of your key are still in ~/.claude.json
under customApiKeyResponses
, and if you ran the repair script there's a ~/.claude.json.bak-apikey
next to it. Neither is dangerous, both are residue, and you'll want to clear them out if you're rotating the key or handing the machine on.
Every failure in this setup arrives dressed as an authentication error. A rejected model ID, a model above your tier, and a key you once declined all surface as 401
, and two of them will send you to the console to rotate a credential that was never broken. Read the message body, not the status code. That's the habit worth keeping.
[ two lanes, one terminal ]
Originally published at peculiarengineer.com.