How do you calculate AI cost per user?

Key facts

Formula	Cost per user = tokens per session x sessions per month x model rate
Model mix	Blended rate depends on which models each feature calls
Caching	Prompt caching and reused embeddings lower cost per session
Fixed costs	Storage, vector database and evaluation runs sit above variable cost
Benchmark	Compare cost per user with revenue per user and target gross margin
Flat-rate effect	Plan cost / active users gives a fixed cost per user on self-serve
Free plan	2 free models (plugsky-micro and plugsky-lite), no card required
Product status	Chat, streaming, function calling, embeddings and RAG are live

TL;DR

• Measure per session first, then multiply by sessions per user per month.
• Blend model tiers into one cost figure per feature, not per model.
• Compare cost per user against revenue per user, not against zero.
• Flat-rate plans turn cost per user into plan price divided by active users.
• Recompute after pricing, prompt or feature changes — the number drifts.

How it works, step by step

1. Instrument token usage per request and tag it with user, feature and session IDs.
2. Compute average tokens and requests per session for each feature.
3. Measure sessions per active user per month from product analytics.
4. Apply current rates for the models each feature actually calls to get cost per session.
5. Add retrieval, embedding and storage cost per user.
6. Divide total monthly AI cost by monthly active users to get cost per user.
7. Track it against revenue per user and re-measure monthly.

Try it yourself

Open the LLM cost calculator →

The formula, step by step

Cost per user is a chain of measured ratios:

1. Tokens per request, split into input and output.
2. Requests per session — a chat turn, a document summary, an agent task.
3. Sessions per active user per month.
4. Blended rate across the models those requests call.

Multiply the first three, apply the fourth, and you have variable cost per user. Then add per-user shares of retrieval, embedding and storage. The cost calculator handles the token arithmetic once you have the ratios.

Worked example structure, without fake numbers

Plug the following into a spreadsheet and fill each cell from your own telemetry:

• input_tokens_per_request and output_tokens_per_request
• requests_per_session and sessions_per_user_month
• input_rate and output_rate from the live pricing page
• retry_overhead as a measured percentage

Cost per user = requests x ((input tokens x input rate) + (output tokens x output rate)) x sessions x (1 + retry overhead). If you cannot fill a cell, instrument it rather than guessing — every estimate here compounds.

Turning cost per user into unit economics

A cost per user figure means nothing in isolation. Pair it with revenue per user and the gross margin you need to run the business. If AI cost is a small fraction of revenue, optimisation is a later problem; if it approaches margin, fix it now.

Useful levers, in order of impact: route easy requests to smaller models, trim context and history, cache stable prefixes, cap completion length, and batch or cache embeddings. Each lowers cost per session without changing the user experience when measured with an evaluation set.

Why flat-rate simplifies the number

On a flat plan with unlimited fair-use usage, cost per user becomes plan price divided by active users. It falls as you grow, it does not move when a prompt gets longer, and finance can model it in one cell. That predictability is valuable for consumer products where per-user revenue is thin.

Self-serve Plugsky plans carry no per-token charges or overage fees, so the only variable left is how many users you serve. Track usage per user anyway: it tells you when a small cohort is heavy enough to warrant enterprise terms.

Honest comparison

Unit-economics factor	Plugsky flat-rate	Per-token API	Self-hosted models
Cost per user	Plan price / active users	Measured tokens x rates	GPU cost / active users
Variance with usage	Fixed under fair use	Grows with sessions and context	Depends on utilisation
Prompt changes	No marginal cost on self-serve	Directly change cost per user	Change GPU time
Forecasting	One plan plus user growth	Requires token forecasting	Capex plus demand modelling
Retries and loops	No per-token charge on self-serve	Increase cost per user	Consume GPU time
Best fit	Predictable consumer and SaaS products	Low or spiky user bases	High, steady utilisation

Frequently asked questions

What is a good AI cost per user?

There is no universal benchmark. Compare it with revenue per user and your target gross margin. The right question is whether AI cost per user leaves room for infrastructure, support and profit.

How do I measure tokens per session?

Log input and output token counts from API responses, tagged with session and user IDs, then aggregate. Instrumentation beats estimation because token counts vary with prompt and model changes.

Should embeddings count toward cost per user?

Yes. Embedding and retrieval calls are part of serving a user and belong in the calculation. Reused embeddings and incremental indexing keep that component small.

Does caching really reduce cost per user?

Prompt caching helps when a stable prefix repeats across requests, which is common in system prompts and RAG. Measure cache hit rate and include only the uncached portion in your estimate.

How does flat-rate pricing change this calculation?

Cost per user becomes plan price divided by active users, which falls as you grow and stays fixed when prompts change. There are no per-token charges or overage fees on self-serve plans.

How often should I recalculate?

Monthly at minimum, and immediately after pricing changes, model migrations or major feature launches. Prompt and model changes shift token profiles faster than most teams expect.

What if heavy users lose money?

Identify the top cohort by usage, check whether their sessions differ structurally, and consider per-user limits, smaller model routing or enterprise terms for the heavy segment.

Can I start measuring without paying?

Yes. The free plan includes two models with no card, so you can instrument real usage and build the calculation before committing to a paid plan or trial.