"Anthropic Billing Guide: Manage Your Claude API Costs Effectively"

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")