Kimi K3 Coding Plan: What Kimi Code Actually Sells (and When It Beats Tokens)

If you searched for a Kimi K3 coding plan, the good news is that a real subscription exists. The bad news is that it is not called that, and its pricing is being rebuilt as you read this. Moonshot sells Kimi Code — a developer coding service bundled into Kimi membership, with a CLI, a VS Code extension, and an Anthropic-compatible endpoint that works in Claude Code, OpenCode and Codex. K3 is a model served inside it to paid tiers, not a plan of its own. On 19 July 2026, three days after K3 launched, Moonshot paused new subscriptions because GPU demand outran capacity, and announced a split into separate Kimi and Kimi Code memberships whose prices are not yet published. This guide gives you the structure as it stands on 21 July 2026, corrects the unit mismatch that makes every Kimi-vs-GLM comparison online wrong, and uses DataLLM Lab first-party measured token spend to find the point where a subscription actually beats paying per token.

What Kimi Code actually is

There is no product called the Kimi K3 Coding Plan. The product is Kimi Code, and K3 is one of the models it serves. Moonshot's own documentation describes Kimi Code as an intelligent programming service for developers that is included in Kimi membership benefits — so you do not buy a coding plan, you buy a Kimi membership tier and Kimi Code comes with it. That distinction matters when you go looking for a checkout page, because there isn't one labelled the way the search results imply.

What you get, per the first-party Kimi Code docs:

• Three models. k3 (the flagship, Moderato tier and above — with the full 1M-token context only from Allegretto up), kimi-for-coding (this is K2.7 Code, available to all paid members), and kimi-for-coding-highspeed (K2.7 Code HighSpeed, Allegretto and above).
• Two of Moonshot's own surfaces. Kimi Code CLI in the terminal and a Kimi Code VS Code extension, both doing code reading, file editing and command execution.
• Explicit third-party support. Claude Code, OpenCode and Codex are named in the docs; JetBrains and Zed connect through the CLI's ACP protocol.
• A subscription endpoint distinct from the token API. OpenAI-compatible at https://api.kimi.com/coding/v1, Anthropic-compatible at https://api.kimi.com/coding/.

If what you actually wanted was raw metered access to the model rather than a subscription, that is a different product with different endpoints and ids — see our Kimi K3 API guide and Kimi API pricing breakdown.

The 19 July pause and the coming split

Every price in this article is a snapshot of a structure Moonshot has already announced it is replacing. K3 launched on 16 July 2026. Three days later, on 19 July 2026, Moonshot paused new subscriptions, saying via its official account that K3 had received far more interest than expected and that its GPUs were feeling it (reported by PYMNTS and corroborated across Yahoo Finance, Dataconomy and SiliconRepublic). Existing subscribers are unaffected; new slots reopen in batches as capacity is added.

In the same breath Moonshot said membership will split into two plans — a Kimi Membership covering Kimi Web, App and Work, and a separate Kimi Code Membership for coding workflows — in order to match compute more precisely and keep the experience stable. Kimi's help centre now carries a notice titled "A Note on Recent Plan Changes" stating that existing paid benefits are unaffected, current plans can still be used, renewed and upgraded, and the new plans are not yet open for purchase.

Tiers, models and quota units

Kimi membership has five tiers, and the coding entitlements step up separately from the agent entitlements. These figures come from Kimi's first-party pricing help page as of 21 July 2026.

First-party (Kimi Help Center, 21 July 2026), pre-split structure. Concurrent agent tasks run 1 / 2 / 2 / 4 / 4 across the tiers; agent features share one credit pool while Kimi Code has its own separate pool. Kimi Claw access starts at Allegretto. Annual billing is offered at a lower effective monthly rate ($15 / $31 / $79 / $159).

The trap here is the 1M context headline. K3 is a 1M-context model, but inside Kimi Code that full window is gated to Allegretto ($39) and above. Moderato at $19 gets K3 — it does not get the whole context. Do not buy the cheap tier on the strength of the big number.

Now the part that breaks naive comparisons: Kimi Code's quota is request-based, not token-based. Per the docs it runs roughly 300–1,200 requests per rolling 5-hour window, up to 30 concurrent requests, output up to about 100 tokens/second, and a maximum of 5 API keys per account. The membership benefits page adds that quota refreshes every 7 days from your subscription date and does not roll over, with the 5-hour rate window applying independently on top.

