DEV Community: Gaige

DeepSeek V4 Pro Free: The Ultimate Guide to the 200 Requests/Day Quota

Gaige — Mon, 17 Aug 2026 02:18:43 +0000

What DeepSeek V4 Pro's free tier actually is, how request-based (not token-based) billing works, what one request means inside an agent loop, and what 200 covers.

"200 requests a day" sounds small until you realize it's counted by request, not token — and that one difference changes how far the free tier actually goes for agent work.

What is DeepSeek V4 Pro?

DeepSeek V4 Pro is DeepSeek's flagship reasoning model — up to 1M tokens of context, multiple reasoning-effort levels, aimed at hard multi-file work and long agent loops. Its fast sibling, DeepSeek V4 Flash, handles cheap high-frequency tasks.

TeamoRouter exposes both, and each has a free tier: deepseek-v4-pro-free and deepseek-v4-flash-free, 200 requests per account per day, reset daily, no payment info required.

Requests vs tokens — the critical distinction

Most APIs bill by token (input + output). The free tier bills by request:

Billing unit	How it's counted	Trait
Token	Input + output tokens	Longer output = more expensive
Request	One full turn	Independent of output length

Here's the payoff: a call that reads 100K tokens of context and outputs a 5,000-token diff counts as 1 request — the same as a one-word "hello." For agent work, where a single turn packs in a huge context and produces a long output, that's dramatically more generous than a token budget.

What one "request" means inside an agent

In plain chat, one request = one Q&A. Inside an agent, the model calls tools, and every tool round-trip is its own request:

Model: "read src/reporting.py"         ← request 1
Tool:  returns file contents
Model: "edit line 45, dedupe branches" ← request 2
Tool:  write done
Model: "run tests"                     ← request 3

So 200 requests really means 200 rounds of model decision-making — not 200 tokens.

What 200 actually covers

Read a file + explain a function → 1–3
Single-file edit → 3–5 (a dozen+ per day)
Multi-file refactor → 10–15
Long agent loop (build + self-test + fix) → 20–40

Bottom line: single-file daily edits are fully covered; heavy agent loops cover 3–5 hard tasks. Past that, paid is cheap.

When it runs out

Drop -free from the model ID — that's the entire migration:

deepseek-v4-pro-free   →  deepseek-v4-pro     ($1.74 / $3.48 per 1M)
deepseek-v4-flash-free →  deepseek-v4-flash   ($0.14 / $0.28)

Paid models have no account-level limit, and even heavy use stays under a few dollars a day.

The takeaway: request-based billing rewards giving the model full context and asking for complete results — not splitting work into many tiny calls.

Take 200 free requests a day → TeamoRouter

How to Access Kimi K3 API: Pricing, Rate Limits, and Setup Guide (2026)

Gaige — Tue, 28 Jul 2026 03:56:43 +0000

Quick Answer

The Kimi K3 API is OpenAI-compatible, costs $3.00/M input tokens (cache miss), $0.30/M input tokens (cache hit), and $15.00/M output tokens, and runs on https://api.moonshot.ai/v1 (international) or https://api.moonshot.cn/v1 (China). The model ID is kimi-k3. A typical single API call costs about $0.007. This guide covers pricing in detail, rate limits, setup in Python and Node.js, caching optimization, and how to route through a stable gateway for production reliability.

Kimi K3 API Pricing Breakdown

K3's pricing marks a significant shift for Moonshot AI — it is substantially more expensive than previous Kimi models, placing it in the same tier as Western frontier models while remaining cheaper than them on a per-task basis.

Per-Token Pricing

Token Type	Price per 1M Tokens (USD)	Price per 1M Tokens (CNY)
Input (cache miss)	$3.00	¥20
Input (cache hit)	$0.30	¥2
Output	$15.00	¥100

How This Compares

Model	Input (Cache Miss)	Output
Kimi K3	$3.00	$15.00
GPT-5.6 Sol	$5.00	$30.00
Claude Fable 5	$10.00	$50.00
DeepSeek V4-Pro	~$0.18	~$0.90
Qwen3.7-Max	~$1.07	~$5.36

K3 sits in an interesting position: it is the most expensive model ever released by a Chinese AI lab (output pricing is roughly 16.7x DeepSeek V4-Pro), yet still 50-70% cheaper than the top Western closed-source models on a per-token basis.

