token-cost-analyzer

Token Cost Analyzer

Audit, analyze, and optimize your LLM API spending.

When to Use

• Monthly AI bill higher than expected
• Need to understand where tokens are spent
• Optimizing prompts for cost efficiency
• Setting up cost monitoring
• Budgeting for AI features

Token Pricing Reference (2026)

Anthropic Claude

Model	Input (per 1M tokens)	Output (per 1M tokens)
Claude 3 Opus	$15.00	$75.00
Claude 3.5 Sonnet	$3.00	$15.00
Claude 3 Haiku	$0.25	$1.25

OpenAI

Model	Input (per 1M tokens)	Output (per 1M tokens)
GPT-4 Turbo	$10.00	$30.00
GPT-4o	$5.00	$15.00
GPT-4o mini	$0.15	$0.60
o1	$15.00	$60.00

Google

Model	Input (per 1M tokens)	Output (per 1M tokens)
Gemini 1.5 Pro	$3.50	$10.50
Gemini 1.5 Flash	$0.075	$0.30

Cost Calculation

interface TokenUsage {
  inputTokens: number;
  outputTokens: number;
  cachedTokens?: number;
}

interface ModelPricing {
  inputPer1M: number;
  outputPer1M: number;
  cachedPer1M?: number;
}

function calculateCost(usage: TokenUsage, pricing: ModelPricing): number {
  const inputCost = (usage.inputTokens / 1_000_000) * pricing.inputPer1M;
  const outputCost = (usage.outputTokens / 1_000_000) * pricing.outputPer1M;
  const cachedCost = usage.cachedTokens
    ? (usage.cachedTokens / 1_000_000) * (pricing.cachedPer1M || pricing.inputPer1M * 0.1)
    : 0;

  return inputCost + outputCost + cachedCost;
}

// Example
const usage = { inputTokens: 50000, outputTokens: 10000 };
const claude35Sonnet = { inputPer1M: 3.00, outputPer1M: 15.00 };
const cost = calculateCost(usage, claude35Sonnet);
// $0.15 + $0.15 = $0.30

Cost Tracking System

interface UsageRecord {
  timestamp: Date;
  model: string;
  operation: string;
  userId?: string;
  inputTokens: number;
  outputTokens: number;
  cost: number;
  metadata: Record<string, unknown>;
}

class CostTracker {
  private records: UsageRecord[] = [];

  record(usage: Omit<UsageRecord, 'timestamp' | 'cost'>): void {
    const pricing = this.getPricing(usage.model);
    const cost = calculateCost(
      { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens },
      pricing
    );

    this.records.push({
      ...usage,
      timestamp: new Date(),
      cost
    });
  }

  // Aggregation methods
  getTotalCost(since: Date): number {
    return this.records
      .filter(r => r.timestamp >= since)
      .reduce((sum, r) => sum + r.cost, 0);
  }

  getCostByOperation(): Map<string, number> {
    const byOp = new Map<string, number>();
    for (const r of this.records) {
      byOp.set(r.operation, (byOp.get(r.operation) || 0) + r.cost);
    }
    return byOp;
  }

  getCostByModel(): Map<string, number> {
    const byModel = new Map<string, number>();
    for (const r of this.records) {
      byModel.set(r.model, (byModel.get(r.model) || 0) + r.cost);
    }
    return byModel;
  }

  getTopExpensiveOperations(limit: number = 10): UsageRecord[] {
    return [...this.records]
      .sort((a, b) => b.cost - a.cost)
      .slice(0, limit);
  }
}