Kimi K3

kimi-k3

Kimi K3 is a flagship reasoning router for complex tasks, suitable for screenshot reconstruction and interactive frontend prototyping, large code repositories, multi-document evidence synthesis, long-running agents, and knowledge tasks that genuinely require a 1.05 million Token working context.

Context window1.1M

ProviderMoonshot

Released2026/08/10

Playground

Pricing

The same model is available through multiple service channels — choose based on latency, reliability and cost.

Prices in $ / 1M tokens

To pick a channel, add a provider field to the request body, for example "provider": { "channel": "direct" }. Valid values are direct / stable / economical; omit it to use the default channel.

Direct

Direct upstream connection — best when you need native behavior and the full context window.

Input	Output	Cache read
3.00/M	15.00/M	0.30/M

Preferred

A balanced route optimized for availability and speed — a good default for production traffic.

Input	Output	Cache read
3.00/M	15.00/M	0.30/M

Overview

Input

Text Image

Output

Text

Kimi K3 API: The 2.8-Trillion-Parameter Open-Source Frontier Multimodal Flagship

Kimi K3 is a massive mixture-of-experts (MoE) model released by Moonshot AI on July 16, 2026, with 2.8 trillion total parameters. It is currently the largest open-weight model and the world's first "open-source 3T-class" model. It natively supports text, image, and video understanding, features a 1M token context window and always-on thinking mode, and its model weights were publicly released on July 27 under a modified MIT license.

In coding benchmarks, Kimi K3 consistently holds a top-tier position: 76.8% on SWE-bench Verified, leading all rivals on SWE Marathon and Program Bench, and ranked #1 in the LMArena Frontend Code Arena with 1679 Elo.

SeaWhale AI provides Kimi K3 through an OpenAI-compatible interface, supporting tool calling, streaming output, vision understanding, and ultra-long context processing.

Get API Key · Model ID: kimi-k3

Why Choose Kimi K3

Largest open-source model — 2.8 trillion total parameters, about 75% larger than DeepSeek V4 Pro, with open weights for private deployment
1M token context — unified pricing across the full window, no long-context surcharge tiers
Native multimodal — text, image, and video understood in a single model, no external adapters needed
Always-on thinking mode — every response undergoes full reasoning, delivering stable quality on complex tasks
Architectural innovation — Kimi Delta Attention linear attention + Attention Residuals, with overall scaling efficiency about 2.5x higher than K2
Top-tier coding — top three on all six coding benchmarks, #1 on SWE Marathon and Program Bench

Core Capabilities

01 Agentic Coding

This is Kimi K3's most talked-about capability. It scores 76.8% on SWE-bench Verified, surpasses Opus 4.8 and GPT-5.6 Sol on SWE Marathon (42.0), and ranks #1 outright in the LMArena Frontend Code Arena with 1679 Elo.

Repository-level GitHub issue localization and fixing
Frontend page and interaction implementation
Long-horizon, multi-step agentic tasks

02 1M Token Long Context

With a 1,048,576-token context window, combined with Kimi Delta Attention linear attention, the efficiency advantage on long sequences grows with length; it scores 90.4 on the BrowseComp long-range retrieval task under the full 1M context.

Load an entire code repository at once
Cross-analysis of ultra-long documents and multiple sources
Unified pricing across the full window, no long-context surcharge

03 Native Multimodal Understanding

Text, images, and video are processed natively within the same model rather than assembled via separate vision adapters, making cross-modal reasoning more coherent.

Screenshot / design mockup to code
Video content understanding and summarization
Mixed image-text document analysis

04 Always-On Reasoning and Scientific Q&A

Thinking mode is always enabled, and every response includes the full reasoning process (reasoning tokens are billed as output). GPQA graduate-level science Q&A reaches 93.5%.

Advanced math and logical reasoning
Graduate-level scientific problem solving
Complex decision-path analysis

Best Use Cases

Scenario	Description
Agentic coding	Repository-level bug fixing and end-to-end feature development
Frontend development	Ranked #1 in the Frontend Code Arena, strong design-to-code fidelity
Long-context analysis	Understanding large projects and datasets within a 1M token window
Multimodal tasks	Unified understanding of images, video, and text
Deep research	Long-range web retrieval and multi-step reasoning (BrowseComp 90.4)
Private deployment	Open weights (modified MIT), deployable locally

What's New in Kimi K3 vs K2

Capability	Kimi K3	Kimi K2
Total parameters	2.8 trillion	1 trillion
Context window	1M tokens	256K tokens
Modalities	Text + image + video	Text
Thinking mode	Always on	Optional
Attention architecture	Kimi Delta Attention + AttnRes	Traditional full attention
Scaling efficiency	~2.5x vs K2	Baseline

For specific pricing, refer to the real-time price card at the top of the page.

