Kimi K3 is Moonshot AI's 2.8-trillion-parameter open-weight model with a 1-million-token context window. You can call it through Moonshot's own platform, or through any OpenAI-compatible gateway that serves it, by changing two lines in code you already have: the base URL and the model name.
This guide walks through the second route on AssemblyAI's LLM Gateway, where the model ID is kimi-k3. You'll get the exact price per million tokens, the context window, which regions and providers serve it, how your data is handled, and copy-paste quickstarts in Python, JavaScript and curl. It also covers something the spec sheets skip: how Kimi K3 scores on real call transcripts, from 30-second voicemails to hour-long meetings, including where it falls behind.
What is Kimi K3?
Kimi K3 is a large language model from Moonshot AI. Moonshot describes it as an open 3T-class model with 2.8 trillion parameters, native visual understanding, and full model weights released.
Three behaviors matter before you write code, all from Moonshot's Kimi K3 quickstart:
- It always thinks. K3 runs with thinking mode on, and you can't turn it off. Moonshot exposes
reasoning_effortwithlow,highandmax, andmaxis the default. - Sampling is fixed. Moonshot fixes
temperatureat 1.0 andtop_pat 0.95, and asks you to leave those out of requests. - Long output is possible. Moonshot defaults
max_completion_tokensto 131,072 and allows up to 1,048,576.
The thinking mode explains a lot of what you'll see in the benchmark section: strong answers, long waits.
Kimi K3 API pricing, context window and specs
Here is the Kimi K3 entry on LLM Gateway as of November 17, 2026, taken from the public models endpoint and the model catalog.
| Spec | Kimi K3 on LLM Gateway |
|---|---|
| Model ID | kimi-k3 |
| Creator | Moonshot AI |
| Input price (global) | $3.00 per 1M tokens |
| Output price (global) | $15.00 per 1M tokens |
| Cached input (read / write) | $0.30 / $3.75 per 1M tokens |
| In-region (US) requests | +10% regional surcharge |
| Context window | 1,000,000 tokens |
| Supported parameters | max_tokens, tools, tool_choice, response_format, stream, reasoning_effort |
| Providers | AWS Bedrock (default, on by default), Fireworks AI (opt-in) |
| Regions | US and global routing. Not on the EU endpoint. |
A few notes on reading that table.
The price is Moonshot's list price. Moonshot's own platform lists K3 at $3.00 per 1M input tokens on a cache miss, $0.30 on a cache hit, and $15.00 per 1M output tokens. LLM Gateway passes provider rates through with no markup, so the global rate matches. Cache writes differ: Moonshot lists $3.00 per 1M, while the Gateway lists $3.75 for its default provider.
Global vs in-region. The listed prices are for global routing, which you turn on by sending "model_region": "global". Requests without it stay in the US region and carry the 10% regional surcharge. If you have no data residency requirement, global routing is the lower-priced path.
There's no temperature. It isn't in the supported parameters for kimi-k3, which lines up with Moonshot fixing it. Leave it out.
Context window. The Gateway lists 1,000,000 tokens. Moonshot's pricing page lists 1,048,576. Plan around the Gateway number if you're calling through the Gateway.
One API key covers Kimi K3, the rest of the 60-model catalog and speech-to-text. Pay provider rates with no markup and switch models by changing one string.
Kimi K3 API quickstart
LLM Gateway is OpenAI-compatible, so the official OpenAI SDKs work as-is. Point the client at https://llm-gateway.assemblyai.com/v1, pass your AssemblyAI API key, and set model to kimi-k3.
Python
pip install openai
export ASSEMBLYAI_API_KEY=your_keyimport os
from openai import OpenAI
client = OpenAI(
base_url="https://llm-gateway.assemblyai.com/v1",
api_key=os.environ["ASSEMBLYAI_API_KEY"],
)
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{"role": "user", "content": "In two sentences, explain what a context window is."}
],
max_tokens=4000,
)
print(response.choices[0].message.content)
print(response.usage)JavaScript
npm install openaiimport OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://llm-gateway.assemblyai.com/v1",
apiKey: process.env.ASSEMBLYAI_API_KEY,
});
const response = await client.chat.completions.create({
model: "kimi-k3",
messages: [
{ role: "user", content: "In two sentences, explain what a context window is." },
],
max_tokens: 4000,
});
console.log(response.choices[0].message.content);
console.log(response.usage);curl
curl -s https://llm-gateway.assemblyai.com/v1/chat/completions \
-H "Authorization: $ASSEMBLYAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k3",
"messages": [
{"role": "user", "content": "In two sentences, explain what a context window is."}
],
"max_tokens": 4000
}'Why max_tokens: 4000? Kimi K3 reasons before it answers, so give it headroom. But don't set it far higher than you need. The Gateway's rate limits reserve your prompt tokens plus max_tokens against your tokens-per-minute allowance while a request runs, and if you leave max_tokens out, 8,000 output tokens are reserved.
Summarize a call transcript with Kimi K3
Most teams calling an LLM through AssemblyAI are running it on transcripts. This example summarizes a support call and adds two production settings: a fallback model, and global routing.
import os
import sys
from openai import OpenAI
client = OpenAI(
base_url="https://llm-gateway.assemblyai.com/v1",
api_key=os.environ["ASSEMBLYAI_API_KEY"],
)
SYSTEM_PROMPT = (
"You summarize customer calls. Return three sections: Summary (3 sentences), "
"Action items (bullets with an owner), and Open questions (bullets). "
"Use only facts stated in the transcript."
)
def summarize(transcript: str) -> str:
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": transcript},
],
max_tokens=4000,
extra_body={
# Retry on another model if Kimi K3 fails.
"fallbacks": [{"model": "claude-sonnet-5-5"}],
# Route to the provider's global endpoint at global pricing.
# Remove this line to keep processing in the US region.
"model_region": "global",
},
)
return response.choices[0].message.content
if __name__ == "__main__":
with open(sys.argv[1], encoding="utf-8") as f:
print(summarize(f.read()))fallbacks and model_region aren't part of the OpenAI schema, so the Python SDK sends them through extra_body. If Kimi K3 errors, the Gateway retries the request on the fallback model and you're billed only for the model that answered. In JavaScript, put the same two fields straight into the request object.
Kimi K3 also accepts tools, tool_choice and response_format, so you can ask for JSON that matches a schema. If structured extraction is your main job, compare it against the models in our guide to the best LLM for extracting structured data first.
The full code, including the JavaScript and curl versions and a sample transcript, is in the companion repo.
Run a summary or extraction prompt against your own calls in the Playground, then compare Kimi K3 with other models before you write a line of code.
How Kimi K3 scores on voice tasks
General leaderboards test coding and reasoning. If your input is a transcript, the more useful question is how a model handles summaries, extraction and clean-up on real calls. AssemblyAI's Voice Standard Bench measures exactly that for every model on the Gateway, on call transcripts of 30 seconds, 2 minutes, 15 minutes and 1 hour. LLM judges score summaries, extraction and clean-up from 1 to 100 against the source transcript, and dictation is scored against an answer key.
Here are Kimi K3's results as of the October 29, 2026 benchmark run, at its default reasoning effort. Fifty-eight models were scored in that run.
| Transcript length | All tasks (top score) | Summaries | Extraction | Clean-up | Dictation | Median latency | Cost per audio hour |
|---|---|---|---|---|---|---|---|
| 30 seconds | 94 (96) | 99 | 88 | 91 | 99 | 13.7 s | $0.25 |
| 2 minutes | 91 (94) | 96 | 88 | 86 | 96 | 32.1 s | $0.31 |
| 15 minutes | 86 (89) | 91 | 84 | 85 | Not measured | 115.1 s | $0.31 |
| 1 hour | 70 (88) | 91 | 83 | 38 | Not measured | 140.2 s | $0.24 |
What the numbers say:
Summaries are its strength. On 30-second audio Kimi K3 scored 99 on summaries, one point behind the top model. On 1-hour meetings it still scored 91, with four models ahead of it. If you're picking a model for call or meeting summaries, it belongs on your shortlist; our post on the best LLM for summarizing transcripts compares the rest of the field.
Extraction is solid on long audio. At 15 minutes and 1 hour, only two and three models respectively scored higher on extracting action items, decisions, participants and entities.
Up to 15 minutes, it's near the top overall. On 30-second, 2-minute and 15-minute transcripts, its all-tasks score sits within 3 points of the best model. The choose-a-model docs treat that gap as about as close as the benchmark can tell models apart.
Clean-up on long transcripts is a weak spot. On 1-hour transcripts its clean-up score drops to 38, against a top score of 88, and 46 models scored higher. That pulls its 1-hour all-tasks score down to 70. For long-form transcript correction, pick a different model.
It's slow. Median latency was 13.7 seconds on a 30-second transcript and 140 seconds on an hour-long one. The fastest models within 3 points of the top score answered in 0.9 to 1.3 seconds at 30 seconds and in about 12 seconds at 1 hour, and the always-on thinking mode accounts for most of the gap. Kimi K3 fits batch jobs that run after a call ends; a live voice agent turn needs a model that answers in about a second.
It isn't the low-cost option for transcript tasks. At $0.24 to $0.31 per audio hour, several near-top models cost a fraction of that on the same tasks.
Treat these results as a list of models to try first. The live Voice Standard Bench chart always shows the latest run, the choose-a-model docs explain how to read it, and the open-source repo has the prompts, rubrics and harness to rerun it on your own transcripts.
Kimi K3 API: Moonshot direct vs LLM Gateway
Both routes give you kimi-k3 over an OpenAI-compatible API. They differ on what surrounds the model.
| Moonshot (platform.kimi.ai) | AssemblyAI LLM Gateway | |
|---|---|---|
| Base URL | https://api.moonshot.ai/v1 | https://llm-gateway.assemblyai.com/v1 |
| Input / output per 1M tokens | $3.00 / $15.00 | $3.00 / $15.00 global; +10% in-region |
| Cached input (hit / write) | $0.30 / $3.00 | $0.30 / $3.75 |
| Context window | 1,048,576 tokens | 1,000,000 tokens |
| Models on one key | Kimi models | 60 models plus speech-to-text |
| Getting started | Top-up of at least $1 | Existing AssemblyAI key |
Go direct if Kimi is the only model you need, you need a Moonshot-only variant, or you want the slightly larger context window. Go through the Gateway if you already transcribe with AssemblyAI, want a fallback when a model fails, or plan to compare Kimi K3 against Claude, GPT, Gemini and open models without managing more keys. Our comparison of LLM gateways covers the other gateway options, and what an LLM gateway does explains the basics.
Data retention and providers
On LLM Gateway, kimi-k3 runs on two providers. AWS Bedrock is the default and is on for every account. Fireworks AI also serves the model and is opt-in, so you turn it on under Data Controls in your dashboard before requests can route there.
The providers page lists both AWS Bedrock and Fireworks AI with zero data retention, and states that no LLM Gateway provider trains on your data. If you need EU data residency, Kimi K3 isn't an option today: the EU endpoint serves Claude and Gemini models only.
Should you use the Kimi K3 API?
Use Kimi K3 when output quality on summaries and extraction matters more than speed, and the work runs after the conversation ends: post-call summaries, meeting notes, CRM updates, compliance review on long recordings. Its scores on those tasks sit with the top of the field up to 15 minutes of audio, and its summaries hold up on hour-long meetings.
Skip it for live voice agent turns, where a 14-second median would stall the conversation, and for cleaning up hour-long transcripts, where it scored 38. If cost per audio hour is the deciding factor, check the near-top models in the benchmark chart first.
Whichever model you pick, the benchmark is where to start, and your own data is where to decide. Swap kimi-k3 for two or three other model IDs from the catalog, run the same prompt on a handful of your real transcripts, and keep the one that wins.
Start with Kimi K3 or the benchmark's top pick, then prove it on your own transcripts. One AssemblyAI key covers the LLM and the speech-to-text.
Frequently Asked Questions (FAQs)
Where can I access the Kimi K3 API?
You can call Kimi K3 directly on Moonshot AI's platform or through OpenAI-compatible gateways. On AssemblyAI's LLM Gateway, the model ID is kimi-k3 and the base URL is https://llm-gateway.assemblyai.com/v1, so the OpenAI Python and JavaScript SDKs work with an AssemblyAI API key.
What does the Kimi K3 API cost?
On LLM Gateway, Kimi K3 costs $3.00 per 1M input tokens and $15.00 per 1M output tokens with global routing, with cached input reads at $0.30 per 1M. Requests processed in the US region carry a 10% regional surcharge. Moonshot lists the same $3.00 and $15.00 rates on its own platform.
What is the Kimi K3 context window?
LLM Gateway lists a 1,000,000-token context window for kimi-k3. Moonshot lists 1,048,576 tokens on its own platform. Either way, a transcript of several hours fits in one request.
Which providers offer Kimi K3 with zero data retention?
On AssemblyAI's LLM Gateway, Kimi K3 runs on AWS Bedrock by default and on Fireworks AI as an opt-in provider. The Gateway's providers page lists both with zero data retention, and no Gateway provider trains on customer data.
Is the Kimi API free to use?
No. Kimi K3 is billed per token on every platform that serves it. Moonshot requires a top-up of at least $1 before you can call it, and LLM Gateway bills Kimi K3 tokens to your AssemblyAI account at the rates above.
Is Kimi K3 open source?
Moonshot says it has released Kimi K3's full model weights and describes it as an open 3T-class model with 2.8 trillion parameters. Running it yourself takes serious GPU capacity, which is why most teams call it through a hosted API.