For deep dives on individual providers see OpenAI API Pricing, Anthropic API Pricing, or AWS Bedrock Pricing. This page is the cross-provider comparison.
For real-world cost examples (classification, generation, RAG) and how to convert token prices to monthly spend, see our LLM Token Pricing Guide.
LLM pricing comparison 2026 starts with the direct OpenAI answer: GPT-4o costs $2.50 input / $10.00 output per 1M tokens, while GPT-4.1 costs $2.00 input / $8.00 output per 1M tokens. GPT-4.1 replaced GPT-4o as the default recommendation for most production workloads. GPT-4o is still a live budget line for teams with an existing integration, cached prompts, or a reason to keep legacy behavior stable.
Model prices shape product decisions long before a customer sees an invoice. A model can look cheap in a prototype and become a literal money pit once every request carries a long prompt, a large response, or repeated agent calls. Input and output pricing belong in the same conversation as quality, latency, tool use, and the amount of context your application sends on every turn.
We update this page monthly. The table covers the OpenAI current and legacy choices alongside the open-model budget path. Prices are per 1M tokens unless stated otherwise.
TLDR
GPT-4.1 is the default OpenAI production pick at $2.00 input / $8.00 output per 1M tokens. GPT-4o remains pricier legacy infrastructure. GPT-4o Mini, Llama 4, and DeepSeek V3 offer cheaper paths for high-volume tasks, while text-embedding-3-small keeps retrieval costs low.
Quick Pricing Reference: All Models at a Glance
This table covers the primary API-accessible models from each provider. Prices are per 1 million tokens unless noted otherwise.
| Model | Provider | Input (per 1M tokens) | Output (per 1M tokens) | Context Window |
|---|---|---|---|---|
| GPT-4.1 | OpenAI | $2.00 | $8.00 | 1M |
| GPT-4.1 mini | OpenAI | $0.40 | $1.60 | 1M |
| GPT-4.1 nano | OpenAI | $0.10 | $0.40 | 1M |
| GPT-4o | OpenAI | $2.50 | $10.00 | 128K |
| GPT-4o Mini | OpenAI | $0.15 | $0.60 | 128K |
| o3 | OpenAI | $2.00 | $8.00 | 200K |
| o3-mini | OpenAI | $1.10 | $4.40 | 200K |
| o4-mini | OpenAI | $1.10 | $4.40 | 200K |
| Claude Opus 4 | Anthropic | $15.00 | $75.00 | 200K |
| Claude Sonnet 4 | Anthropic | $3.00 | $15.00 | 200K |
| Claude Haiku 3.5 | Anthropic | $0.80 | $4.00 | 200K |
| Gemini 2.5 Pro | $1.25 | $10.00 | 1M | |
| Gemini 2.5 Flash | $0.15 | $0.60 | 1M | |
| Gemini 2.0 Flash | $0.10 | $0.40 | 1M | |
| Llama 4 Maverick | Meta (via providers) | $0.20 | $0.60 | 1M |
| Llama 4 Scout | Meta (via providers) | $0.10 | $0.25 | 10M |
| Mistral Large 2 | Mistral | $2.00 | $6.00 | 128K |
| Mistral Small | Mistral | $0.10 | $0.30 | 32K |
| Cohere Command R+ | Cohere | $2.50 | $10.00 | 128K |
| Cohere Command R | Cohere | $0.15 | $0.60 | 128K |
| DeepSeek V3 | DeepSeek | $0.14 | $0.28 | 128K |
| text-embedding-3-small | OpenAI | $0.02 | n/a | 8,191 |
Prices reflect standard API rates. Volume discounts, committed-use agreements, and batch processing can reduce costs by 25-50% depending on the provider.
The price gap is wide enough to change architecture. GPT-4.1 mini costs $0.40 input / $1.60 output per 1M tokens, while GPT-4.1 costs $2.00 input / $8.00 output per 1M tokens. That makes the smaller model a sensible default for extraction, classification, routing, formatting, and other work where a larger model adds cost without adding much useful judgment.
For the full OpenAI catalog and rate details, see our OpenAI API pricing page. If you need to estimate actual request costs from prompt and response length, use the LLM token pricing guide.
OpenAI Pricing Breakdown
OpenAI runs the largest model portfolio in the market. The current lineup spans from nano-class models at $0.10/1M input tokens up to the full o3 reasoning model. For most production workloads, the GPT-4.1 family replaced GPT-4o as the default recommendation.
GPT-4.1 Family
GPT-4.1 is OpenAI's workhorse. It handles coding, analysis, and long-context tasks with a 1M token context window. The mini variant cuts cost by 80% with surprisingly small quality tradeoffs on structured tasks. The nano variant is built for high-volume, latency-sensitive workloads where you need sub-100ms responses.
Cost example: processing 10,000 customer support tickets (average 500 tokens input, 200 tokens output each) costs roughly $16 with GPT-4.1, $3.20 with GPT-4.1 mini, and $0.80 with GPT-4.1 nano.
Reasoning Models (o3, o4-mini)
OpenAI's reasoning models think before answering. They consume more tokens internally (chain-of-thought tokens are billed as output), which means actual costs run 2-5x higher than the per-token price suggests. Use these for complex analysis, math, and multi-step reasoning. Not cost-effective for simple classification or extraction tasks.
For detailed OpenAI pricing tiers and rate limits, see our OpenAI API Pricing page.
GPT-4o Pricing Per Million Tokens
GPT-4o costs $2.50 input / $10.00 output per 1M tokens Related analysis. That is the direct answer for teams searching for legacy GPT-4o API costs.
The model still appears in production stacks because replacing a deployed model has costs beyond the API bill. Prompts may have been tuned around its response style. Evaluation sets may have been built around it. Downstream parsers may quietly depend on the format it tends to produce. A migration can expose all of those assumptions at once.
That does not make GPT-4o the obvious buying choice for a new project. GPT-4.1 costs $2.00 input / $8.00 output per 1M tokens Related analysis. The newer family gives a buyer a lower listed rate and a clearer starting point for fresh production work.
The important distinction is between a migration decision and a purchasing decision. An existing GPT-4o application may earn its place until an evaluation shows that another model keeps quality stable. A new application should begin with GPT-4.1 or a smaller option, then earn its way up only when the task demands it.
Output tokens deserve the closer look. GPT-4o charges $10.00 output per 1M tokens Related analysis, compared with $2.50 input per 1M tokens. Applications that generate long reports, detailed explanations, agent traces, or large code edits feel that difference quickly. Tight response instructions and structured outputs can improve product behavior while keeping that part of the bill under control.
There is also a human cost to leaving the model decision vague. Teams tend to send every task to the strongest familiar model because it is easy. Then the system grows, product usage grows, and the finance conversation arrives late. Put models behind a routing layer early. The first version can be simple. It only needs to make cost a deliberate product decision.
GPT-4o Mini vs GPT-4.1 Mini: Budget Model Pricing
GPT-4o Mini costs $0.15 input / $0.60 output per 1M tokens Related analysis. GPT-4.1 mini costs $0.40 input / $1.60 output per 1M tokens Related analysis.
GPT-4o Mini wins the listed-price comparison. Teams with huge volumes of straightforward work should care. Classification, tagging, basic extraction, short-form transformations, and simple support routing can often tolerate a lower-cost model well. The job is to prove that with examples from your own traffic, not to assume every cheaper model is good enough.
GPT-4.1 mini costs more, so it needs a reason to be there. That reason is usually better task performance, more dependable structured responses, or fewer failures that require a second call. A model rate is only one input to unit economics. If a cheaper model creates malformed output, sends too many requests to a fallback, or creates support work for humans, its apparent advantage shrinks.
This is where teams often over-focus on a single benchmark. Production tasks are messier. Customer text is inconsistent. Documents have strange formatting. Tool results can be incomplete. The prompt that looked clean in a test environment gets hit with an attachment, a typo, and a pasted table from a spreadsheet. Run the model through that mess.
A practical split often emerges. Use the lowest-cost model that handles the repetitive portion of the workflow. Reserve GPT-4.1 mini for tasks that need more careful extraction or a higher success rate. Send the narrow slice of difficult requests to GPT-4.1. That kind of routing keeps the expensive model from becoming the default answer to every product feature.
The buyer who wins is the one measuring completed work, rather than just tokens. Track whether the response was accepted, retried, escalated, or edited by a human. You want a cost per useful result. Raw token price is where the comparison starts.
OpenAI Embeddings Pricing
OpenAI embeddings run text-embedding-3-small at $0.02/1M tokens Related analysis. Embeddings are one of the cheapest lines in a typical AI stack, which is why teams often treat them as background plumbing.
That can be a mistake. Retrieval quality determines what your generation model sees. If the search layer surfaces the wrong documents, an expensive model will write a polished answer around the wrong facts. The model bill is then the visible symptom of a retrieval problem.
Embedding cost is tied to how much text you index and how often you refresh it. Documentation, product catalogs, support conversations, policy updates, and customer files all add tokens before a user asks a question. The $0.02/1M tokens rate for text-embedding-3-small Related analysis makes broad indexing economically accessible, but it does not remove the need for sensible data hygiene.
Good retrieval starts with material worth retrieving. Remove duplicate pages. Separate unrelated topics. Preserve useful titles and metadata. Keep permissions intact. An embedding model can help locate relevant language, but it cannot fix a knowledge base where the latest policy sits beside outdated copies with the same title.
Budget owners should treat embeddings and generation as connected layers. Spending a little effort on chunking, document freshness, and evaluation can reduce wasted generation calls. A customer gets the correct answer sooner. Your application sends fewer retries. The strongest model in the world cannot rescue a search result that never included the answer.
If your product uses retrieval-augmented generation, test the full path. Ask whether the right source was found, whether the right passage was selected, and whether the final response stayed grounded in that material. The cheap component can decide whether the expensive component has a chance.
Anthropic Pricing Breakdown
Anthropic prices on a three-tier system: Haiku (fast and cheap), Sonnet (balanced), and Opus (maximum capability). The gap between tiers is significant. Opus costs 5x more than Sonnet on input and 5x more on output.
When Opus Is Worth the Premium
Claude Opus 4 is the most expensive mainstream LLM at $15/$75 per million tokens. That price point only makes sense for tasks where quality differences directly impact revenue: legal document analysis, complex code generation, research synthesis, and agentic workflows where errors cascade. For most applications, Sonnet 4 handles the work at 80% of the quality for 20% of the cost.
Haiku: The Budget Workhorse
Claude Haiku 3.5 at $0.80/$4.00 fills the high-quality budget slot. It outperforms GPT-4o mini on many benchmarks while costing roughly double. The tradeoff is worth it when you need Anthropic's safety characteristics or superior instruction following on subtle reasoning tasks.
Full Anthropic tier comparison at our Anthropic API Pricing page.
Google Gemini Pricing Breakdown
Google's pricing strategy is aggressive. Gemini 2.5 Flash at $0.15/$0.60 per million tokens undercuts nearly everything except open-source models, and it includes a 1M token context window. The free tier (see our AI Free Tiers 2026 guide) is generous enough for prototyping and low-volume production use.
Gemini 2.5 Pro
At $1.25/$10.00, Gemini 2.5 Pro offers strong reasoning and coding performance. The input pricing undercuts Claude Sonnet and GPT-4.1, but output tokens are priced at $10 per million, making generation-heavy workloads expensive. Use Gemini Pro when your prompts have high input-to-output ratios (document analysis, summarization of long texts).
Flash Models
Gemini 2.5 Flash and 2.0 Flash are the price-performance leaders. At $0.10-$0.15 per million input tokens, they compete directly with open-source model hosting costs while requiring zero infrastructure management.
Open-Source Model Costs
Llama 4, Mistral, and other open-weight models don't have a single price. Your cost depends on how you host them.
Hosted API Pricing
Providers like Together AI, Fireworks, Groq, and AWS Bedrock host open-source models and charge per token. Typical rates for Llama 4 Maverick range from $0.15-$0.30 per million input tokens depending on the provider and commitment level. Self-hosting on your own GPUs can be cheaper at scale but requires significant DevOps investment.
Self-Hosting Economics
Running Llama 4 Maverick (400B+ parameters, mixture-of-experts) requires multiple high-end GPUs. A typical setup costs $3-8/hour on cloud GPU instances. At sustained high throughput (100+ requests/minute), self-hosting breaks even with API pricing around the 50,000 requests/day mark. Below that, hosted APIs are cheaper.
The Open-Model Budget Path
Llama 4 Maverick via hosted providers costs $0.20 input / $0.60 output per 1M tokens, and Llama 4 Scout costs $0.10 / $0.25 Related analysis. DeepSeek V3 prices at $0.14/$0.28 per million input/output tokens Related analysis.
Those rates put hosted open models in a different budget bracket from OpenAI's larger general models. Llama 4 Scout is particularly cheap for workloads where prompt volume is high and the task is constrained. DeepSeek V3 offers another low-cost route for teams evaluating general language tasks without starting from an OpenAI default.
Price alone does not pick the winner. Hosted open models introduce a different set of buying questions: provider reliability, data handling, regions, throughput limits, model version changes, tool support, and the ease of moving workloads if the provider changes terms. A low token rate is useful only if the service works where and how your application needs it to work.
Still, this is the budget path worth testing. Developers who have been using a premium model for bulk transformation work may find that a hosted open model handles much of the volume. The savings can fund a better evaluation process, more retrieval coverage, or selective use of a stronger model where quality affects revenue.
The open-model route also gives buyers negotiating power. If every task depends on one provider and one model family, the team has little flexibility when pricing or performance shifts. A second working path changes the conversation. It also forces cleaner abstractions in the application, which tends to pay off later.
Do we really need the same model for a customer-facing explanation, a document classifier, and a short JSON extraction task? Most products do not. They need an evaluation suite that makes the tradeoffs visible.
Cost Comparison by Workload
Raw per-token pricing tells part of the story. Actual costs depend on your workload pattern.
Chatbot / Conversational AI
Average conversation: 2,000 tokens input (system prompt + history), 500 tokens output per turn, 5 turns per session.
| Model | Cost per Session | Cost per 10K Sessions/Month |
|---|---|---|
| GPT-4.1 | $0.06 | $600 |
| GPT-4.1 mini | $0.012 | $120 |
| Claude Sonnet 4 | $0.068 | $675 |
| Gemini 2.5 Flash | $0.005 | $45 |
| Llama 4 Maverick (hosted) | $0.005 | $55 |
Document Processing Pipeline
Average document: 8,000 tokens input, 1,000 tokens output (summary + extraction).
| Model | Cost per Document | Cost per 50K Docs/Month |
|---|---|---|
| GPT-4.1 | $0.024 | $1,200 |
| GPT-4.1 nano | $0.001 | $60 |
| Claude Haiku 3.5 | $0.010 | $520 |
| Gemini 2.5 Flash | $0.002 | $90 |
| Gemini 2.0 Flash | $0.001 | $60 |
Code Generation / Analysis
Average request: 3,000 tokens input (code + instructions), 2,000 tokens output.
| Model | Cost per Request | Cost per 100K Requests/Month |
|---|---|---|
| GPT-4.1 | $0.022 | $2,200 |
| Claude Sonnet 4 | $0.039 | $3,900 |
| Claude Opus 4 | $0.195 | $19,500 |
| Gemini 2.5 Pro | $0.024 | $2,375 |
| Mistral Large 2 | $0.018 | $1,800 |
Cost Optimization Strategies
The cheapest model isn't always the best value. Here's how to optimize spend without sacrificing quality.
1. Tiered Model Routing
Route requests to different models based on complexity. Use a cheap classifier (GPT-4.1 nano or Gemini 2.0 Flash) to assess request difficulty, then route simple requests to budget models and complex ones to premium models. This typically cuts costs 40-60% compared to using a single model for everything.
2. Prompt Caching
Both OpenAI and Anthropic offer prompt caching for system prompts and repeated context. Cached input tokens cost 50-90% less than fresh tokens. If your system prompt is 2,000+ tokens, caching pays for itself immediately. Anthropic's prompt caching reduces cached input to $0.30/1M on Sonnet (90% discount).
3. Batch Processing
OpenAI's Batch API charges 50% less for non-real-time workloads. If your use case can tolerate 24-hour turnaround (nightly report generation, weekly analysis runs), batch processing is the simplest cost reduction available.
4. Context Window Management
Stuffing the full context window costs money. A 100K token input to Claude Sonnet costs $0.30 per request. Trim your context to what's actually needed. Use RAG to retrieve only relevant chunks instead of passing entire documents.
5. Output Token Optimization
Output tokens cost 2-5x more than input tokens across all providers. Request concise outputs. Use structured output formats (JSON) to avoid verbose prose. Set max_tokens limits to prevent runaway generation.
Provider Comparison: Beyond Price
Price alone doesn't determine value. Consider these factors when choosing a provider.
Rate Limits and Availability
OpenAI offers the highest default rate limits. Anthropic's rate limits are more restrictive but increase with usage tier. Google provides generous free-tier limits but can throttle aggressively during peak hours. For production workloads, check each provider's rate limit documentation and request increases proactively.
Quality vs. Cost Tradeoff
The best model for your use case isn't always the most expensive one. Run evaluations on your specific tasks. We've seen cases where GPT-4.1 mini outperforms GPT-4.1 on well-structured extraction tasks, and where Claude Haiku beats Gemini Pro on context-heavy classification. Price per token matters less than price per correct output.
Ecosystem and Tooling
OpenAI has the largest ecosystem: fine-tuning, assistants API, function calling, and 500+ third-party integrations. Anthropic offers the best developer experience for complex system prompts and tool use. Google integrates tightly with GCP services (Vertex AI, BigQuery). Your existing infrastructure should influence your choice.
Pricing Trends: Where Costs Are Heading
LLM API prices have dropped roughly 10x over the past two years. GPT-4-class performance that cost $30/1M input tokens in early 2024 now costs $2-3/1M. Several forces continue pushing prices down.
- Hardware improvements: New GPU architectures (NVIDIA Blackwell, AMD MI350) increase inference throughput, reducing per-token serving costs.
- Model efficiency: Mixture-of-experts architectures (used by Llama 4, Gemini, Mistral) activate only a fraction of total parameters per request, cutting compute costs.
- Competition: Google, Meta, and Mistral are subsidizing pricing to gain market share. This benefits buyers.
- Open-source pressure: Free open-weight models set a floor on how much providers can charge for closed models of similar quality.
Expect another 2-3x price reduction over the next 12 months for equivalent quality levels.
How to Compare LLM API Costs Without Fooling Yourself
Start with the unit you are buying: useful output. A rate card shows token prices. Your product needs completed tasks, accurate answers, valid structured output, and a response time customers will accept. The cheapest API can lose if it produces enough failures to create retries or human cleanup.
Build a test set from real inputs. Include the clean examples that make demos look good, then include the ugly ones. Long documents. Vague requests. Misspelled fields. Requests that need a refusal. Inputs where the desired answer is short but the available context is large. Your model choice should survive the conditions it will face after launch.
Keep input and output tokens separate in your estimates. A retrieval system may send a large context window and request a short answer. A report generator may receive a compact prompt and create a long response. GPT-4.1 costs $2.00 input / $8.00 output per 1M tokens Related analysis, so the response side can drive spend even when the prompt is carefully trimmed.
Then test routing. A low-cost model can classify incoming work and identify the small share that needs more judgment. A mid-tier model can handle the main flow. A premium model can cover the edge cases where the cost of a bad answer is higher than the API bill. This approach is less glamorous than declaring one model the company standard. It is also how budgets stay intact.
Provider comparisons need to include operational work. An API that makes logging, observability, version control, evaluation, and fallback handling easier may be worth a higher rate for a team that lacks infrastructure capacity. The answer depends on your workload. That is why a pricing page should narrow the field, not pretend to settle every technical decision.
Our LLM API pricing comparison goes deeper on cross-provider choices. Teams deploying through cloud marketplaces should also check AWS Bedrock pricing, since the delivery path can affect the model options available to them.
Which Model Should You Choose?
Here's the decision framework we recommend.
- Lowest possible cost, acceptable quality: Gemini 2.0 Flash or GPT-4.1 nano
- Best price-performance balance: GPT-4.1 mini or Gemini 2.5 Flash
- Production quality, reasonable cost: GPT-4.1 or Claude Sonnet 4
- Maximum quality, cost secondary: Claude Opus 4 or o3
- High volume, cost-sensitive: Llama 4 Maverick (self-hosted) or Cohere Command R
- Privacy/compliance requirements: Self-hosted Llama 4 or Mistral via VPC deployment
For provider-specific deep dives, see our OpenAI pricing guide, Anthropic pricing guide, and Cohere pricing guide.
Key Takeaways
- GPT-4.1 costs $2.00 input / $8.00 output per 1M tokens and is the default OpenAI choice for new production work.
- GPT-4o costs $2.50 input / $10.00 output per 1M tokens, making it a legacy model to evaluate rather than a default.
- GPT-4o Mini at $0.15 input / $0.60 output per 1M tokens is the lowest-cost OpenAI option in this comparison.
- Llama 4 and DeepSeek V3 offer a budget path for workloads that can use hosted open models.
- text-embedding-3-small costs $0.02/1M tokens, but retrieval quality still decides whether generation has the right context.
Frequently Asked Questions
OpenAI API pricing for April 2026: what are the current rates?
April 2026 OpenAI rates: GPT-4.1 at $2/1M input and $8/1M output. GPT-4.1 Mini at $0.40/$1.60. GPT-4.1 Nano at $0.10/$0.40. o3 reasoning at $15/$60. GPT-4o is grandfathered for existing users at the legacy $2.50/$10 rate. Batch API discounts everything 50%. Prompt caching reduces repeated input up to 90%. Rates have not changed since the GPT-4.1 launch in January 2026.
OpenAI GPT-4o API pricing for April 2026?
GPT-4o is grandfathered for existing users at $2.50/1M input and $10/1M output as of April 2026. New API integrations default to GPT-4.1 family at $2/$8 (full) or $0.40/$1.60 (Mini). For most production workloads, GPT-4.1 Mini matches GPT-4o quality at lower cost. Existing GPT-4o integrations continue at legacy pricing but should be evaluated for migration to Mini. New deployments should not start on GPT-4o.
OpenAI API pricing changes for April 2026?
No list price changes from OpenAI in April 2026. The most recent significant change was the GPT-4.1 family launch in January 2026 which replaced GPT-4o pricing. Through February-April, OpenAI added GPT-4.1 Nano at the lowest tier ($0.10/$0.40) and expanded o3 reasoning access at $15/$60. Batch API discount confirmed at 50% across all models. Prompt caching automatic discount up to 90% on cached input. The 2026 trend is capability expansion at stable list rates rather than price increases.
LLM API pricing comparison for 2026: which is cheapest?
Cheapest per-million-token rates in April 2026: GPT-4.1 Nano at $0.10/$0.40, Claude Haiku 4.5 at $1/$5, Gemini 1.5 Flash at $0.075/$0.30, DeepSeek V3 at $0.14/$0.28. Cheapest absolute is Gemini Flash. Best price-quality ratio for production: GPT-4.1 Mini at $0.40/$1.60 or Claude Haiku 4.5 at $1/$5 depending on task. For complex reasoning, o3 ($15/$60) and Claude Opus 4.6 ($5/$25) are the premium tier. Compare actual cost with prompt caching enabled (90% off) and Batch API where applicable (50% off).
OpenAI GPT API pricing for April 2026: full breakdown?
Full April 2026 OpenAI breakdown: GPT-4.1 at $2/$8 per million tokens. GPT-4.1 Mini at $0.40/$1.60. GPT-4.1 Nano at $0.10/$0.40. o3 reasoning at $15/$60. GPT-4o legacy at $2.50/$10 (grandfathered). Batch API: 50% off all models. Prompt caching: up to 90% off cached input. Embeddings: text-embedding-3-small at $0.02/1M, text-embedding-3-large at $0.13/1M. Whisper audio transcription at $0.006/minute. DALL-E 3 image generation at $0.04-$0.08 per image.
Pricing Update Tracker (2026)
LLM API pricing changes throughout the year. We track every update so this page stays the most current cross-provider source. Last reviewed: April 2026.
- April 2026: No list price changes across major providers. OpenAI, Anthropic, and Google held rates steady. Gemini 1.5 Flash still undercut on absolute price ($0.075/$0.30).
- March 2026: Anthropic 1M-token context window general availability for Sonnet 4.6 and Opus 4.6. OpenAI o3 reasoning expanded to broader API access.
- February 2026: OpenAI GPT-4.1 Nano launched at $0.10/$0.40, becoming the cheapest GPT-4-class endpoint. DeepSeek V3 pricing held at $0.14/$0.28.
- January 2026: OpenAI GPT-4.1 family launched at $2/$8 (full), $0.40/$1.60 (Mini). GPT-4o moved to legacy pricing. Anthropic Claude 4.6 family generally available at the same rates as 4.5.
- Q4 2025: Batch API discount confirmed at 50% across OpenAI and Anthropic. Prompt caching expanded to up to 90% off cached input across major providers.
Sources
- PE Collective LLM pricing 2026: $2.50 input / $10.00 output
- PE Collective OpenAI API pricing: $0.15 input / $0.60 output
- PE Collective OpenAI API pricing: $0.02/1M tokens