The Cache Advantage

The headline numbers don't tell the full story. K3's architecture is purpose-built for high cache hit rates. Moonshot's Mooncake serving infrastructure reportedly achieves over 90% cache hit rates in coding-heavy agent workloads. This means that in practice, most of your input tokens are billed at the cached rate of $0.30/M — a 90% discount.

Third-party testing by Artificial Analysis found that despite the high per-token output price, K3's average per-task cost (~$0.94) is comparable to GPT-5.6 Sol (~$1.04) and roughly half of Claude Opus 4.8 (~$1.80). The model simply consumes fewer total tokens to complete equivalent tasks. On the DeepSWE benchmark, K3's cost per rollout was $4.65 — compared to $13.41 for Claude Fable 5 and $8.37 for GPT-5.6 Sol.

Real-World Cost Estimates

Here is what typical usage patterns cost with K3:

Scenario	Tokens In	Tokens Out	Cost
Single chat message	~500	~300	~$0.006
Code generation task	~2,000	~1,500	~$0.029
Full agent coding session	~50,000	~20,000	~$0.45 (with caching)
Large repo analysis (1M context)	~500,000	~5,000	~$0.23 (with caching)
Heavy daily developer usage	~2M	~500K	~$13.50 (with caching)

These are estimates — your actual costs depend on cache hit rates, task complexity, and output verbosity.

Rate Limits and Access Restrictions

Moonshot AI has not published explicit RPM (requests per minute) or TPM (tokens per minute) caps, but several access constraints are known:

Consumer Subscription Pause

Within 48 hours of K3's July 16, 2026 launch, Moonshot paused new consumer (C-end) subscriptions. Server load had reached capacity, and the existing GPU cluster could not handle the exponential growth in call volume. Available compute was prioritized for existing paid users. As of late July 2026, this restriction is gradually being lifted as additional capacity comes online.

API Parameter Restrictions

At launch, several parameters are locked:

Reasoning effort: Only reasoning_effort="max" is available. You cannot set it to low or medium to reduce token consumption. Lighter modes are promised for future releases.
Temperature, top_p, penalty parameters: All fixed. Developers must omit these from API requests — including them may cause errors or be silently ignored.
Public image URLs: Not supported through the API at launch. Use base64-encoded images or file uploads for vision inputs.

Throughput Observations

Third-party gateway data from Vercel shows two performance tiers:

Variant	Throughput	Latency
Kimi K3 (standard)	~33-35 tokens/sec	~5.5-6.3s
Kimi K3 Fast	~117 tokens/sec	~2.8s

The standard tier is noticeably slower than GPT-5.6 Sol and Claude Fable 5. If latency matters for your use case, target the Fast variant or implement streaming to hide the delay.

Python Setup (Under 5 Minutes)

Kimi K3 uses the OpenAI SDK. If you have used the OpenAI API before, switching to K3 requires changing exactly three values.

Step 1: Install the SDK

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

Step 2: Get Your API Key

Go to platform.moonshot.ai (international) or platform.moonshot.cn (China).
Sign in or create an account.
Navigate to the API Keys page.
Click Create to generate a new key (it starts with sk-).
Copy the key immediately — you will not be able to see it again after closing the page.
Add a small balance (a few dollars is enough to start).

Step 3: Set Up Your Environment

export MOONSHOT_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

Step 4: Write Your First Call

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",  # International endpoint
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function that parses a CSV file and returns summary statistics."},
    ],
    max_completion_tokens=1200,
)

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

Step 5: Add Streaming

For a real-time typewriter effect:

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Explain the Kimi Delta Attention mechanism."}],
    stream=True,
)

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

Node.js Setup

For JavaScript/TypeScript developers:

npm install openai

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: "user", content: "Write a React component for a search bar with debounce." },
  ],
  max_completion_tokens: 1500,
});

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

Streaming in Node.js:

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [{ role: "user", content: "Explain REST vs GraphQL." }],
  stream: true,
});

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

Migrating from OpenAI in 30 Seconds

If you already have code using the OpenAI SDK, switch to K3 with three changes:

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

