Cost = (Input Tokens × Input Price) + (Output Tokens × Output Price)

# AI API Cost Calculator
MODEL_PRICING = {
 "gpt-5.2": {"input": 10.0, "output": 30.0},
 "gpt-5-mini": {"input": 0.4, "output": 1.6},
 "claude-opus-4-6": {"input": 15.0, "output": 75.0},
 "claude-sonnet-4-5": {"input": 3.0, "output": 15.0},
 "claude-haiku-4-5": {"input": 0.25, "output": 1.25},
 "gemini-3-pro": {"input": 7.0, "output": 21.0},
 "gemini-2.5-flash": {"input": 0.15, "output": 0.60},
 "deepseek-v3.2": {"input": 0.27, "output": 1.10},
}

# Crazyrouter discount rates
CRAZYROUTER_DISCOUNT = {
 "gpt-5.2": 0.30,
 "claude-opus-4-6": 0.30,
 "claude-sonnet-4-5": 0.30,
 "gemini-3-pro": 0.20,
 "deepseek-v3.2": 0.30,
}

def calculate_cost(model: str, input_tokens: int, output_tokens: int, 
 use_crazyrouter: bool = False) -> dict:
 """Calculate API cost for a given model and token usage."""
 pricing = MODEL_PRICING[model]
 
 input_cost = (input_tokens / 1_000_000) * pricing["input"]
 output_cost = (output_tokens / 1_000_000) * pricing["output"]
 total = input_cost + output_cost
 
 result = {
 "model": model,
 "input_tokens": input_tokens,
 "output_tokens": output_tokens,
 "input_cost": round(input_cost, 6),
 "output_cost": round(output_cost, 6),
 "total_cost": round(total, 6),
 }
 
 if use_crazyrouter and model in CRAZYROUTER_DISCOUNT:
 discount = CRAZYROUTER_DISCOUNT[model]
 cr_total = total * (1 - discount)
 result["crazyrouter_cost"] = round(cr_total, 6)
 result["savings"] = round(total - cr_total, 6)
 
 return result

# Example: Calculate cost for a coding assistant session
session = calculate_cost(
 model="claude-opus-4-6",
 input_tokens=50_000, # ~37K words of context
 output_tokens=10_000, # ~7.5K words of output
 use_crazyrouter=True
)

print(f"Official cost: ${session['total_cost']:.4f}")
print(f"Crazyrouter cost: ${session['crazyrouter_cost']:.4f}")
print(f"Savings: ${session['savings']:.4f}")
# Official cost: $1.5000
# Crazyrouter cost: $1.0500
# Savings: $0.4500

def estimate_monthly_cost(model: str, requests_per_day: int,
 avg_input_tokens: int, avg_output_tokens: int,
 use_crazyrouter: bool = False) -> dict:
 """Estimate monthly API costs."""
 daily_requests = requests_per_day
 monthly_requests = daily_requests * 30
 
 total_input = monthly_requests * avg_input_tokens
 total_output = monthly_requests * avg_output_tokens
 
 result = calculate_cost(model, total_input, total_output, use_crazyrouter)
 result["monthly_requests"] = monthly_requests
 result["total_input_tokens"] = total_input
 result["total_output_tokens"] = total_output
 
 return result

# Estimate for a SaaS product with 1000 daily API calls
estimate = estimate_monthly_cost(
 model="claude-sonnet-4-5",
 requests_per_day=1000,
 avg_input_tokens=2000,
 avg_output_tokens=500,
 use_crazyrouter=True
)

print(f"Monthly requests: {estimate['monthly_requests']:,}")
print(f"Official monthly cost: ${estimate['total_cost']:.2f}")
print(f"Crazyrouter monthly cost: ${estimate['crazyrouter_cost']:.2f}")
print(f"Monthly savings: ${estimate['savings']:.2f}")
# Monthly requests: 30,000
# Official monthly cost: $405.00
# Crazyrouter monthly cost: $283.50
# Monthly savings: $121.50

def smart_route(task_complexity: str, messages: list) -> str:
 """Route to the most cost-effective model based on task complexity."""
 routing_map = {
 "simple": "gemini-2.5-flash", # $0.15/$0.60 per 1M
 "medium": "claude-sonnet-4-5", # $3/$15 per 1M
 "complex": "claude-opus-4-6", # $15/$75 per 1M
 "long_context": "gemini-3-pro", # $7/$21 per 1M, 2M context
 }
 return routing_map.get(task_complexity, "claude-sonnet-4-5")

# Instead of sending full system prompt every time,
# use prompt caching for repeated context
response = client.chat.completions.create(
 model="claude-sonnet-4-5",
 messages=[
 {
 "role": "system",
 "content": long_system_prompt, # This gets cached
 "cache_control": {"type": "ephemeral"}
 },
 {"role": "user", "content": user_query}
 ]
)
# Cached input: $0.75/1M instead of $3.00/1M = 75% savings on system prompt

# BAD: Verbose prompt (wastes tokens)
prompt_bad = """
I would like you to please help me write a Python function. 
The function should take a list of numbers as input and return 
the sum of all even numbers in the list. Please make sure to 
include proper error handling and type hints. Thank you!
"""

# GOOD: Concise prompt (saves ~40% tokens)
prompt_good = """
Write a Python function: sum of even numbers from a list. 
Include type hints and error handling.
"""

# Instead of 100 individual API calls, batch related items
items_to_analyze = ["item1", "item2", "item3", ...]

# BAD: One call per item
for item in items_to_analyze:
 response = client.chat.completions.create(
 model="claude-sonnet-4-5",
 messages=[{"role": "user", "content": f"Analyze: {item}"}]
 )

# GOOD: Batch multiple items in one call
batch_prompt = "Analyze each item and return JSON array:\n" + "\n".join(items_to_analyze)
response = client.chat.completions.create(
 model="claude-sonnet-4-5",
 messages=[{"role": "user", "content": batch_prompt}],
 response_format={"type": "json_object"}
)

# Set max_tokens to prevent runaway responses
response = client.chat.completions.create(
 model="gpt-5.2",
 messages=[{"role": "user", "content": "Summarize this article."}],
 max_tokens=500 # Cap output to ~375 words
)

import hashlib
import json

def cached_completion(client, model, messages, **kwargs):
 """Cache API responses to avoid duplicate calls."""
 cache_key = hashlib.md5(
 json.dumps({"model": model, "messages": messages}).encode()
 ).hexdigest()
 
 cache_file = f".cache/{cache_key}.json"
 
 try:
 with open(cache_file) as f:
 return json.load(f)
 except FileNotFoundError:
 response = client.chat.completions.create(
 model=model, messages=messages, **kwargs
 )
 result = response.choices[0].message.content
 with open(cache_file, "w") as f:
 json.dump(result, f)
 return result

# Just change the base URL — everything else stays the same
client = OpenAI(
 api_key="your-crazyrouter-key",
 base_url="https://api.crazyrouter.com/v1"
)
# Instant 20-30% savings on every API call