Kimi K3

Moonshot AI — Kimi K3

Model Details

Kimi K3 is Moonshot AI's most capable open-weight model, combining native vision with a 1-million-token context window for long-running coding and knowledge workflows that sustain context across large repositories, documents, and images. For more information about model development and performance, see the model/service card.

• Model launch date: 18th Sept 2026

• EOL no sooner than: Not Applicable, at least 45 day EOL Notice will be provided

• Legacy period: at least 45 days

• Model lifecycle policy: Bedrock Model Lifecycle

• Model EOL date: N/A

• End User License Agreements and Terms of Use: View

• Model lifecycle: Active

• Context window: 1M tokens

Input Modalities	Output Modalities	APIs supported	Endpoints supported
Audio	Embedding	Responses	bedrock-runtime
Image	Image	Chat Completions	bedrock-mantle
Speech	Speech	Converse
Text	Text	Invoke
Video	Video

Tip

Whenever possible, we recommend using the bedrock-runtime endpoint for new applications. For Kimi K3, we recommend using the Chat Completions API. See Endpoints supported by Amazon Bedrock for details.

Capabilities and Features

Bedrock Features

Features supported using bedrock-runtime endpoint

Supported	Not Supported
Response streaming Implicit Prompt Caching Explicit Prompt Caching (Responses and Chat Completions APIs only) Client-side tool calling Structured outputs Invocation logs	Intelligent prompt routing Knowledge base

Explicit prompt caching using bedrock-runtime endpoint

For more information, see Prompt caching for faster model inference.

Explicit Prompt Caching supported	Min tokens per cache checkpoint	Cache retention (TTL)
Yes	1,024	At least 30 minutes

Note

By default, Kimi K3 supports implicit (automatic) prompt caching. Configuring explicit cache controls can improve your cache hit rate, and therefore reduce latency and cost, so we recommend using explicit prompt caching. Currently, only the Responses and Chat Completions APIs support explicit prompt caching. See the prompt caching guide for more details.

Pricing

Inference option	Input	Output	Cache read	Cache write (30 min)
Global CRIS	$3.00	$15.00	$0.30	$3.75
US CRIS	$3.30	$16.50	$0.33	$4.125

All prices are per 1 million tokens. Pricing shown is for the Standard tier.

Priority and Flex tier support: In addition to Standard, Kimi K3 supports the Priority and Flex service tiers. Priority is billed at 1.75x the Standard per-token rate (a 75% premium) and Flex at 0.5x the Standard rate (a 50% discount); apply these multipliers to whichever Standard base rate (Global or US CRIS) applies to your request. For details on each service tier, see service tiers.

Programmatic Access

Use the following model ID and endpoint URL to access this model programmatically. Kimi K3 is available through US Geo and Global cross-Region inference. For more information about the available APIs and endpoints, see APIs supported and Endpoints supported.

Endpoint	Model ID	In-Region endpoint URL	Geo inference ID	Global inference ID
bedrock-runtime	moonshotai.kimi-k3	https://bedrock-runtime.{region}.amazonaws.com	us.moonshotai.kimi-k3	global.moonshotai.kimi-k3

For example, if region is us-east-1 (N. Virginia), then the bedrock-runtime endpoint URL will be "https://bedrock-runtime.us-east-1.amazonaws.com".

Service Tiers

Amazon Bedrock offers multiple service tiers to match your workload requirements. Standard provides pay-per-token access with no commitment (set "service_tier": "default" or omit the field). Priority delivers the fastest response times for a price premium (set "service_tier": "priority"). Flex provides lower-cost access for flexible, non-time-sensitive workloads (set "service_tier": "flex"). For more information, see service tiers.

Standard	Priority	Flex	Reserved

Note

Currently, only the Responses and Chat Completions APIs support service tiers. The Converse and Invoke APIs do not support service tiers and support only Standard on-demand inference.

Regional Availability

Regional availability at a glance

Amazon Bedrock offers three inference options: In-Region keeps requests within a single Region for strict compliance, Geo Cross-Region routes across Regions within a geography (such as US, EU, and APAC) while respecting data residency, and Global Cross-Region routes anywhere worldwide when there are no residency constraints. Refer to the Regional availability by models page for more details.

Kimi K3 is available through US Geo cross-Region inference (using the us.moonshotai.kimi-k3 profile, which routes requests only among US-geography Regions to respect US data residency) and Global cross-Region inference (using the global.moonshotai.kimi-k3 profile, which routes to any supported commercial AWS Region worldwide). You choose the AWS Region you send requests to, and Amazon Bedrock routes each request accordingly.

