Stop overpaying for AI tokens
The average developer spends $200-500/month on AI API calls. With these 7 strategies, you can cut that to $40-100/month while maintaining the same output quality.
I tested each strategy on a real production workload (500K tokens/day across coding, analysis, and chat tasks). Here are the results:
Strategy 1: Use a discount provider
The easiest win. Switch from direct API to Izzi API and save 30% instantly:
| Model | Direct price | Izzi API price | Monthly savings (500K/day) |
|---|---|---|---|
| Claude Sonnet 4 | $3/$15/M | $2.1/$10.5/M | $59 |
| GPT-5 | $2.5/$10/M | $1.75/$7/M | $50 |
| Gemini 2.5 Pro | $1.25/$10/M | $0.88/$7/M | $43 |
Strategy 2: Use free models for 80% of tasks
Most tasks don't need Claude Opus 4. Route simple tasks to free models:
Python
def smart_route(task: str, complexity: str) -> str:
"""Route tasks to the cheapest adequate model."""
if complexity == "simple":
return "qwen3-30b-a3b" # Free, fast
elif complexity == "medium":
return "deepseek-r1-0528" # Free, high quality
elif complexity == "hard":
return "claude-sonnet-4-20250514" # Paid, best quality
else:
return "claude-opus-4-20250514" # Paid, maximum qualityReal impact: If 80% of your tasks are simple/medium, you cut costs by 60-80%.
Strategy 3: Implement prompt caching
Prompt caching reduces input token costs by 90% for repeated system prompts:
Python
import anthropic
client = anthropic.Anthropic(
api_key="izzi-YOUR_KEY_HERE",
base_url="https://api.izziapi.com/anthropic"
)
# The system prompt is cached after the first call
SYSTEM_PROMPT = """You are a senior code reviewer. Review code for:
1. Security vulnerabilities (SQL injection, XSS, CSRF)
2. Performance bottlenecks (N+1 queries, missing indexes)
3. Code quality (naming, structure, error handling)
Provide specific line numbers and fix suggestions."""
# First call: full price for system prompt
# Subsequent calls: 90% discount on cached system prompt
response = client.messages.create(
model="claude-sonnet-4-20250514",
system=[{
"type": "text",
"text": SYSTEM_PROMPT,
"cache_control": {"type": "ephemeral"}
}],
messages=[{"role": "user", "content": code_to_review}],
max_tokens=2000
)
# Check cache usage
print(f"Cache hit: {response.usage.cache_read_input_tokens} tokens at 90% discount")
print(f"Cache miss: {response.usage.cache_creation_input_tokens} tokens at full price")Strategy 4: Batch requests
Process multiple items in a single API call instead of one-at-a-time:
Python
# ❌ Expensive: 10 separate API calls
for file in files:
response = client.chat.completions.create(
model="claude-sonnet-4-20250514",
messages=[{"role": "user", "content": f"Review this file: {file}"}]
)
# ✅ Cheap: 1 API call with all files
all_files = "\n---\n".join(f"File: {f.name}\n{f.content}" for f in files)
response = client.chat.completions.create(
model="claude-sonnet-4-20250514",
messages=[{"role": "user", "content": f"Review these {len(files)} files:\n{all_files}"}]
)Strategy 5: Right-size your max_tokens
Python
# ❌ Wasteful: requesting 4000 tokens when you need 200
response = client.chat.completions.create(
model="claude-sonnet-4-20250514",
messages=[{"role": "user", "content": "Is this a valid email? [email protected]"}],
max_tokens=4000
)
# ✅ Efficient: request only what you need
response = client.chat.completions.create(
model="claude-sonnet-4-20250514",
messages=[{"role": "user", "content": "Is this a valid email? [email protected]"}],
max_tokens=50 # "Yes" or "No" plus brief explanation
)Strategy 6: Implement a response cache
Python
import hashlib
import json
from functools import lru_cache
# In-memory cache for identical requests
response_cache = {}
def cached_completion(model: str, messages: list, **kwargs) -> str:
"""Cache identical API calls to avoid duplicate charges."""
cache_key = hashlib.md5(
json.dumps({"model": model, "messages": messages}, sort_keys=True).encode()
).hexdigest()
if cache_key in response_cache:
return response_cache[cache_key] # Free!
response = client.chat.completions.create(
model=model, messages=messages, **kwargs
)
result = response.choices[0].message.content
response_cache[cache_key] = result
return resultStrategy 7: Use smaller context windows
Truncate unnecessary context before sending to the API:
Python
def trim_context(text: str, max_chars: int = 8000) -> str:
"""Keep only the most relevant parts of context."""
if len(text) <= max_chars:
return text
# Keep first 2000 chars (intro/setup)
# Keep last 6000 chars (most recent/relevant)
return text[:2000] + "\n...truncated...\n" + text[-6000:]Combined savings calculator
| Strategy | Effort | Savings | Cumulative |
|---|---|---|---|
| 1. Izzi API discount | 5 min | 30% | 30% |
| 2. Free model routing | 30 min | 40% | 58% |
| 3. Prompt caching | 15 min | 15% | 64% |
| 4. Batch requests | 20 min | 10% | 68% |
| 5. Right-size tokens | 5 min | 5% | 70% |
| 6. Response cache | 15 min | 8% | 72% |
| 7. Trim context | 10 min | 8% | 78% |
Total: ~78% cost reduction in ~100 minutes of implementation work.