Compare LLM API Costs Across Providers
Current Situation Analysis
LLM pricing architecture is fundamentally fragmented and misaligned with engineering workflows. Traditional cost estimation relies on manual cross-referencing of provider dashboards, each with inconsistent token definitions, hidden fine print, and decoupled input/output rates. Output tokens frequently cost 3x to 20x more than input tokens, yet most teams optimize solely for input rates, leading to severe budget miscalculations. Additionally, context window constraints act as a hidden cost multiplier: models with lower per-token rates but smaller limits (e.g., 128K) force chunking logic, additional API calls, and engineering overhead that often exceed the total cost of higher-priced, 1M+ context models. Without a neutral, real-time aggregation layer, teams fall into the failure mode of selecting models based on headline price rather than capability-to-cost ratio, resulting in either degraded output quality or 99%+ unnecessary infrastructure spend.
WOW Moment: Key Findings
Empirical cost modeling across 1 million requests (100 input + 50 output tokens per request) reveals that tier selection drastically outperforms individual model optimization within a tier. The cost spread between capability levels consistently exceeds 100x, making architectural tiering the primary lever for cost control.
| Approach | Total Cost (1M reqs) | Cost per 1K Requests | Quality/Complexity Fit | Engineering Overhead |
|---|---|---|---|---|
| Budget Tier | $11.00 – $28.00 | $0.011 – $0.028 | High-volume classification, prototyping | Low |
| Advanced Tier | ~$145.00 | ~$0.145 | Code generation, structured analysis | Low-Medium |
| Flagship Tier | ~$2,000.00 | ~$2.000 | Complex reasoning, critical decisions | Medium |
Key Findings:
- Cost Spread: The cheapest viable model is consistently 100–200x less expensive than flagship counterparts for identical token 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
Advancedtier, downgrade toBudgetif output quality meets acceptance criteria, and escalate toFlagshiponly 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 A
I 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.