How to Use the Kimi K3 API

1. Create a SeaWhale AI API key Generate a key in the console and top up your balance.

2. Leverage context caching K3's always-on thinking mode generates reasoning tokens (billed as output), but cache hit rates are generally very high for coding workloads, so the actual cost in multi-turn conversations and agentic scenarios is far lower than the paper unit price.

3. Call the API

curl -X POST https://api.seawhaleai.com/v1/chat/completions \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "user", "content": "Read this repository, find and fix the code paths causing memory leaks, and add regression tests."}
    ],
    "stream": true
  }'

FAQ

When was Kimi K3 released? Released on July 16, 2026; model weights were made public on July 27 under a modified MIT license.

Will 2.8 trillion parameters be expensive? No. It uses a sparse MoE architecture (only 16 of 896 experts activated per token) with MXFP4 quantization-aware training, so inference costs are far lower than a dense model of comparable scale.

What level is its coding capability? Top three on all six coding benchmarks: 76.8% on SWE-bench Verified, 42.0 on SWE Marathon (surpassing Opus 4.8 and GPT-5.6 Sol), and #1 outright in the Frontend Code Arena.

Can thinking mode be turned off? No. K3's reasoning mode is always on; every response includes the reasoning process, and reasoning tokens are billed as output tokens. In exchange, you get stable output quality on complex tasks.

What are the context and output limits? Context is 1,048,576 tokens (~1M), with a default output limit of 131,072 tokens that can be increased as needed. Pricing is unified across the full window with no long-context markup.

How do I choose between it and DeepSeek V4 Pro? Both are open-source MoE flagships. K3 has a larger parameter count, native multimodality, and the same 1M context; V4 Pro has a higher output limit (384K). Choose K3 if you need image/video understanding or frontend development; consider V4 Pro for pure-text ultra-long output scenarios.

Why Use SeaWhale AI for the Kimi K3 API

No self-built cluster required — official self-deployment needs 64+ GPUs; SeaWhale AI is ready to use out of the box
OpenAI-compatible interface — connect existing code with a two-line change
One key, multiple models — freely switch between K3 and Claude, GPT, Gemini, and DeepSeek for comparison
RMB settlement — domestic models are billed in RMB, keeping accounting clear

API

API integration

Model IDUse this value as the model in inference requests

kimi-k3

API KeyBearer token used to authenticate inference requests

Manage API keys

Base URLOpenAI compatible · /chat/completions

https://api.seawhaleai.com/v2/

provider OptionalSelects a service channel; omit it and the system picks the default

"provider": { "channel": "direct" }

kimi-k3 usage examples

SeaWhale AI is compatible with the OpenAI API protocol, so you can call it with the OpenAI SDK or plain HTTP requests. Streaming is enabled by default.

About the provider parameter (optional, a SeaWhale AI extension): most models are served over several channels that differ slightly in price and reliability. Add a provider field to the request body to pick one; omit it and the system selects the default channel — normal calls are unaffected.

provider is not part of the official OpenAI protocol — it is a SeaWhale AI extension that only takes effect on this platform. The OpenAI SDK allows custom fields like this to pass through; see the examples below.

Value	Channel	Best for
`direct`	Direct	The official upstream link, for native behavior and the full context window
`stable`	Preferred	Balanced availability and speed — a good default for production traffic
`economical`	Economy	Cost first, well suited to batch processing and price-sensitive workloads

Available channels and their prices are listed under "Pricing" above (channels vary by model). Additional notes:

Syntax: "provider": { "channel": "direct" }.
If the requested channel is not enabled for that model, the request automatically falls back to the default channel and returns normally — it does not error.
With the official SDKs: in Python pass it via extra_body; in Node.js put it directly on the request object and it passes through. In TypeScript projects, add a // @ts-expect-error line to skip the type check.

cURLPythonNode.js

curl https://api.seawhaleai.com/v2/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API_KEY>" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "provider": { "channel": "direct" },
    "stream": true
  }'
# provider is optional — remove this line to use the default channel

from openai import OpenAI

client = OpenAI(
    base_url="https://api.seawhaleai.com/v2",
    api_key="<API_KEY>",
)

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"},
    ],
    stream=True,
    # Optional: pick a service channel; omit to use the default
    extra_body={"provider": {"channel": "direct"}},
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import OpenAI from 'openai'

const client = new OpenAI({
  baseURL: 'https://api.seawhaleai.com/v2',
  apiKey: '<API_KEY>',
})

const stream = await client.chat.completions.create({
  model: 'kimi-k3',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello!' },
  ],
  stream: true,
  // Optional: pick a service channel; omit to use the default
  // @ts-expect-error provider is a SeaWhale AI extension, not in the OpenAI SDK types
  provider: { channel: 'direct' },
})

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