Kimi API Pricing: K3 Rate Card and Real Monthly Cost

Kimi API pricing for the flagship K3 model looks simple at first glance — a cached-input rate, an uncached-input rate, and an output rate — but the real monthly bill depends on three things the rate card does not show: how much of your input hits the cache, whether you pay for cache writes, and how long your agent loops and chat sessions actually are. Kimi K3 is a 2.8-trillion-parameter multimodal reasoning model with a 1,048,576-token context window, aimed at long-horizon coding, knowledge work, visual understanding, and agentic workflows.

This guide walks through the Kimi K3 API rate card on OurToken, what each line item means, and how to turn it into a monthly cost estimate for the two workloads that actually consume Kimi tokens: coding agents and chat assistants. It uses the live OurToken Kimi K3 page as the billing source, and the official Moonshot pricing and Kimi app plans as reference.

Verification status: Prices in this article are dated 2026-10-14 and were verified against the live OurToken Kimi K3 model page and the official Moonshot pricing documentation. Prices change; confirm the current rate card before budgeting.

Kimi API Pricing: The K3 Rate Card at a Glance

Kimi K3 is billed per million tokens. On OurToken the route is listed at 60% of the official reference price, so each token category carries an official reference and a discounted OurToken rate.

Note the ordering of the table above: the official reference price for uncached input is $3.00 per million tokens, and cached input is $0.30 per million tokens. On OurToken those become $1.80 and $0.18 respectively. The rate card does not list a separate cache-write price because the official price information does not define an independent cache-write rate for K3.

The model ID and endpoint

Use the verified model ID kimi-k3 through the OurToken endpoint:

Base URL:      https://api.ourtoken.ai/v1
Full endpoint: https://api.ourtoken.ai/v1/chat/completions
Model ID:      kimi-k3
Context:       1,048,576 tokens

Both cached and uncached input are subsets of the same input stream. When a usage object reports prompt_tokens_details.cached_tokens, those cached tokens are billed at the cached-input rate, and the rest of the prompt at the uncached-input rate — you never pay both prices for the same tokens.

What Each Kimi K3 Price Line Actually Means

Cached input ($0.30 official / $0.18 on OurToken per 1M). When a request reuses a prefix that Kimi's context cache already holds — a stable system prompt, tool schemas, or a long document loaded earlier — those tokens bill at the cache-hit rate. The official Moonshot documentation says Kimi API automatically enables context caching for repeated request prefixes. This is where most of your cost savings live on long sessions.

Uncached input ($3.00 official / $1.80 on OurToken per 1M). Tokens that miss the cache. Every edit near the top of a prompt — a changed system instruction, a timestamp, a reordered tool block — invalidates the cache for everything below it, converting a cheap cached-input read into a full uncached-input charge.

Output ($15.00 official / $9.00 on OurToken per 1M). All generated tokens, including thinking. K3 is a reasoning model, and its thinking output can be substantial; on long coding-agent runs, output cost can rival input even though the output volume is far smaller than the resending conversation.

Cache writes (official: ¥20 per 1M for 5-minute TTL, ¥40 for 1-hour TTL). The official Moonshot rate card lists cache-write prices for K3: ¥20 per 1M tokens for the default 5-minute cache, ¥40 per 1M for a 1-hour cache. OurToken does not list a separate cache-write line for K3 because the official reference it uses does not define an independent rate — but if you budget against the official platform, cache writes are a real line item on long conversations that reload the same document.

The practical takeaway is the same one that dominates every Kimi cost discussion: your cache hit rate moves the bill more than any rate card does. Keep the stable parts of your prompt at the top, put the changing parts (the question, the timestamp, the tool result) at the end, and most of your input becomes cached reads.

The Kimi K3 Model and Why It Bills the Way It Does

Kimi K3 is Kimi's flagship: a 2.8-trillion-parameter multimodal reasoning model with native visual understanding, a 1,048,576-token context window, and long-horizon coding support, per the official Kimi materials. The Kimi K3 API key setup guide covers the endpoint and the Python client in detail; this article focuses on the money side.

The billing pattern follows directly from the model's design. It is a reasoning model, so output includes thinking tokens. It has a huge context window, so input sizes are large. It is built for long coding sessions and knowledge work, so a single task resends the growing conversation on every step — which is why input, not output, is usually the bigger line on agent workloads.

Kimi K3 vs the app subscription

There are two ways to pay for Kimi K3, and they are billed separately:

The official Kimi membership page lists those plans. The API and the app are separate accounts: an app membership does not grant API credit, and API credit does not unlock app features. If you are building on the API, only the rate card matters.

