Same API Price, Half the Bill: Why Your LLM Costs Differ Between Platforms
Comparing LLM API pricing by "price per million tokens" alone often fails to explain real monthly bills. This article breaks down why platforms with identical list prices can produce invoices that differ by up to 50%, covering batch processing discounts, subscription plan coverage rules, off-peak pricing, prompt caching, free quotas, and billing transparency. It includes a cost formula, a practical monthly cost worksheet, and actionable guidance on matching request types, model capabilities, and billing rules to sustainably reduce spending.
When choosing an LLM API, many teams start by comparing “price per million tokens.” That works as a first filter, but it doesn’t explain the actual bill. Real costs depend not only on input and output token prices, but also on caching, request timing, task latency requirements, subscription plan coverage, free quotas, and batch processing rules.
That’s why it’s not contradictory that “multiple platforms list exactly the same prices, but monthly bills differ by half.” What you really need to compare is not a single price, but the complete billing function.
1. List Price vs. Actual Cost
Suppose a high-performance model has these standard prices:
- Input: 20 per million tokens
- Cached input: 2 per million tokens
- Output: 100 per million tokens
A model geared more toward complex reasoning and professional tasks might be priced at:
- Input: 13 per million tokens
- Cached input: 1.3 per million tokens
- Output: 68 per million tokens
Across the public price lists of four common model access channels, the pay-as-you-go unit prices for these two model types are essentially identical. In other words, if you only use the standard on-demand API and your input, output, and cache hit volumes are exactly the same, the theoretical cost should be the same.
But enterprise bills usually include additional variables:
- Whether batch processing is used
- Whether a subscription plan is purchased
- Whether off-peak discounts apply
- Whether free quotas for new users or new models exist
- Whether cache write fees are incurred
- Whether each channel fully discloses all billing rules
So identical unit prices only mean “identical base rates,” not “identical final payment amounts.”
2. Calculating Model Cost on a Common Basis
Start with a simple formula to estimate the base cost:
Base cost =Input tokens ÷ 1,000,000 × input price+ Cache-hit tokens ÷ 1,000,000 × cache price+ Output tokens ÷ 1,000,000 × output price
For example, suppose a month generates:
- 100 million regular input tokens
- 400 million cache-hit input tokens
- 50 million output tokens
Using Model A’s prices:
Regular input cost = 100 × 20 = 2,000Cache-hit cost = 400 × 2 = 800Output cost = 50 × 100 = 5,000Total = 7,800
If some of these requests could be handled via batch processing, or covered by a subscription plan, the actual payment would fall below 7,800. Conversely, if input prefixes change frequently and the cache rarely hits, costs can rise noticeably.
Note that the price gap between input and output tokens is usually large. For long-form generation, code generation, report writing, and complex reasoning tasks, output cost often deserves more attention than input cost. Optimizing only inputs while ignoring outputs rarely reduces the total bill significantly.
3. How Batch Processing Can Change the Cost Structure
Batch processing suits tasks that don’t require immediate responses, such as:
- Overnight batch summary generation
- Offline processing of historical documents
- Bulk classification, labeling, and moderation
- Scheduled daily and weekly reports
- Uniform analysis across large volumes of code or text
Some platforms offer a percentage discount on standard prices for batch requests. For example, one channel charges 60% of the standard price for batch processing on designated models. A task that would cost 10,000 at standard rates could theoretically drop to about 6,000 once converted to batch processing.
But batch processing isn’t right for everything. Online customer support, real-time search, interactive coding, and transaction risk control typically require low latency and can’t simply be made asynchronous.
So split your requests by latency tolerance:
Real-time: online Q&A, interactive operations, instant decisionsNear-real-time: completion within minutes to tens of minutesOffline: delays of hours or longer are acceptable
Whenever the business allows delay, evaluate batch processing first instead of defaulting every task to the real-time API.
4. Subscription Plans: Coverage Rules Matter More Than the Monthly Fee
Subscription plans usually include a fixed monthly fee, a quota of calls, or discounts on specific models. To judge whether a plan is worth it, don’t just look at the price—answer three questions:
1. Which requests does the plan cover?
Some plans cover only designated models; others count by total tokens, request count, or model tier. If the models your business actually uses fall outside the coverage, the plan won’t reduce your main costs.
2. How are overages charged?
Common approaches include:
- Overage reverts to standard pay-as-you-go pricing
- Overage is billed at the plan’s discounted rate
- Calls are throttled once the quota is exhausted
- Prices vary by time of day
The most easily overlooked case is “low price inside the plan, standard price after overage.” If you estimate based on average monthly usage without accounting for peak traffic, overage charges can wipe out the plan’s savings.
3. Do off-peak rules fit your business?
Some subscription plans offer lower prices during off-peak hours. If a business can shift roughly half its requests to designated off-peak windows, the overall bill could drop by nearly half. But this depends on the discount size, available quota, and actual task distribution—don’t treat the theoretical ceiling as guaranteed savings.
Before committing, gather at least two consecutive weeks of hourly usage data to assess whether your workload can actually shift.
5. Caching Makes Identical Inputs Cost Different Amounts
LLM APIs typically offer cache-based pricing for repeated prefixes or repeated context. Common scenarios include:
- Every request carries the same system prompt
- Multi-turn conversations continually reuse conversation history
- Repeated questions against the same long document
- Batch tasks share a common set of instructions
On a cache hit, the input portion may be billed at a much lower rate. But caches aren’t permanent—they usually have a TTL. If two requests are too far apart, or the prefix changes, the cache may miss.
The key to cache optimization isn’t simply resending text—it’s stabilizing the request prefix. Split your content into:
Stable prefix: system rules, fixed terminology, long-lived background materialDynamic part: user question, current time, real-time data, task parameters
Placing stable content first and dynamic content last generally favors a reusable prefix. Also avoid inserting per-request timestamps, random IDs, or irrelevant logs into the system prompt.
Be aware that cache writes may have their own billing rules. When evaluating costs, check all three: cache writes, cache retention time, and cache hits—not just the hit price.
6. Free Quotas Aren’t Long-Term Discounts
Some channels offer free quotas for new models, new users, or specific promotions. Free credits genuinely reduce early trial costs, but they typically come with restrictions:
- Only for newly registered users
- Only for designated models
- Expiration dates
- Only partial coverage of input or output
- Specific usage conditions to qualify
- Standard pricing after the quota is exhausted
So free quotas are suitable for validating model quality, testing prompts, and estimating throughput—not as a basis for long-term budgeting. Budget for production using full pricing without free credits, and treat the free portion as a one-time benefit.
7. How to Compare Access Channels When Base Prices Are Identical
With unit prices equal, screen channels in this order:
First priority: workload shape
If your workload is mostly offline, prioritize batch processing support and its discount. If it’s mostly real-time, focus on plans, overage pricing, and latency stability.
Second priority: usage structure
Don’t just record total tokens—break them down:
- Regular input
- Cache-hit input
- Output
- Real-time requests
- Offline requests
- Peak-hour requests
- Off-peak requests
Third priority: integration cost
If your business already runs in a particular cloud environment, co-locating reduces network configuration, permission management, log collection, and troubleshooting overhead. Even with identical API prices, differences in operational complexity affect total cost of ownership.
Fourth priority: billing transparency
For channels whose pages don’t clearly explain caching, batch processing, or overage rules, don’t assume “there’s no such fee” or “the discount applies by default.” Mark them as items to confirm, and verify with small-scale tests or sample bills before launch.
8. An Actionable Monthly Cost Worksheet
Set up a worksheet like this:
| Item | Monthly usage | Unit price | Monthly cost |
|---|---|---|---|
| Regular input tokens | X | Standard input price | X |
| Cache-hit tokens | X | Cache input price | X |
| Output tokens | X | Output price | X |
| Batch requests | X | Discounted price | X |
| Subscription base fee | 1 | Monthly fee | X |
| Overage calls | X | Overage unit price | X |
Total cost can be expressed as:
Total cost =Standard pay-as-you-go cost+ Batch processing cost+ Subscription base fee+ Overage fees- Free quota deductions- Confirmed, redeemable discounts
The value of this worksheet is converting “advertised prices” into “business bills.” Even when channels share identical list prices, a single differing rule can produce significantly different outcomes.
9. Practical Recommendations
For teams that don’t want long-term plan commitments, favor channels with transparent rules and clear pay-as-you-go billing, and design caching and batch processing into the architecture.
For teams with a high share of offline tasks, prioritize reworking the task queue to concentrate deferrable work into off-peak windows or batch pipelines.
For teams with stable usage at large scale, compare the break-even point of subscription plans:
Break-even usage =Subscription monthly fee ÷ (standard pay-as-you-go cost − effective plan unit price)
A subscription is more likely to pay off only when actual usage consistently exceeds the break-even point and the plan covers your core models.
Finally, don’t route every request to your most capable model. Build a tiered strategy by task difficulty: use low-cost models for simple classification and extraction, high-spec models for complex analysis and high-quality generation, and human evaluation where needed. Combining model routing, cache reuse, batch processing, and off-peak scheduling is usually more effective than hunting for a lower list price.
Ultimately, LLM API cost optimization isn’t about “finding the lowest unit price”—it’s about matching request types, model capabilities, billing rules, and business latency requirements. With unified token accounting, task tiering, and monthly reconciliation in place, you can explain bill differences even when every channel charges the same base prices, and find genuinely sustainable savings.
