Pure Usage Pricing: Examples & Companies

What is it

Pure Usage Pricing is a pricing model where the customer pays only for what they consume, with no fixed recurring fee beyond a possible minimum. The bill starts at zero and scales linearly — or with volume discounts — as consumption rises. Every incremental unit is billed at a rate, and there is no seat charge, platform fee, or subscription floor doing the revenue heavy-lifting.

It is the no-commitment model, and it dominates the developer-facing inference and infrastructure segments. DeepSeek bills its API from $0.0028 per 1M tokens on a V4-Flash cache hit; Cohere charges $2.50 / $10 per 1M tokens for Command A, $0.12 per 1M for Embed v4, and $2 per 1,000 queries for Rerank; AssemblyAI meters transcription at $0.15/hr for Universal-2 with no minimum, upfront fee, or contract on its pay-as-you-go plan. In each case the developer-as-buyer wants exactly one thing: to pay nothing until they ship production traffic.

The model spans two structurally different clusters. On the API side sit LLM and embedding endpoints, speech and audio APIs, image generators, and web-search APIs. On the infrastructure side sit GPU clouds and serverless-compute platforms — RunPod rents pods by the GPU-hour, Modal meters serverless work by the GPU-second. What unites them is that idle capacity generates no charge: no tokens processed, no GPU-seconds consumed, no bill.

The trade-off is symmetrical and well understood. The vendor gives up a revenue floor — a slow month is a slow invoice — and the buyer gives up cost predictability, since a busy month or a misconfigured agent can multiply the bill. Most of the discipline in this category is about managing that two-sided uncertainty: prepaid credits and committed tiers for the vendor, spend caps and alerts for the buyer.

How it works

Pure usage pricing has one moving part: a meter multiplied by a rate. The design decisions are which unit to meter, how steep the volume curve is, and what structural discounts sit on top. The billing unit follows the workload — tokens for text models, minutes for audio, GPU-hours or GPU-seconds for compute, requests for search and scraping.

The math is deliberately legible. A worked example on Cohere’s Rerank API: reranking 500,000 queries in a month at $2 per 1,000 queries costs 500,000 ÷ 1,000 × $2 = $1,000, with no seat or platform fee added. A worked example on Modal: running an H100 for 40 hours of serverless inference at $0.001097 per GPU-second costs 40 × 3,600 × $0.001097 ≈ $158, billed per second so a job that finishes early stops the meter.

Unit math: Total bill = Σ (units_consumed × unit_rate) − discounts. There is no + base_fee term — that absence is what makes the model “pure.”

Rates are rarely a single flat number. Four structural discounts recur across the corpus. Volume tiers drop the per-unit rate above a monthly threshold. Batch / async processing typically earns roughly half the synchronous rate. Cached-input discounts apply when input tokens match a cached prefix — DeepSeek’s $0.0028/1M cache-hit rate is an order of magnitude below its cache-miss rate. Prepaid credits reward paying in advance: Deepgram’s Growth plan offers up to 20% savings via prepaid annual credits ($4K+/year).

Companies using this

113 companies in the corpus price primarily on pure usage — the largest single pricing-model cohort here, concentrated in developer APIs (DeepSeek, Cohere, Tavily) and GPU / serverless infrastructure (RunPod, Modal, Vast.ai). The table below lists every one, with its billing units, free-tier status, and verification date.

Patterns observed

Three patterns hold consistently across the 113 companies on this page.

• A free tier is nearly universal, and it is the acquisition funnel. Pure-usage vendors give developers a way to integrate at zero cost, then let real traffic convert them. The shapes vary: Deepgram grants a $200 credit with no card required; Modal bundles $30 of free credits into its $0 Starter tier; Tavily refreshes 1,000 free search credits every month. Because the meter only becomes valuable at production volume, giving away the low end costs the vendor little.

