Kimi API pricing is pay-as-you-go and should be budgeted per accepted workload, not per prompt. The direct international API bills cached input, uncached input, and output at different rates. Tool calls, retries, long reasoning, images, video, and document text can add cost. A consumer Kimi membership is a separate product and does not replace an API balance. K2.8 Preview in Kimi Code is not a new Open Platform pricing row: Kimi Code membership access and the pay-as-you-go Moonshot Open Platform are separate billing paths.
This page owns one decision: How much will a Kimi API workload cost, and which controls keep that cost within budget? It does not choose the best model, teach API setup, explain every caching rule, or troubleshoot failed requests. Use Kimi API Models for routing, Kimi API Quickstart for the first request, Kimi Context Caching for cache engineering, and Kimi API Errors for failures.
Budgeting rule: calculate cost per successful business outcome. A request that is cheap but fails validation, requires three retries, or creates twenty minutes of review work may be the expensive route.
Current Direct-API Price Card
The following rates apply to the international Moonshot Open Platform direct API and exclude applicable taxes. The public price card was rechecked on September 13, 2026. Third-party providers can use different identifiers, prices, caching rules, and billing units. Do not add K2.8 Preview to this table unless Kimi publishes it as an Open Platform model with an official direct-API price.
| Direct model route | Cached input / 1M tokens | Uncached input / 1M tokens | Output / 1M tokens | Budgeting role |
|---|---|---|---|---|
kimi-k3 | $0.30 | $3.00 | $15.00 | Flagship route; justify it through a higher accepted-task rate or a requirement the lower-cost route cannot meet |
kimi-k2.7-code | $0.19 | $0.95 | $4.00 | Standard coding route |
kimi-k2.7-code-highspeed | $0.38 | $1.90 | $8.00 | Speed-optimized coding route; compare time saved with its higher token cost |
kimi-k2.6 | $0.16 | $0.95 | $4.00 | General-purpose, cost-sensitive route with switchable thinking |
K2.8 Preview in Kimi Code Is Not a New Open Platform Price Row
K2.8 Preview is currently documented inside Kimi Code, not as a separately priced model on the public Open Platform price card. Kimi fully rolled it out in Kimi Code on September 11, 2026 through the existing kimi-for-coding ID. Kimi Code is included in membership benefits, and eligible members can use Kimi Code credentials with supported coding clients and third-party developer tools.
That route is different from the Moonshot Open Platform used by the price table above. Open Platform requests use the public developer account, Open Platform balance and model IDs returned for that service. A Kimi membership or Kimi Code credential does not turn membership usage into pay-as-you-go Open Platform balance.
Pricing rule for K2.8 Preview: do not invent a cached-input, uncached-input or output price by copying the K2.7 Code rates. Until K2.8 Preview is officially listed on the Open Platform with its own direct-API pricing, budget its Kimi Code usage under the applicable membership credits and Kimi Code usage controls instead.
For membership prices, shared credits and Kimi Code limits, use the Kimi AI Pricing guide. For public API costs, continue using the Open Platform price card on this page.
One million means 1,000,000 tokens. Do not estimate tokens from word count alone for production budgets. Code, tables, non-English text, image and video processing, tool definitions, reasoning, and serialized JSON can change token use. Use the token counts returned by the API or the official token-calculation endpoint.
Build the Estimate From Billable Events
A reliable forecast separates every billable event instead of multiplying “average prompt size” by one headline price.
| Event | What to measure | Common budgeting mistake |
|---|---|---|
| Cache-hit input | Input tokens billed at the cache-hit rate | Assuming a repeated document will always hit the cache |
| Cache-miss input | New or changed input tokens billed at the normal input rate | Counting only the user message and ignoring system prompts, history, tools, and extracted documents |
| Output and reasoning | All billed output categories reported by the route | Budgeting for the visible answer while ignoring reasoning or verbose tool planning |
| Web search | Successful paid search calls plus the tokens returned to the model | Counting only the per-call fee |
| Files and media | Tokens created when document text, images, or video are passed to inference | Assuming free upload or extraction means free model processing |
| Retries and fallbacks | Every repeated request and every escalation to another route | Dividing only the first attempt by completed tasks |
| External services | Your own search, database, browser, storage, OCR, or execution fees | Calling the model price the total application cost |
Kimi’s official billing documentation says file storage and extraction interfaces are temporarily free, but extracted document content becomes billable input when it is sent to a model. The official web-search pricing page lists a $0.005 fee for each successful search call, in addition to model tokens. Kimi is currently updating its web-search route, so confirm availability and production guidance before including it in a new system.
The Cost Formula
model_cost =
(cached_input_tokens / 1_000_000 × cached_input_rate)
+ (uncached_input_tokens / 1_000_000 × uncached_input_rate)
+ (output_tokens / 1_000_000 × output_rate)
tool_cost = successful_paid_tool_calls × tool_rate
request_cost = model_cost + tool_cost + external_service_cost
effective_cost_per_accepted_task =
(all request costs + retry costs + fallback costs + human review cost)
/ accepted tasksUse the response usage object as the accounting source whenever possible. If a provider does not expose a category you need, label it as unmeasured rather than silently treating it as zero.
Create a Monthly Workload Sheet
Estimate each workload class separately. A support classifier, coding agent, and research report should not share one average because their input size, output size, cache behavior, retries, and acceptance criteria differ.
| Column | Definition |
|---|---|
| Workload ID | Stable name such as ticket-classification or repository-fix |
| Candidate route | Exact model identifier and provider |
| Requests per month | Expected first attempts before retries |
| Average cached input | Measured cache-hit input tokens per request |
| Average uncached input | Measured cache-miss input tokens per request |
| Average output | Measured billed output tokens per request |
| Paid tool calls | Successful billable calls per request |
| Retry rate | Share of requests repeated after a retryable failure |
| Fallback rate | Share escalated to another route |
| Acceptance rate | Share passing the business acceptance test |
| Human review minutes | Average reviewer time per completed task |
| Monthly budget | Forecast plus an explicit contingency |
Three Worked Budgets
These examples are transparent calculations, not claims about this site’s account. Replace their assumptions with measurements from your own traffic.
Workload A: Structured Document Extraction
Assumption: 10,000 requests on kimi-k2.6; 3,000 input tokens per request; 60% of input is served as a cache hit; 300 output tokens; no paid search calls.
| Component | Monthly volume | Rate | Cost |
|---|---|---|---|
| Cached input | 18M tokens | $0.16 / 1M | $2.88 |
| Uncached input | 12M tokens | $0.95 / 1M | $11.40 |
| Output | 3M tokens | $4.00 / 1M | $12.00 |
| Estimated model total | — | — | $26.28 |
The forecast is $0.002628 per first attempt. It is not yet cost per accepted extraction. Add invalid-schema retries, fallback calls, and review time before approving the budget.
Workload B: Long-Context Coding Tasks
Assumption: 2,000 tasks on the direct Open Platform route kimi-k2.7-code; 30,000 input tokens per task; 50% cached; 8,000 output tokens. This example remains a K2.7 Code direct-API budget and should not be relabeled as K2.8 Preview.
| Component | Monthly volume | Rate | Cost |
|---|---|---|---|
| Cached input | 30M tokens | $0.19 / 1M | $5.70 |
| Uncached input | 30M tokens | $0.95 / 1M | $28.50 |
| Output | 16M tokens | $4.00 / 1M | $64.00 |
| Estimated model total | — | — | $98.20 |
Do not automatically double this number to estimate the HighSpeed route without checking the live price and whether faster output actually changes throughput, developer waiting time, or the number of simultaneous workers required.
If you are using kimi-for-coding in Kimi Code, this worked example does not apply. That identifier now routes to K2.8 Preview in Kimi Code, where membership credits and Kimi Code-specific limits govern usage instead of the Open Platform K2.7 Code token rates shown here.
Workload C: Research Tasks With Paid Search
Assumption: 500 tasks on kimi-k3; 50,000 input tokens; 20% cached; 10,000 output tokens; three successful paid search calls per task. This scenario is only relevant when the paid search route is currently available and approved for production.
| Component | Monthly volume | Rate | Cost |
|---|---|---|---|
| Cached input | 5M tokens | $0.30 / 1M | $1.50 |
| Uncached input | 20M tokens | $3.00 / 1M | $60.00 |
| Output | 5M tokens | $15.00 / 1M | $75.00 |
| Search calls | 1,500 calls | $0.005 each | $7.50 |
| Estimated direct total | — | — | $144.00 |
Search-result tokens passed back to the model are already part of the input/output token accounting and should not be mistaken for a free payload.
Turn a Forecast Into a Budget Envelope
A production budget needs thresholds that change system behavior before the account reaches an emergency state.
| Threshold | Suggested action |
|---|---|
| Per-request estimate | Reject or require approval when predicted tokens or tool calls exceed the workload contract |
| Daily spend | Alert the owner when spend exceeds the traffic-adjusted daily envelope |
| Retry budget | Stop automatic retries after the approved count or dollar ceiling |
| Fallback budget | Limit how many tasks may escalate to the expensive route |
| Monthly soft limit | Reduce nonessential workloads, lower output budgets, or investigate anomalies |
| Monthly hard limit | Pause optional jobs and require an authorized budget change |
A top-up increases available balance; it does not fix server overload or a defective request. Rate-limit tiers are also separate from token prices. Diagnose 429 responses by their error type before changing spend.
Log the Numbers Needed for Cost Control
timestamp, workload_id, request_id, provider, model,
cached_input_tokens, uncached_input_tokens, output_tokens,
paid_tool_calls, latency_ms, http_status, error_type,
retry_number, fallback_model, accepted, reviewer_minutes,
estimated_cost_usd, invoiced_cost_usdDo not log API keys, sensitive prompts, personal data, or full document content merely to calculate cost. Store usage metadata and a safe fixture or trace identifier. Restrict access to billing and request logs.
Investigate Variance Instead of Blaming the Price Table
| Unexpected result | Likely cause to test first |
|---|---|
| Input cost rose | Stable prefixes changed, conversations grew, tools expanded, or document text was inserted repeatedly |
| Output cost rose | Reasoning increased, completion limits were too high, or the prompt encouraged verbose output |
| Tool fees rose | The agent called search repeatedly or retried successful operations |
| Accepted-task cost rose | Schema failures, poor routing, reviewer corrections, or fallback use increased |
| Invoice exceeds estimate | Taxes, untracked routes, missing usage categories, or a bad rate snapshot |
| Spend rose but traffic did not | Prompt or history size changed; compare token distributions, not request count alone |
Where This Page Stops
| Question | Owner page |
|---|---|
| Which current route should run the task? | Kimi API Models |
| How do I improve cache hits? | Kimi Context Caching |
| How do I create and protect a key? | How to Get a Kimi API Key |
| How do I send the first request? | Kimi API Quickstart |
| Why did the request fail? | Kimi API Errors |
| What do consumer memberships cost? | Kimi Pricing |
| How is K2.8 Preview billed in Kimi Code? | Kimi AI Pricing for membership pricing and Kimi Code limits |
Cost Estimates and Verification Scope
The worked budgets on this page are illustrative calculations based on published API rates and the assumptions stated in each example. They are not presented as measured results from a seven-day account-level billing audit. Compare estimates with your own usage records and invoices before relying on them for a production budget.
Pricing Questions
Does a Kimi membership include direct API balance?
No. Treat consumer membership, Kimi Code membership usage and the Moonshot Open Platform as separate billing paths. A Kimi member may be able to create a Kimi Code API key for supported coding integrations, but that credential and its membership usage limits are not the same as Open Platform pay-as-you-go balance. Use Open Platform balance and invoices for the direct API, and the Kimi subscription/Kimi Code usage views for membership usage.
Does K2.8 Preview have a direct Open Platform API price?
Not on the public Open Platform price card reviewed for this update. K2.8 Preview is currently documented through Kimi Code as kimi-for-coding. Do not assign it K2.7 Code’s token rates or add a separate K2.8 price to this page unless Kimi publishes an official Open Platform listing and price.
Is uploading a document free?
The official billing documentation says file extraction and storage interfaces are temporarily free, but extracted text is billed as input when it is passed to a model. Media can also create billable tokens.
Does a cache hit make the whole request cheap?
Only the matched input receives the cache-hit rate. New input and all output remain billable at their applicable rates. A high cache-hit percentage can still accompany expensive output or tool use.
Should I choose the cheapest model?
Choose the lowest-cost route that passes the workload acceptance test. A lower rate can lose if it increases retries, fallbacks, or human correction. Model selection belongs to the dedicated API Models page.
Are third-party Kimi prices the same?
No assumption should be made. A third-party provider can use different identifiers, routes, margins, cache behavior, and billing units. Use that provider’s current documentation and keep its costs separate from Moonshot direct API costs.
Price Sources and Verification Record
- Kimi API Platform — current headline rates for active direct routes.
- Model inference pricing explanation — billing units, input/output logic, document extraction and storage treatment.
- Kimi K3 pricing.
- Kimi coding-route pricing.
- Kimi K2.6 pricing.
- Kimi web-search pricing — verify current availability before production use.
- Top-up and rate-limit rules — separate from token-price calculations.
- Kimi Code model configuration — current Kimi Code model IDs, K2.8 Preview mapping and context limits.
- Kimi Code What’s New — September 11, 2026 K2.8 Preview rollout through
kimi-for-coding.
Last verified: September 13, 2026. Recheck live Open Platform prices, taxes, search availability, rate-limit rules and model availability before publishing or deploying. Kimi Code model access and membership usage are separate from Open Platform pay-as-you-go pricing.
