What usage-based billing is — and what it replaced
Usage-based billing charges customers for what they consume: API calls, tokens, seats used, gigabytes stored, minutes transcribed, rows processed. The invoice is computed after the fact from a meter, not fixed in advance by a plan. Stripe's own documentation now frames it this way: Metronome, a Stripe product, is the usage-based billing platform that provides real-time metering, pricing, billing, and reporting — ingest usage events, define flexible pricing models, and automate invoice generation without building custom billing infrastructure.
The model replaced the flat subscription for products whose cost scales with use. A flat $99 plan loses money on the customer who makes ten million API calls and overcharges the customer who makes ten thousand. The meter fixes both sides: light users pay little, heavy users pay in proportion, and the vendor's revenue tracks the infrastructure cost that usage creates. The trade is predictability: the customer cannot know the invoice until the month ends, and the vendor cannot know revenue until the meter is read.
This playbook is for SaaS founders, B2B operators, and finance leads pricing an AI, API, or infrastructure product — the businesses where the unit of value is countable. It is not for a business whose value is access: a content library or a community sells a subscription, and metering it adds cost without adding fairness.
The four pricing models, and the meter underneath them
Every usage-based price is one of four rating shapes, and the shape decides who bears the volume risk.
| Model | How the price is computed | Who it favors | Authority |
|---|---|---|---|
| Per-unit (metered) | A fixed price per event, token, or gigabyte | Light users; simple to explain | Stripe usage-based billing docs |
| Tiered | A different per-unit price inside each usage band | Heavy users; rewards volume | Metronome pricing models |
| Volume | One per-unit price for all usage, set by the total volume reached | The largest customers; a cliff at each threshold | Metronome pricing models |
| Stairstep / flat-fee tiers | A fixed fee per band of usage, regardless of exact count | The vendor; predictable per band | Chargebee pricing structure |
A tiered price of $0.10 per 1,000 events for the first million, $0.08 for the next nine million, and $0.05 above ten million is not a discount program — it is a margin schedule. The vendor's infrastructure cost per event falls with volume, and the tier passes part of that fall to the customer while keeping the rest. A volume price is sharper: if the whole month reprices at the rate of the highest band reached, a single event can reprice millions of earlier events, and the invoice jumps by thousands on one API call. Founders who choose volume pricing without a cap on the reprice are writing a surprise invoice for their largest customer.
Underneath every model sits the same pipeline: an event is emitted by the product, ingested by the meter, rated against the price, aggregated into a billing period, and invoiced. Metronome's pricing page states the two charges for that pipeline plainly: billing volume at 0.8%, and ingest events at $0.04 per 1,000 events. The meter is not free — at 50 million events a month, the ingest charge alone is $2,000.
The Stripe split: who does what now
Stripe's documentation now routes new usage-based builds to Metronome, and the split of duties is explicit. Metronome handles usage-based billing, credit-based pricing, enterprise contracts, and multi-dimensional rating. Stripe handles payment collection, tax calculation, revenue recognition, data export, and fraud screening with Radar. The llms.txt guidance is blunt: for all new integrations, use Metronome; use the basic Stripe usage-based billing documentation only to maintain existing basic Stripe usage-based billing integrations.
That split changes the build decision. A founder building usage-based billing on Stripe in 2026 is choosing between two stacks: Stripe's native metered billing for an existing integration, or Metronome on top of Stripe for a new one. The native path keeps one vendor and one contract; the Metronome path buys the rating engine — multi-dimensional rating, credit grants, enterprise contracts — that the native path does not offer. The ASC 606 revenue recognition playbook covers what happens after the invoice: usage-based revenue is variable consideration, which is why revenue-recognition automation exists as a named feature on the billing vendors' own price lists.
The cost math: three layers, one invoice
A usage-billed dollar passes through three charges, and founders who budget only one of them are surprised by the other two.
The take rate matters because it is the only number that combines all three layers. A vendor quoting 0.8% is quoting the billing layer only, and therefore the negotiation that moves the total is the payment method, not the billing vendor — as a result, the first question in any billing-vendor comparison is which payment rails the largest customers will use.
The processing layer is Stripe's card rate, verified on Stripe's pricing page: 2.9% plus 30 cents per successful domestic card transaction, with 0.5% added for manually entered cards, 1.5% for international cards, and 1% where currency conversion is required. Bank debits are cheaper — ACH Direct Debit at 0.8% with a $5.00 cap — which is why annual enterprise contracts paid by ACH carry a materially lower take rate than monthly card payments.
Example: $500,000 a month, 50 million events, 5,000 card transactions
A B2B API product bills $500,000 in a month across 5,000 customer card payments, and its meter ingests 50 million usage events. The three layers price out as follows:
| Layer | Metronome stack | Chargebee stack |
|---|---|---|
| Billing software | 0.8% × $500,000 = $4,000 | $0 + 0.80% × $500,000 = $4,000 |
| Event ingest | 50,000 × $0.04 = $2,000 | $0 (100M events included) |
| Card processing | 2.9% × $500,000 + 5,000 × $0.30 = $16,000 | 2.9% × $500,000 + 5,000 × $0.30 = $16,000 |
| Total | $22,000 a month | $20,000 a month |
The two billing vendors charge the same 0.8% on volume at this scale. The entire $2,000 gap is the event-ingest charge: Metronome bills $0.04 per 1,000 events, and Chargebee's plan includes 100 million usage events a month. The effective take rate is 4.4% on the Metronome stack and 4.0% on the Chargebee stack — and 3.2 points of either is card processing, not billing software. The cheapest way to cut the take rate at this volume is not to renegotiate the billing vendor; it is to move the largest customers to ACH, where 0.8% with a $5 cap replaces 2.9% plus 30 cents.
The comparison inverts below $66,000 of monthly invoicing volume. Chargebee's pricing slider starts at $0 up to a $66,000 monthly invoicing breakeven — the billing software costs nothing at that scale. Metronome charges 0.8% from the first dollar. A product billing $50,000 a month with 5 million events pays $600 a month on Metronome — $400 of volume charge plus $200 of ingest — and $0 on Chargebee Billing. The break-even is not a negotiation; it is the slider. Run your own volume through both before you sign, with the break-even calculator for the threshold where the meter cost overtakes the volume saving.
The failure modes: leakage, duplication, and the surprise invoice
Usage-based billing fails in three ways, and all three are metering failures, not pricing failures.
Leakage is usage the meter never sees. An API route that bypasses the event emitter, a background job that calls the model without a meter write, a free tier that never had a counter attached — every one of them is revenue the product delivered and never billed. The fix is architectural: the meter write happens in the same code path as the work, not in a wrapper that can be skipped, and a daily reconciliation compares events ingested against work performed.
Duplication is the same usage counted twice. A retry that re-emits the event, a webhook delivered twice, a clock skew that splits one session into two billing periods — each one overcharges the customer by exactly the duplicated amount, and the customer who finds it first is the customer who churns loudest. The fix is idempotency: every event carries a unique key, and the meter deduplicates on it before rating.
The surprise invoice is correct metering with a bad model. A volume price that reprices the whole month, an overage rate with no cap, a prepaid-credit balance that silently exhausts mid-month — each produces an invoice the customer did not expect, and the support ticket that follows costs more than the overage. The fix is commercial, not technical: usage alerts at 50%, 80%, and 100% of the expected band, a hard cap or a spend limit the customer sets, and a first-invoice review before the second month bills. The dunning and involuntary churn playbook covers what happens when the surprise invoice fails to pay: the recovery sequence, the retry logic, and the revenue that never comes back.
Prepaid credits, overage, and the hybrid
Not every customer wants a metered invoice. Enterprise buyers want a number they can budget, and the answer is prepaid credits: the customer buys a block of usage — $10,000 of credits, say — and the meter draws it down. Overage above the block bills at the metered rate, and the unused balance expires or rolls over on terms the contract states. Credit-based pricing is the hybrid that lets a sales-led enterprise deal and a product-led self-serve motion share one meter: the enterprise customer prepays, the self-serve customer pays as they go, and the rating engine is the same.
The accounting follows the meter. Prepaid credits are deferred revenue until consumed — the ASC 606 playbook carries the recognition mechanics — and overage is recognized when the usage happens. A vendor that recognizes the whole credit purchase as revenue on day one has misstated the month, and the restatement lands in the audit.
Founder & CEO Insight — Enow A. Jovial
The build sequence
- [x] Step 1 — Name the metered unit: one countable event per product — an API call, a token, a gigabyte, a minute — and define it in the contract, not just in code.
- [x] Step 2 — Choose the rating shape: per-unit for simplicity, tiered for volume, volume only with a reprice cap, stairstep for predictable bands.
- [x] Step 3 — Pick the stack: Metronome on Stripe for a new build with multi-dimensional rating, native Stripe metered billing only to maintain an existing integration.
- [x] Step 4 — Price the three layers: billing software, event ingest, and card processing — and run the $500,000 example on your own volume.
- [x] Step 5 — Build the meter in the work path: emit the event where the work happens, with an idempotency key on every event.
- [x] Step 6 — Reconcile daily: events ingested against work performed, and rating output against the price book.
- [x] Step 7 — Alert before the invoice: usage alerts at 50%, 80%, and 100% of the expected band, plus a customer-set spend cap.
- [x] Step 8 — Keep the raw events: for the life of the invoice plus the refund window, with versioned rating logic.
- [x] Step 9 — Review the first invoice by hand: before the second month bills, verify the meter, the rating, and the processing fee against the contract.
Who should not meter
Do not meter a product whose value is access, a customer whose usage is unpredictable and uncontrollable, or a market where the invoice itself is the churn trigger. A community, a content library, and a dashboard sell a subscription. A customer who cannot cap spend will churn on the first surprise invoice, and a product whose unit cost is near zero gains nothing from metering it. Meter where the cost of serving scales with use, where the customer can see the value in the unit, and where the meter can be reconciled event by event. Everywhere else, the subscription is cheaper to run and easier to sell — and the Stripe Tax nexus playbook covers the sales-tax side of whatever you charge, metered or flat.