Wiring it into Claude Code and friends

The single most confusing part of Kimi Code is that the same model has different ids depending on how you are billed. On the subscription path you call kimi-for-coding; on the pay-per-token Moonshot API the same family is kimi-k2.7-code. Get this wrong and your requests either fail or quietly bill the wrong way.

For Claude Code on the pay-per-token route, Moonshot's platform docs spell out the environment and two live gotchas:

# Moonshot's Anthropic-compatible endpoint (pay-per-token route)
export ANTHROPIC_BASE_URL="https://api.moonshot.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="your-moonshot-key"
export ANTHROPIC_MODEL="kimi-k3[1m]"   # 1M-context variant named in Moonshot's Claude Code guide

# Required, per Moonshot docs: the endpoint does not support tool search yet
export ENABLE_TOOL_SEARCH="false"

claude

Two documented limitations to plan around: WebFetch is not supported yet on the Kimi endpoint, and ENABLE_TOOL_SEARCH must be set to false because the endpoint does not implement it. Also note kimi-k2.7-code requires requests to explicitly enable thinking — otherwise it returns a 400 invalid thinking. On the subscription route you swap the base URL to https://api.kimi.com/coding/, use the API key you generate from your membership, and call kimi-for-coding. If you juggle several of these routes, a Claude Code router setup is the cleaner way to switch than editing shell exports all day.

Break-even: our measured numbers

Every subscription-vs-tokens guide online hand-waves this. We ran the models, so we can do it properly — with the honest caveat that half of it is measured and half is modelled.

The measured half: in the DataLLM Lab first-party executed coding benchmark (July 2026 — 13 models, 9 generate-code-then-run-hidden-tests tasks, cost computed from real token usage at list price per 1,000 tasks), 10 of 13 models scored a perfect 9/9. Correctness is table stakes; the spread that mattered was 88× on cost. Full methodology and leaderboard in our coding cost benchmark.

DataLLM Lab first-party executed run, July 2026. Costs are real measured token usage × list price. Grok 4.3 scored 8/9 at $1.75/1k (missed nested-dict flatten). GPT-5.6, Grok 4.5 and Fable 5 were not in this run and carry no first-party score here.

Now the arithmetic. K3's pay-per-token list price is $3.00 / 1M input, $15.00 / 1M output, $0.30 / 1M on cache hit, flat across the whole 1,048,576-token context. At our measured $0.0044 per benchmark task, a $19 subscription needs about 4,350 tasks a month to break even — which makes the subscription look absurd.

It isn't, because a benchmark task is not an agentic coding request. Our tasks are small single-function problems with tiny prompts. A realistic Kimi Code turn drags in file context, tool results and diffs. Model it at ~40k input (partly cached) plus ~3k output on K3 list rates and you get roughly $0.06–$0.17 per request — 15 to 40× a benchmark task. At $0.10 a request, Moderato's $19 breaks even at about 190 requests a month. A developer using an agent daily clears that in a week.

Left column derived from DataLLM Lab measured per-task token usage; right column modelled, not measured. Both use K3 list pricing ($3/$15/$0.30 cached). Neither accounts for the request cap, which limits how much value you can extract from any tier.

Kimi Code vs GLM Coding Plan, normalized

Every guide compares $19 against $18 and 300–1,200 "requests" against 80–1,600 "prompts" as if those units were the same thing. They are not, and the mismatch inverts the answer.

Kimi Code meters raw API requests. The GLM Coding Plan meters user prompts — and one GLM prompt reportedly fans out to roughly 15–20 model calls as the agent reasons, reads files and edits. Convert both to a common basis of model calls per 5-hour window and GLM Lite's modest-looking 80 prompts becomes ~1,200–1,600 calls, landing at the top of Kimi's entire band rather than far below it.