• The billing unit tracks the underlying cost driver, not the customer’s mental model. AssemblyAI bills the hour of audio it processes, RunPod bills the GPU-hour it rents, Cohere bills the token it generates. This is the opposite of outcome-based pricing: the meter is chosen so the vendor’s margin is protected regardless of whether the customer got value from any given call.

• Prices deflate, and vendors bake in discount ladders rather than one flat rate. Cache-hit discounts, batch rates, and volume tiers are standard equipment — Cohere alone lists distinct Command, Embed, and Rerank rates, each with its own volume curve. Every serious inference vendor ships some version of this laddering; the flat “one rate for everyone” model is now the exception, not the rule.

A fourth, softer pattern: pure-usage vendors sell almost entirely self-serve. The overwhelming majority onboard with a credit card and no purchase order, which is why the model and the developer buyer are so tightly coupled — the pricing structure is itself a go-to-market choice.

Counterexamples & variants

The cleanest counterexample is the drift toward hybrid. Pure usage is often a starting point, not an endpoint. Exa launched as Metaphor Systems selling flat $100 and $250/month subscription tiers in early 2024, scrapped them within months for pure pay-as-you-go credits — then in the April 2026 endpoint-card redesign re-introduced per-endpoint pricing structure and raised its base Search rate from $5 to $7 per 1,000 requests. The trajectory of many vendors here is pure-usage → small platform or seat fee + metered usage, i.e. hybrid pricing, once they start selling to teams and enterprises.

Modal is the instructive variant: it is tagged pure-usage because its economics are per-second GPU, CPU, and memory, but it layers flat plan fees ($0 Starter, $250 Team) on top. That flat fee is small relative to the metered spend for any real workload, so the model reads as pure usage in practice — but it is technically a hybrid, and the line between the two categories is genuinely fuzzy at the edges. ElevenLabs sits on the other side of the same line: it appears in the pure-usage cohort for its PAYG API surface but is primarily hybrid, pairing subscription plans with usage metering.

The other genuine variant is the sales-gated pure-usage vendor. Metronome, itself a usage-billing infrastructure platform now part of Stripe, prices usage-based but publishes no public rates beyond a free Starter tier — the Custom plan is sales-quoted. This inverts the category’s usual transparency: pure usage normally means published per-unit prices a developer can read off a page, but billing-infra vendors and enterprise-tier compute providers frequently hide the number behind a conversation. The model is still consumption-based; the legibility that usually comes with it is not.

Finally, the “minimum” clause in the definition matters. A handful of vendors run pure-usage rates but enforce a monthly minimum spend or a minimum prepaid credit purchase. That minimum is a soft floor — it does not make the model hybrid, but it does mean the bill does not literally start at zero, which is worth checking in procurement.

What this means for buyers vs vendors

For buyers

Pure usage is the friendliest model to start with and the easiest to lose control of. The zero floor means you can pilot at near-zero cost, so favor it for early-stage and spiky workloads where you can’t yet forecast volume. Before you scale, ask three questions: is there a spend cap, alert, or hard-stop credit wallet (Deepgram, Modal, and prepaid-wallet vendors offer these); what discounts unlock at your volume (cache-hit, batch, and volume-tier rates can cut the effective price by 50-90%); and how stable is the rate — pure-usage vendors reprice more often than seat plans, so read the pricing page’s change history. See our guide to usage invoicing and billing cycles for how these bills are actually computed, and model your own numbers in the pricing calculators.

For vendors

Pure usage fits when your buyer is a developer, your cost is genuinely variable, and your unit of consumption is measurable and cheap to meter. It removes friction from acquisition — a free tier plus per-unit rates is the lowest-commitment ask you can make — but it hands you revenue that swings with customer traffic and offers no floor. The standard mitigations are all visible in this corpus: prepaid credits and committed-use tiers to pull revenue forward, and a paid team/enterprise tier that adds a flat platform fee once accounts are large enough to tolerate it, drifting you toward hybrid pricing. Start from our introduction to usage-based pricing before committing to a meter — the unit you pick is nearly impossible to change once customers have built against it.

Explore this theme in the knowledge graph →