"The honest answer to 'is Kimi K2.7 Code free' is that three of the paths people quote are real and one does not exist."
There is no free hosted Kimi K2.7 Code API, and no :free endpoint on OpenRouter. What genuinely costs nothing: rate-limited web chat, the free Kimi Code CLI tier, and Modified-MIT downloadable weights for self-hosting.
Kimi K2.7 Code Free: What You Can Do at $0 (and What You Can't)
Kimi K2.7 Code is Moonshot AI's open-weight model—approximately 1T parameters (32B active), 256K context, with a vision encoder. Below are the three legitimate zero-cost paths, checked against first-hand sources.
| What you want | Free path that works | What you can't do free |
|---|---|---|
| Chat with Kimi in a browser | Web chat at kimi.com, no card, rate-limited | Call it as an API, or guarantee it runs K2.7 |
| Run a coding agent for a few tasks | Kimi Code CLI, free "Adagio" tier | Work in it all day; it is 6 agent uses per week |
| Run the model on hardware you own | Download Modified-MIT weights, quantize, serve | Avoid the ~577 GB+ hardware bill |
| Call it as a backend API | No free hosted API; no OpenRouter :free variant |
Get a kimi-k2.7-code:free endpoint, which does not exist |
The fabrication happens in the API row: people search "kimi k2.7 code free api," land on a guide that points them at an OpenRouter :free route, and lose an afternoon. It is not there.
Decision Frame: Which Free Path Fits You
When each free path is the right call
Use the kimi.com web chat if you want to try Kimi's reasoning in a browser through copy-paste interaction. No installation or payment method required—fastest zero-cost entry point.
Use the free Kimi Code CLI tier if you want to see the agent interact with real files and tools. The Adagio tier provides 6 agent runs weekly, sufficient to evaluate agent fit before purchasing.
Self-host the Modified-MIT weights if you have multi-GPU infrastructure, need offline inference, or require auditable open weights for compliance. License-free; costs appear as hardware and electricity.
When NOT to chase free
- Needing a hosted backend API at $0. That does not exist. The floor is the paid rate: $0.95/M input, $4.00/M output on ofox.
- Planning daily agent use. The free CLI tier supplies 6 uses weekly—a trial, not production infrastructure.
- Operating a single 24 GB or 48 GB GPU. A ~1T MoE requires hundreds of gigabytes even quantized to INT4.
Stop rule
Evaluating output quality needs only the free web chat (ten minutes). Testing agent capabilities requires the free CLI tier (six runs). Everything beyond requires sustained programmatic access where "free" involves real constraints.
What You Need for Each Free Path
| Free path | What you need | Time to first output |
|---|---|---|
| Web chat (kimi.com) | A browser and a Kimi login (no card) | Under 1 minute |
| Kimi Code CLI, Adagio tier | The CLI installed, a free Kimi account, and a terminal | A few minutes |
| Self-host open weights | A multi-GPU or large-memory host, vLLM/SGLang/KTransformers, ~600 GB free disk | Hours (download plus load) |
Memory is the hard constraint for self-hosting. Kimi K2.7 Code is a ~1T-parameter MoE: even native INT4 lands in the high-hundreds of gigabytes. A single consumer GPU is not in the running.
Path 1: Kimi Web Chat (Genuinely Free, Rate-Limited)
The web application at kimi.com enables chat without requiring a credit card and supports code writing inline.
Two limits and one caveat define this path:
No API. The web chat is a user interface only. The moment you need programmatic access, this path ends and you are into the CLI, self-hosting, or a paid API.
Rate limits. Free tiers carry rate restrictions with unpublished fixed numbers, so treat specific figures elsewhere as unverified. Heavy usage will encounter a ceiling.
Model version is not guaranteed to be K2.7 Code. The homepage defaults to K2.6, with K2.7 Code primarily available through the separate Kimi Code product. Do not assume the free chat hands you K2.7 Code specifically. Look at the model label in your own session, because that is the only source that reflects your account and the current rollout.
The web chat lacks codebase memory and tool access, answering only pasted queries. This suffices for assessing code style and reasoning, but fails for file-reading or command execution tasks.
Path 2: The Free Kimi Code CLI Tier (Real Agent, Small Quota)
Moonshot provides an official Kimi Code CLI with a free tier.
Installation via official script:
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
The free tier called Adagio grants 6 agent uses with 1 concurrent task weekly, running K2.7 Code and the HighSpeed variant. Unlike the web chat, this executes as a real agent: it reads files, runs tools, and drives multi-step edits.
| Kimi Code CLI tier | Price | What you get |
|---|---|---|
| Adagio | $0 | 6 agent uses/week, 1 concurrent task |
| Moderato | $19/mo | Higher quota, agent workflows |
| Allegretto | $39/mo | More quota again |
| Allegro | $99/mo | Team-scale usage |
| Vivace | $199/mo | Top quota |
Six agent runs is enough to point Kimi at a real refactor, a bug hunt, and a test-writing pass, and decide whether its agent behavior is worth paying for. It is not enough to adopt it as your daily coding agent.
For integration into existing coding agents, Moonshot exposes an Anthropic-compatible endpoint: set ANTHROPIC_BASE_URL to https://api.moonshot.ai/anthropic to use Kimi with Claude Code or similar tools. This path charges per-token rather than using the free CLI tier.
Path 3: Self-Host the Open Weights (Free of License, Not of Hardware)
Moonshot released weights under Modified MIT on Hugging Face (moonshotai/Kimi-K2.7-Code). This license requires attribution from very large operators but costs nothing for developers and small teams—behaving like standard MIT.
The license does not provide free compute. Kimi K2.7 Code is a ~1T-total-parameter MoE with about 32B active per token, 61 layers, and 384 experts, plus a 400M MoonViT vision encoder. Moonshot recommends vLLM, SGLang, or KTransformers with native INT4 quantization.
| Precision | Approx. weights size | Realistic host | Notes |
|---|---|---|---|
| Native INT4 | ~577-639 GB | Multi-GPU server (e.g. 8x A100/H100 class) | Community estimate; card gives no official figure |
| INT4 + KV cache/overhead | ~830 GB+ total memory | Large-memory host | Comfortable inference headroom |
| Full precision | Well over 1 TB | H200-class cluster | Production throughput |
Moonshot's own model card publishes no VRAM or disk number, so the sizes above come from third-party self-host calculators and should be read as directional, not exact.
Once served, an OpenAI-compatible endpoint becomes available:
from openai import OpenAI
# vLLM started with: vllm serve moonshotai/Kimi-K2.7-Code --quantization compressed-tensors
client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
resp = client.chat.completions.create(
model="moonshotai/Kimi-K2.7-Code",
messages=[{"role": "user", "content": "Refactor this function to async."}],
)
print(resp.choices[0].message.content)
This path caps at the hardware bill. It is free of license fees and free of per-token cost, but the entry ticket is a large-memory, multi-GPU host, and the electricity is not free either. Self-hosting wins at high volume, offline requirements, and compliance-mandated auditable weights—not casual use.
The Path That Does Not Exist: "Kimi K2.7 Code Free on OpenRouter"
There is no free Kimi K2.7 Code endpoint on OpenRouter. Verified against the OpenRouter models API on July 14, 2026:
-
moonshotai/kimi-k2.7-codeexists as a paid model (~$0.72/M input, ~$3.49/M output). - OpenRouter lists
moonshotai/kimi-k2.6:free(the older K2.6, not K2.7 Code), showing an empty endpoints list with no live provider. - A URL like
openrouter.ai/moonshotai/kimi-k2.7-code:freereturns an HTTP 200 because it loads the single-page app shell, not because a free route exists.
OpenRouter's free tier is real but does not cover this model at this version. For coding work with free API tiers, choose from :free variants, which carry day and minute rate limits.
One More Free-for-You Path: The Puter User-Pays Bridge
Puter exposes moonshotai/kimi-k2.7-code through its browser SDK on a "user-pays" model. Developers integrate the SDK at zero cost; end users cover their own token consumption. It is free the way a BYO-bar is free to the host.
Legitimate for client-side tools where users bring their own usage. Not a method for free tokens on your backend. Puter's "unlimited" framing describes the developer's cost, not a documented usage limit. Review the platform's billing and data terms before deployment.
Every Free Path to Its Limit: A Side-by-Side
flowchart TD
A[Need Kimi K2.7 Code at $0?] --> B{How do you want to use it?}
B -->|Chat in a browser| C[kimi.com web chat]
B -->|Drive an agent for a few tasks| D[Kimi Code CLI Adagio]
B -->|Run on my own hardware| E[Modified-MIT weights]
B -->|Ship in an app| F[Puter user-pays]
B -->|Call as a backend API| G[No free hosted API]
C --> C1[Cap: no API, rate-limited, version not guaranteed K2.7]
D --> D1[Cap: 6 agent uses/week, 1 concurrent]
E --> E1[Cap: ~577GB+ INT4, multi-GPU host]
F --> F1[Cap: end users pay tokens, no SLA]
G --> G1[Floor is paid: $0.95/M in, $4.00/M out]
G1 --> H[Managed: moonshotai/kimi-k2.7-code on one endpoint]
| Path | Free for you? | Hard limit | Best for |
|---|---|---|---|
| Web chat (kimi.com) | Yes | No API, rate-capped, version not guaranteed K2.7 | Evaluating output quality |
| Kimi Code CLI Adagio | Yes | 6 agent uses/week, 1 concurrent | Trying the agent on real tasks |
| Self-host weights | Yes (no license fee) | ~577 GB+ INT4, multi-GPU host | Offline / auditable / high volume |
| Puter user-pays | Yes (users pay) | Cost moves to end users, no SLA | Client-side apps |
OpenRouter :free K2.7 Code |
Does not exist | No such endpoint (K2.6 :free listed with no live provider) |
(not an option) |
| Managed API (ofox / Moonshot) | No | Paid: $0.95/M in, $4.00/M out | Backends that need reliability |
Common Errors When Chasing Free Kimi K2.7 Code
| Symptom | Cause | Fix |
|---|---|---|
model not found for moonshotai/kimi-k2.7-code:free
|
That free variant does not exist | Use the paid moonshotai/kimi-k2.7-code, the free CLI tier, or self-host |
OpenRouter :free call finds nothing usable |
The kimi-k2.6:free ID is older and has no live provider |
K2.6 free is a different model with an empty endpoints list; K2.7 Code has no free endpoint |
| Free web chat writes weaker code than expected | Free chat may serve K2.6, not K2.7 Code | Check the model label in the session; K2.7 Code lives in the Kimi Code product |
| CLI stops after a few tasks | Adagio free tier is 6 agent uses/week | Wait for the weekly reset, upgrade, or switch paths |
| vLLM load fails or OOMs on one GPU | ~1T MoE will not fit a single GPU | Use a multi-GPU host; INT4 weights alone are hundreds of GB |
| Kimi Code plan looks like $19 for K2.5 | You are reading a stale pre-K2.7 blog | Use the official pricing page; tiers now tie to K2.7 Code |
Free Kimi K2.7 Code for a Team: Where $0 Stops Scaling
The free paths work for individuals. Team scaling breaks immediately.
The web chat has no shared-account model. Each developer opens their own session against personal rate limits—no pooled quota or usage dashboard. The free CLI tier fails worse for teams: 6 agent uses a week is a single person's trial, and there is no way to pool it across engineers. Two people evaluating is fine. A ten-person team trying to standardize on the free tiers is not a plan.
Self-hosting scales for a team but ceases being free once hardware is provisioned. A single large-memory host running INT4 weights can handle a few concurrent agent sessions; teams require real GPUs, power, and operational management. At scale, per-token API costs often undercut amortized self-host infrastructure.
For teams: use the free paths to evaluate, then standardize on a paid endpoint with per-key usage visibility. Shared configuration means one base URL, one model ID, unified billing against an org wallet, and traceable usage—features no free tier provides.
Alternatives: When the Free Paths Cap Out
Free is a starting point, not a conclusion. When rate limits, quotas, or hardware bills activate, practical options shift to "cheapest reliable API," with no honest $0 answer for a frontier model.
| Option | K2.7 Code API rate | What you get | When to pick it |
|---|---|---|---|
ofox (moonshotai/kimi-k2.7-code) |
$0.95/M in, $4.00/M out ($0.19/M cached) | One OpenAI-compatible endpoint, one key across many models, 256K context | You want Kimi plus other models behind a single API without per-vendor signups |
| Moonshot direct | Paid per token, Anthropic + OpenAI compatible | First-party API, Kimi Code CLI subscription option | You only use Kimi and want the source, or want the CLI plans |
| OpenRouter | ~$0.72/M in, ~$3.49/M out | Aggregator with usage-based routing | You already route everything through OpenRouter |
| Self-host | $0/token, ~577 GB+ hardware cost | Full control, offline, Modified-MIT weights | Very high volume or hard compliance needs |
When free paths exhaust and you need a managed Kimi K2.7 Code API without Moonshot signups or self-hosted infrastructure, ofox serves the model at $0.95/M input and $4.00/M output on one OpenAI-compatible endpoint. The same OpenAI SDK pattern used for self-hosting applies, changing only base URL and API key:
from openai import OpenAI
client = OpenAI(base_url="https://api.ofox.ai/v1", api_key="YOUR_OFOX_KEY")
resp = client.chat.completions.create(
model="moonshotai/kimi-k2.7-code", # 256K context; swap to -highspeed for the faster variant
messages=[{"role": "user", "content": "Refactor this function to async."}],
)
print(resp.choices[0].message.content)
That is not free, and no gateway claiming a frontier model at $0 per token is telling the truth. The honest trade sequence: free chat for evaluation, free CLI tier for agent testing, self-host if hardware exists, paid managed endpoint for reliable API access.
Sources Checked for This Refresh
- Hugging Face model repo: https://huggingface.co/moonshotai/Kimi-K2.7-Code
- Kimi Code CLI page: https://www.kimi.com/code
- Kimi K2.7 Code pricing tiers: https://www.kimi.com/resources/kimi-k2-7-code-pricing
- Moonshot OpenAI/Anthropic API migration docs: https://platform.moonshot.ai/docs/guide/migrating-from-openai-to-kimi
- OpenRouter Kimi K2.7 Code model page: https://openrouter.ai/moonshotai/kimi-k2.7-code
- ofox managed Kimi K2.7 Code model page: https://ofox.ai/models/moonshotai/kimi-k2.7-code
"The pattern with every 'is it free' question about a frontier model is the same: a demo, a trial, or the weights are free, the sustained compute never is." Kimi K2.7 Code exemplifies this with Modified-MIT downloadable weights, browser chat access, six-run agent evaluation, and a mandatory paid floor for scaled token use or GPU infrastructure. Claims of zero-cost APIs shift costs to users or lack substance.
Originally published on ofox.ai/blog.
Top comments (0)