Normalization is ours; treat it as an estimate, not a promise. Kimi figures are first-party (Kimi Code docs, 21 July 2026). GLM prices ($18 / $72 / $160, with billing-cycle discounts reported at 10% monthly, 20% quarterly and 30% yearly) and prompt quotas come from aggregator sites, not z.ai's own machine-readable page, and sources conflict on the weekly multiplier. GLM also applies peak-hour quota multipliers (peak reported as 14:00–18:00 UTC+8) with an off-peak 1× promotion reported through September 2026. Verify both before you buy.

Three honest conclusions from that table. First, on raw throughput per dollar the GLM plan looks more generous once you normalize — but its unit is fuzzier, since "one prompt" is defined by GLM's agent, not by you. Second, Kimi's unit is the one you can predict: a request is a request, and you can count them in your own client logs today. Third, the model comparison is closer than the plans: in our executed run, Kimi K2.7 Code hit 9/9 at $1.34/1k against GLM 5.2 at 9/9 for $1.99/1k. Both are correct; Kimi is ~33% cheaper per task at list price.

A decision rule you can actually apply

Stop comparing sticker prices and measure one number: your median cost per agent request over a normal working week. Here is the rule, in order:

1. Instrument first. Run your agent on metered tokens for five working days and log input, cached input and output per request. That gives you your real per-request cost — no modelling required.
2. Below ~$0.005 a request, do not subscribe. If your work looks like our benchmark — small, self-contained, low-context tasks — you need thousands of requests a month to justify even $19. Pay per token and route to something cheap; our cheap coding model guide has options at a tenth of K3's cost that still scored 9/9.
3. Above ~200 requests a month at realistic agentic sizes, a $19-class plan pays for itself. That is the crossover, and it arrives fast for anyone with an agent open all day.
4. Check the ceiling, not just the floor. Kimi's cap is 300–1,200 requests per 5-hour window with 30 concurrent and 5 keys, refreshed weekly with no rollover. A subscription you cannot fully consume in a week is a subscription you are overpaying for.
5. Before upgrading a tier, shrink the request. Context trimming and cache hits ($0.30 vs $3.00 per 1M on K3 — a 10× difference) move your per-request cost far more than any plan change. Our guide to cutting token costs in coding agents is the cheaper first move.
6. Right now, factor in availability. New Kimi Code subscriptions are paused as of 19 July 2026 and reopen in batches, and the tier structure is being replaced. That is a real cost of choosing this plan today.

Paying per token instead

If the plan is closed, mid-restructure, or simply the wrong shape for your usage, metered access is the fallback that always works. Moonshot's published list rates as of 21 July 2026: K3 at $3.00 in / $15.00 out / $0.30 cached per 1M tokens, and K2.7 Code at $0.95 in / $4.00 out with cache-hit input around $0.19 (K2.7 Code released 12 June 2026, 262,144-token context). Be careful quoting the second one: K2.7 Code pricing varies by route — OpenRouter and other resellers list lower figures, currently $0.74 in / $3.50 out, and our $1.34/1k benchmark cost was computed at Moonshot list price, so state your basis whenever you reproduce a cost number.

K3's architecture, per Moonshot's launch materials: 2.8 trillion total parameters in a highly sparse MoE (16 of 896 experts active per token, roughly 1.8%), 1M-token context, native vision. Its published scores — SWE-bench Verified 76.8%, Terminal-Bench 2.1 88.3, DeepSWE 67.5, FrontierSWE 81.2, Program Bench 77.8, SWE Marathon 42.0 — are vendor-reported by Moonshot and were not independently replicated at the time of writing. Open weights were not downloadable at launch; Moonshot committed to a release on 27 July 2026. The only independent execution data in this article is ours.

from openai import OpenAI

client = OpenAI(
    base_url="https://www.datallmlab.com/v1",
    api_key="YOUR_DATALLMLAB_KEY",
)

# Same client, swap the model string to price-test your own workload
for m in ["moonshotai/kimi-k2.7-code", "z-ai/glm-5.2", "qwen/qwen3-coder-next"]:
    r = client.chat.completions.create(
        model=m,
        messages=[{"role": "user", "content": "Refactor this module..."}],
    )
    print(m, r.usage.prompt_tokens, r.usage.completion_tokens)

That loop is the whole argument in eight lines: log usage across a week of real work, multiply by list prices, and you will know whether $19 a month is a bargain or a donation — without waiting for Moonshot to reopen the queue.

FAQ