Compare LLM API Costs Across Providers

n volumes.

• Tier Dominance: At scale, choosing the correct capability tier matters more than fine-tuning model selection within that tier.
• Context Window Tax: Smaller context windows introduce chunking and retry overhead that negate per-token savings.
• Sweet Spot: Begin with Advanced tier, downgrade to Budget if output quality meets acceptance criteria, and escalate to Flagship only for tasks requiring complex reasoning or high-stakes decision-making.

Core Solution

The llmprices CLI eliminates pricing fragmentation by aggregating real-time rates, automatically tokenizing prompts, and decoupling capability tiers from cost metrics. It operates on a YAML-driven pricing database, enabling instant cross-provider estimation, head-to-head comparison, and value-based sorting.

Installation & Core Commands

pip install llmprices

calc
Estimates the cost of a prompt across all models and sorts by price.

llm-cost calc "Build a Python REST API" --output 500

╭── Cost estimate · 7 input + 500 output ───────────────────────────────────╮
│  #  Provider      Model                Total cost    vs cheapest           │
│  1  Mistral AI    Mistral Small 3.2    $0.000090     cheapest              │
│  2  DeepSeek      DeepSeek V4 Flash    $0.000141     1.6x                  │
│  3  Google        Gemini 2.5 Flash-L   $0.000200     2.2x                  │
│  4  xAI           Grok 4.1 Fast        $0.000251     2.8x                  │
│  5  OpenAI        GPT-5.4 Nano         $0.000626     7.0x                  │
│  6  Anthropic     Claude Haiku 4.5     $0.002507     27.9x                 │
│  7  Google        Gemini 3.1 Pro       $0.006014     66.8x                 │
│  8  OpenAI        GPT-5.5              $0.015035    167.1x                 │
╰───────────────────────────────────────────────────────────────────────────╯

You can pass a raw text prompt (tokens are counted automatically) or skip it and specify token counts directly:

llm-cost calc --input 4000 --output 1000
llm-cost calc --input 10000 --output 2000 --top 5 --provider google

compare
Direct head-to-head comparison between specific models.

llm-cost compare gpt-5-5 claude-opus-4-7 gemini-3-1-pro

llm-cost compare claude-sonnet-4-6 gpt-5-4 gemini-3-flash --input 5000 --output 1000

llm-cost compare gpt-5-5 claude-opus-4-7 --prompt "Explain how transformers work"

list
Browse the full catalog with filtering and sorting.

llm-cost list
llm-cost list --provider anthropic
llm-cost list --sort output
llm-cost list --search gemini

Efficiency Tiers Architecture Models are grouped into four capability tiers independent of price to prevent capability-cost misalignment:

• Flagship — GPT-5.5, Claude Opus 4.7, o3. Complex analytical tasks, critical decision-making, high-quality creative work.
• Advanced — GPT-5.4, Claude Sonnet 4.6, DeepSeek R1, o4 Mini. Professional workloads: code generation, detailed analysis, structured output.
• Standard — GPT-5, Claude Haiku 4.5, Gemini Flash, Mistral Large 3. Everyday tasks, basic text processing, simple QA at scale.
• Budget — Mistral Small 3.2, Command R7B, DeepSeek V4 Flash. High-volume pipelines, classification, prototyping.

Usage with tier filtering and value sorting:

llm-cost list --tier budget
llm-cost calc "Code review" --tier advanced --sort value
llm-cost calc "Complex analysis" --tier flagship --sort value

Extensibility & Configuration Prices are stored in a plain YAML file at llm_cost/data/prices.yaml. Adding a new model requires four fields:

my-new-model:
  name: My New Model
  input: 1.50      # $ per 1M input tokens
  output: 6.00     # $ per 1M output tokens
  context: 200000  # context window in tokens

Pitfall Guide

1. Ignoring Output Token Multipliers: Output costs typically run 3x–20x higher than input. Optimizing pipelines solely for input token rates will cause severe budget overruns when generating long responses or structured JSON.
2. Overlooking Context Window Constraints: Selecting a model with a lower per-token rate but a restricted context (e.g., 128K) forces chunking, state management, and additional API calls. The engineering overhead and retry costs often exceed the premium of a 1M+ context model.
3. Price-First Model Selection: Choosing the absolute cheapest model for complex reasoning or code generation yields unusable outputs, triggering retry loops that inflate the effective cost per successful task.
4. Misaligning Tier with Task Complexity: Deploying Flagship models for high-volume classification or Budget models for architectural code generation creates a 99%+ cost inefficiency or catastrophic quality degradation. Always map task complexity to the tier matrix first.
5. Static Pricing Assumptions: LLM providers adjust rates weekly. Hardcoding pricing into CI/CD pipelines or budget forecasts without a dynamic aggregation tool leads to stale financial models and unexpected invoice spikes.
6. Neglecting Value-Based Sorting: Pure cost sorting ignores capability density. Always use --sort value to balance price-to-quality ratio, ensuring you aren't paying for unused capability or sacrificing output reliability for marginal savings.

Deliverables

• 📘 LLM Cost Optimization Blueprint: Step-by-step workflow for integrating llm-cost into CI/CD, prompt engineering pipelines, and budget forecasting. Includes tier-mapping matrices and context-window tradeoff calculators.
• ✅ Pre-Deployment Cost Validation Checklist: 12-point verification protocol covering input/output token ratios, context limit validation, tier alignment, value-sort configuration, and dynamic price refresh scheduling.
• ⚙️ Configuration Templates: Production-ready prices.yaml extension schema, provider-specific rate override patterns, and automated token-counting integration snippets for Python/Node.js pipelines.