Anthropic API Cost Optimization Guide: Cut Your Monthly Bill by 50–70%

const selectModel = (taskType: string): string => {
  const modelMap = {
    // Simple tasks
    'classify': 'claude-3-5-haiku-20241022',
    'extract': 'claude-3-5-haiku-20241022',
    'format': 'claude-3-5-haiku-20241022',
 
    // Balanced tasks (default)
    'summarize': 'claude-3-5-sonnet-20241022',
    'generate': 'claude-3-5-sonnet-20241022',
    'translate': 'claude-3-5-sonnet-20241022',
    'code_review': 'claude-3-5-sonnet-20241022',
 
    // Complex tasks
    'complex_reasoning': 'claude-opus-4-1-20250805',
    'research_synthesis': 'claude-opus-4-1-20250805',
    'creative_writing': 'claude-opus-4-1-20250805',
  };
 
  return modelMap[taskType] || 'claude-3-5-sonnet-20241022';
};
 
// Usage
const model = selectModel('classify'); // → Haiku
const response = await anthropic.messages.create({
  model,
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Classify this email...' }]
});

const codeReviewSystemPrompt = `You are an expert code reviewer...
[400–2000 lines of detailed guidelines]`;
 
const reviewCode = async (code: string, language: string) => {
  const response = await anthropic.messages.create({
    model: 'claude-opus-4-1-20250805',
    max_tokens: 2048,
    system: [
      {
        type: 'text',
        text: codeReviewSystemPrompt,
        cache_control: { type: 'ephemeral' } // ← Enable cache
      }
    ],
    messages: [
      {
        role: 'user',
        content: `Review this ${language} code:\n\n${code}`
      }
    ]
  });
 
  return response.content[0].type === 'text' ? response.content[0].text : '';
};
 
// Usage: Review multiple codes with same system prompt
const codes = [
  'function foo() { ... }',
  'class Bar { ... }',
  'const baz = () => { ... }'
];
 
for (const code of codes) {
  const review = await reviewCode(code, 'javascript');
  console.log(review);
  // From 2nd request onward, system prompt cached—90% cost savings
}

const createBatchRequest = async (
  items: { id: string; content: string }[]
): Promise<string> => {
  const requests = items.map((item, idx) => ({
    custom_id: item.id,
    params: {
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 256,
      messages: [
        {
          role: 'user',
          content: `Analyze this: ${item.content}`
        }
      ]
    }
  }));
 
  const batch = await anthropic.beta.messages.batches.create({
    requests
  });
 
  return batch.id;
};
 
// Poll for batch completion
const waitForBatchCompletion = async (batchId: string) => {
  let batch = await anthropic.beta.messages.batches.retrieve(batchId);
 
  while (batch.processing_status === 'processing') {
    console.log('Batch processing...');
    await new Promise(resolve => setTimeout(resolve, 5000)); // 5-sec wait
    batch = await anthropic.beta.messages.batches.retrieve(batchId);
  }
 
  return batch;
};
 
// Retrieve results
const getBatchResults = async (batchId: string) => {
  const batch = await waitForBatchCompletion(batchId);
 
  if (batch.processing_status === 'succeeded') {
    const results = await anthropic.beta.messages.batches.results(batchId);
    return results;
  } else {
    throw new Error(`Batch failed: ${batch.processing_status}`);
  }
};
 
// Usage
const items = [
  { id: '1', content: 'Log entry 1...' },
  { id: '2', content: 'Log entry 2...' },
  // ... 5000+ items
];
 
const batchId = await createBatchRequest(items);
const results = await getBatchResults(batchId);
 
// Cost: 50% of real-time pricing for same processing

// Bad: Verbose system prompt (800 tokens)
const systemPromptBad = `You are a customer support agent.
You should be helpful, harmless, and honest.
You should respond in a polite manner.
...
[1000+ more lines]`;
 
// Good: Concise system prompt (200 tokens)
const systemPromptGood = `You are a customer support agent.
- Be concise and helpful
- Prioritize user satisfaction
- Clarify when unsure`;
 
