Moonshot AI’s Kimi K3 represents a significant leap in open-weight AI model development. Released on July 16, 2026, this 2.8-trillion-parameter reasoning model has quickly become a focal point for developers seeking frontier-level intelligence with the flexibility of open weights. This analysis evaluates Kimi K3’s technical specifications, benchmark performance, and compares the leading API providers offering access to the model, including DeepInfra, which now hosts Kimi K3 as both a public and private endpoint.

At a Glance

Metric	Value	Context
Intelligence Index Score	57	Well above median 32 for open-weight models
Context Window	1M tokens	~1,573 A4 pages equivalent
Input Modalities	Text + Image	Multimodal reasoning model
Architecture	MoE (2.8T total / 104B active)	16 of 896 experts activated per token
Input Pricing	$3.00/M tokens	Median: $1.75
Output Pricing	$15.00/M tokens	Median: $10.00
Cache Hit Price	$0.30/M tokens	90% discount
Output Speed	32.0 t/s	Below median for reasoning models of this class
TTFT Latency	144.34s	High relative to median due to always-on reasoning
Output Tokens (Intelligence Index)	130M	Median: 63M
Evaluation Cost	$2,437.41	Full Intelligence Index run

What is the Kimi K3 Model?

Kimi K3 is Moonshot AI’s flagship open-weight model, representing the first publicly available AI system in the 3-trillion-parameter class. The model utilizes a Mixture of Experts (MoE) architecture with 2.8 trillion total parameters, activating 104 billion parameters during inference through its Stable LatentMoE framework (16 of 896 experts per token).

The architecture incorporates two key innovations: Kimi Delta Attention (KDA), a hybrid linear attention mechanism, and Attention Residuals (AttnRes), both designed to improve information flow through longer sequences and deeper model layers. Moonshot claims these structural advances provide approximately 2.5x the scaling efficiency compared to K2.

Kimi K3 is a reasoning model that uses extended chain-of-thought thinking to work through complex problems. Thinking mode is always on, and reasoning effort is configurable via the reasoning_effort parameter, which accepts low, high, or max, with max as the default. The model supports multimodal input (text and images) and generates text output.

Technical Specifications

Specification	Value
Release Date	July 16, 2026
Developer	Moonshot AI
Total Parameters	2.8 trillion
Active Parameters	104 billion
Architecture	MoE with Stable LatentMoE
Expert Configuration	16 of 896 experts active
Context Window	1,048,576 tokens (1M)
Input Modalities	Text, Image
Output Modalities	Text
Output Speed	32.0 tokens/sec
Time to First Token	144.34s
License	Kimi K3 License (commercial use requires separate agreement)
Weights Availability	Open weights (released July 27, 2026)

API Provider Analysis

Kimi K3 is available through multiple API providers, each offering distinct advantages for different deployment scenarios. The following analysis compares the primary options available to developers.

Moonshot AI (First-Party)

Moonshot’s first-party API serves as the reference implementation for Kimi K3. All benchmark figures in this analysis derive from Kimi’s API performance.

• Input: $3.00 per 1M tokens
• Output: $15.00 per 1M tokens
• Cache Hit: $0.30 per 1M tokens (90% discount)
• Blended Rate: $2.31 per 1M tokens (7:2:1 cache/input/output ratio)
• Output Speed: 32.0 t/s
• TTFT: 222.66s
• Context: Full 1M context window support

The first-party API provides the official baseline behavior used in referenced benchmarks and is recommended when exact alignment with Moonshot’s specifications is required.

DeepInfra

DeepInfra hosts Kimi K3 as both a public endpoint and a private endpoint deployment option, making it one of the more cost-effective routes into the model.

• Input: $2.85 per 1M tokens
• Output: $14.25 per 1M tokens
• Cache Hit: $0.285 per 1M tokens (90% discount)
• Blended Rate: ~$2.19 per 1M tokens (7:2:1 cache/input/output ratio), roughly 5% below Kimi’s first-party list pricing across every tier
• Model ID: moonshotai/Kimi-K3
• Context: Full 1,048,576-token context window support
• Features: JSON mode, function calling, and multimodal input supported natively
• Infrastructure: OpenAI-compatible API, zero data retention policy, SOC 2 and ISO 27001 certified

DeepInfra is a strong default for teams that want Kimi K3’s full capability set at a documented, predictable rate. Its published cache-hit price matters more than the headline input rate for the workloads that actually justify a 1M-token context window, since repo-scale coding sessions, long-context RAG, and persistent agent scaffolding all repeatedly re-send the same large static prompts. Independent third-party speed and latency benchmarks for DeepInfra’s Kimi K3 deployment were not yet available at the time of writing.

OpenRouter

OpenRouter aggregates multiple Kimi K3 providers, offering flexible routing options for developers seeking optimal price-performance balance.

• Routing Modes: Balanced (optimizes for price and speed), Nitro (fastest response times), Exacto (highest tool-calling accuracy)
• Model ID: moonshotai/kimi-k3 (alias: ~moonshotai/kimi-latest)
• Full 1M-token context support, text and image input, tool calls, and structured outputs

OpenRouter is ideal for developers already using its API ecosystem who want automatic provider selection based on real-time performance metrics.

CometAPI

CometAPI operates as an AI API aggregator, exposing Kimi K3 alongside more than 500 other models behind a single endpoint. Its value proposition is operational rather than architectural: intelligent traffic management, automatic failover, and consolidated billing across providers.

