LLM Inference Service Pricing and Plan Quota Evaluation: A Task-Level Cost Method
This article presents an engineering-oriented method for evaluating LLM inference pricing and plan quotas. It explains how to break pricing into input, output, and cache-hit token rates; convert plan quotas into effective discount multipliers; calculate task-level costs using cache hit rates and output share; and assess performance, throttling, observability, and migration constraints. Readers can use the cost formula, pseudocode, and evaluation checklist to compare services and build cost attribution for real workloads.
LLM Inference Service Pricing and Plan Quota Evaluation: A Task-Level Cost Method
When assessing whether an LLM inference service is “expensive,” looking only at the input price, output price, or monthly plan fee often leads to misleading conclusions. A more reasonable approach is to break the price into accountable billing items and then combine them with real task workloads, cache hit rates, output share, concurrency limits, and plan conversion multipliers to calculate the “task-level effective cost.” This article provides an engineering-oriented evaluation method for developer selection, enterprise budgeting, and platform-side cost monitoring.
1. Break Unit Prices into a Computable Structure
Common inference service billing distinguishes three types of tokens: input tokens, output tokens, and cache-hit tokens. Naming and definitions may differ across services, but from an engineering perspective they can be abstracted as follows:
- Input price: the part that enters the model, such as user requests, context, and retrieved snippets;
- Output price: the part generated by the model;
- Cache-hit price: the part billed at a lower rate when repeated context or prefixes are reused.
Take a set of example parameters used only to illustrate the method: assume a service lists input at CNY 20 per million tokens, output at CNY 100 per million tokens, and cache hits at CNY 1 per million tokens. This does not refer to any specific service and is used only to demonstrate the calculation. As shown, the output price is 5 times the input price, and the cache-hit price is about 5% of the input price. This means different task types have completely different cost sensitivity: input-intensive tasks such as summarization, Q&A, and retrieval-augmented generation pay more attention to input and cache prices; output-intensive tasks such as code generation, long-form writing, and multi-turn agents are more affected by the output price.
Therefore, when evaluating pricing, at least three questions should be asked: What is the average input token count for the task? What is the average output token count? How high are the repeated context share and cache hit rate? Without these three data points, simply comparing “input at CNY 20” or “output at CNY 100” makes it difficult to determine the real cost.
2. Convert Plan Quotas into an “Effective Discount Multiplier”
There is usually a discount multiplier between the plan price and the quota converted at list price. It can be defined as:
Plan discount multiplier = usable quota inside the plan converted at list price ÷ plan price
For example, if a CNY 199 plan has a list-price equivalent usable quota of about CNY 1,200–2,800, the nominal discount multiplier is about 6–14x; another type of plan may reach 20–50x. This difference in multiplier directly affects users’ perception of whether a plan is cost-effective. However, note that the discount multiplier is only a nominal value. The actual effective multiplier also depends on:
- Whether the quota has an expiration date and whether unused quota is cleared;
- Whether concurrency, rate, or single-request context length is limited;
- Whether the billing price after overage is increased;
- Whether discounts such as cache hits and batch processing also apply within the plan;
- Whether real tasks can consume the high quota rather than being constrained by throttling or latency limits.
Therefore, when comparing plans, do not compare only the “monthly fee.” Compare “the number of tasks that can be completed under the target workload.” If a plan has a high quota but low concurrency, its effective value for high-concurrency businesses will decline; if a plan has a low price but a high output price, it may not be cheap for generation-heavy tasks.
3. Task-Level Cost Formula and the Impact of Cache Hits
Let the number of input tokens be Tin, the number of output tokens be Tout, the input price be P_in, the output price be P_out, the cache-hit price be P_cache, and the cache hit rate be h. The effective input price is:
Effective input price = h × P_cache + (1 - h) × P_in
The cost per task is:
Cost = Tin / 1,000,000 × effective input price + Tout / 1,000,000 × P_out
The following pseudocode demonstrates the calculation logic:
function task_cost(Tin, Tout, P_in, P_out, P_cache, hit_rate):if hit_rate < 0 or hit_rate > 1:raise error("hit_rate must be between 0 and 1")effective_input_price = hit_rate * P_cache + (1 - hit_rate) * P_ininput_cost = Tin / 1000000 * effective_input_priceoutput_cost = Tout / 1000000 * P_outreturn input_cost + output_cost# Example parameters are for method illustration onlyP_in = 20P_out = 100P_cache = 1# Task A: 800k input tokens, 200k output tokens, 60% cache hit ratecost_a = task_cost(800000, 200000, P_in, P_out, P_cache, 0.6)# Task B: same workload, but 90% cache hit ratecost_b = task_cost(800000, 200000, P_in, P_out, P_cache, 0.9)
Using the example parameters above, Task A has an effective input price of 0.6×1 + 0.4×20 = 8.6 CNY per million tokens, and a total cost of about 0.8×8.6 + 0.2×100 = 26.88 CNY. Task B has an effective input price of 0.9×1 + 0.1×20 = 2.9 CNY per million tokens, and a total cost of about 0.8×2.9 + 0.2×100 = 22.32 CNY. It can be seen that when the cache hit rate increases from 60% to 90%, cost drops by about 17%. For long-context, multi-turn dialogue, and retrieval-augmented generation scenarios, the engineering value of caching strategy may be no less than price negotiation.
4. Why the Weight of Output Price Is Easily Underestimated
Many evaluation tables list only the input price because input tokens are easier to count. In real business workloads, however, output tokens are often less controllable: the model may generate lengthy explanations, repeated content, or structured JSON; multi-turn agents also produce intermediate reasoning and tool-call descriptions. If the output price is several times the input price, controlling output length becomes a core means of cost optimization.
From an engineering perspective, the following measures can be taken:
- Set maximum output tokens and stop conditions for generation tasks;
- Use structured output constraints to reduce unnecessary natural language;
- Use short output templates for summarization, classification, and extraction tasks;
- Compress historical context for multi-turn tasks to improve cache hit rates;
- Route simple tasks to smaller or lower-cost services and reserve high-capability services for complex tasks;
- Record input, output, cache hits, and task type for each request at the gateway layer to form cost attribution.
5. Technical Constraints Behind Plan Design
High-discount plans are not purely a market behavior; they are constrained by the cost structure of inference. Service providers need to deal with GPU utilization, batching efficiency, KV cache memory usage, scheduling complexity, rate-limiting policies, and SLA guarantees. The higher the plan discount, the more providers need to rely on high-concurrency filling, cache reuse, request merging, quantization, or distillation to reduce costs. Therefore, when evaluating a plan, pay attention to “availability constraints”: whether it is stable during peak hours, whether long-context requests are slowed down, whether cache can be reused, and whether overage is controllable. For enterprises, a plan with a low nominal price but frequent throttling may have a higher actual unit task cost.
6. Selection Evaluation Checklist
It is recommended to build an evaluation table from the following dimensions:
- Price definitions: whether input, output, and cache hits are listed separately and whether units are consistent;
- Task-level cost: use real samples to calculate average input, output, and cache hit rate;
- Plan conversion: calculate the nominal discount multiplier and the effective discount multiplier under the target workload;
- Performance constraints: concurrency, rate, P95/P99 latency, and context length;
- Stability: throttling policy, overage behavior, and failure recovery;
- Observability: whether token usage, cache hits, call logs, and budget alerts are provided;
- Migration cost: API compatibility, prompt adaptation, evaluation regression, and data compliance.
Conclusion
Price evaluation for LLM inference services should not stop at superficial comparisons such as “the unit price is several times higher” or “how much does the plan cost.” A more rigorous method is to break down input, output, and cache-hit prices, establish a task-level cost formula, calculate effective cost using cache hit rate and output share, and then correct nominal prices with plan discount multipliers and availability constraints. For developers, it is advisable to first run real workloads as benchmarks; for enterprises, it is advisable to include token usage, cache hits, task success rate, and unit task cost in monitoring. Only in this way can reproducible technical decisions be made among price, performance, and stability.
