DEV Community: Vanessa Massey

How to Get a Kimi API Key and Start Building in 5 Minutes (2026)

Vanessa Massey — Tue, 28 Jul 2026 04:07:02 +0000

Quick Answer

Getting a Kimi K3 API key takes under 5 minutes: (1) sign up at platform.moonshot.ai, (2) create an API key from the console, (3) install the OpenAI SDK, (4) point the base URL to https://api.moonshot.ai/v1 with model ID kimi-k3. Your first API call costs about $0.007. For production use, route through TeamoRouter to get automatic failover and multi-provider stability without changing your code.

Step 1: Get Your API Key (2 Minutes)

1.1 Sign Up for a Moonshot Account

Go to the Moonshot developer platform:

International users: platform.moonshot.ai
China-based users: platform.moonshot.cn

Click Sign Up and create an account. You can use email or phone number registration. If you already have a Kimi (kimi.com) account, you can use the same credentials — the developer platform uses the same identity system.

1.2 Navigate to API Keys

Once logged in, you will see the developer console dashboard. In the left sidebar, click API Keys (or the key icon). This page shows all your existing keys and lets you create new ones.

1.3 Create a New Key

Click the Create or New API Key button. Give your key a descriptive name (e.g., "my-dev-machine" or "production-backend") so you can identify it later. Click confirm.

Important: Your API key will be displayed exactly once. It starts with sk- followed by a long string of characters. Copy it immediately and store it somewhere secure — a password manager, an environment variable file, or your secrets manager. Once you navigate away from the page, the full key will not be shown again. If you lose it, you will need to create a new one.

1.4 Add Funds to Your Account

Before you can make API calls, you need a balance. Go to the Billing or Balance section of the console and add funds. A few dollars is enough to start — at $0.007 per typical call, $5 gives you roughly 700 API calls. Moonshot supports credit card and Alipay/WeChat Pay (for China-based accounts).

Step 2: Install the SDK (30 Seconds)

Kimi K3 uses the standard OpenAI SDK. No special library or wrapper is needed.

Python

python -m pip install --upgrade "openai>=1.0"

Requires Python 3.9 or later.

Node.js

npm install openai

Or with your package manager of choice:

yarn add openai
pnpm add openai
bun add openai

Step 3: Set Your Environment Variable (30 Seconds)

Store your API key as an environment variable. This keeps it out of your source code.

macOS / Linux

Add this to your ~/.zshrc or ~/.bashrc:

export MOONSHOT_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

Then reload:

source ~/.zshrc

Windows (PowerShell)

[System.Environment]::SetEnvironmentVariable('MOONSHOT_API_KEY', 'sk-xxx', 'User')

Temporary (Current Terminal Only)

export MOONSHOT_API_KEY="sk-xxx"

Using a .env File (Recommended for Projects)

Create a .env file in your project root:

MOONSHOT_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Then load it in Python:

from dotenv import load_dotenv
load_dotenv()

Or in Node.js with the dotenv package:

npm install dotenv

import "dotenv/config";

Never commit your .env file to git. Add .env to your .gitignore.

Step 4: Make Your First API Call (2 Minutes)

Python Example

Create a file called first_call.py:

import os
from openai import OpenAI

# Initialize the client with Kimi's endpoint
client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

# Make your first API call
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain what Moonshot AI's Kimi K3 model is in two sentences."},
    ],
    max_completion_tokens=200,
)

print(completion.choices[0].message.content)

Run it:

python first_call.py

You should see a response from K3 in under 10 seconds.

Node.js Example

Create first_call.mjs:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const completion = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Explain what Moonshot AI's Kimi K3 model is in two sentences." },
  ],
  max_completion_tokens: 200,
});

console.log(completion.choices[0].message.content);

Run it:

node first_call.mjs

Streaming Example (Real-Time Output)

For a typewriter-style experience, add streaming:

Python:

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Write a short poem about programming."}],
    stream=True,
)

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

Node.js:

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [{ role: "user", content: "Write a short poem about programming." }],
  stream: true,
});

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

Step 5: Migrate Existing OpenAI Code (Bonus — 30 Seconds)

Already have code that uses the OpenAI SDK? Switching to Kimi K3 requires exactly three changes:

# === Before (OpenAI) ===
from openai import OpenAI
client = OpenAI(api_key="sk-openai-xxx")
model = "gpt-4o"

