Back to blog
·7 min read

How to Estimate Runtime AI API Costs Before You Have a Single User

Build cost and maintenance cost both scale with your team. Runtime AI cost is different — it scales with your users, which means it's zero on launch day and can quietly become your largest monthly line item six months later. That gap is exactly why so many products launch without a runtime AI budget at all, and then scramble when the first real invoice arrives.

The good news: you don't need production traffic to get a useful estimate. You need six inputs, each of which you can reason about from your product plan alone.

The six inputs that drive your runtime AI bill

  • Monthly active users. Even a rough bracket — under 100, 100–1k, 1k–10k — changes the estimate by an order of magnitude. Use your realistic 6–12 month number, not your best-case one.
  • Interactions per user. How many times does an active user trigger an AI call per month? A support chatbot answering every question behaves very differently from an AI feature used once during onboarding.
  • Average input size. Short prompts, medium context, or large documents — this is usually the single biggest driver of input token volume.
  • Average output size. Output tokens are typically priced several times higher than input tokens, so a feature that generates long responses (reports, long-form content) costs more per call than one that returns a short classification or extraction.
  • RAG context.If you're retrieving documents or knowledge-base chunks and stuffing them into the prompt, that's additional input tokens on every call — often more than the user's own message.
  • Tool calls and retry rate. Agentic features that call tools multiple times per request, or features with a meaningful retry/error rate, multiply the effective number of model calls per user interaction.

Why model choice swings the bill by 10x or more

The same workload routed to a different model can cost an order of magnitude more or less. Here's a snapshot of per-million-token pricing for a few commonly used models:

ModelInput / 1M tokensOutput / 1M tokens
Claude Haiku 4.5$1.00$5.00
Claude Sonnet 4.5$3.00$15.00
GPT-4o mini$0.15$0.60
GPT-4o$2.50$10.00
Gemini 2.5 Flash Lite$0.10$0.40

Illustrative pricing used in Forecost's runtime cost calculator. Verify current pricing with each provider before budgeting — these change often.

A worked example

Say you're launching an AI support chatbot with 1,000 monthly active users, averaging 8 interactions per user per month, with a medium-sized RAG context and short outputs. That's roughly 8,000 interactions per month. If each interaction averages ~2,000 input tokens (including retrieved context) and ~300 output tokens, you're looking at about 16M input tokens and 2.4M output tokens per month.

  • On Claude Haiku 4.5: roughly $16 + $12 ≈ $28/month.
  • On Claude Sonnet 4.5: roughly $48 + $36 ≈ $84/month.

Same product, same usage — a 3x difference based on model choice alone. This is why Forecost shows a model comparison alongside a single "best value" recommendation: the right choice depends on whether a feature needs frontier reasoning or can run on a fast, cheap model.

Caching and retries quietly double your bill

Two factors rarely show up in back-of-envelope math but show up immediately in production: prompt caching (which can cut repeated-context costs significantly when supported) and retry rate — failed tool calls, validation failures, or low-confidence outputs that trigger a second pass. A 15% retry rate effectively adds 15% to every token count above. If your feature is agentic — multiple tool calls per user request — that multiplier compounds fast.

Treat the runtime estimate as a living number

Your pre-launch estimate is a starting point, not a forecast you set and forget. Once you have real usage data — even a few weeks of it — replace the assumed interaction count and token sizes with actuals and re-run the numbers. The framework stays the same; only the inputs get more accurate.

Want to run these numbers for your own product, including a side-by-side model comparison?