Moonshot AI (Kimi) Review: Pricing & Comparison

Long documents: Kimi thought of it first

Most large language models have context windows between 8K and 32K tokens. That limit becomes an unavoidable wall when you’re working with a 30-page legal contract, a code repository with dozens of files, or a complete technical book — you end up manually chunking, stitching, and making multiple calls, a workflow that’s tedious and error-prone.

Moonshot AI’s Kimi (platform.kimi.com) was among the first to turn ultra-long context into a productized, market-ready capability. Drop in the whole book and let the model find the answer itself — that’s Kimi’s core usage pattern, and the core capability that sets it apart from most other models.

Available models and spec comparison

Model	Context window	Notes
kimi-k2.7-code	256K tokens	Flagship coding model, automatic context caching
kimi-k2.7-code-highspeed	256K tokens	High-speed variant, ~5-6x output speed, double the cost
moonshot-v1-128k	128K tokens	General-purpose chat, suited to non-coding long-document scenarios

kimi-k2.7-code is currently Moonshot’s strongest model, leading in code generation, code review, and long-document analysis.

Pricing at a glance

kimi-k2.7-code (standard)

Billing type	Price
Input (cache miss)	¥6.5 / 1M tokens (~$0.95)
Input (cache hit)	¥1.3 / 1M tokens (~$0.19)
Output	¥27 / 1M tokens (~$4.00)

kimi-k2.7-code-highspeed (high-speed)

Billing type	Price
Input (cache miss)	¥13 / 1M tokens
Input (cache hit)	¥2.6 / 1M tokens
Output	¥54 / 1M tokens

Input cost drops 80% on a cache hit — one of the core economic reasons to choose Moonshot’s official API over a relay platform, since most relays don’t support the official context-caching protocol.

Real-world uses for Kimi K2.7

Legal/financial document review

from openai import OpenAI

client = OpenAI(
    api_key="your Kimi API key",
    base_url="https://api.moonshot.cn/v1"
)

with open("contract.txt", "r") as f:
    contract_text = f.read()

response = client.chat.completions.create(
    model="kimi-k2.7-code",
    messages=[
        {"role": "system", "content": "You are a senior legal counsel specializing in contract risk identification"},
        {"role": "user", "content": f"Please analyze the following contract for potential risk clauses:\n\n{contract_text}"}
    ],
    max_tokens=4096
)
print(response.choices[0].message.content)

Codebase analysis: feed in an entire project’s source code and let Kimi understand the code structure, find bugs, and generate refactoring suggestions — no need to manually extract relevant files.

Research report synthesis: feed in multiple research reports at once and have Kimi cross-compare them, surfacing points of consensus and disagreement — saving the time of manual comparison.

Context caching: controlling the cost of long-text calls

If you’re asking multiple questions against the same long document, resending the full document’s tokens every time gets expensive fast. kimi-k2.7-code supports automatic context caching: the first time a long document is sent in, it gets cached, and later questions only need to send the question itself — once cached, the input price drops from ¥6.5 to ¥1.3/M tokens.

# First call: document content gets automatically cached
response1 = client.chat.completions.create(
    model="kimi-k2.7-code",
    messages=[
        {"role": "user", "content": f"Here is a technical specification document:\n\n{long_doc}\n\nFirst question: what are the core constraints in this spec?"}
    ]
)

# Subsequent call: document is already cached, only the question is sent, input cost drops 80%
response2 = client.chat.completions.create(
    model="kimi-k2.7-code",
    messages=[
        {"role": "user", "content": f"Here is a technical specification document:\n\n{long_doc}\n\nSecond question: what are common types of violations?"}
    ]
)
# On a cache hit, prompt_tokens_details in response.usage will show cached_tokens

Caching is managed automatically by the platform — no need to explicitly turn it on — and delivers significant cost savings for “repeatedly querying the same file” scenarios (legal contracts, technical specs, product manuals).

Official Kimi vs. Kimi through a relay

Some relay platforms on the market also support calling the Kimi model series. Reasons to choose the official platform instead:

1. Always the latest model version: the official platform is always first to launch the newest Kimi release
2. No middle-layer latency: avoids the uncertainty that comes with relay acceleration
3. Context caching is only available officially: relay platforms generally don’t support this feature, and the cost gap is significant for long-document use cases
4. Account security: no need to entrust your API key to a third party

If your use case centers on Kimi’s long-context or coding capability, going directly through Moonshot’s official platform is the more solid choice.

Compared with other document-processing tools

Developers who need long-document processing usually pick between a few directions:

• Moonshot Kimi: 256K context, drop in the document and just ask, context caching lowers cost
• AiHubMix’s Prompt Caching: suited to Claude + system-prompt caching scenarios
• OpenRouter’s multi-model routing: a flexible option when you need to switch between multiple models

Kimi’s ultra-long context has almost no direct substitute for document-heavy applications — that’s its moat.

Information verified 2026-07-04. Kimi’s model versions and pricing are updated continuously — defer to the official documentation at platform.kimi.com.

Related reviews

• UU API: MAX account pool, image generation at ¥0.04/image, ¥1 new-user bonus
• Yiye API: no minimum top-up, friendly for lightweight testing, zero barrier for proof-of-concept
• 302.AI: pay-as-you-go with no monthly fee, access global models through one platform
• ModelScope: Alibaba’s open-source model community, free inference tier for Qwen/DeepSeek