// Technique: Keep only essential system instructions

// Bad: Send all chat history (15,000 tokens)
const messages = allChatHistory; // 6 months of conversation
 
// Good: Recent messages + summary (3,000 tokens)
const recentMessages = allChatHistory.slice(-20);
const summary = await generateSummary(allChatHistory.slice(0, -20));
 
const optimizedMessages = [
  {
    role: 'user',
    content: `Previous conversation summary: ${summary}`
  },
  ...recentMessages
];

// Bad: Free-form response (1000+ output tokens)
const query = 'Extract all important details from this email';
 
// Good: JSON format (200 output tokens)
const structuredQuery = `Extract as JSON:
{
  "sender": "...",
  "subject": "...",
  "action_items": [...],
  "deadline": "..."
}`;
 
const response = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 256,
  messages: [
    {
      role: 'user',
      content: structuredQuery + '\n\n' + emailContent
    }
  ]
});
 
// Parse JSON and use only needed fields
const extracted = JSON.parse(response.content[0].text);

import json
from anthropic import Anthropic
from datetime import datetime
 
usage_log = []
 
def log_usage(response):
    """Log token usage from API response"""
    usage = {
        'input_tokens': response.usage.input_tokens,
        'output_tokens': response.usage.output_tokens,
        'model': response.model,
        'timestamp': datetime.now().isoformat()
    }
    usage_log.append(usage)
    return usage
 
client = Anthropic()
 
response = client.messages.create(
    model='claude-3-5-sonnet-20241022',
    max_tokens=1024,
    messages=[{
        'role': 'user',
        'content': 'Hello, Claude!'
    }]
)
 
usage = log_usage(response)
print(f"Input: {usage['input_tokens']}, Output: {usage['output_tokens']}")

import json
from collections import defaultdict
 
def generate_cost_report(usage_log):
    """Generate cost report from usage logs"""
 
    model_stats = defaultdict(lambda: {
        'input_tokens': 0,
        'output_tokens': 0,
        'calls': 0
    })
 
    pricing = {
        'claude-3-5-haiku-20241022': {
            'input': 0.048,
            'output': 0.24
        },
        'claude-3-5-sonnet-20241022': {
            'input': 0.96,
            'output': 4.8
        },
        'claude-opus-4-1-20250805': {
            'input': 3.6,
            'output': 18
        }
    }
 
    for entry in usage_log:
        model = entry['model']
        model_stats[model]['input_tokens'] += entry['input_tokens']
        model_stats[model]['output_tokens'] += entry['output_tokens']
        model_stats[model]['calls'] += 1
 
    total_cost = 0
    report = {'models': {}, 'total_cost': 0}
 
    for model, stats in model_stats.items():
        if model not in pricing:
            continue
 
        input_cost = stats['input_tokens'] * pricing[model]['input'] / 1000
        output_cost = stats['output_tokens'] * pricing[model]['output'] / 1000
        model_cost = input_cost + output_cost
        total_cost += model_cost
 
        report['models'][model] = {
            'input_tokens': stats['input_tokens'],
            'output_tokens': stats['output_tokens'],
            'calls': stats['calls'],
            'cost_jpy': round(model_cost, 2)
        }
 
    report['total_cost'] = round(total_cost, 2)
    return report
 
report = generate_cost_report(usage_log)
print(json.dumps(report, indent=2))

def daily_cost_alert(report, threshold=500):
    """Alert if daily cost exceeds threshold"""
    if report['total_cost'] > threshold:
        print(f"⚠️ Alert: Daily cost ¥{report['total_cost']} exceeds ¥{threshold}")
        print(f"Breakdown: {report['models']}")
        # Send to Slack/email
        return True
    return False
 
# Run daily via Cron/Cloud Scheduler
if __name__ == '__main__':
    report = generate_cost_report(usage_log)
    daily_cost_alert(report)

// Bad: Dynamic system prompts
const systemPrompt = `You are helping ${userId}...`; // Changes per user
 
// Result: Cache never hits because prompt is unique per request