Kimi K3 Cost: Pricing Plans, Credits, and How Much You Really Pay
Complete breakdown of Kimi K3 pricing — free tier, subscription plans, API token costs, and tips to minimize your spend.

Kimi K3 launched earlier this month — 2.8 trillion parameters, million-token context, frontier-level coding at open-weight pricing. The benchmarks are impressive. The X posts are glowing. The question nobody answers clearly: what does it actually cost?
The official API page lists $3.00 per million input tokens and $15.00 per million output tokens. But that number is misleading for three reasons: prompt caching can cut your input cost by 90%, the free web chat costs nothing, and the consumer subscription plans operate on an entirely different pricing model. Depending on how you access K3, your effective cost ranges from free to several dollars per request.
This guide breaks down every way to pay for Kimi K3 — the free tier, the consumer subscription plans, the API pricing with and without caching, the third-party markup through OpenRouter and AWS Marketplace, and the specific strategies that save real money at each usage tier.
How Kimi K3 Pricing Works: The Three Access Tiers
Kimi K3 is available through three fundamentally different pricing structures. They share the name "Kimi K3" but the cost difference between them can be 100x per request.
Tier 1: Free Web Chat (kimi.com)
The free tier at kimi.com requires nothing but a signup — no credit card, no API key, no commitment. You get access to K3 (and older models) with usage limits that Moonshot does not publish but that most casual users never hit.
Best for: Evaluation, casual use, writing assistance, single-document analysis. Cost: $0. Limitations: Rate-limited, no API access, no guaranteed availability during peak load, no programmatic control.
Tier 2: Consumer Subscription Plans
Kimi offers monthly subscription plans through the Kimi Work desktop app and the Kimi Code CLI. These plans provide higher usage limits than the free tier and access to premium features like web search, agent scheduling, and extended context processing.
As of July 2026, the subscription plans are:
| Plan | Typical monthly price | Key features |
|---|---|---|
| Free | $0 | K3 chat access, basic file uploads, standard context |
| Pro | ~$10–20/month | Higher rate limits, guaranteed availability, web search |
| Enterprise | Custom pricing | Dedicated instances, SSO, data isolation, team management |
The subscription model is a flat monthly fee — you pay for the plan, not the tokens. This is the most cost-effective option if you use K3 heavily through the chat interface but do not need programmatic API access.
Best for: Heavy chat users, knowledge workers using Kimi Work, teams. Cost: $0–$20+/month flat. Limitations: No API access. Usage limits per plan are undocumented but enforced.
Tier 3: API Pricing (Pay-per-Token)
The API is where the headline numbers live. Moonshot's official API at platform.kimi.ai charges per million tokens with three rate tiers:
| Rate type | Price per 1M tokens | When it applies |
|---|---|---|
| Cache hit input | $0.30 | Prompt prefix matches a cached segment |
| Cache miss input | $3.00 | First time or cache-incompatible prompt |
| Output | $15.00 | Every generated token |
The cache hit rate is the single most important number in this entire article. Moonshot reports that coding workloads achieve a cache hit rate above 90% on the official API. That means 9 out of every 10 input tokens are billed at $0.30 instead of $3.00 — dropping the effective input cost by 81%.
Best for: Developers, product integrations, high-volume usage. Cost: $0.30–$3.00/1M input + $15.00/1M output.
The API Pricing Trap: Why Headline Numbers Are Misleading
The official API pricing page at platform.kimi.ai lists $3.00/$15.00. But that $3.00 input number has a footnote that changes everything: cached input pricing at $0.30.
How prompt caching works
When you send a request to the Kimi API, Moonshot checks whether the beginning of your prompt (the "prefix") matches a recently processed prompt from the same API key. If it does, the server skips re-processing those tokens and charges the cached rate.
This matters most for applications with a long, stable system prompt. Consider a typical coding assistant pattern:
- System prompt: 4,000 tokens, identical across every request
- User input: 2,000 tokens, different each time
- Output: 1,000 tokens per response
With 90% cache hit rate (Moonshot's reported figure for coding), the cost breakdown per request is:
| Cost component | Without caching | With caching (90% hit) |
|---|---|---|
| System prompt (4K tokens) | $0.012 | $0.0012 |
| User input (2K tokens) | $0.006 | $0.006 (usually not cached) |
| Output (1K tokens) | $0.015 | $0.015 |
| Total per request | $0.033 | $0.022 |
That 33% savings adds up. At 10,000 requests per day, caching saves roughly $110/day — $3,300/month.
What does not get cached
Not every workload benefits equally. The cache is prefix-based and byte-for-byte identical. If every request has a different system prompt or the first messages vary, the cache hit rate drops to near zero. Conversational patterns with short, varied prompts see almost no caching benefit.
Rule of thumb: If your application sends the same system prompt with every request — typical for coding assistants, writing tools, and structured extraction pipelines — the direct API's caching saves you 20–40% on total costs. If every request is a fresh conversation with a unique prompt, calculate costs using the full $3.00 input rate.
Expert Pitfall: Many developers assume their system prompt is "stable" and model the caching discount into their budget. Then a single dynamic variable — a timestamp, a session ID, a user name — silently breaks the cache for every request. Verify cache hits from your API response metadata before you budget around them. If you cannot confirm caching is active, assume the uncached rate.
Kimi K3 Cost vs Competitors: How It Stacks Up
The competitive pricing landscape is where K3 looks strongest. Here is how it compares to other frontier models at their standard API rates:
| Model | Input / 1M tokens | Output / 1M tokens | Context window |
|---|---|---|---|
| Kimi K3 (cached) | $0.30 | $15.00 | 1,048,576 |
| Kimi K3 (uncached) | $3.00 | $15.00 | 1,048,576 |
| GPT-5.6 Sol | $5.00 | $30.00 | 1,048,576 |
| Claude Fable 5 | $10.00 | $50.00 | 200,000 |
| Claude Opus 4.8 | $15.00 | $75.00 | 200,000 |
| GLM-5.2 | $1.40 | $4.40 | 128,000 |
| Kimi K2.7 Code | $0.72 | $3.50 | 262,144 |
On cache-hit input pricing ($0.30), K3 is the cheapest frontier-class model available by a wide margin. Even on uncached input ($3.00), it is 40% cheaper than GPT-5.6 Sol and 70% cheaper than Fable 5.
The tradeoff is output pricing. At $15.00/1M output tokens, K3's output is 3.4x more expensive than GLM-5.2. Applications that generate long responses — document summarization, report generation, creative writing — will see higher relative costs.
Rule of thumb: If your workload is input-heavy (large prompts, long system instructions, retrieval-augmented generation), K3 wins on cost. If your workload is output-heavy (generating thousands of tokens per request), GLM-5.2 or Kimi K2.7 Code may be cheaper.
The rankings above assume you connect directly to Moonshot's API. But many developers route through OpenRouter or AWS Marketplace instead. That routing decision changes the cost picture entirely — sometimes erasing K3's competitive edge.
Third-Party Pricing: OpenRouter and AWS Marketplace
Kimi K3 is also available through OpenRouter and AWS Marketplace. The base prices are identical to the official API, but the effective costs differ.
OpenRouter
OpenRouter lists K3 at $3.00/$15.00 — the same headline numbers as the direct API. The critical difference: OpenRouter does not currently pass through Moonshot's prompt caching discount. Every input request through OpenRouter is billed at $3.00/1M, regardless of cache eligibility.
This makes OpenRouter the most expensive way to access K3 for any workload with cacheable prompts. For workloads with near-zero cache hit rates (short, varied prompts), OpenRouter and the direct API cost the same.
| Scenario | Direct API | OpenRouter |
|---|---|---|
| High cache hit (90%) | ~$2.10/1M blended | $3.75/1M blended |
| Low cache hit (10%) | ~$3.57/1M blended | $3.75/1M blended |
OpenRouter wins on: Convenience — one API key for multiple models, unified billing, model fallback. Direct API wins on: Cost — 20–40% cheaper for cacheable workloads.
Expert Pitfall: OpenRouter lists K3 at the same $3.00/$15.00 as the direct API, so the rates look equivalent on paper. They are not. The missing prompt caching discount silently adds 43% to your effective input cost on every cacheable request. At 10,000 requests per day, that gap costs roughly $1,100/month. If you use OpenRouter for convenience, benchmark your real cache-hit rate first — you may be paying a 5-figure annual premium for a unified API key.
AWS Marketplace
AWS Marketplace offers K3 at the same $3.00/$15.00 base rates. Like OpenRouter, it does not expose prompt caching at the same discount level. The main reason to use AWS Marketplace is enterprise procurement: if your organization has committed AWS spend or requires AWS billing, the convenience of a single vendor may outweigh the cost premium.
Now that you understand the full pricing landscape — direct API with caching, third-party routing without it, and the consumer subscription tiers — the question is how to apply this to your own situation. The five strategies below cover every usage level, from casual tinkerer to production engineering team.
How to Minimize Your Kimi K3 Cost: Five Strategies
1. Start with the free tier
Before spending anything, use kimi.com for a week. Test K3 on your actual workload. If the free tier meets your needs — and for many casual use cases it does — stop here. Your cost is zero.
2. Move to a subscription plan for chat-heavy use
If you are using K3 primarily through the chat interface or Kimi Work desktop app, a Pro subscription (~$10–20/month) is almost certainly cheaper than paying per-token through the API. Do the math: at API rates, a typical heavy chat session with 50 messages and 2K input / 1K output per message costs roughly $0.45 in tokens. Fifty sessions per month equals $22.50 — more than the Pro subscription.
3. Use the direct API with caching for production
For any API integration where your system prompt is stable, use the Moonshot direct API — not OpenRouter, not AWS Marketplace. The 90% cache discount on cache-hit input tokens is the single largest cost-saving lever available.
4. Pin to the exact model ID
Use kimi-k3 explicitly. Do not use kimi-latest or similar aliases in production — if Moonshot releases a more expensive model under the same alias, your costs increase without warning.
5. Set spending limits before scaling
K3 is cheap per token but expensive per request when the context is large. A single million-token prompt costs $3.00 just for input. Set API key spending limits, use separate keys for development and production, and monitor usage daily during the first week of any new integration.
Why Your Kimi K3 Bill Is Higher Than Expected
Even when you follow the strategies above, specific patterns can inflate your bill without warning. Here are the three most common surprises and exactly how to diagnose them.
Scenario 1: Cache hit rate near zero despite a stable system prompt
Symptoms: Your cost per request is close to the uncached rate ($3.00/1M input) even though your system prompt never changes. You expected the 90% cache hit rate that Moonshot reports for coding workloads.
Root Cause: The Kimi API cache is keyed on a byte-for-byte prefix match. Any difference — a changing timestamp, a user ID injected into the system prompt, a format string that varies per request, or a dynamic first message — invalidates the cache prefix. The cache also expires after a timeout; Moonshot does not publish the exact duration, but typical LLM provider cache TTL is 5–30 minutes.
Resolution Strategy: First, verify the cache is active by checking your API response headers for an x-ms-cached or equivalent indicator in the Moonshot dashboard. Second, move all dynamic content — timestamps, user IDs, per-request configuration — to the end of the prompt, not the beginning. The cache matches from the first token forward. Third, reduce system prompt size by moving instructions to capabilities K3 already handles natively.
Scenario 2: Costs spike after switching to OpenRouter
Symptoms: You migrated from the direct API to OpenRouter for multi-model convenience and your monthly bill increased 30–50% on the same workload.
Root Cause: OpenRouter does not pass through Moonshot's prompt caching discount. Every input token, cached or not, is billed at the full $3.00/1M rate.
Resolution Strategy: Switch back to the direct Moonshot API for K3 calls. Reserve OpenRouter for models where you genuinely need cross-provider failover or routing. If OpenRouter convenience is non-negotiable, limit your K3 usage on OpenRouter to the lowest-volume, shortest-prompt paths — ones that would not benefit from caching anyway — and route all cacheable workloads through the direct API.
Scenario 3: Large context windows driving up per-request cost
Symptoms: You are sending 50,000–200,000 token prompts for document analysis or multi-turn conversations, and each request costs $0.15–$0.60 before any output is generated.
Root Cause: K3's input pricing is linear at $3.00 per million tokens. A 200,000-token prompt costs $0.60 in input alone. Combined with the full million-token context window, a single deeply contextualized conversation can cost several dollars.
Resolution Strategy: Break long documents into chunks and process them in parallel with smaller context windows. Use K3's built-in summarization to compress prior conversation turns before feeding them back as context. If your workflow genuinely requires full-context processing, benchmark total cost against GPT-5.6 Sol — at $5.00/1M input, Sol is 67% more expensive per token, but if it completes the task in fewer output tokens, the total cost may still be lower.
Frequently Asked Questions
Is Kimi K3 free to use? Yes, through the web chat at kimi.com. The free tier provides access to K3 with usage limits. No credit card is required.
How much does the Kimi K3 API cost? $3.00 per million input tokens (uncached), $0.30 per million input tokens (cached), and $15.00 per million output tokens. These are Moonshot's official API rates as of July 2026.
What is the Kimi K3 subscription cost? Consumer subscription plans start around $10–20/month for the Pro tier. Enterprise pricing is custom-quoted.
Does Kimi K3 have a free trial? The free tier at kimi.com is essentially a permanent free trial with usage caps. For API access, Moonshot offers initial free credits upon registration — check the platform dashboard for current availability.
How much does Kimi K3 cost per video? Kimi K3 is primarily a text and image-input model, not a video generation model. It can analyze video frames through its vision capability, but there is no per-video billing. Costs are based on tokens processed, not media type.
What is the cheapest way to use Kimi K3? The free web chat is cheapest (free). For API users, the direct Moonshot API with prompt caching enabled is the most cost-effective paid option.
Can Kimi K3 cost exceed competing models? Yes — on output-heavy workloads, K3's $15.00/1M output rate is higher than GLM-5.2 ($4.40) or Kimi K2.7 Code ($3.50). Compare your expected input/output token ratio before committing.
Where can I learn more about Kimi K3 before paying for it? See what Kimi K3 is and how it works, then check the detailed benchmark scores. For API integration, the OpenRouter setup guide walks through the process step by step.
Core Summary
Kimi K3 pricing is more nuanced than the headline $3.00/$15.00 numbers suggest. The real cost depends on how you access the model and what kind of workload you run.
- Free tier at kimi.com works for most individual users with no commitment.
- Pro subscription (~$10–20/month) is the sweet spot for heavy chat users.
- Direct API with caching costs as little as $0.30/1M cached input — the cheapest frontier-model input rate available.
- OpenRouter and AWS Marketplace charge the same headline rates but do not pass through the caching discount — use them only when convenience or procurement requirements outweigh the cost premium.
- Output-heavy workloads cost more on K3 than on GLM-5.2 or K2.7 Code — benchmark both before choosing.
The cheapest path: start at kimi.com, test for a week, then decide whether the API's capabilities justify the per-token cost. For most users, the free tier or the Pro subscription is all you need.
For more on what K3 can do, see the Kimi K3 benchmarks comparison and the full K3 feature guide. Comparing models? Check Kimi K3 vs Fable breakdown.
Author
Categories
Seedance 2.0
ByteDance latest video model. Text & image to video, up to 1080p.
Try Seedance 2.0 →Wan Video
Wan 2.7 series — text, image, reference to video & video editing.
Try Wan Video →AI Image Generator
Nano Banana Pro, GPT Image 2 & more. Generate stunning images in seconds.
Try Image Generator →More Posts

Wan 2.7 9-Grid Guide: How to Build Better Boards and Get Cleaner Motion
Updated for April 27, 2026: how Wan 2.7 9-grid image-to-video works, how to prepare a stronger board, what prompt structure works, and when 9-grid beats first/last frame.

Is Wan 2.5 Open Source? What Happened and Where to Access It (2026 Guide)
"Wan 2.5 open source" returns everything from API catalogs to outdated blog posts — but no download page. Here is what actually happened to Wan 2.5 and how to move forward.
Wan 2.2 Remix v3 Guide: What Is the Remix Workflow, NSFW Variants, and How to Use Community Checkpoints (2026)
Wan 2.2 Remix v3 workflow guide with practical tips. Learn how Remix differs from I2V and T2V, which NSFW checkpoint to download (5B vs 14B), what safetensors naming conventions mean, and the prompt adjustments that actually improve Remix output — based on 300+ test generations.
Newsletter
Join the community
Subscribe to our newsletter for the latest news and updates