# After (Kimi K3)
client = OpenAI(
    api_key="sk-moonshot-xxx",                        # 1. New API key
    base_url="https://api.moonshot.ai/v1",            # 2. New base URL
)
model = "kimi-k3"                                      # 3. New model ID

Remove any temperature, top_p, or penalty parameters from your request — K3 does not support them at launch. Also remove reasoning_effort unless you are explicitly targeting "max".

Optimizing for Cost: Context Caching

K3's most powerful cost-saving feature is context caching. When you send repeated requests with overlapping context (common in agentic workflows), the system reuses cached computations for shared prefix tokens, billing them at the $0.30/M rate instead of $3.00/M.

To maximize cache hits:

Put static content first. System prompts, tool definitions, and project context should appear at the beginning of your message sequence. Changing only the last user message preserves the shared prefix.
Keep system prompts stable. Avoid dynamic timestamps, random IDs, or session-specific data in your system prompt. Every change to the prefix invalidates the cache.
Use consistent message structure. If your agent always uses the same tool definitions and project rules in the same order, cache hit rates can exceed 90%.
Batch similar tasks. Run related queries close together in time. The cache persists for a limited window after the last request.

The difference between good and bad caching discipline can be a 5-10x factor in your effective input cost.

Production Considerations: The Case for an API Gateway

Calling the Moonshot API directly works fine for development and low-traffic use cases. For production workloads, however, a direct dependency introduces several risks:

Single-provider risk. If Moonshot's API experiences an outage or rate-limiting event, your application stops working. This happened within 48 hours of K3's launch when demand overwhelmed the GPU cluster.
No failover. Direct API calls have no automatic fallback. If api.moonshot.ai is unreachable, your requests fail.
Scaling complexity. Managing API keys, monitoring usage, and handling retry logic across multiple models and providers adds operational overhead.

TeamoRouter addresses these issues as a stable API gateway layer. Instead of calling Moonshot directly, your application sends requests to TeamoRouter's endpoint, which handles:

Automatic failover. If the primary K3 endpoint becomes unavailable, traffic is seamlessly routed to alternative endpoints.
Load balancing. Requests are distributed across multiple provider channels to avoid hitting rate limits.
Unified billing. One API key, one bill — regardless of how many underlying providers you use.
Health monitoring. Continuous probing of all upstream providers so failing endpoints are detected and bypassed before your requests hit them.

For teams building production applications on K3, routing through a gateway like TeamoRouter turns API reliability from something you manage into something you get by default.

Common Pitfalls and Troubleshooting

"Model not found" errors

Make sure your model ID is kimi-k3 (lowercase, hyphenated). kimi_k3, kimik3, or Kimi-K3 will not work.

Authentication failures

Verify your API key starts with sk- and that you have added funds to your account. An empty balance will produce authentication-like errors.

Temperature/top_p errors

Remove temperature, top_p, frequency_penalty, and presence_penalty from your API calls. K3 ignores or rejects these at launch.

Slow responses

K3's standard tier generates ~33-35 t/s. This is architectural — the recurrent KDA state computation adds overhead. Use streaming to make the experience feel faster, and consider the Fast tier (~117 t/s) for latency-sensitive applications.

Vision/image uploads failing

At launch, only base64-encoded images and file uploads work. Do not pass public URLs in image_url fields — they will fail.

Rate limiting

If you receive 429 errors, you are hitting rate limits. Reduce concurrency, add exponential backoff, or route through a gateway like TeamoRouter that distributes load across multiple provider endpoints.

Quick Reference Card

Base URL (International):  https://api.moonshot.ai/v1
Base URL (China):          https://api.moonshot.cn/v1
Model ID:                  kimi-k3
SDK:                       openai (Python), openai (Node.js)
Input (cache miss):        $3.00 / 1M tokens
Input (cache hit):         $0.30 / 1M tokens
Output:                    $15.00 / 1M tokens
Context window:            1,048,576 tokens
Key format:                sk-...
API key page:              platform.moonshot.ai → API Keys

Next Steps

Start small. Get an API key, make a few test calls, and understand the pricing before integrating K3 into a production pipeline.
Design for caching. Structure your prompts and system messages to maximize cache hit rates. The 90% discount on cached input is K3's biggest cost advantage.
Plan for reliability. For anything beyond experimentation, route K3 traffic through TeamoRouter to get automatic failover and multi-provider resilience without changing your application code. One endpoint, stable access to K3 and hundreds of other models, with health monitoring and failover built in.

