Overview
T9 Token Budget helps you estimate the likely API/token cost of an AI feature before you launch it. The goal is to give you a realistic range to plan with — so a bill does not surprise you later.
This is a planning tool, not a billing guarantee. The numbers are estimates based on documented assumptions and published model prices. Your real bill depends on your provider, your model, and how your application actually behaves in production.
What T9 estimates
Each estimate is built from the parts of a request that providers typically bill. New to these terms? Start with what AI tokens are (input, output and context window explained).
- Input tokens — the text your application sends to the model.
- Output tokens — the text the model generates in reply. Output is usually billed at a higher rate than input.
- Conversation history — earlier turns that are re-sent as input on each new message in a multi-turn chat.
- System prompt — the standing instructions sent on every call.
- Optional knowledge base / context — retrieved document chunks (RAG) injected as additional input when you use them.
- Model pricing — the published input and output price per million tokens for the model you select.
We combine these into a Low / Likely / High range rather than a single number, because real usage varies. The Likely column uses mid-range assumptions; Low and High show the realistic spread around it.
Pricing data sources
Every model price used across T9's calculators comes from that model's own official, first-party provider pricing or model documentation — never a search-result snippet, a third-party aggregator, a blog post, or a cached mirror.
Prices are normalized to one common basis before they reach a calculator: USD per one million tokens, shown separately for input and output, using each provider's standard, synchronous, pay-as-you-go rate — not a cached-input, batch, or promotional rate, unless a model's own listing explicitly says otherwise.
When a provider changes its pricing, T9's dataset is re-verified and updated; models that are retired or no longer officially priced are removed rather than left stale. Where a provider publishes a temporary introductory rate with a known expiry and successor price, T9 records both the current rate and the date it stops applying, so the figure in the calculator does not silently go stale after that date.
How pricing is verified
Every price is checked directly against its provider's own official documentation and recorded with the exact source page, the date it was checked, and supporting notes — one record per model, in a version-controlled register kept alongside the pricing data itself. An automated test cross-checks every price in that register against the live pricing dataset on every change, so the two cannot silently drift apart.
How estimates are calculated
Every T9 calculator reduces to the same underlying cost formula once it has estimated how many input and output tokens your workload uses:
Estimated cost = (input tokens ÷ 1,000,000) × input price + (output tokens ÷ 1,000,000) × output price Input and output price come directly from the model you select (see pricing). Input and output tokens are estimated differently per workload — a chatbot conversation, a meeting transcript, a document, or a set of questions each build their own token estimate from their own inputs, then this same formula converts that estimate into a cost.
With the calculator's own default assumptions (standard system prompt, medium-length messages, 5 messages per conversation, no knowledge base), one conversation's input tokens work out to:
350 (system prompt) + 5 × 50 (messages) + 3 × (50 + 300) (steady-state history) + 0 (no knowledge base) = 1,650 input tokens
That figure — and the equivalent output-token estimate — is what the formula above then multiplies by the selected model's price.
Assumptions
Because nobody knows their exact future usage before launch, every calculator has to assume typical values for things it cannot know in advance — for example, how long a message or document tends to be, how many turns a conversation runs, or how much context is retrieved. Each of the four calculators (chatbot, meeting summary, document summary, document Q&A) uses its own set of assumptions, matched to that workload — a chatbot's "messages per conversation" has no equivalent in a document-summary calculator, for instance.
Rather than duplicate four different assumption tables here, every current default is shown directly in the calculator that uses it — open any of the four calculators to see and adjust the exact values behind your own estimate.
Why real bills can differ
An estimate is a model of reality, not reality itself. Several things can move your actual bill away from the estimate:
- Billing rules vary by provider and model — units, rounding, and what counts as a billable token are not identical everywhere.
- Output length can change — a more verbose answer costs more, and output is the expensive side.
- Chat history accumulates — long multi-turn conversations re-send a growing history as input on every turn.
- System prompts may be resent on every call, multiplying their cost across all requests.
- RAG / knowledge base context can increase input tokens, especially if content is retrieved on every message rather than once per conversation.
- Some models or providers may bill reasoning or additional tokens that are not obvious from the visible final answer. This behaviour varies — check your provider's documentation.
- Non-English text can tokenize differently — many languages, including Portuguese and Spanish, can use more tokens than English for the same meaning.
- Pricing can change over time — providers update prices, and our figures reflect what was verified on a given date.
Using estimates safely
- Compare Low / Likely / High. Budget against the High scenario; plan against the Likely one.
- Test before production. Run a small real workload and compare it to the estimate.
- Check official pricing pages for your provider and model before committing.
- Monitor your usage / billing dashboard once live — it is the source of truth for what you are actually charged.
- Set budgets or limits where your provider supports them.
- Reduce history and context when you can — a sliding window of recent turns and a lean system prompt are the biggest practical savings.
Limitations
- No login or account.
- No credit card.
- No API calls to any provider.
- No connection to your provider accounts.
- No file uploads.
- No billing guarantee — every result is an estimate.
All calculations run locally in your browser. Nothing you enter is sent to a server.
Why this matters before launch
Most cost surprises happen after the first invoice, when the cause is hard to unwind. Estimating first lets you:
- Avoid surprise bills by seeing the realistic range before you build — see why an AI API bill can be higher than expected.
- Compare models before committing — the cheapest capable model for your use case can cost a fraction of a frontier model.
- Understand your cost drivers — history, output length, and context — before they reach production scale.
Ready to try it? Open the calculator that matches your use case — chatbot, meeting summary, document summary, or document Q&A.