Guides / price a usage based ai product
Pricing a usage-based AI product on a markup you can defend
Usage-based pricing passes model cost through to the customer, so the only real decision is the markup and what it covers. A markup set on accepted spend under-recovers, because retries, evaluation traffic and calls that produced nothing you kept all bill too. Culpa, a local-first LLM cost, margin, and forecast ledger, counts every billed call, so the markup sits on real spend.
Why this happens
Usage-based pricing feels safe because cost and revenue move together, and that intuition holds only if you bill on the same quantity you're charged for. Most teams bill on the work the customer received and pay for the work the provider generated, which are different numbers. The difference is retries, timeouts, discarded structured output and the evaluation calls that ran against the same account. A 2x markup on the first number isn't a 2x markup on the second, and only one of them is your actual cost.
What this usually looks like
- Your markup was chosen as a round multiple and has never been checked against a real invoice.
- Metered usage shown to customers reconciles with neither your provider bill nor your revenue.
- Margin on usage-based accounts falls during incidents, which is when retries multiply.
- Evaluation and quality-check calls run against customer accounts and land in nobody's cost model.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Mistakes that cost the most
| Mistake | Why it hurts | Do instead |
|---|---|---|
| Applying the markup to accepted spend rather than billed spend. | You under-recover by exactly your waste ratio, and the shortfall is worst on the accounts with the hardest workloads. | Compute the markup against everything the provider billed, then decide separately what to show the customer. |
| Publishing a per-token price and pinning it to one model. | A model change or a dated rate rise moves your cost while your published price stands still. | Price the outcome rather than the token, and keep the right to re-rate on a stated notice period. |
| Metering the customer with a different counter than the one you reconcile against. | Two counters always diverge, and the first person to notice is a customer disputing an invoice. | Meter once, then derive both the customer's number and your own from the same records. |
Run this check tonight
- Take one account, total what you billed it and what the provider billed you for it. Divide.
- Compute your waste ratio: billed tokens over accepted tokens. That's the gap in your markup.
- Check whether evaluation and guardrail calls run under a customer identifier, and where their cost lands.
- Recompute your effective markup on your worst incident day rather than on an average one.
- Confirm the counter shown to customers and the counter used for reconciliation come from the same source.
The same 2x markup, applied to two different numbers
Illustrative example
One account on GPT-5.4 mini at real rates of $0.75 per million input and $4.50 output. Accepted work for the month is 40M input and 6M output. The waste and evaluation figures below are modelled.
Both plans advertise a 2x markup and one returns 37.6% while the other returns 50%. The 12 points sitting between them are spend that was billed to you and counted by nobody.
Every number, with its confidence and source
| Figure | What it means | Confidence | Source |
|---|---|---|---|
| $57.00 to $71.18 | modelled monthly provider spend for one account, accepted work alone against everything billed | estimated | Both endpoints at real GPT-5.4 mini rates per million from the price book, effective 2026-07-02. A range because the waste and evaluation shares are modelled. |
| 37.6% | modelled gross margin when a 2x markup is applied to accepted spend rather than billed spend | calculated | ($114.00 minus $71.18) divided by $114.00, from the teardown arithmetic at real GPT-5.4 mini rates. |
What a generic answer can’t know
Splitting a provider invoice into accepted work, waste and evaluation traffic per account needs a tag on each call at the moment it's made, and those tags exist only inside your application. Culpa captures them on your infrastructure, keeps your prompts and responses there, and counts the calls to run your plan.
Questions founders ask next
What markup should a usage-based AI product charge?
There's no defensible industry figure, because waste ratios and support costs differ enormously. The reliable method is to compute your true billed spend per account, including retries and evaluation, then set the multiple that clears your target margin on your worst realistic month.
Should customers be billed for retries?
Usually not directly, because a retry is your failure rather than their request. The cost still has to be recovered, which means it belongs inside the markup rather than as a line item the customer sees and disputes.
How do I keep a published per-token price safe from rate changes?
Price the outcome rather than the token where you can, and keep a stated re-rating notice period where you can't. Provider rates change on dates you don't control, such as the Claude Sonnet 5 rise on 2026-09-01, and a pinned published price absorbs all of it.
On your infrastructure
Culpa runs on your infrastructure. Your prompts and responses never leave it. Culpa counts calls to run your plan, and it fails open, so if it ever breaks your app keeps running.
How Culpa works
Find the culprit. Not just the total.
Your dashboard shows what you spent. It stops short of who spent it. Culpa shows the conversation, the user and the feature behind it.
Your prompts stay local.
Culpa runs on your own infrastructure. What you send to a model reaches us at no point.
Every dollar has a name.
Follow any charge to the conversation, the user, the feature and the customer behind it.
See the bill before it lands.
Cost your next feature before you ship it. You get the likely bill and the worst case, at best, median, p90 and p99.
Three steps to your first answer.
Change one base URL.
Or drop in the Python or TypeScript library.
Find your most expensive conversation.
In the first session, not the first week.
Cost your next feature before you ship it.
Why the bill went up
Example dashboardCalls traced
418,209
across 3 projects
Spend this week
$378.41
+ $182 vs last week
Failed calls
312
74% retried, and you paid for all of them
+ $182 this week traced to one culprit
Spend over 14 days
Most expensive users
Next week forecast
Graded against reality. Accuracy shown as results land.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Keep reading
Sources: OpenAI API pricing. Last reviewed 2026-08-01. Plain text version.