Recommended settings for getting started:
- Monthly limit: $50-100
- Notification at: 80% of limit
- Per-key limit: Match your expected usage

# Your API key looks like this:
# sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# Test it:
curl https://api.anthropic.com/v1/messages \
 -H "x-api-key: your-api-key" \
 -H "anthropic-version: 2023-06-01" \
 -H "content-type: application/json" \
 -d '{
 "model": "claude-sonnet-4-5-20250929",
 "max_tokens": 100,
 "messages": [{"role": "user", "content": "Hello"}]
 }'

import anthropic

client = anthropic.Anthropic(api_key="your-key")

# Check rate limit headers in response
response = client.messages.create(
 model="claude-sonnet-4-5-20250929",
 max_tokens=10,
 messages=[{"role": "user", "content": "Hi"}]
)

# Rate limit info is in response headers
# x-ratelimit-limit-requests
# x-ratelimit-limit-tokens
# x-ratelimit-remaining-requests
# x-ratelimit-remaining-tokens

# Simple tasks → Haiku (cheapest)
simple_response = client.messages.create(
 model="claude-haiku-4-5-20251001",
 max_tokens=200,
 messages=[{"role": "user", "content": "Summarize this in one sentence: ..."}]
)

# Standard tasks → Sonnet (balanced)
standard_response = client.messages.create(
 model="claude-sonnet-4-5-20250929",
 max_tokens=1000,
 messages=[{"role": "user", "content": "Review this code for bugs: ..."}]
)

# Complex reasoning → Opus (most capable)
complex_response = client.messages.create(
 model="claude-opus-4-5-20251101",
 max_tokens=4000,
 messages=[{"role": "user", "content": "Design a distributed system architecture for..."}]
)

# ❌ Wasteful: Sending full file when you only need part
messages = [{"role": "user", "content": f"Here's my entire 5000-line codebase: {full_code}\n\nWhat does line 42 do?"}]

# ✅ Efficient: Send only relevant context
messages = [{"role": "user", "content": f"What does this function do?\n\n{relevant_function}"}]

response = client.messages.create(
 model="claude-sonnet-4-5-20250929",
 max_tokens=1000,
 system=[
 {
 "type": "text",
 "text": "You are a code review assistant. Here are the project guidelines: ...(long text)...",
 "cache_control": {"type": "ephemeral"}
 }
 ],
 messages=[{"role": "user", "content": "Review this PR: ..."}]
)
# Subsequent calls with the same system prompt use cached tokens at 10% of the price

# ❌ Don't set max_tokens higher than needed
response = client.messages.create(
 model="claude-sonnet-4-5-20250929",
 max_tokens=100000, # Wasteful if you only need a short answer
 messages=[{"role": "user", "content": "What is 2+2?"}]
)

# ✅ Set reasonable limits
response = client.messages.create(
 model="claude-sonnet-4-5-20250929",
 max_tokens=100, # Short answer expected
 messages=[{"role": "user", "content": "What is 2+2?"}]
)

from openai import OpenAI

# Same OpenAI-compatible SDK, lower prices
client = OpenAI(
 api_key="your-crazyrouter-key",
 base_url="https://api.crazyrouter.com/v1"
)

response = client.chat.completions.create(
 model="claude-sonnet-4-5",
 messages=[{"role": "user", "content": "Hello!"}]
)

import anthropic
from datetime import datetime

client = anthropic.Anthropic()

# Track costs per request
def tracked_completion(model, messages, max_tokens=1000):
 response = client.messages.create(
 model=model,
 max_tokens=max_tokens,
 messages=messages
 )

 # Calculate cost
 input_tokens = response.usage.input_tokens
 output_tokens = response.usage.output_tokens

 pricing = {
 "claude-opus-4-5-20251101": (15, 75),
 "claude-sonnet-4-5-20250929": (3, 15),
 "claude-haiku-4-5-20251001": (0.80, 4),
 }

 input_rate, output_rate = pricing.get(model, (3, 15))
 cost = (input_tokens * input_rate + output_tokens * output_rate) / 1_000_000

 print(f"[{datetime.now()}] Model: {model} | In: {input_tokens} | Out: {output_tokens} | Cost: ${cost:.4f}")

 return response

import time

def call_with_retry(func, max_retries=5):
 for attempt in range(max_retries):
 try:
 return func()
 except anthropic.RateLimitError:
 wait = 2 ** attempt
 print(f"Rate limited. Waiting {wait}s...")
 time.sleep(wait)
 raise Exception("Max retries exceeded")