Kimi K3 Fast
Kimi K3 Fast is the faster serving path for Moonshot AI's Kimi K3. It trades a higher per-token rate for lower latency, keeps the context window of 1M tokens, and routes through AI Gateway via Fireworks, Morph.
View API reference- Input and output price
- Prices from: Input $4.50, Output $22.50, Per 1M tokens
- 24h uptime
- Loading AI Gateway uptime
import { streamText } from 'ai'
const result = streamText({ model: 'moonshotai/kimi-k3-fast', prompt: 'Why is the sky blue?'})Copy link to headingPlayground
Try out Kimi K3 Fast by Moonshot AI. Usage is billed to your team at API rates. Free users (those who haven't made a payment) get $5 of credits every 30 days.
Kimi K3 Fast
Kimi K3 Fast
Copy link to headingProviders
Route requests across multiple providers. Copy a provider slug to set your preference. Visit the docs for more info. Using a provider means you agree to their terms, listed under Legal.
Copy link to headingUptime24 hours
Direct request success rate on AI Gateway and per-provider. Visit the docs for more info.
Copy link to headingThroughput24 hours
P50 throughput on live AI Gateway traffic, in tokens per second (TPS). Visit the docs for more info.
Copy link to headingLatency24 hours
P50 time to first token (TTFT) on live AI Gateway traffic, in milliseconds. View the docs for more info.
Getting started
Call Kimi K3 Fast through AI Gateway with the AI SDK generateText and streamText functions, or through the OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs by changing the base URL. AI Gateway authenticates the request and routes it to an available provider.
Install the AI SDK (pnpm add ai dotenv), create an API key from the API Keys page, and set it as AI_GATEWAY_API_KEY in your environment. Full setup is covered in the text generation quickstart.
import { generateText } from 'ai';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', prompt: 'Why is the sky blue?', });
console.log(result.text);}
main().catch(console.error);Top-level parameters
The same Kimi K3 Fast request in each API format AI Gateway supports.
import { generateText } from 'ai';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', system: 'You are a concise technical assistant.', prompt: 'Summarize the tradeoffs between static generation and SSR.', maxOutputTokens: 1024, });
console.log(result.text);}
main().catch(console.error);Standard parameters like prompt, messages, temperature, and tools work as documented in the AI SDK docs. These are the parameters with model-specific behavior.
| Parameter | Type | Required | Description |
|---|---|---|---|
model | string | Yes | Model ID in the form creator/model, e.g. moonshotai/kimi-k3-fast. AI Gateway routes the request to an available provider. |
maxOutputTokens | number | No | Hard cap on generated tokens. Kimi K3 Fast supports up to 1,000,000 output tokens. Reasoning tokens count toward this limit. |
reasoning | 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | No | Provider-agnostic reasoning effort, available in AI SDK 7 or later. Maps to the provider’s native reasoning configuration; reasoning settings under providerOptions take precedence when both are set. See the Reasoning section below. |
providerOptions | Record<string, JSONValue> | No | AI Gateway routing options under gateway, plus any provider-native options under the provider’s own namespace — see the table below. |
Input limits
| Input | Formats | Sources | Max count | Max size | Limits |
|---|---|---|---|---|---|
| Text | — | — | — | — | Prompt and response share the 1M-token context window |
| Image | — | URL, base64, Uint8Array | — | — | Sent as image parts in messages; counts as input tokens |
| — | URL, base64, Uint8Array | — | — | Sent as file parts in messages; counts as input tokens |
Provider options
Set AI Gateway routing options under providerOptions.gateway. For provider-specific options, pass them under the provider’s namespace as documented by the AI SDK.
Learn more in the AI SDK moonshotai provider docs.
import { generateText } from 'ai';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', prompt: 'Why is the sky blue?', providerOptions: { gateway: { only: ['fireworks', 'morph'], }, }, });
console.log(result.text);}
main().catch(console.error);These AI Gateway routing options apply to every model. Provider-specific options pass through under the provider’s own namespace (for example providerOptions.anthropic) exactly as documented by the AI SDK.
| Parameter | Type | Required | Description |
|---|---|---|---|
providerOptions.gateway.only | string[] | No | Restrict routing to these provider slugs. Requests fail over only within the listed providers. |
providerOptions.gateway.order | string[] | No | Preferred provider order. Listed providers are tried first; unlisted providers remain available as fallbacks. |
providerOptions.gateway.sort | 'cost' | 'ttft' | 'tps' | No | Rank candidate providers by price, time to first token, or tokens per second instead of the default routing order. |
providerOptions.gateway.zeroDataRetention | boolean | No | Route only to providers with a zero-data-retention policy for this model. |
Routing across providers
AI Gateway serves the same model through multiple providers and fails over automatically. order expresses a preference while keeping every provider eligible; only is a hard allowlist — if none of the listed providers are available the request fails instead of falling back.
Options under a provider's own namespace (for example providerOptions.anthropic) are forwarded to that provider with the request. Providers ignore option namespaces that don't apply to them, so it is safe to set provider options alongside gateway routing options.
Reasoning
AI Gateway bridges reasoning across every API format. The AI SDK exposes a provider-agnostic top-level reasoning level (none, minimal, low, medium, high, or xhigh); the Chat Completions and Responses formats take the same effort under reasoning.effort; and the Anthropic Messages format uses a native thinking token budget. Whichever you send, the gateway maps it to the target model’s native configuration, converting between effort levels and token budgets as needed. Reasoning-related settings under providerOptions take full precedence over the top-level reasoning value and are never merged. Reasoning tokens typically count toward your output-token usage, though how they’re reported and billed varies by provider.
Learn more in the AI Gateway reasoning guide.
import { generateText } from 'ai';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', prompt: 'Explain the Monty Hall problem step by step.', reasoning: 'high', });
console.log(result.text);}
main().catch(console.error);Image input
Send images alongside text as message parts. Images count as input tokens.
import { generateText } from 'ai';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', messages: [ { role: 'user', content: [ { type: 'text', text: 'Describe this image.' }, { type: 'image', image: 'https://example.com/photo.jpg' }, ], }, ], });
console.log(result.text);}
main().catch(console.error);PDF input
Attach PDFs as file parts. Their contents count as input tokens.
import { generateText } from 'ai';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', messages: [ { role: 'user', content: [ { type: 'text', text: 'Summarize this document.' }, { type: 'file', mediaType: 'application/pdf', data: 'https://example.com/document.pdf', }, ], }, ], });
console.log(result.text);}
main().catch(console.error);Tool calling
Expose tools the model can call. Define each tool’s inputs with a Zod schema.
import { generateText, tool } from 'ai';import { z } from 'zod';import 'dotenv/config';
async function main() { const result = await generateText({ model: 'moonshotai/kimi-k3-fast', prompt: 'What is the weather in San Francisco?', tools: { getWeather: tool({ description: 'Get the current weather for a location', inputSchema: z.object({ location: z.string() }), execute: async ({ location }) => ({ location, temperatureC: 18 }), }), }, });
console.log(result.text);}
main().catch(console.error);Copy link to headingMore models by Moonshot AI
| Model |
|---|
| 1M | 0.6 s | 163 tps | $2.50/M+1 more | $12.75/M+1 more | Read$0.29/M | — | +2 |    +11 | 07/16/2026 | |||||
| 262K | 2.1 s | 181 tps | $1.90/M | $8/M | Read$0.38/M | — | +2 | | 06/15/2026 | |||||
| 262K | 0.8 s | 90 tps | $0.74/M+1 more | $3.50/M+1 more | Read$0.15/M | — | +2 |   +1 | 06/12/2026 | |||||
| 262K | 0.4 s | 131 tps | $0.95/M | $4/M | Read$0.16/M | — | +1 | +1 | 04/20/2026 | |||||
| 262K | 0.7 s | 52 tps | $0.60/M | $3/M | Read$0.10/M | — | +1 |   | 01/26/2026 | |||||
| 216K | 0.9 s | 15 tps | $0.47/M | $2/M | Read$0.14/M | — | | 11/06/2025 |
Copy link to headingAbout Kimi K3 Fast
Kimi K3 Fast is the fast serving tier for Kimi K3, Moonshot AI's open-source model for long-horizon engineering work. Released July 27, 2026, Kimi K3 Fast trades a higher per-token cost for lower latency. The model's capabilities don't change.
Everything documented for the base model carries over. Kimi K3 Fast accepts text, image, and video input, supports a context window of 1M tokens, and keeps thinking mode always on. The strengths match too: long-horizon software engineering, knowledge work, deep reasoning, and tasks where code meets visual and spatial reasoning like frontend development, game development, and computer-aided design (CAD).
Two paths reach the fast tier. Set the speed option to fast while keeping the model ID on moonshotai/kimi-k3, and AI Gateway routes to the fast tier and falls back to standard speed when it isn't available. Or call moonshotai/kimi-k3-fast directly, which pins every request to the fast tier without that fallback.
Serving speed counts when someone is waiting. Interactive coding assistants stream output while a developer watches, and edit-run-fix loops repeat many times in a session, so per-turn latency compounds. Batch and offline jobs gain little. Throughput varies with load and context length, so read the live metrics on this page instead of planning around a fixed number.
AI Gateway routes Kimi K3 Fast across Fireworks, Morph, including US-based providers for teams with data residency and compliance requirements. To keep inference in US data centers, set inferenceRegion with scope zone and geo region us. Zero Data Retention is configured per request with zeroDataRetention or turned on for every request from AI Gateway dashboard settings, and support varies by provider.
Use the identifier moonshotai/kimi-k3-fast with the AI SDK or any supported interface like Chat Completions, Responses, or Messages. Kimi K3 Fast supports a context window of 1M tokens and completions up to 1M tokens per request, at $4.5 per million input tokens and $22.5 per million output tokens.
Copy link to headingWhat To Consider When Choosing a Provider
- Configuration: The fast tier lists above the base model, so compare $4.5 and $22.5 against Kimi K3 before you move high-volume traffic. Pinning
moonshotai/kimi-k3-fastskips the fallback to standard speed that thespeedoption provides on the base model ID, so decide which behavior you want during a fast-tier shortage. Thinking mode stays always on, and those reasoning tokens still count toward the completion cap of 1M tokens. Measured throughput varies with load and context length, so use the live metrics on this page rather than a published figure. - Zero Data Retention: Zero Data Retention is available for this model. It is offered on a per-provider and model basis. See the documentation for details.
- Authentication: AI Gateway authenticates requests using an API key or OIDC token. You do not need to manage provider credentials directly.
Copy link to headingWhen to Use Kimi K3 Fast
Best for
- Interactive Coding Assistants: Streaming output to a developer who watches the session
- Tight Iteration Loops: Edit-run-fix cycles where per-turn latency compounds across a session
- Latency-Budgeted Agents: Long-horizon agents that need Kimi K3 quality under a response-time cap
- Drop-In Speed Upgrade: Teams on Kimi K3 that want faster serving with the same behavior
Consider alternatives when
- Cost-Sensitive Traffic: Kimi K3 serves the same model at the standard per-token rate
- Batch and Offline Jobs: Faster serving adds little when nobody waits on the output
- Automatic Speed Fallback: The
speedoption on the base model ID falls back to standard speed - Optional Thinking Mode: A non-thinking Kimi K2 variant answers without a reasoning pass
Copy link to headingConclusion
Kimi K3 Fast gives you Kimi K3 with less waiting. When the output already meets your bar and response time is the remaining bottleneck, switch the model ID to moonshotai/kimi-k3-fast or set the speed option on the base model, then read the live metrics on this page to see what you gain.
Copy link to headingFrequently Asked Questions
How is Kimi K3 Fast different from Kimi K3?
Serving speed and price. Kimi K3 Fast is the faster serving path for the same model, so the context window, native visual understanding, and always-on thinking all carry over. The per-token rate is higher; compare the rates and live metrics on each model's page.
How do I request the fast tier?
Two ways. Set the
speedoption tofastwhile keeping the model ID onmoonshotai/kimi-k3, which falls back to standard speed when the fast tier isn't available. Or callmoonshotai/kimi-k3-fastdirectly to pin every request to the fast tier.How fast is Kimi K3 Fast?
Speed varies with load, context length, and routing, so a single number would mislead. Check the live throughput and latency metrics on this page for measured performance through AI Gateway.
Does Kimi K3 Fast accept images and video?
Yes. Text, image, and video input all work, matching the base model. Visual understanding is native, so screenshots and screen recordings feed a coding loop without a separate vision model.
Can I turn off thinking mode on Kimi K3 Fast?
No. Thinking mode is always on for the Kimi K3 models, so every response includes a deliberation pass. Budget output tokens for it, and reach for a non-thinking Kimi K2 variant when deliberation doesn't help.
Can I keep Kimi K3 Fast inference in the United States?
Yes. AI Gateway serves the Kimi K3 models from US-based providers, and
inferenceRegionrestricts a request to US data centers. Regional inference lists above the standard rate, so check the pricing panel on this page first.How do I use Kimi K3 Fast on AI Gateway?
Use the identifier
moonshotai/kimi-k3-fastwith the AI SDK or any supported interface like Chat Completions, Responses, or Messages. AI Gateway routes acrossfireworks,morphand handles failover automatically.Does Kimi K3 Fast support zero data retention?
Yes, Zero Data Retention is available for this model. Zero Data Retention is offered on a per-provider basis. See https://vercel.com/docs/ai-gateway/capabilities/zdr for details.
Your use is subject to Moonshot AI's Terms & Privacy Policies.