"Kimi K2 API Pricing Guide: Moonshot AI Costs, Token Limits & Budget Optimization 2026"

import openai

# Direct Moonshot API
client = openai.OpenAI(
    api_key="your-moonshot-key",
    base_url="https://api.moonshot.cn/v1"
)

# Or via Crazyrouter (50% cheaper)
client = openai.OpenAI(
    api_key="sk-cr-your-key",
    base_url="https://crazyrouter.com/v1"
)

# Standard completion
response = client.chat.completions.create(
    model="kimi-k2",
    messages=[
        {"role": "system", "content": "You are a senior software architect."},
        {"role": "user", "content": "Design a rate limiting system for a "
         "multi-tenant API gateway. Consider distributed state, fairness, "
         "and burst handling."}
    ],
    max_tokens=4096,
    temperature=0.7
)

print(response.choices[0].message.content)
print(f"Tokens: {response.usage.prompt_tokens} in / "
      f"{response.usage.completion_tokens} out")

# Thinking mode for complex problems
response = client.chat.completions.create(
    model="kimi-k2-thinking",
    messages=[
        {"role": "user", "content": """
        A company has 3 factories and 4 warehouses. 
        Transportation costs per unit:
        Factory A → W1: $4, W2: $8, W3: $1, W4: $5
        Factory B → W1: $6, W2: $3, W3: $7, W4: $2
        Factory C → W1: $3, W2: $5, W3: $4, W4: $6
        
        Supply: A=300, B=400, C=300
        Demand: W1=250, W2=350, W3=200, W4=200
        
        Find the optimal transportation plan that minimizes total cost.
        Show your work step by step.
        """}
    ],
    max_tokens=8192
)

# Thinking mode shows reasoning chain
print(response.choices[0].message.content)

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Search the product database",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "category": {"type": "string", "enum": ["electronics", "clothing", "food"]},
                    "max_price": {"type": "number", "description": "Maximum price filter"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"},
                    "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="kimi-k2",
    messages=[
        {"role": "user", "content": "Find me wireless headphones under $100 "
         "and check if it's good weather for a walk in Tokyo"}
    ],
    tools=tools,
    tool_choice="auto"
)

# Kimi K2 will call both tools in parallel
for tool_call in response.choices[0].message.tool_calls:
    print(f"Function: {tool_call.function.name}")
    print(f"Args: {tool_call.function.arguments}")

const OpenAI = require('openai');

const client = new OpenAI({
  apiKey: 'sk-cr-your-key',
  baseURL: 'https://crazyrouter.com/v1'
});

async function analyzeCode(code) {
  const response = await client.chat.completions.create({
    model: 'kimi-k2',
    messages: [
      { role: 'system', content: 'You are a code review expert. Find bugs, ' +
        'security issues, and performance problems.' },
      { role: 'user', content: `Review this code:\n\n${code}` }
    ],
    max_tokens: 4096,
    temperature: 0.3
  });
  
  return response.choices[0].message.content;
}

// Usage
const review = await analyzeCode(fs.readFileSync('app.py', 'utf8'));
console.log(review);

curl https://crazyrouter.com/v1/chat/completions \
  -H "Authorization: Bearer sk-cr-your-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2",
    "messages": [
      {"role": "user", "content": "Explain the CAP theorem with real-world examples for each trade-off"}
    ],
    "max_tokens": 2048
  }'

def smart_route(query: str, complexity: str = "auto"):
    """Route to standard or thinking based on complexity"""
    
    if complexity == "auto":
        # Simple heuristic: use thinking for math/logic keywords
        thinking_keywords = ["prove", "calculate", "optimize", "solve",
                           "step by step", "reasoning", "analyze"]
        needs_thinking = any(kw in query.lower() for kw in thinking_keywords)
    else:
        needs_thinking = complexity == "high"
    
    model = "kimi-k2-thinking" if needs_thinking else "kimi-k2"
    
    return client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": query}],
        max_tokens=4096
    )

# Stuff the entire document into context (free up to 128K)
with open("annual_report.txt") as f:
    document = f.read()  # ~80K tokens

response = client.chat.completions.create(
    model="kimi-k2",
    messages=[
        {"role": "system", "content": "Analyze this annual report."},
        {"role": "user", "content": f"{document}\n\nWhat are the top 3 risks?"}
    ]
)

import hashlib
import json

cache = {}

def cached_completion(messages, model="kimi-k2", **kwargs):
    """Simple in-memory cache for repeated queries"""
    cache_key = hashlib.md5(
        json.dumps(messages, sort_keys=True).encode()
    ).hexdigest()
    
    if cache_key in cache:
        return cache[cache_key]
    
    response = client.chat.completions.create(
        model=model, messages=messages, **kwargs
    )
    cache[cache_key] = response
    return response

# One API key, automatic routing and fallback
client = openai.OpenAI(
    api_key="sk-cr-your-key",
    base_url="https://crazyrouter.com/v1"
)