Kimi K3 in Your IDE: VS Code, Cursor, and Cline Integration Guide for Developers

Gaige — Mon, 27 Jul 2026 05:46:24 +0000

Kimi K3 in Your IDE: VS Code, Cursor, and Cline Integration Guide for Developers

Kimi K3 has established itself as a serious contender in AI-assisted coding. With a 1-million-token context window, strong reasoning benchmarks, and OpenAI-compatible API, it slots into your existing toolchain without forcing you to learn a new workflow. The question is not whether K3 is useful -- it is how to wire it up so you reach for it when it matters and fall back to cheaper models when it does not.

This guide covers the exact configuration steps, feature compatibility table, and tiered-model strategy for running Kimi K3 inside VS Code (via Cline), Cursor, and standalone Cline.

Prerequisites: One Endpoint, Every Model

All three integrations below use the OpenAI-compatible chat completions format. You can point each tool directly at Moonshot's API (https://api.moonshot.cn/v1), but a unified LLM gateway is the better play.

TeamoRouter provides an OpenAI-compatible endpoint that gives you access to Kimi K3, Claude, GPT, Gemini, and 500+ other providers through a single API key. Its Agentic Routing inspects each request and selects the best model based on task complexity, language, and framework -- hard architectural problems go to K3 or Claude, routine edits go to fast and cheap models, all transparently. One base URL, one key, no key rotation.

For every setup below, your base URL is https://api.teamorouter.com/v1 and your model IDs include kimi-k3, claude-sonnet-4-20250514, gpt-4o, teamo-best, and teamo-eco.

Integration 1: Cline in VS Code

Cline is the most capable open-source AI coding agent for VS Code. It reads your file tree, writes and edits files, executes terminal commands, and iterates on its own output in an autonomous loop. Because Cline speaks the OpenAI chat completions protocol natively, K3 integration is a one-minute configuration.

Setup Steps

Install the Cline extension from the VS Code marketplace.
Open the Cline panel and click the settings gear icon.
Under API Provider, select OpenAI Compatible.
Configure the endpoint:

{
  "apiProvider": "openai",
  "openAiBaseUrl": "https://api.teamorouter.com/v1",
  "openAiApiKey": "sk-your-teamorouter-key",
  "openAiModelId": "kimi-k3"
}

Alternatively, set these in .vscode/settings.json so the configuration travels with your project:

{
  "cline.openAiBaseUrl": "https://api.teamorouter.com/v1",
  "cline.openAiApiKey": "${env:TEAMOROUTER_API_KEY}",
  "cline.openAiModelId": "kimi-k3"
}

Using ${env:TEAMOROUTER_API_KEY} keeps credentials out of committed config files.

Tuning for the 1M Context Window

Cline defaults to a conservative context limit. When using K3, increase it to take full advantage:

{
  "openAiContextWindow": 1000000,
  "maxOpenFileTabs": 0,
  "includeFullFileContent": true
}

Setting maxOpenFileTabs to 0 disables Cline's tab-based context management, forcing it to use file-search tools instead. Combined with includeFullFileContent: true, K3 ingests whole files rather than truncated snippets. The 1M window absorbs it comfortably.

What Cline + K3 Unlocks

Whole-codebase refactors. Ask K3 to trace a data flow across 50 files and refactor a shared interface. It will not lose track mid-way.
Autonomous debugging. Drop in a stack trace, let K3 search the codebase, identify the root cause, apply the fix, and run the test suite to verify -- all in one pass.
Cross-service reasoning. Load your frontend, BFF layer, and microservice code together. K3 can reason across the full call chain.
Model switching mid-task. Cline lets you switch models between messages in the same conversation. Start with kimi-k3 for architecture planning, switch to teamo-eco for the repetitive implementation rounds.

Integration 2: Cursor