Availability using the bedrock-runtime endpoint

Region	In-Region	Geo	Global
us-east-1 (N. Virginia)
us-east-2 (Ohio)
us-west-1 (N. California)
us-west-2 (Oregon)
ca-central-1 (Canada)
ca-west-1 (Calgary)
eu-central-1 (Frankfurt)
eu-central-2 (Zurich)
eu-north-1 (Stockholm)
eu-south-1 (Milan)
eu-south-2 (Spain)
eu-west-1 (Ireland)
eu-west-2 (London)
eu-west-3 (Paris)
ap-east-2 (Taipei)
ap-northeast-1 (Tokyo)
ap-northeast-2 (Seoul)
ap-northeast-3 (Osaka)
ap-south-1 (Mumbai)
ap-south-2 (Hyderabad)
ap-southeast-1 (Singapore)
ap-southeast-2 (Sydney)
ap-southeast-3 (Jakarta)
ap-southeast-4 (Melbourne)
ap-southeast-5 (Malaysia)
ap-southeast-6 (New Zealand)
ap-southeast-7 (Thailand)
il-central-1 (Tel Aviv)
me-central-1 (UAE)
me-south-1 (Bahrain)
af-south-1 (Cape Town)
sa-east-1 (São Paulo)

Quotas and Limits

Your AWS account has default quotas to maintain the performance of the service and to ensure appropriate usage of Amazon Bedrock. The default quotas assigned to an account might be updated depending on regional factors, payment history, fraudulent usage, and/or approval of a quota increase request. See your default quotas in Service Quotas and request limit increases as necessary.

Usage Considerations and Limitations

• Prefer the OpenAI-compatible APIs over Converse — Although Kimi K3 can be called through the Converse and ConverseStream APIs, we recommend using the OpenAI-compatible Responses or Chat Completions APIs where possible. Converse has known limitations with this model, including a failure (InternalServerException) when reasoning content from earlier turns is included in a multi-turn request, which affects frameworks such as LangChain and Strands Agents in their default configurations, and rejection of attached document inputs such as PDF and HTML. To use Converse for multi-turn requests, remove reasoning blocks from prior turns.

• Video inputs are not supported — Amazon Bedrock does not support attaching video inputs to Kimi K3 requests.

• Place images before text for combined inputs — For requests that combine text and images, Kimi K3 can produce higher-quality answers when image content blocks are placed before text content blocks. This behavior is prompt-dependent, so test both orderings for your own workload.

• Image detail parameter — The detail parameter that controls image input fidelity (low for lower cost or high for higher-fidelity understanding) is honored only on the Chat Completions API. On the Responses API, images are always processed at high detail.

Sample Code

Step 1 - AWS Account: If you have an AWS account already, skip this step. If you are new to AWS, sign up for an AWS account.

Step 2 - API key: Go to the Amazon Bedrock console and generate a long-term API key.

Step 3 - Get the SDK: To use this getting started guide, you must have Python already installed. Then install the relevant software depending on the APIs you are using.

Responses / Chat Completions API

pip install -U openai aws-bedrock-token-generator

Invoke/Converse API

pip install boto3

Step 4 - Run your first inference request: Save the file as bedrock-first-request.py

Responses API

from aws_bedrock_token_generator import provide_token
from openai import OpenAI

region = "us-west-2"
client = OpenAI(
    api_key=provide_token(region=region),
    base_url=f"https://bedrock-runtime.{region}.amazonaws.com/openai/v1",
)

resp = client.responses.create(
    input="Can you explain the features of Amazon Bedrock?",
    model="global.moonshotai.kimi-k3",
)
print(resp.output_text)

Converse API

import boto3

client = boto3.client('bedrock-runtime', region_name='us-west-2')
response = client.converse(
    modelId='global.moonshotai.kimi-k3',
    messages=[
        {
            'role': 'user',
            'content': [{'text': 'Can you explain the features of Amazon Bedrock?'}]
        }
    ]
)
print(response)

Invoke API

import json
import boto3

client = boto3.client('bedrock-runtime', region_name='us-west-2')
response = client.invoke_model(
    modelId='global.moonshotai.kimi-k3',
    body=json.dumps({
            'messages': [{ 'role': 'user', 'content': 'Can you explain the features of Amazon Bedrock?'}],
            'max_tokens': 1024
    })
)
print(json.loads(response['body'].read()))