Model / Kimi K3

Kimi K3 API

Moonshot AI-Text generation-$3.00 / 1M input Token-Available

1.05M contextPrompt cacheStreaming SSEOpenAI compatible

View model

24h status

No traffic yet

100%LiveLanguage model

Provider

Moonshot AI

Model

Kimi K3

Context window

1,048,576 Token

Protocol

Chat Completions

Choose Kimi K3 when context is the bottleneck

Kimi K3 is a long-context text model for workflows where the hard part is keeping enough evidence in the prompt: code repositories, legal or policy packets, research notes, logs, previous tool calls, and agent memory. AIReiter makes that model available through a familiar OpenAI-compatible Chat endpoint.

Best fit

Long-context reasoning route

Use Kimi K3 when you want one large request to carry the working set, instead of building a retrieval or chunking workflow first.

Put complex context in one request

Use it for large codebases, evidence-heavy document packs, and long-running agent tasks without aggressively splitting the context.

Keep the integration lightweight

AIReiter exposes Kimi K3 through OpenAI Chat Completions, so existing apps usually change only baseURL and model.

Make long prompts cache-aware

When stable system prompts, project background, or document prefixes repeat, verify cache reads directly from usage fields.

Budget reference

Estimate callable requests from the current token mix.

Recharge Credits

$10

about 13 sample requests

Quick testing

$50

about 65 sample requests

Daily development

$100

about 130 sample requests

Production evaluation

Pricing

Kimi K3 token rates

Prices are shown per 1M tokens. AIReiter currently lists Kimi K3 at the same public model rate, so the value of this page is fast access, endpoint clarity, and usage visibility.

Token type	Rate	Notes
Input	$3.00 / 1M	Prompt tokens when the stable prefix is not served from cache.
Cache read	$0.30 / 1M	Cached prompt tokens reported in usage fields.
Output	$15.00 / 1M	Generated response tokens, including reasoning-heavy answers.

Production layer

Where Kimi K3 fits in a production model stack

The model is most useful when context continuity changes the outcome: not just answering one prompt, but carrying enough project state, evidence, and tool output to make the next step reliable.

Large codebase development

Review architecture notes, service contracts, old tests, diffs, and issue reports together before making a risky change.

Long-document analysis

Read contracts, policies, research notes, and evidence packs in one working context instead of summarizing away important details.

Multi-step tool agents

Keep tool call IDs, intermediate observations, parameters, and decisions in the transcript so later steps can stay consistent.

Prototype-to-production review

Use Kimi K3 to check whether a prototype, migration, or agent workflow has enough context to survive production edge cases.

Production checklist

Confirm these four things before shipping Kimi K3

Large-context models fail differently from small prompt models. Check the model ID, context path, conversation state, and usage records before calling the route production-ready.

Use the production model ID

Send kimi-k3 in API requests. The page-chat key chat-kimi-k3 is only for the AIReiter chat UI.

Model ID

Do not treat 256K as the same entry

Kimi K3 supports 1,048,576 tokens here. Confirm your client, proxy, and timeout settings can actually carry large requests.

Context

Preserve assistant and tool state

Long agent runs need previous assistant messages, tool outputs, and parameters. Dropping them often creates false continuity.

Tool state

Record cache and usage fields

Cache reads, output tokens, and reasoning-heavy responses should be measured from usage fields, not guessed from request count.

Usage

request.ts

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.AIREITER_API_KEY,
  baseURL: "https://aireiter.com/api/v1",
});

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "user", content: "Analyze this repository and identify the three highest-risk implementation assumptions." }
  ],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

terminal

curl "https://aireiter.com/api/v1/chat/completions"   -H "Authorization: Bearer $AIREITER_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "kimi-k3",
    "messages": [
      { "role": "user", "content": "Analyze this repository and identify the three highest-risk implementation assumptions." }
    ],
    "stream": true
  }'

cache-check.json

{
  "model": "kimi-k3",
  "messages": [
    { "role": "system", "content": "<stable repository or document context>" },
    { "role": "user", "content": "Review today's diff against that context." }
  ],
  "stream": true
}

// Confirm cache reads from usage:
// usage.prompt_tokens_details.cached_tokens > 0

Use cases

What Kimi K3 is good at

These are the situations where a 1M-token context window changes the workflow more than another small latency or style improvement.

Long-context reasoning

Read a whole project brief, architecture notes, logs, and recent diffs in one request.

Coding assistant

Use it for codebase review, risky-change discovery, migration planning, and implementation critique.

Research synthesis

Summarize and reconcile many long documents without building a separate retrieval step first.

Agent planning

Keep tool traces, task history, and decision records in the conversation window.

Cost quality review

Do not compare token price without task cost

For production work, Kimi K3 should be measured by usable-result cost: retries, manual edits, tool success, cache hits, and time to a reliable answer.

First-pass success rate

Human rewrite rate

Retry count

Output tokens

Cache hit rate

Tool-call success rate

Time to usable answer

Escalation rate

If Kimi K3 reduces retries and keeps more context available, a higher token count can still produce a lower finished-task cost. If the task is short and stateless, use a lighter model.

Compare

How Kimi K3 compares with AIReiter text models

Dimension	Kimi K3	GPT-5.6 Sol	Gemini 3.1 Pro	Claude Sonnet 4.6
Dimension	kimi-k3	gpt-5.6-sol	chat-gemini-3.1-pro	chat-claude-sonnet-4-6
AIReiter protocol	Chat Completions	Chat / Responses family page	Chat model route	Claude Messages route
Best fit	1M-context codebases, long documents, agent state	OpenAI-compatible flagship reasoning	Large-context multimodal and document-heavy tasks	Code review and document judgment
When to pick it	When context continuity is the bottleneck	When GPT-5.6 quality or routing is required	When Gemini document or multimodal behavior matters	When Claude-style coding quality matters

Ready to test

Create a key, add credits, then send one Kimi K3 request

For developers, the fastest path is: create an API key, keep the Chat Completions endpoint, and start with a small streaming request before moving large context into production traffic.

Create API key Recharge Credits

FAQ

Kimi K3 API questions

What does Kimi K3 cost per 1M tokens?

The live public pages consistently list Kimi K3 at $3.00 per 1M cache-miss input tokens, $0.30 per 1M cache-read input tokens, and $15.00 per 1M output tokens.

How large is the Kimi K3 context window?

Kimi K3 is listed with a 1,048,576-token context window, which is the main reason teams evaluate it for codebases, long documents, and agent transcripts.

Does context caching really reduce cost?

Yes. Cached input is commonly shown at $0.30 per 1M tokens versus $3.00 per 1M uncached input tokens, a 90% lower input rate when reusable context is served from cache.

What is the model ID for API calls?

Use "kimi-k3" in the model field and send the request to https://aireiter.com/api/v1/chat/completions. Do not use the internal page-chat key as the public API model ID.

Can I call Kimi K3 with an OpenAI-style SDK?

Yes. Kimi K3 API guides commonly show OpenAI-style clients. On AIReiter, set baseURL to https://aireiter.com/api/v1, keep Chat Completions format, and send model "kimi-k3".

What should I watch in production usage?

Track cache-read tokens, output tokens, long-request latency, retry rate, and whether reasoning-heavy responses produce the usable answer your workflow needs.