From Rate Card to Monthly Cost: Two Real Workloads

A per-token rate is not a budget. Here are two worked examples using the OurToken K3 rates, with assumptions spelled out so you can substitute your own numbers.

A coding-agent session

A coding agent fixing a feature-sized bug runs many steps, and every step resends the whole conversation. A realistic session sends roughly 6 million input tokens total, with 90% hitting the cache, plus 80,000 output tokens.

If your prompt layout drops the cache hit rate to 70%, the same session costs about $4.60 — so the cache-hit rate, not the per-token price, is the lever that decides whether K3 is cheap or expensive for coding.

A daily chat assistant

A personal assistant handling 50 messages a day, each sending 6,000 tokens (system prompt plus history, 80% cached) and returning 1,500 output tokens:

That is about $0.83 per day, or roughly $25 per month for 50 messages a day. Short chat flips the pattern: output becomes the biggest cost, and the cheapest way to reduce it is lowering the reasoning effort for simple conversations.

How Kimi K3 Compares With Other Cheap Routes

K3 is a frontier-class model, so the honest comparison is against other frontier and near-frontier routes on OurToken:

Kimi K3 is the most expensive of the group on list price, and that is expected — it is the flagship, not the budget route. The right way to use it is with a router: send complex, long-horizon coding and knowledge work to K3, and send high-volume simple requests to a Flash-class route. The LLM model routing guide covers exactly this pattern, and the DeepSeek V4 API pricing guide shows how to budget a cheap route with a cost calculator.

Five Ways to Cut the Kimi K3 Bill

The rate card is fixed, so savings come from how many tokens you send and how you send them.

1. Match reasoning effort to the job. K3 is a reasoning model and defaults to heavy thinking. For classification, formatting, or quick answers, use the lowest effort that holds up; for hard coding, keep it high.
2. Keep your prompt prefix stable. System prompt, tool definitions, and reference files go at the top; the question, tool results, and timestamps go at the end. Every edit near the top throws away the cache for everything below it.
3. Load long context once, then reuse it. A 200,000-token document loaded once and cached becomes cheap reads on every following question. Let it expire and every question pays the full uncached price.
4. Use a Flash-class route for high-volume traffic. Simple chat and extraction do not need a 2.8T-parameter flagship. Route them to DeepSeek, Qwen, or GLM Flash and reserve K3 for the tasks that need it.
5. Monitor the cache-hit rate in real usage. Do not assume a prefix is cached. Inspect the usage object's prompt_tokens_details and log the cached-token share; the prompt caching guide explains how to read and normalize it.

Conclusion

Kimi API pricing for K3 is three rates that matter — cached input, uncached input, and output — plus a cache-write line on the official platform. On OurToken the route is 60% of the official reference: $0.18 cached input, $1.80 uncached input, and $9.00 output per million tokens. A real coding-agent session costs a few dollars; a 50-message-a-day chat assistant costs roughly $25 a month. Both numbers move more with your cache hit rate and reasoning-effort setting than with the rate card itself.

If you are building with Kimi K3, get the key from the OurToken API Keys page, keep the stable prefix cached, and route the high-volume traffic to a cheaper model. The Kimi K3 API setup guide covers the endpoint, and the LLM API pricing guide is the general framework for turning token usage into a monthly number.

FAQ

What is the Kimi K3 API price on OurToken?

As of 2026-10-14, $0.18 / 1M cached input, $1.80 / 1M uncached input, and $9.00 / 1M output, at 60% of the official reference. The official Moonshot rates are $0.30, $3.00, and $15.00 per 1M respectively.

What is the Kimi K3 model ID?

Use kimi-k3 on OurToken, with the endpoint https://api.ourtoken.ai/v1/chat/completions.

Is Kimi K3 cheaper than the app subscription?

It depends on volume. The API bills per token; the Kimi app sells memberships from free to $199/month. They are separate — an app membership does not include API credit.

How much does a Kimi K3 coding agent session cost?

A realistic feature-fix session of about 6M input tokens (90% cached) and 80K output tokens costs roughly $2.77 at OurToken rates. At a 70% cache hit rate the same session is closer to $4.60.

Why is the cache hit rate so important?

Cached input is 10x cheaper than uncached input on K3. Keeping the stable prefix at the top of the prompt and the changing parts at the end keeps most of your input in the cached lane.

How do I route between Kimi K3 and a cheaper model?

Send long-horizon coding and knowledge work to kimi-k3, and high-volume simple traffic to a Flash-class route such as deepseek-v4-flash, qwen3.8-flash, or glm-5.3-flash. The LLM model routing guide covers the pattern.