How to Reduce AI API Costs: Developer's Guide for 2026

// Anthropic Claude with caching (see docs for current model IDs)
const response = await anthropic.messages.create({
  model: "claude-sonnet-latest",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: "You are a customer support assistant...", // Long system prompt
      cache_control: { type: "ephemeral" }  // Cache this content
    }
  ],
  messages: [{ role: "user", content: "How do I reset my password?" }]
});

// OpenAI with caching (see docs for current caching params)
const response = await openai.chat.completions.create({
  model: "gpt-latest",
  messages: [
    {
      role: "system",
      content: "You are a customer support assistant...",
      // Enable caching per provider docs
    },
    { role: "user", content: "How do I reset my password?" }
  ]
});

// Route requests based on complexity
function selectModel(requestType: string, complexity: string) {
  // Simple tasks → Fast, low-cost tier
  if (complexity === 'simple') {
    switch (requestType) {
      case 'classification':
      case 'extraction':
      case 'validation':
        return 'fast-model';
      case 'faq':
      case 'translation':
        return 'fast-model';
    }
  }

  // Medium complexity → Balanced tier
  if (complexity === 'medium') {
    return 'balanced-model';
  }

  // Complex tasks → Flagship tier
  return 'flagship-model';
}

// Real-world usage example
async function handleChatMessage(message: string, history: Array) {
  // Detect intent and complexity
  const intent = await classifyIntent(message);  // Uses fast tier
  const complexity = assessComplexity(message, history);

  // Route to appropriate model
  const model = selectModel(intent, complexity);
  const response = await callAI(model, message, history);

  return response;
}

// Set appropriate limits for different endpoints
const TOKEN_LIMITS = {
  classification: LIMIT_SHORT,
  faq: LIMIT_MEDIUM,
  summary: LIMIT_MEDIUM,
  code: LIMIT_LONG,
  article: LIMIT_EXTENDED
};

async function generateResponse(type: string, prompt: string) {
  const response = await openai.chat.completions.create({
    model: "flagship-model",
    messages: [{ role: "user", content: prompt }],
    max_tokens: TOKEN_LIMITS[type],  // Prevent excessive output
    temperature: 0.7
  });

  return response.choices[0].message.content;
}

// Batch processing implementation
async function classifyEmails(emails: string[]) {
  const BATCH_SIZE = 10;  // Process 10 at a time
  const results = [];

  for (let i = 0; i < emails.length; i += BATCH_SIZE) {
    const batch = emails.slice(i, i + BATCH_SIZE);

    // Single request for entire batch
    const prompt = `Classify these emails as spam/not_spam.
Return JSON array with same order:

${batch.map((email, idx) => `${idx + 1}. ${email}`).join('\n\n')}`;

    const response = await openai.chat.completions.create({
      model: "fast-model",
      messages: [
        { role: "system", content: "You are an email classifier." },
        { role: "user", content: prompt }
      ],
      max_tokens: 100  // Brief JSON response
    });

    const batchResults = JSON.parse(response.choices[0].message.content);
    results.push(...batchResults);
  }

  return results;
}

// Usage
const emails = [...]; // 1000 emails
const classifications = await classifyEmails(emails);
// 100 batched requests instead of 1000 individual requests
// Saves significant system prompt repetition