MaaS Gross Margins Explained: From ARR to Cost per Token

    Model-as-a-Service businesses grow through recurring API usage, but every token sold also incurs inference costs. This article explains how to interpret usage-based ARR, analyze token-level unit economics, and improve margins through inference optimization and customer mix. It also outlines practical ways for developers to control API spending and the risks that can limit long-term profitability.

    1. From Project Delivery to API Usage: A Different Growth Model

    In its first annual report after going public, a leading Chinese large language model provider reported approximately CNY 724 million in fiscal 2025 revenue, up 131.9% year over year. Its revenue for 2022–2024 was CNY 57 million, CNY 125 million, and CNY 312 million, respectively, showing accelerating growth. Another Hong Kong-listed large model company reported approximately USD 79 million in annual revenue.

    Beyond the headline figures, the more important distinction is how these companies generate revenue. Some primarily monetize AI-native applications. Others focus on Model as a Service, or MaaS, selling model capabilities to enterprises and developers through APIs.

    These are not simply different sales channels. They have different revenue mechanisms:

    • Application revenue: Customers pay for a usable product. Revenue depends on daily active users, subscriptions, and retention, while inference costs sit within the product’s overall gross-margin structure.
    • MaaS revenue: Customers pay for model usage. Revenue is directly linked to token consumption and accumulates as customers make API calls.

    Under a project-based model, a few large contracts can dominate revenue. Quarterly results fluctuate, work is difficult to reuse, and incremental delivery often requires additional staff.

    When API consumption becomes the main revenue source, growth increasingly depends not just on signing another customer, but on whether existing customers keep using the service and expand their consumption. That shift is central to interpreting the financial results.

    2. Why ARR Matters for MaaS

    One key figure in the report was approximately CNY 1.7 billion in annual recurring revenue, or ARR, for the company’s MaaS API platform—roughly 60 times the previous year’s level.

    ARR represents an annualized recurring revenue run rate. It is not the same as revenue recognized during the reporting period.

    An ARR figure of CNY 1.7 billion and annual recognized revenue of CNY 724 million are therefore not inherently contradictory:

    • Recognized annual revenue accumulates usage across the entire preceding year, including earlier months with a smaller customer base.
    • ARR typically annualizes a recent month or quarter, reflecting the current operating run rate.
    • During rapid growth, ARR can substantially exceed trailing annual revenue because recent usage is much higher than earlier usage.

    However, the gap alone does not establish the durability of that growth. The calculation method and the persistence of the underlying consumption matter.

    ARR is useful for evaluating MaaS because it focuses attention on recurring activity rather than:

    1. One-off projects: Revenue that ends when delivery is complete.
    2. Promotion-driven usage spikes: Temporary consumption generated by discounts that may disappear when incentives end.

    A usage-based ARR calculation does not automatically exclude promotional spikes. Its value depends on distinguishing sustained production workloads from temporary demand.

    For token-based businesses, durable recurring revenue generally comes from customers embedding model calls into production workflows: customer support, code completion, document processing, analytics, and agent orchestration. Exploratory proof-of-concept calls provide much weaker evidence of recurring demand.

    The following heuristic checks usage frequency and variability:

    1. def is_recurring_usage(events, window_days=30):
    2. """
    3. Estimate whether a customer's usage is recurring:
    4. 1) A sufficiently high share of active days indicates stickiness.
    5. 2) Controlled daily variation suggests a production workload
    6. rather than a burst of load testing.
    7. """
    8. active_days = len({e.day for e in events if e.in_window(window_days)})
    9. daily = {}
    10. for e in events:
    11. if e.in_window(window_days):
    12. daily[e.day] = daily.get(e.day, 0) + e.tokens_total
    13. stickiness = active_days / window_days
    14. mean = sum(daily.values()) / max(len(daily), 1)
    15. var = sum((v - mean) ** 2 for v in daily.values()) / max(len(daily), 1)
    16. cv = (var ** 0.5) / mean if mean else float("inf") # Coefficient of variation
    17. return {
    18. "stickiness": round(stickiness, 3),
    19. "cv": round(cv, 3),
    20. "recurring": stickiness >= 0.5 and cv <= 1.0,
    21. }

    This is a rough operational indicator, not proof of production adoption or a formal ARR calculation.

    Providers can use these patterns for capacity planning and compute procurement. Customers can use the same analysis when choosing purchasing commitments: highly intermittent consumption may indicate that model usage is not yet deeply embedded in the business, making a long-term commitment harder to justify.

    3. Why MaaS Revenue Growth Does Not Automatically Produce Higher Margins

    The central concern about MaaS economics is straightforward: revenue is billed per token, and serving those tokens requires ongoing computation.

    Revenue and cost grow along the same usage chain. Increasing volume can expand both at once, putting pressure on gross margins.

    A request’s cost has several components:

    • Prefill: Processing the input prompt. Longer inputs require more computation, and this stage is often compute-intensive.
    • Decode: Generating output tokens autoregressively. Each step accesses the KV cache, making decoding frequently memory-bandwidth-bound, with relatively low utilization of GPU arithmetic capacity.
    • Memory occupancy: KV-cache requirements grow with concurrency and context length, limiting how many requests a machine can serve simultaneously.
    • Supporting infrastructure: API gateways, authentication, logging, metering, object storage, monitoring, network egress, and operations staff.

    A simplified request-level model makes the relationship explicit:

    1. def request_economics(p_tokens, c_tokens, price_in, price_out,
    2. cost_prefill_per_mtok, cost_decode_per_mtok,
    3. hit_ratio=0.0, cached_price_factor=0.25):
    4. """
    5. Prices and costs are in CNY per million tokens.
    6. hit_ratio: Share of input tokens served through prefix caching.
    7. Cached input is billed at a discount and retains some serving cost.
    8. This simplified model excludes supporting infrastructure costs.
    9. """
    10. billed_in = (
    11. p_tokens * (1 - hit_ratio)
    12. + p_tokens * hit_ratio * cached_price_factor
    13. )
    14. revenue = (billed_in * price_in + c_tokens * price_out) / 1_000_000
    15. cached_in = p_tokens * hit_ratio
    16. cost = (
    17. (p_tokens - cached_in) * cost_prefill_per_mtok
    18. + cached_in * cost_prefill_per_mtok * 0.2
    19. + c_tokens * cost_decode_per_mtok
    20. ) / 1_000_000
    21. return {
    22. "revenue": revenue,
    23. "cost": cost,
    24. "gross_margin": (revenue - cost) / revenue if revenue else 0.0,
    25. }

    The cache discount and residual compute factor above are illustrative assumptions, not universal provider characteristics.

    At an aggregate level:

    Gross margin = 1 − effective cost per token / effective selling price per token

    For workloads with different input, output, and cached-token prices, both figures must use a consistent, weighted token mix.

    There are three main ways to improve this relationship:

    1. Reduce unit costs.
    2. Increase the effective selling price.
    3. Improve the mix of workloads and revenue.

    The reported increase in API platform gross margin from 3.3% to 18.9% is consistent with these levers working together, although the headline figures alone do not establish each lever’s contribution.

    4. Path One: Reduce Cost per Token Through Inference Efficiency

    The report described overall gross margins above 50%, alongside an API platform margin increase from 3.3% to 18.9%. These figures highlight the difference between company-wide economics and the economics of serving API traffic.

    Several engineering techniques can lower the platform’s unit costs.

    Continuous Batching

    With static batching, completed requests can leave capacity unused while the batch waits for longer sequences to finish.

    Continuous batching schedules work at the decoding-iteration level. Completed requests leave the batch, and new requests fill available slots, improving effective throughput.

    Paged KV-Cache Management

    Allocating KV cache in fixed-size blocks avoids reserving large contiguous memory regions for each request’s maximum possible length.

    This reduces fragmentation and wasted capacity, potentially allowing substantially more concurrent requests. The actual gain depends on the workload and implementation.

    Prefix Caching

    Enterprise workloads often share long, stable prefixes: system instructions, tool definitions, or common knowledge context.

    Reusing the corresponding KV cache can avoid much of the repeated prefill computation. Stable cache identity is essential:

    1. import hashlib
    2. import json
    3. def prefix_cache_key(model, messages, tools=None, system=None):
    4. payload = json.dumps(
    5. {
    6. "model": model,
    7. "system": system,
    8. "messages": messages,
    9. "tools": tools or [],
    10. },
    11. ensure_ascii=False,
    12. sort_keys=True,
    13. separators=(",", ":"),
    14. )
    15. return hashlib.sha256(payload.encode("utf-8")).hexdigest()

    This illustrates deterministic key construction; actual cache behavior depends on the serving system. The content represented by the key should correspond to the reusable prefix.

    Timestamps, random identifiers, and other changing fields inside that prefix can cause keys to change and sharply reduce cache hit rates.

    Quantization and Mixed Precision

    Lower-bit weights and compressed or quantized KV caches reduce memory usage and bandwidth demand.

    Within acceptable quality constraints, these techniques can improve concurrency and reduce serving costs.

    Speculative Decoding

    A smaller draft model or lightweight prediction head proposes several tokens, which the main model verifies in parallel.

    With a sufficiently high acceptance rate, this can reduce serial decoding overhead and improve latency and serving efficiency. The benefit depends on the balance between drafting cost, verification cost, and accepted tokens.

    Model Routing and Cascades

    A smaller model handles a request first, with escalation to a larger model when confidence is low. Alternatively, a router assigns requests according to task difficulty.

    This can reduce both cost and latency, but it depends on accurately identifying which tasks require the larger model.

    Elastic Scaling and Resource Pooling

    Online traffic has peaks and troughs. Scheduling offline batch work during quieter periods, pooling resources, and using autoscaling can be more efficient than reserving capacity for peak demand at all times.

    Logging, monitoring, and object storage provide the metering and observability foundation. These are general cloud infrastructure capabilities, not a proprietary inference interface. Providers such as Baidu AI Cloud offer such infrastructure through general cloud product categories; availability and scope must be checked for the relevant deployment region.

    5. Path Two: Shift Toward Higher-Value Workloads

    Engineering improvements can steadily improve margins. Larger step changes may also reflect a shift in the customer and revenue mix.

    The report described more than four million enterprise users and developers making ongoing production calls across 218 countries and regions. The economically important question is how usage and revenue are distributed across customer segments.

    • Long-tail developers: Typically have smaller usage volumes, high price sensitivity, and limited negotiating power. Collectively, they contribute to covering fixed platform costs.
    • Mid-sized and large enterprises: Can bring steadier workloads, longer contexts, more complex tasks, and stronger requirements for service-level agreements and compliance. They may also purchase higher-value services such as private deployments or reserved throughput.

    A greater share of high-value customers can improve margins through three mechanisms:

    1. Higher compute utilization: Predictable workloads reduce capacity left idle between demand peaks.
    2. Lower acquisition and operating cost per unit of revenue: Serving one large account can be more efficient than supporting many small accounts generating the same revenue, depending on support requirements.
    3. Higher effective pricing: Customers may pay for reliability, compliance, and dedicated capacity rather than comparing token prices alone.

    Customer growth and margin improvement can therefore occur together. What matters is not simply the number of accounts, but the distribution of revenue, workload characteristics, and service costs across them.

    6. How Developers Can Reduce MaaS API Bills

    The cost of using the same model can vary substantially depending on workload design.

    Keep Reusable Prefixes Stable

    Place system instructions, tool schemas, and few-shot examples at the beginning of the prompt, with changing content afterward. This improves the opportunity for prefix-cache reuse where supported.

    Use Batch and Asynchronous Processing

    Send non-real-time work through batch interfaces where available, and manage it with asynchronous queues. Use backoff when retrying to avoid repeatedly hitting concurrency or rate limits.

    Route Tasks by Complexity

    Use smaller models or rules for intent classification, format validation, and straightforward extraction. Reserve larger models for tasks that require more complex reasoning.

    Govern Context Budgets

    Rerank and trim retrieved material instead of sending everything to the model. Long contexts are not free: processing more input increases prefill work.

    Build Observability First

    Record the model, input and output token counts, cache hits, latency, and cost for each request. Use those records to build a unit-economics dashboard.

    Bound Failure Costs

    Set timeouts, retry limits, and fallback paths so abnormal traffic or repeated failures cannot consume the entire budget.

    A simple budget guard can trigger degradation before the daily limit is reached:

    1. def budget_guard(cost_log, daily_budget_cny, price_per_mtok=1.0):
    2. spent = sum(cost_log) * price_per_mtok / 1_000_000
    3. ratio = spent / daily_budget_cny
    4. if ratio >= 1.0:
    5. return "stop"
    6. if ratio >= 0.8:
    7. return "downgrade_to_small_model"
    8. return "normal"

    Here, cost_log contains token counts, and the function assumes a positive daily budget and one uniform price per million tokens. Real billing analysis must account for differing input, output, cached-token, and model prices.

    7. Three Risks to Watch

    Diminishing Returns from Optimization

    Early improvements from batching, caching, and quantization can be substantial. Further gains may require deeper architectural changes and greater engineering investment.

    Token Price Competition

    Token prices face downward pressure. Providers may pass some efficiency gains to customers, so sustainable margin expansion requires costs to fall faster than effective selling prices.

    Compute Supply and Compliance

    Procurement lead times, supply volatility, cross-border data requirements, and content-safety obligations can affect both unit costs and the markets a provider can serve.

    Conclusion

    MaaS competitiveness is not just a matter of model benchmark scores. It depends on the relationship between cost per million tokens and the durability of recurring usage.

    The reported roughly 60-fold increase in API ARR points to a much stronger current usage run rate, while the rise in API gross margin from 3.3% to 18.9% indicates improved platform economics. Neither metric alone proves that growth or profitability will persist; together, they provide a useful framework for assessing progress.

    For providers, the transition is from selling model access to operating an efficient inference business. For developers and enterprise customers, understanding ARR, token metering, and unit economics helps turn experimental model usage into sustainable production systems—with spending kept within budget.