How to Calculate AI App Cost per Active User Before You Launch

The most common AI product spreadsheet starts with a provider pricing table and ends with a false sense of control.

A founder picks a model, estimates average input and output tokens, multiplies by requests, and gets a number that looks affordable. Then the product launches. Users paste longer context than expected. The app retries failed calls. A few accounts automate the workflow. Retrieval adds more tokens than the answer itself. Support asks engineering to store traces so bad outputs can be debugged. Suddenly the cost per active user is not the number from the pricing page.

This is the calculation ByteCosts exists to make visible. A token price is an input. The business metric is cost per active user.

Start with the unit that actually pays the bill

For most AI apps, the most useful unit is not cost per token or cost per request. It is cost per active user per month.

That number lets you answer the pricing questions you actually face:

• Can a $19 plan survive normal usage?
• Does a $49 plan subsidize power users?
• How many requests can the free tier include?
• What margin remains after model, retrieval, and support cost?
• Which users need metering, throttling, or an enterprise plan?

The basic shape is simple:

Monthly AI COGS per user = inference + cache writes + cache reads + retrieval + retries + tool calls + observability + support overhead

Do not make the mistake of treating those add-ons as optional. In a production product, they are usually the difference between the demo and the thing customers trust.

Build the raw inference line

Start with one representative request. Count input tokens and output tokens separately because output is usually more expensive. Then multiply by monthly requests per user.

A simple example:

Input cost: 250 × 1,800 = 450,000 tokens, or $1.35.

Output cost: 250 × 500 = 125,000 tokens, or $1.88.

Raw inference: about $3.23 per active user per month.

That is a useful first line. It is not the answer. Current provider pricing can include separate input, cached input, output, batch, realtime, and tool pricing, so the exact numbers need to come from the provider page or from the ByteCosts provider pricing index on the day you model the workload.

Model the distribution, not the average

Averages hide the users that destroy margin.

Model at least three users:

The median user tells you whether the product can work. The 95th percentile tells you whether the plan design can survive adoption. The abuse case tells you whether you need caps before launch.

For AI products, power users are not just heavy users. They are users whose enthusiasm has a variable cost attached to it.

Add the context tax

Most early estimates use the first prompt, not the fifth week of product usage.

Real apps accumulate context:

• System prompts
• Tool schemas
• Policy instructions
• Conversation history
• Retrieved documents
• User profile memory
• Previous outputs
• Debug metadata

A request that started at 1,800 input tokens can become 6,000 or 12,000 tokens once the product is useful. Long context is not bad. It is often the reason the product works. But it has to be priced.

Use the context window cost calculator to model how much each additional block of context adds at the request and monthly level.

Account for retries and fallback models

Production systems retry. They fall back. They re-ask the model with stricter instructions. They sometimes escalate a cheap model response to a premium model.

A safe early overhead assumption is 10 to 30 percent above raw inference, then replace it with real logs as soon as you have production traffic. The overhead can be lower for short deterministic tasks and higher for agentic workflows, tool calls, or customer-facing support answers.

Retries are especially dangerous because they are invisible to the user. The user sees one answer. You may have paid for three attempts.

Count retrieval as part of COGS

If the feature uses RAG, include:

• Embedding generation
• Vector storage
• Vector reads
• Reranking
• Extra context tokens from retrieved chunks
• Re-embedding when source documents change

The retrieved context line often becomes larger than the user question. That means a RAG feature can look cheap in a per-request demo and become expensive when real documents and real update frequency arrive. The RAG cost calculator is the right place to model this instead of hiding it in a generic infrastructure line.

Include observability and quality control

AI products need traces. They need sampled evaluations. They need failure review. They need enough logging to explain why an answer was wrong.

This does not mean every output needs a human review. It means the quality system has cost:

• Trace storage
• Evaluation runs
• Golden set refreshes
• Manual review for sampled outputs
• Support time for bad outputs
• Engineering time to tune prompts and routing

If the feature affects customer decisions, a zero-quality-control budget is deferred debt rather than a saving.

Turn COGS into pricing

Once you have per-user COGS, connect it to ARPU.

Gross margin = (ARPU - AI COGS - non-AI COGS) / ARPU

If a $29 plan has $7.50 of AI COGS and $3 of non-AI COGS, the gross margin is about 64 percent before support, payment fees, and refunds. That may be acceptable. If the 95th percentile user costs $31 on the same plan, the plan is not safe without usage allowances.

The decision is not always to raise prices. Often the better decision is structure:

• Include a clear monthly allowance
• Add metered overage above the allowance
• Route simple tasks to cheaper models
• Cache stable prompt prefixes
• Move extreme users to BYOK or enterprise
• Alert users before they create a surprise bill

You can model the full plan shape with Scenario Studio, then check plan-level margin with the per-user margin calculator.

The checklist before launch

Before shipping an AI feature, make the team answer these questions with numbers:

1. What is the median cost per active user?
2. What is the 95th percentile cost per active user?
3. What is the worst credible abuse case in one day?
4. How much cost does retrieved context add?
5. What percentage of traffic can be cached?
6. What retry rate did testing show?
7. Which model handles easy, normal, and hard requests?
8. What plan allowance preserves the target margin?
9. What happens when a user exceeds it?
10. Who sees the spend alert before finance sees the invoice?

If those answers are missing, the launch plan is incomplete.

AI app cost is knowable once you treat it as layered. Start with tokens, but do not stop there. Price the user, price the tail, price the product layer, and price the trust layer. That is the difference between an AI feature that grows the business and one that grows the bill.

---

Sources and method

The cost figures in this guide are illustrative assumptions modeled on published per-token rates, not provider quotes. Provider rates change quickly, so verify current rates against the source pages below and model your own numbers in the calculator.

• OpenAI API pricing
• Anthropic Claude pricing
• Google Gemini API pricing
• AWS Bedrock pricing
• ByteCosts AI cost calculator