• Model ID: kimi-k3
• Endpoint: POST https://api.cometapi.com/v1/chat/completions (OpenAI-compatible)
• Routing: Automatic fallback to an alternate provider when one endpoint returns an error or degrades
• Billing: Consolidated across Moonshot, OpenAI, Anthropic, Google, DeepSeek, and other providers
• Features: Structured output, JSON mode, tool calling, tool_choice, dynamic tool loading, and context caching

For teams running Kimi K3 in mission-critical paths, the failover behavior is the main draw. Moonshot temporarily gated new Kimi K3 subscriptions following a demand spike after launch, which is exactly the scenario where a routing layer with automatic fallback protects an application from a single-provider outage. The consolidated billing and unified endpoint also reduce operational overhead for teams already evaluating Kimi K3 against models from several vendors at once.

Puter

Puter takes a fundamentally different approach, offering a cloud platform and JavaScript library that lets developers call Kimi K3 directly from the browser with no backend, no server-side configuration, and no API key management.

• Model ID: moonshotai/kimi-k3
• Integration: Puter.js for frontend and Node.js projects; also available via an OpenAI-compatible API for Python and cURL
• Billing: User-Pays model, in which end users cover their own inference costs, making the model free to add for the developer
• Context: Full 1M-token context window support

For frontend developers and small teams, Puter removes the infrastructure question entirely. The tradeoff is control: you do not select or influence the serving path, which makes it better suited to prototypes, demos, and consumer-facing web apps than to production systems with latency or compliance requirements.

Provider Comparison Table

Provider	Best For	Key Advantage	Considerations
Moonshot AI (First-Party)	Official baseline	Reference implementation	Higher pricing, slower performance
DeepInfra	Cost-efficient production use	Lowest published cache rate, full JSON/tool/multimodal support, private endpoint option	Independent speed and latency benchmarks not yet published
OpenRouter	Multi-provider routing	Automatic optimization across Balanced, Nitro, and Exacto modes	Aggregated pricing; final economics depend on routed provider
CometAPI	Production failover and consolidation	Automatic fallback, consolidated billing across 500+ models	Routes to third-party providers rather than hosting directly
Puter	Frontend and browser-based apps	Zero backend, no API key, User-Pays billing	No control over serving path or provider selection

Performance Benchmarks

Kimi K3 achieves a score of 57 on the Artificial Analysis Intelligence Index, a composite benchmark evaluating models across reasoning, knowledge, mathematics, and coding. This places K3 well above the median score of 32 for comparable open-weight models.

• Token usage: K3 generated 130M output tokens during Intelligence Index evaluation, well above the median of 63M (a reflection of its verbose, always-on chain-of-thought reasoning).
• Evaluation cost: $2,437.41 to run the full Intelligence Index.
• Comparative performance: Trails Anthropic’s Claude Fable 5 and OpenAI’s GPT-5.6 Sol on overall performance, but outperforms Claude Opus 4.8 and GPT-5.5 on select benchmarks, and leads Arena.ai’s Code WebDev leaderboard.

Pricing Analysis

Kimi K3’s pricing positions it in the mid-to-premium tier for open-weight models:

Metric	Kimi K3	Open-Weight Median
Input (per 1M)	$3.00	$0.43
Output (per 1M)	$15.00	$1.20
Cache Hit (per 1M)	$0.30	—

• Cache economics: The 90% cache discount is significant for repetitive workloads, and is the single largest lever on total cost for long-context applications.
• Flat context pricing: No long-context surcharge across the full 1M window.
• Effective blended rate: $2.31/M tokens at Kimi’s first-party list price with typical cache hit ratios.
• Versus DeepInfra: DeepInfra prices Kimi K3 roughly 5% below Kimi’s first-party list rate across input, output, and cached tokens, for an effective blended rate of approximately $2.19/M, and is the only provider covered here publishing an explicit cache-hit price.
• Versus Claude Opus: Approximately 40% cheaper on both input and output.

Conclusion

Kimi K3 represents a compelling option for developers requiring frontier-level reasoning capabilities with the flexibility of open weights. Its massive 1M-token context window, multimodal input support, and strong benchmark performance make it particularly suited for complex, long-horizon tasks in coding, research, and enterprise workflows.

• For cost-efficient production use: DeepInfra offers a documented cache-hit rate alongside full JSON mode, function calling, and multimodal support, plus a straightforward path to private endpoint deployment as usage scales.
• For multi-model workflows: OpenRouter’s intelligent routing can optimize cost and performance across providers automatically.
• For production failover and consolidated billing: CometAPI adds automatic fallback across providers and unified billing, useful when Kimi K3 sits in a critical path alongside models from several vendors.
• For frontend and browser-based apps: Puter removes backend and API-key setup entirely through its User-Pays billing model.
• For official baseline behavior: Kimi’s first-party API remains the reference implementation for exact benchmark alignment.

The model’s primary limitations, high latency and slower output speed relative to peers, make it better suited for asynchronous, high-complexity tasks where reasoning accuracy is prioritized over immediate response times. For latency-sensitive applications, consider routing simpler queries to faster models while reserving K3 for complex reasoning tasks.

Kimi K3 is now live on DeepInfra, joining OpenRouter, CometAPI, Puter, and Kimi’s first-party API as one of the primary ways to access the model in production. Head to the Kimi K3 model page on DeepInfra to run it in the playground, or check the API reference to pull a key and start building.