Cursor is the most polished AI-first IDE on the market. Its architecture splits AI features into two pipelines: the Chat and Plan panels (which accept custom model providers) and the Composer + inline editing (which are hard-wired to Cursor's own backend). K3 works in the former, not the latter.

Setup Steps

Open Cursor Settings (Cmd+, on macOS, Ctrl+, on Windows/Linux).
Navigate to the Models section.
Under OpenAI API Key, toggle Override OpenAI Base URL to ON.
Enter your gateway configuration:

Base URL: https://api.teamorouter.com/v1
API Key:  sk-your-teamorouter-key

Under Custom Models, add kimi-k3.
The model now appears in the dropdown inside Chat and Plan panels.

What Works

Chat panel (Cmd+L): Select kimi-k3 from the model dropdown. Use it for codebase questions, architecture discussions, and one-shot code generation. Highlight relevant files to control context.

Plan mode (Cmd+Shift+P then "Cursor: Plan Mode"): K3 excels here. Drop a complex requirement, let K3 survey the codebase through its 1M window, and get back a structured implementation plan that accounts for far more of your project than other models can see.

Critical Caveat: Composer and Inline Edit Are Locked

Cursor's Composer (Cmd+I) and inline edit (Cmd+K on selected code) always route through Cursor's proprietary backend. If you select K3 and trigger Composer, Cursor silently falls back to its default model. There is no configuration workaround -- this is Cursor's architecture, not a Kimi limitation.

Practical takeaway: Use K3 in Cursor for analysis, planning, and large-scale understanding. Hand off implementation to Composer with Cursor's native model, or switch to Cline when you want K3 driving the edits directly.

Integration 3: Standalone Cline via LLM Gateway Routing

If you use Cline across multiple editors, or want to share a single model configuration across a team, routing everything through a gateway like TeamoRouter centralizes your setup.

Why Route Through a Gateway?

Single API key. One key unlocks K3, Claude, GPT, Gemini, DeepSeek, and hundreds more. No per-provider key rotation.
Centralized cost tracking. See token usage across tools and team members in one dashboard. Know exactly how much each tier costs.
Agentic Routing. TeamoRouter inspects each request and routes it to the optimal model. Routine completions hit cheap models; complex refactors hit K3 or Claude. You do not manually flip between providers.
Provider fallback. If one provider is down or rate-limited, requests automatically route to the next best option. Your IDE keeps working.

Configuration

The configuration block is identical whether you are using VS Code Cline, Cursor (custom model), or any other tool that accepts an OpenAI-compatible endpoint:

{
  "apiProvider": "openai",
  "openAiBaseUrl": "https://api.teamorouter.com/v1",
  "openAiApiKey": "sk-your-teamorouter-key",
  "openAiModelId": "kimi-k3"
}

Model Switching Without Reconfiguration

With a gateway in place, switching models is a one-string change. The base URL and API key never change:

// Hard problems: Kimi K3
"openAiModelId": "kimi-k3"

// Routine edits: fast and cheap
"openAiModelId": "teamo-eco"

// Complex architecture: deep reasoning
"openAiModelId": "claude-sonnet-4-20250514"

// Agentic routing: gateway picks the best model per task
"openAiModelId": "teamo-best"

This is especially valuable in teams where different developers prefer different models. Everyone points at the same gateway, and billing is unified.

Feature Compatibility Table

Not every feature in every tool routes through your custom model. Here is the full breakdown:

Feature	Cline (VS Code)	Cursor	Notes
Chat / Q&A	Full	Full	Both support streaming responses
Plan / structured output	Full	Full (Plan mode)	K3's 1M window gives Plan mode a broader view of the codebase
Agentic file read/write/edit	Full	Not available	Cursor locks file edits to its proprietary backend
Terminal command execution	Full	Not available	Cline only
MCP tool integration	Full	Not available	Cline supports MCP servers; K3 consumes them via tool calls
Inline code completion	N/A (Cline does not do inline)	Not available	Always routes through Cursor's native model
Composer / inline edit	N/A	Not available	Hard-wired to Cursor backend; no custom model support
Full-codebase context loading	Full (1M window)	Full (Chat/Plan only)	K3's standout feature across both tools
Model switching mid-task	Full	Manual only	Cline lets you switch between messages; Cursor requires session reset
Custom system prompts	Full	Limited	Cline exposes full system prompt control
Git-aware operations	Full	Full	Both tools integrate with version control
Image/vision input	Limited	Not available	K3's vision support is limited; verify current capabilities

Bottom line: For agentic coding where K3 reads, writes, and executes, Cline is the tool. For planning and analysis inside a familiar IDE, Cursor's Chat and Plan panels work well.

Tiered-Model Strategy: Keep Costs Down, Keep Quality Up

K3 is powerful but token-hungry, averaging around 25K tokens per coding task. You should not pay $0.50 to rename a variable. A tiered strategy dispatches each task to the right model.

Tier 1: Routine Edits (Cheapest)

Use for: Rename variable, add a docstring, fix a linter warning, generate a boilerplate component.

Models: teamo-eco, deepseek-chat, claude-haiku

Configuration:

{ "openAiModelId": "teamo-eco" }

Narrow context, predictable output. A cheap model handles these in under a second for a fraction of a cent.

Tier 2: Moderate Complexity (Balanced)

Use for: Implement a feature spanning 2-3 files, write unit tests with edge cases, debug a non-trivial regression.

Models: claude-sonnet-4-20250514, gpt-4o

Tier 3: Hard Problems (Frontier)

Use for: Multi-file refactors, architecture migrations, debugging production incidents with large log contexts, understanding an unfamiliar codebase from scratch.

Models: kimi-k3

Configuration:

{ "openAiModelId": "kimi-k3" }

This is where the 1M context window earns its keep. Dump the relevant slice of the monorepo into context. Let K3 trace call graphs across dozens of files. Models with smaller windows see fragments; K3 sees the whole picture.

Tiered Workflow in Practice

1. Start with kimi-k3. Drop the entire feature module into context.
   "Give me a map of how user auth flows through this codebase."

2. K3 returns a thorough analysis. Now you understand the lay of
   the land.

3. Switch to teamo-eco for the first small task:
   "Rename UserSession.token to UserSession.accessToken across
    these 3 files."

4. Switch back to kimi-k3 for the hard part:
   "Refactor the session middleware to support JWT rotation."

5. Switch to claude-sonnet-4 for code review on the final diff.

Each model does what it does best. Your API bill reflects the complexity of the work, not the ceiling of your most expensive model.

The 1M Context Window: What It Actually Means

Numbers are abstract. Here is what 1 million tokens translates to in real-world development:

~600-700 average source files fit simultaneously. A typical mid-size React application with 100 files at 1,500 tokens each totals 150K tokens -- K3 can hold four or five such applications at once.
Entire microservice codebases load in a single prompt. Drop in the whole service and ask K3 to find architectural inconsistencies.
Monorepo sub-projects are no longer clipped. If your frontend lives in packages/web/ with 200 components, K3 sees the full picture without summarization.
Documentation alongside code stays in context. Load your API spec, database schema, and implementation files together. K3 cross-references them all.
Long debugging sessions do not degrade. After 50 round-trips, a 128K model has forgotten the original error. K3 still remembers the stack trace from message one.

The practical mindset shift: stop asking "which files do I need to include?" and start asking "what question do I want answered about this entire codebase?"

Quick-Start Cheat Sheet

Cline (VS Code / Standalone)

{
  "apiProvider": "openai",
  "openAiBaseUrl": "https://api.teamorouter.com/v1",
  "openAiApiKey": "sk-your-teamorouter-key",
  "openAiModelId": "kimi-k3",
  "openAiContextWindow": 1000000
}

Cursor

Base URL:              https://api.teamorouter.com/v1
API Key:               sk-your-teamorouter-key
Custom Model Name:     kimi-k3
Override Base URL:     ON

Direct Moonshot API (no gateway)

{
  "apiProvider": "openai",
  "openAiBaseUrl": "https://api.moonshot.cn/v1",
  "openAiApiKey": "sk-your-moonshot-key",
  "openAiModelId": "kimi-k3"
}

Getting Started in Five Minutes

Sign up at TeamoRouter and grab your API key.
Install Cline in VS Code, or open Cursor.
Configure the OpenAI-compatible endpoint with https://api.teamorouter.com/v1 and your key.
Set kimi-k3 as your model for agentic and planning tasks.
Add teamo-eco as a secondary model for quick edits and boilerplate.

You now have Kimi K3 running in your IDE, alongside every other major model, through a single API endpoint. The 1M context window, strong reasoning, and competitive pricing make K3 a genuine addition to any developer's toolkit -- and the tiered-model strategy ensures you get the benefits without overpaying for routine work.