# === After (Kimi K3) ===
from openai import OpenAI
client = OpenAI(
    api_key="sk-moonshot-xxx",                     # Change 1: Moonshot key
    base_url="https://api.moonshot.ai/v1",          # Change 2: Moonshot endpoint
)
model = "kimi-k3"                                   # Change 3: Model ID

That is literally it. The request and response formats are identical to OpenAI's — K3 is a drop-in replacement at the SDK level. All your existing prompt engineering, message formatting, and response parsing code works without modification.

What to Remove

K3 has several parameters locked at launch. Remove these from your API calls:

temperature — K3 ignores or rejects this.
top_p — Same.
frequency_penalty and presence_penalty — Remove them.
reasoning_effort — Only "max" is available; remove the parameter unless you are explicitly setting it to "max".

If your existing code sets any of these, either comment them out or wrap them in a conditional based on the model being used.

Common Issues and How to Fix Them

"The api_key client option must be set"

You forgot to set the MOONSHOT_API_KEY environment variable, or you are not loading it correctly. Check with:

echo $MOONSHOT_API_KEY

If nothing prints, the variable is not set. Re-run your export command or check your .env file.

"Invalid API key" or 401 Unauthorized

Possible causes:

Your API key is misspelled or truncated. Keys are long — copy-paste carefully.
You created the key but did not add funds. Go to the billing page and add a balance.
You are using the wrong endpoint. International users should use https://api.moonshot.ai/v1, China-based users should use https://api.moonshot.cn/v1.

"Model not found" or 404

Check your model ID. It must be exactly kimi-k3 — lowercase, with a hyphen, no spaces. Common mistakes: kimi_k3 (underscore), kimik3 (no hyphen), Kimi-K3 (mixed case).

429 Too Many Requests

You are being rate limited. Options:

Add exponential backoff to your retry logic.
Reduce the number of concurrent requests.
For production workloads, route through an API gateway like TeamoRouter that distributes traffic across multiple provider endpoints, effectively multiplying your rate limit capacity.

Slow Responses

K3's standard tier generates ~33-35 tokens per second. A 500-token response takes about 15 seconds. This is normal. To improve the experience:

Always use streaming so output appears incrementally rather than all at once after the full generation.
Consider the Kimi K3 Fast tier (~117 t/s) if latency is critical.

Vision/Image Uploads Failing

At launch, K3's API does not support public image URLs. You must pass images as base64-encoded strings or use file uploads. Do not use image_url with a remote URL — it will fail.

Beyond the Quickstart: Production Best Practices

1. Do Not Hardcode API Keys

Environment variables are the minimum. For production, use a secrets manager:

# AWS Secrets Manager
import boto3, json
secret = json.loads(boto3.client("secretsmanager").get_secret_value(SecretId="moonshot-api-key")["SecretString"])
api_key = secret["MOONSHOT_API_KEY"]

// Google Cloud Secret Manager
const { SecretManagerServiceClient } = require("@google-cloud/secret-manager");
const client = new SecretManagerServiceClient();
const [version] = await client.accessSecretVersion({ name: "projects/my-project/secrets/moonshot-api-key/versions/latest" });
const apiKey = version.payload.data.toString();

2. Use a Stable API Gateway for Production

Calling Moonshot's API directly works for development. For production applications that need reliability, a single-provider dependency is risky. Moonshot paused new subscriptions within 48 hours of K3's launch because demand exceeded GPU capacity — a direct API dependency would have meant downtime for your application.

TeamoRouter provides a stable API gateway layer:

Your App → TeamoRouter (single endpoint) → Kimi K3 (primary)
                                          → Kimi K3 (backup provider #1)
                                          → Kimi K3 (backup provider #2)
                                          → Fallback model (if all K3 providers down)

Your code never changes — you swap base_url from api.moonshot.ai to TeamoRouter's endpoint, and TeamoRouter handles provider selection, health monitoring, and automatic failover. For teams building on K3, this is the difference between hoping the API stays up and knowing your application will keep running.

3. Implement Retry Logic

Even with a gateway, transient failures happen. Add robust retry logic:

import time
from openai import OpenAI, APIError

def call_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(**kwargs)
        except APIError as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # Exponential backoff: 1s, 2s, 4s
            print(f"API error, retrying in {wait}s... ({e})")
            time.sleep(wait)

4. Monitor Your Usage

Moonshot's console shows basic usage stats. For production monitoring, track:

Tokens per request (input and output separately).
Cache hit rate (higher is cheaper — aim for >80%).
Error rate and latency per endpoint.
Cost per task (total cost divided by number of completed user tasks).

5. Design for Caching

K3's context caching gives a 90% discount on cached input tokens. Structure your prompts so the cache works for you:

Put static content (system prompts, tool definitions, project rules) at the beginning of the message sequence.
Keep system prompts identical across requests. Avoid dynamic elements like timestamps or request IDs in the prefix.
Send related requests close together in time. The cache has a limited TTL.

Quick Reference: Endpoints and Model IDs

International API:  https://api.moonshot.ai/v1
China API:          https://api.moonshot.cn/v1
Model ID (API):     kimi-k3
Model ID (Kimi Code): k3
API Key Page:       platform.moonshot.ai → API Keys
Billing Page:       platform.moonshot.ai → Billing
SDK:                openai (Python pip install openai)
                    openai (Node.js npm install openai)

Next Steps

Now that you have your API key and your first call working:

Explore K3's capabilities. Try different prompt styles, system messages, and task types to understand where K3 excels and where it struggles. If you work with Go or frontend development, you are in K3's sweet spot.
Set up for production. Route your API traffic through TeamoRouter for automatic failover, load balancing, and multi-provider resilience. Your base_url changes once — everything else stays the same, and you get production-grade reliability without building it yourself.
Read the full pricing and setup guide. For a deeper dive into rate limits, caching strategies, and cost optimization, see our Kimi K3 API guide.
Compare plans. If you are considering a Kimi subscription instead of (or in addition to) API access, read our Kimi K3 coding plan comparison.

Kimi K3 is the most exciting open-source model for developers in 2026. Five minutes to your first API call is all it takes to start building with it.

Kimi K3 vs DeepSeek V4 Pro vs Qwen 3.8: Which Open-Weight Model Should Developers Choose in 2026?

Vanessa Massey — Mon, 27 Jul 2026 06:49:36 +0000

Kimi K3 vs DeepSeek V4 Pro vs Qwen 3.8: Which Open-Weight Model Should Developers Choose in 2026?

The open-weight AI landscape has never been more competitive. Three Chinese-born models — Kimi K3, DeepSeek V4 Pro, and Qwen 3.8 — are reshaping how English-speaking developers think about self-hosted LLMs. Each occupies a distinct niche, and picking the right one for your stack isn't just about benchmark scores. It's about cost, hardware, ecosystem maturity, and the actual quality of the code and text these models generate.

This article gives you an honest, developer-focused comparison. No hype. No vendor spin. Just the numbers, the gotchas, and the decision framework you need.

The Three Contenders at a Glance

	Kimi K3	DeepSeek V4 Pro	Qwen 3.8
Developer	Moonshot AI (Beijing)	DeepSeek (Hangzhou)	Alibaba Cloud (Hangzhou)
Release Date	Q2 2026	Q1 2026	Q2 2026
Architecture	Dense MoE hybrid	Mixture of Experts (MoE)	Dense Transformer
Total Parameters	~400B (est.)	685B	70B
Active Parameters	~40B (est.)	37B	70B (dense, always active)
Context Window	1M tokens	128K tokens	128K tokens (256K via YaRN)
License	Kimi Community License	MIT	Apache 2.0
GitHub Stars	8.2K	74K	32K

Benchmark Comparison

Scores pulled from public leaderboards as of July 2026. Numbers are best-reported for each model in their standard chat configuration. Take cross-leaderboard comparisons with a grain of salt — methodology matters — but the pattern is consistent enough to draw conclusions.

Benchmark	Kimi K3	DeepSeek V4 Pro	Qwen 3.8	Notes
MMLU-Pro	85.2	82.1	78.4	Multi-discipline knowledge
HumanEval (Python)	91.5	89.0	85.3	Code generation
MBPP (Multi-lingual)	88.7	86.2	82.1	Code generation across languages
GSM8K	95.3	93.1	90.2	Grade-school math reasoning
MATH-500	92.8	90.5	86.7	Competition-level math
GPQA Diamond	67.1	63.4	58.9	Graduate-level Q&A
Arena Elo (Chatbot Arena)	1302	1276	1231	Human preference
SWE-bench Verified	54.3%	49.8%	41.2%	Real GitHub issue resolution

Kimi K3 leads convincingly across knowledge, math, and code benchmarks. The margins are real but not dramatic — typically 2-5 points over DeepSeek V4 Pro, and 6-10 points over Qwen 3.8.

But benchmarks don't write production code. Real-world developer experience often differs from leaderboard scores. Let's dig into what matters day-to-day.

API Pricing: The Real Cost of Intelligence

All three models are available through managed API services. Here's current pricing (July 2026):

Model	Input (per 1M tokens)	Output (per 1M tokens)	Cached Input	Notes
Kimi K3	$3.00	$15.00	$0.60	Premium tier
DeepSeek V4 Pro	$0.04/task (flat)	—	—	Task-based billing
Qwen 3.8	$0.50	$2.00	$0.10	Lowest per-token cost

DeepSeek's $0.04/task pricing is unusual. A "task" is typically a single completion request with a token budget around 8K. For heavy usage, this flat-rate model can be significantly cheaper than per-token billing — but it also caps how much thinking the model can do per request. If you need K3's 1M context and deep chain-of-thought reasoning, the flat-rate model won't work.

K3 at $3/$15 per million tokens is positioned squarely against GPT-4-level pricing. It's the "premium open-weight" play — frontier intelligence you can self-host, at frontier prices. For teams that need the absolute best quality and are willing to pay for it, K3 earns its price tag. For cost-sensitive workloads, it's hard to justify against DeepSeek.

Qwen 3.8 at $0.50/$2.00 is the budget champion for raw per-token cost, but remember: its 70B dense architecture means you need beefier hardware to self-host compared to DeepSeek's MoE design with only 37B active parameters.

Pricing Calculator

Here is a quick cost projection for a typical developer workload (50K input, 2K output per request, 1,000 requests/day):

Model	Daily Cost	Monthly Cost	Annual Cost
Kimi K3	$30/day (input) + $30/day (output) = $60/day	~$1,800	~$21,600
DeepSeek V4 Pro	$40/day (1,000 tasks x $0.04)	~$1,200	~$14,400
Qwen 3.8	$25/day (input) + $4/day (output) = $29/day	~$870	~$10,440

For high-throughput, moderate-quality workloads, the savings from DeepSeek or Qwen add up fast. For low-volume, high-stakes tasks (code review, architecture decisions, security audits), K3's premium is easy to justify.

Coding Quality: Write Code Like a Senior Engineer

This is the category that matters most for developer tools. Across our testing (LeetCode hard, Django CRUD scaffolding, React component generation, bug-fix patches):

Kimi K3: Best for complex, multi-file code.
K3 excels at tasks that require reasoning across files, understanding project structure, and generating idiomatic code with proper error handling. It rarely hallucinates APIs, produces clean docstrings without being asked, and handles large refactors well. For complex code generation, K3 is the best of the three by a clear margin.

# K3 example: Generating a clean, idiomatic async FastAPI endpoint
import httpx
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel, Field

router = APIRouter(prefix="/models", tags=["models"])


class ModelCompareRequest(BaseModel):
    models: list[str] = Field(..., min_length=1, max_length=3)
    prompt: str = Field(..., min_length=1, max_length=8000)


async def _fetch_completion(client: httpx.AsyncClient, model: str, prompt: str) -> dict:
    resp = await client.post(
        f"https://api.teamorouter.com/v1/completions",
        json={"model": model, "messages": [{"role": "user", "content": prompt}]},
        timeout=60.0,
    )
    resp.raise_for_status()
    return resp.json()


@router.post("/compare")
async def compare_models(body: ModelCompareRequest):
    async with httpx.AsyncClient() as client:
        tasks = [_fetch_completion(client, m, body.prompt) for m in body.models]
        results = await asyncio.gather(*tasks, return_exceptions=True)
    return {
        m: {"ok": not isinstance(r, Exception), "data": r if not isinstance(r, Exception) else str(r)}
        for m, r in zip(body.models, results)
    }

DeepSeek V4 Pro: Reliable, predictable, slightly verbose.
DeepSeek produces solid, working code consistently. It is less creative than K3 — it won't surprise you with an elegant abstraction — but it also won't surprise you with a hallucinated library. For CRUD, API wiring, and routine engineering tasks, DeepSeek is the safest bet. Its verbosity means you'll occasionally trim generated output, but the code itself is sound.

Qwen 3.8: Efficient but needs guidance.
Qwen 3.8 generates correct code for well-defined problems but struggles with ambiguity. Where K3 might infer your intent from context, Qwen needs explicit instructions. For teams with strong prompt engineering practices, this is manageable. For junior developers or rapid prototyping, the extra guidance overhead adds up.

The 1M-Token Context Window: K3's Killer Feature

K3's 1-million-token context window is a genuine differentiator. Here is why it matters:

Drop your entire codebase in, ask questions. No chunking, no RAG setup, no context-window gymnastics. Just load the repo and query it.
Multi-file refactors across a large codebase. K3 can hold the entire context of a medium-sized project in working memory and produce coherent changes across dozens of files.
Long conversation threads. Support tickets, code reviews with extensive back-and-forth, documentation generation — anything where context accumulates.

DeepSeek and Qwen top out at 128K (Qwen extends to 256K via YaRN position encoding, but quality degrades at the far end). If your use case involves large-context reasoning, K3 has no competition in this trio.

Hardware Requirements for Self-Hosting

If you plan to run these models on your own infrastructure, hardware is the real cost driver.

	Kimi K3	DeepSeek V4 Pro	Qwen 3.8
Recommended GPU	8x H100 (80GB) / 4x H200	4x A100 (80GB) / 2x H100	4x A100 (80GB) / 2x H100
VRAM Minimum (FP16)	~320GB	~140GB (active params)	~140GB
VRAM (4-bit quantized)	~100GB	~45GB	~40GB
Throughput (tok/s, 8xH100)	~180 tok/s	~350 tok/s	~220 tok/s
Self-host Practicality	Enterprise only	Accessible to mid-size teams	Accessible to mid-size teams

DeepSeek V4 Pro wins on self-hosting economics. Its MoE architecture activates only 37B of 685B parameters per token, making it dramatically cheaper to serve than a dense model of equivalent capability. Four A100s running DeepSeek deliver throughput comparable to K3 on eight H100s — and at roughly half the GPU cost.

Qwen 3.8's 70B dense model is the easiest to quantize and run on consumer-ish hardware (2x RTX 4090 with GGUF Q4 quantization), but you lose significant quality at low bit depths.

K3 is not practical for self-hosting outside enterprise budgets. Its dense-MoE hybrid design delivers frontier quality at frontier hardware cost. If self-hosting is your primary deployment model, K3 only makes sense if you are already running a cluster of H100s or H200s.

Ecosystem and Developer Experience

SDK Compatibility

All three models expose OpenAI-compatible APIs, which means you can use the openai Python/JS SDK directly:

# Works for Kimi K3, DeepSeek V4 Pro, and Qwen 3.8
from openai import OpenAI

client = OpenAI(
    base_url="https://api.moonshot.cn/v1",  # or api.deepseek.com, dashscope.aliyuncs.com
    api_key="your-key",
)

response = client.chat.completions.create(
    model="kimi-k3",  # or "deepseek-v4-pro", "qwen3.8"
    messages=[{"role": "user", "content": "Explain monads in TypeScript."}],
)
print(response.choices[0].message.content)

Feature	Kimi K3	DeepSeek V4 Pro	Qwen 3.8
OpenAI SDK Compatible	Yes	Yes	Yes
Native SDK	Moonshot Python SDK	DeepSeek Python SDK	DashScope SDK
LangChain Integration	Community	Official + Community	Official + Community
LlamaIndex Integration	Community	Official	Official
OpenAI-compatible tool calls	Yes	Yes	Yes
Streaming	SSE only	SSE + chunked	SSE only
Function Calling	Full	Full	Partial (no parallel)
JSON Mode	Yes	Yes	Yes
Vision (image input)	Yes	No	Yes

English Documentation Quality

This is the Achilles' heel for Chinese-origin models targeting international developers.

Kimi K3: Documentation is Mandarin-first with partial English translations. The API reference is fully translated; guides and cookbooks are spotty. Moonshot's engineering blog is high-quality but infrequently updated in English.
DeepSeek V4 Pro: Best English documentation of the three. DeepSeek invested early in international developer relations. API docs are clear, cookbooks are available, and the community has produced extensive third-party guides. The GitHub repo's README is excellent.
Qwen 3.8: Alibaba's documentation is comprehensive but Chinese-first. The English docs exist but feel translated — awkward phrasing, inconsistent terminology. Qwen's Hugging Face model cards are well-maintained, which compensates somewhat.

Community and GitHub

DeepSeek (74K stars): The open-source darling. Active Discord, subreddit, and Twitter community. Extensive third-party blog posts, video tutorials, and deployment guides in English. If community support matters, DeepSeek is the clear winner.
Qwen (32K stars): Strong Chinese community; growing international adoption. Alibaba's corporate backing means regular releases and maintained model cards. The Qwen Chat web interface has attracted casual users.
Kimi K3 (8.2K stars): Newest release. Smaller community but growing fast. Moonshot's focus on frontier quality over broad adoption means fewer but more engaged community members.

The Decision Framework

Choose Kimi K3 when:

Quality is non-negotiable. You are building a product where model errors have real consequences — code review, security auditing, medical/legal document processing.
You need the 1M context window. If your use case involves whole-codebase reasoning, long documents, or extended conversations, K3 is in a class of its own.
You have the budget. At $3/$15 per million tokens, K3 costs more than DeepSeek or Qwen. For low-volume, high-value tasks, this is worth it.
You value frontier intelligence. Benchmarks consistently place K3 near GPT-4-class models. If you want the best open-weight model available, this is it.

Choose DeepSeek V4 Pro when:

Cost efficiency is critical. At $0.04/task, DeepSeek is the cheapest way to get near-frontier quality for high-throughput workloads.
You are self-hosting with a modest GPU budget. MoE design with 37B active parameters means it runs on 2-4 A100s.
You need reliable, predictable output. DeepSeek is the "boring but dependable" choice — it rarely hallucinates and produces consistent results.
English documentation and community matter. DeepSeek has the strongest international developer ecosystem of the three.

Choose Qwen 3.8 when:

You are on a tight per-token budget. At $0.50/$2.00 per million tokens, Qwen is the cheapest per-token option.
You need vision capabilities. Qwen 3.8 supports image input natively; DeepSeek V4 Pro does not.
You are building in the Alibaba Cloud ecosystem. DashScope integration, Alibaba Cloud deployment, and Chinese-language use cases benefit from Qwen's native platform.
You prefer Apache 2.0 licensing. Qwen's license is the most permissive of the three.

Using All Three Through One API

Manually juggling three different API endpoints, rate limits, billing dashboards, and SDK versions is a productivity tax. That is where TeamoRouter comes in.

TeamoRouter provides a single API endpoint for 500+ providers including Kimi K3, DeepSeek V4 Pro, Qwen 3.8, and global models like Claude and GPT. Its Agentic Routing feature automatically selects the optimal model per task based on your requirements — quality, cost, latency, or a balanced mix.

Here is how you can use all three models through one integration:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.teamorouter.com/v1",
    api_key="your-teamorouter-key",
)

# Agentic Routing picks the best model automatically
response = client.chat.completions.create(
    model="teamorouter/auto",  # Auto-select based on task
    messages=[
        {"role": "system", "content": "You are an expert code reviewer."},
        {"role": "user", "content": "Review this PR diff for security issues: ..."},
    ],
)
# TeamoRouter routes complex tasks to K3, routine work to DeepSeek

# Or pin a specific model
response = client.chat.completions.create(
    model="kimi/k3",           # For complex reasoning
    messages=[{"role": "user", "content": "Analyze this architecture decision: ..."}],
)

response = client.chat.completions.create(
    model="deepseek/v4-pro",   # For cost-sensitive batch processing
    messages=[{"role": "user", "content": "Generate 100 unit tests for: ..."}],
)

response = client.chat.completions.create(
    model="qwen/3.8",          # For image analysis with tight budget
    messages=[{"role": "user", "content": "Describe this diagram: ..."}],
)

Practical workflow: Test K3 on complex reasoning tasks where quality is paramount. Fall back to DeepSeek for cost-sensitive workloads like batch processing or routine completions. Use Qwen when vision capabilities or the tightest per-token budget is needed. With TeamoRouter, all three are accessed through the same API key, the same SDK, and the same billing — no integration overhead.

Conclusion

The 2026 open-weight model landscape gives developers real choice — not just between models, but between different philosophies of how AI should be built, priced, and deployed.

Kimi K3 is the premium option: frontier quality, massive context, enterprise-grade hardware requirements. If you can afford it and need the best, this is your model.

DeepSeek V4 Pro is the pragmatic workhorse: excellent quality at dramatically lower cost, the most mature English-language ecosystem, and the easiest path to self-hosting thanks to its efficient MoE architecture.

Qwen 3.8 is the accessible specialist: vision support, Apache 2.0 licensing, and Alibaba-scale infrastructure, with the lowest per-token API pricing.

The smartest approach? Use all three. Route complex, high-stakes tasks to K3; batch and cost-sensitive work to DeepSeek; vision and budget tasks to Qwen. One API, one key, no trade-offs.

Want to try K3, DeepSeek V4 Pro, and Qwen 3.8 through a single API? Get started with TeamoRouter — 500+ providers, competitive pricing, one integration.