Usage-Based Pricing for AI SaaS: Tokens, Credits, and Cost Controls
Usage-based pricing advice assumes your cost per unit is stable. In AI SaaS it isn’t. A model migration can change your cost of goods by 5x. A tokenizer update can change it by 30%. A customer’s prompt crossing a length threshold can change it 5x on input alone — without the customer doing anything different.
That’s the difference between pricing a cloud product and pricing an AI product. AWS’s costs per GB-hour move slowly. Your inference costs move when your vendor ships a new model.
This page covers the three value metrics available to AI SaaS, why passing tokens through 1:1 destroys your positioning, how to absorb cost volatility without repricing customers, and the spend controls that prevent a runaway bill from becoming your support queue.
All vendor figures below were read from vendor pricing pages on 15 October 2026.
Why AI SaaS breaks the standard usage-based playbook
Conventional usage-based pricing says: pick a unit that correlates with customer value, apply a rate card, meter it. That works when your unit cost is roughly constant.
In AI SaaS, four things break that assumption:
1. Your unit cost depends on which model you use. Claude Sonnet 5.5 costs $2 per million input tokens and $10 per million output. Claude Fable 5.1, positioned for demanding reasoning work, costs $10 and $50 [1]. Same customer, same prompt, same output — 5x the cost.
2. Your unit cost depends on prompt length. Claude Haiku 5.5 costs $0.10 per million input tokens for prompts up to 100,000 tokens, and $0.50 per million for prompts over that [1]. A 5x jump at a threshold the customer never sees.
3. Your unit cost depends on the tokenizer. Anthropic documents that Claude 4.7 and later models use a newer tokenizer producing approximately 30% more tokens for the same text [1]. If you migrate models, your token-metered COGS rises 30% while your customer’s usage is unchanged.
4. Your unit cost depends on features beyond tokens. Web search is billed at $10 per 1,000 searches on Anthropic [1] and $10 per 1,000 calls on OpenAI [2]. Anthropic’s code execution tool bills $0.05 per hour per container beyond 1,550 free hours per month [1]. Claude Managed Agents bill $0.08 per session-hour on top of tokens [1]. None of that is captured by a per-token rate card.
The conclusion: your customer-facing unit and your cost-facing unit should not be the same thing. That single idea drives everything below.
The three value metrics
1. Tokens
You meter input and output tokens and bill accordingly.
When it works: developer-facing API products where the buyer already thinks in tokens and monitors usage programmatically.
When it fails: any product where the buyer isn’t a developer, and any product where you expect to change models. Token pricing locks your margin to your vendor’s pricing sheet.
Real-world anchor: OpenAI prices GPT-6 Astra at $10 per million input and $50 per million output, GPT-6.1 Sol at $2 and $10, and GPT-6 Luna at $0.10 and $0.50 [2]. Anthropic’s range runs from $0.10/$0.50 on Haiku 5.5 to $10/$50 on Fable 5.1 [1]. A 100x spread across models — which is why “per token” tells your customer almost nothing about what they’re buying.
2. Credits
You define an internal currency. Customers buy credits; you consume credits per action. The credit-to-cost ratio is yours to manage.
Why this is the default for AI SaaS: credits decouple your pricing from your COGS. When you migrate models, when the tokenizer changes, when a vendor reprices — you adjust the conversion rate internally instead of sending every customer a new price list.
Credits also let you handle the non-token costs cleanly. A “report generated” credit can absorb input tokens, output tokens, a web search, and code execution time in one unit.
The cost: credits require metering, balances, expiry rules, and customer-facing transparency. That’s real infrastructure — see the implementation section below.
3. Outcomes
You bill per completed unit of value: per report, per image, per analysis, per workflow.
When it works: the unit of value is unambiguous and roughly consistent in cost.
Real-world anchors from Replicate, which mixes all three models on one page [3]:
Product
Unit
Price
FLUX 1.1 Pro
FLUX dev
FLUX schnell
Ideogram v3 Quality
Recraft V3
Wan 2.1 i2v 480p
Wan 2.1 i2v 720p
Notice what outcome pricing buys Replicate’s customers: resolution is a pricing dimension, not a token count. Nobody wants to reason about how many tokens a video second costs.
Which to choose
Your situation
Metric
Developer API, buyer monitors usage in code
Model mix will change, or costs include tools/search/execution
One clear deliverable per action
Non-technical buyer who needs a predictable bill
You expect to compete on quality by upgrading models
The pass-through trap
The most expensive mistake in AI SaaS pricing is charging customers a markup on your token cost.
If you pay $2/$10 per million tokens and charge 20% markup, you are a reseller. Your customer can compute your margin, your price moves whenever your vendor reprices, and the only lever you have is lowering your markup. You become the cheapest wrapper, and the next wrapper undercuts you.
Price on value instead. If a generated report saves a customer two hours of analyst time at $75/hour, the report is worth $150. Charging $0.50 per report is not leaving money on the table — it’s a 300x discount that still gives you 84% gross margin.
The margin math, with verified numbers. Say your product generates reports averaging 15,000 input and 5,000 output tokens on Claude Sonnet 5.5 [1]:
Line
Calculation
Cost
Input tokens
Output tokens
COGS per report
Charge $0.50 per report: 84% gross margin. Charge cost-plus-20%: $0.096, and you’ve told your customer exactly what you pay.
Absorbing cost volatility
This is where credits earn their keep. Three verified scenarios that would break a token-based price list:
Scenario 1: model migration
You move from Sonnet 5.5 to Fable 5.1 for better reasoning. Same workload — 15,000 in, 5,000 out [1]:
Model
Input
Output
COGS/report
Sonnet 5.5
Fable 5.1
Cost of goods rises 5x. Under token pass-through you must raise customer prices 5x for an identical deliverable. Under credits, you change one internal ratio — 1 credit now costs 5 tokens instead of 1 — and your price list is untouched.
Scenario 2: prompt caching
Anthropic prices cache reads at 0.05x base input on Sonnet 5.5, with a 1.25x multiplier for a 5-minute cache write and 2x for a 1-hour write [1]. Re-run the report above with 10,000 of the input tokens served from cache:
Line
Calculation
Cost
Uncached input
Cache read
Output
Total
COGS falls from $0.080 to $0.061 — a 24% margin improvement your customer never sees, because they’re buying a report, not a token count. Anthropic’s own worked example shows the same shape: a one-hour Opus 5.5 session drops from $0.58 to $0.428 when 40,000 of 50,000 input tokens are cache reads [1].
Caching is not just cost reduction. Under outcome pricing it is pure margin.
Scenario 3: batch and residency
Anthropic’s Batch API discounts input and output tokens 50% [1]. OpenAI’s Batch mode is −50%, and data residency is +10% [2]. Anthropic applies a 1.1x multiplier for US-only inference via inference_geo: "us" [1].
Two pricing consequences:
- If your product can tolerate asynchronous processing, your COGS halves. That’s a product design decision disguised as an engineering one.
- If you sell to regulated customers who require regional inference, budget a 10% COGS premium and price it into that tier rather than absorbing it.
The long-context cliff
Claude 4.6 and later models include the full 1M token context window at standard pricing — except Haiku 5.5, where prompts over 100,000 tokens jump from $0.10 to $0.50 per million input [1].
If you use Haiku for a high-volume task and a customer’s prompt shape shifts, your input cost multiplies by 5 with no change in their behavior. Meter prompt length as a cost dimension, or don’t expose Haiku workloads to unbounded context.
Runaway costs: the controls that matter
Usage-based AI billing fails in one specific way — a bug, a loop, or an abusive customer generates a bill nobody can pay. Support tickets, non-payment, churn.
Vercel’s model is the clearest pattern to copy, and it’s instructive because Vercel is both a usage-based vendor and a platform where AI workloads run:
- Default usage budget. New teams get a $200 on-demand usage budget, customizable, with email, web, and SMS notifications as they approach it [4].
- Optional hard limit. At 100% of budget, customers can configure Vercel to automatically pause all projects [4].
- Structural protections. Vercel lists recursion protection for serverless functions, improved function defaults, and hard spend caps as features added specifically to prevent runaway spend [4].
- A deliberate free-tier asymmetry. Hobby accounts are capped and cannot purchase additional usage; Pro can pay as you go uncapped [4]. Free tiers are where unbounded metering is most dangerous.
Note also that Vercel offers Flat Rate CDN on Pro as an alternative to usage-based CDN billing — a fixed monthly price, no overages, traffic spike protection [4]. Even the most usage-native company in the category sells a predictability escape hatch.
Minimum controls for an AI SaaS product:
- Per-customer spend caps, settable by the customer
- Alerts at 50%, 80%, and 100% of projected spend
- A hard stop option, not just a notification
- Loop and recursion detection on agentic workloads
- Rate limits per key, per org, and per plan
- Free-tier caps that cannot be exceeded by purchase
- Real-time usage visibility in the customer’s dashboard
Item 4 matters more than it looks. An agent stuck in a retry loop against a per-token price list is the single fastest way to generate an unpayable invoice.
Implementation checklist
- Choose your customer-facing unit (token, credit, or outcome) and write down why
- Model COGS per unit at current vendor rates, and at 2x and 5x
- Define credit expiry policy, if you use credits
- Instrument usage events with idempotency keys so retries don’t double-charge
- Meter non-token costs separately: searches, tool calls, execution hours
- Build customer-facing usage and spend dashboards
- Implement alerts at 50/80/100% of projected spend
- Implement a hard cap the customer can enable
- Set free-tier limits that cannot be purchased past
- Track gross margin per unit, not just revenue per unit
- Plan the repricing path for a model migration before you need it
Where Serial Subscriptions fits. We handle usage event ingestion, plan and limit definitions, overage calculation, and customer-facing usage reporting as part of the same integration as auth and billing — so the metering layer isn’t a separate build. Our plan builder supports monthly AI credits, usage-based overages, base fee plus bill-for-credits, and per-project limits. Integration is via the platform library: log usage events from your app, and the platform handles aggregation, invoicing, and proration.
That’s our own claim about our own product, not a vendor benchmark — treat it accordingly and check the docs.
Fact Check
Vendor pricing on this page was read directly from vendor pricing pages on 15 October 2026. AI model pricing changes frequently — treat every figure as a snapshot, not a quote.
Verified against vendor sources:
- Claude Sonnet 5.5 at $2/$10 per MTok; Haiku 5.5 at $0.10/$0.50 (prompts ≤100k) and $0.50/$2.50 (over 100k); Fable 5.1 at $10/$50 — Anthropic pricing docs [1]
- Prompt caching: 1.25x for 5-minute write, 2x for 1-hour write, 0.05x base input on cache reads for Sonnet 5.5 and Opus 5.5 — Anthropic pricing docs [1]
- Batch API discounts input and output tokens 50% — Anthropic pricing docs [1]
- US-only inference (
inference_geo: "us") applies a 1.1x multiplier — Anthropic pricing docs [1] - Web search $10 per 1,000 searches; code execution $0.05/hour per container beyond 1,550 free monthly hours; Managed Agents $0.08 per session-hour — Anthropic pricing docs [1]
- Claude 4.7+ tokenizer produces approximately 30% more tokens for the same text — Anthropic pricing docs [1]
- 1M token context at standard pricing for Claude 4.6+ except Haiku 5.5 — Anthropic pricing docs [1]
- Anthropic worked example: $0.58 → $0.428 with 40,000 cache-read input tokens — Anthropic pricing docs [1]
- OpenAI GPT-6 Astra $10/$50, GPT-6.1 Sol $2/$10, GPT-6 Luna $0.10/$0.50 per million tokens; Batch −50%, data residency +10%; web search $10 per 1,000 calls — OpenAI pricing page [2]
- Vercel Pro $20/month with $20 included usage credit; default $200 on-demand usage budget with alerts and optional automatic pause; Hobby cannot purchase additional usage; Flat Rate CDN as a fixed-price alternative — Vercel pricing page [4]
- Replicate per-output and per-second pricing (FLUX 1.1 Pro $0.04/image, FLUX schnell $3.00/1,000 images, Wan 2.1 480p $0.09/sec, 720p $0.25/sec); hardware billed per second (A100 $5.04/hr, H100 $5.49/hr); private models billed for setup, idle, and active time — Replicate pricing page [3]
This page’s own calculations, not vendor figures:
- COGS per report ($0.080, $0.400, $0.061) — derived by applying the vendor rates above to a hypothetical 15,000 input / 5,000 output token workload. The workload is illustrative; the rates are vendor-published.
- 84% gross margin at $0.50 per report — derived from the $0.080 figure above.
- The 5x model-migration and 5x long-context cliff framings — arithmetic on vendor-published rates.
Claims deliberately excluded:
- Industry adoption statistics (e.g. “60% of SaaS companies use usage-based pricing”) — earlier versions of this page carried these with misattributed sources. They are omitted rather than re-sourced.
- Twilio, SendGrid, Scale AI, Backblaze, and Cloudflare pricing — not re-verified this pass.
FAQ
Should I price per token in AI SaaS?
Only if your buyer is a developer who already meters tokens programmatically. For everyone else, token pricing makes your bill uninterpretable and ties your margin to your vendor’s pricing sheet.
What's the difference between credits and tokens?
Tokens are your vendor’s unit. Credits are yours. Credits let you change models, absorb tokenizer changes, and bundle non-token costs like search and code execution into one customer-facing number.
Why not just charge cost plus a margin?
Because it makes you a reseller. Your customer can compute your markup, your price moves whenever your vendor reprices, and your only competitive lever is lowering that markup.
How much should I mark up inference?
Price on the value of the outcome, not on cost. If a report saves two hours of analyst time, its price is anchored to that, not to the $0.08 of tokens it consumed.
How do I handle model migrations without repricing customers?
Credits or outcomes. Both let you change the internal cost-to-unit ratio without changing the customer’s price list.
What causes runaway AI bills?
Retry loops, agentic recursion, unbounded context, and abuse. Controls: per-customer caps, alerts at 50/80/100%, an optional hard stop, recursion detection, and free tiers that can’t be purchased past.
Do I pay for tools beyond tokens?
Yes, on both major providers. Web search is $10 per 1,000 searches on Anthropic and $10 per 1,000 calls on OpenAI. Anthropic bills code execution at $0.05 per hour per container beyond 1,550 free monthly hours, and Managed Agents at $0.08 per session-hour.
Sources
- Anthropic — Models & pricing — https://platform.claude.com/docs/en/about-claude/pricing
- OpenAI — API Pricing — https://openai.com/api/pricing/
- Replicate — Pricing — https://replicate.com/pricing
- Vercel — Pricing — https://vercel.com/pricing
- Vercel — Spend Management — https://vercel.com/docs/spend-management/
- Vercel — Flat Rate CDN — https://vercel.com/docs/pricing/flat-rate-cdn
- Serial Subscriptions — Integrate Serial Subscriptions — https://docs.serialsubscriptions.com/integrate-serial-subscriptions/
All sources accessed 15 October 2026.