# AI Token Cost: Estimate Your Monthly LLM Bill

> AI token cost is the price of each million input and output tokens. Estimate a monthly LLM bill from workload, model rates, cache use, and reasoning, then compare it with measured usage.

AI token cost looks tiny until a feature sends the same long context again and again. Then the question isn’t “what does one token cost?” It’s how many billable tokens your feature creates in a month.

**Short answer:** Multiply the workload’s uncached input, cached input, cache-write, and output token totals by the matching per-token rates, then divide by one million. Include reasoning tokens in output where the provider bills them there, and apply any eligible batch rate. For a simple support-answer feature handling 10,000 tickets a month at 2,000 input and 350 output tokens each, this estimate ranges from $8.20 to $75 across four current API model IDs at standard rates, before non-token charges. After launch, replace the assumptions with response usage and reconcile them against the provider’s cost report.

Prices below were checked October 2026. They’re API list prices in USD; the AI token cost calculator in this guide is for estimating, not a quote for hosted products or reseller endpoints.

## How much does an AI token cost?

There’s no single AI token cost. Providers set different rates for input tokens vs output tokens, and may charge another rate for cache reads, cache writes, long context, or service tier. Compare prices for the exact model ID and endpoint you plan to call.

Here is the cost per token for four current text models, quoted per million tokens:

| Provider and exact model ID           | Input |     Cached input/read |                        Cache write | Output |
| ------------------------------------- | ----: | --------------------: | ---------------------------------: | -----: |
| OpenAI `gpt-5.6-luna`                 | $0.20 |                 $0.02 |                              $0.25 |  $1.20 |
| Anthropic `claude-sonnet-5-5`         | $2.00 |                 $0.20 |               $2.50 (5m) / $4 (1h) | $10.00 |
| Anthropic `claude-haiku-4-5-20251001` | $1.00 |                 $0.10 |               $1.25 (5m) / $2 (1h) |  $5.00 |
| Google `gemini-3.1-flash-lite`        | $0.25 | $0.025 cached context | provider cache/storage terms apply |  $1.50 |

Rates come from the vendors’ current [OpenAI model pricing](https://developers.openai.com/api/docs/models/gpt-5.6-luna), [Claude Sonnet 5.5 model page](https://platform.claude.com/docs/en/models/sonnet-5-5/overview), [Claude Haiku 4.5 model page](https://platform.claude.com/docs/en/models/haiku-4-5/overview), and [Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing). These aren’t capability rankings. A lower input price doesn’t tell you how many calls or output tokens your task will need.

A rough tokens-to-words conversion for English helps size a prompt, but not price it precisely: OpenAI’s guide estimates [100 tokens at about 75 words](https://help.openai.com/en/articles/4936856-understanding-and-counting-tokens), while Google says [100 Gemini tokens are about 60–80 English words](https://ai.google.dev/gemini-api/docs/tokens). Treat those as planning ranges. For an actual prompt, use the selected model’s token counter or the provider’s returned usage.

## How do I calculate monthly AI token cost?

Use separate token buckets so a cache hit isn’t charged again at the ordinary input rate. For a provider whose prices are quoted per million tokens:

```text
standard-rate token cost =
  (uncached_input × input_rate
 + cached_input × cache_read_rate
 + cache_write × cache_write_rate
 + billed_output × output_rate) / 1,000,000

eligible batch cost = eligible standard-rate token cost × batch_multiplier
```

`billed_output` includes visible answer tokens and any reasoning tokens the provider bills as output. `batch_multiplier` is 1 for standard requests and 0.5 where the vendor documents a 50% batch discount; apply it only to batch-eligible token charges. If cache and batch modifiers interact, use the vendor’s final rate for each token category rather than multiplying a blended subtotal. Add fixed tool-call, search, storage, audio, or other usage fees separately. For example, OpenAI lists its Responses and Chat Completions APIs at the chosen model’s token rates and separately prices some built-in tools in its [API price list](https://developers.openai.com/api/docs/pricing).

The expanded form avoids two easy mistakes: applying one blended rate to both input and output, and treating all input as fresh when some was read from cache.

Claude explicitly itemizes cache creation and cache reads; its [pricing guide](https://platform.claude.com/docs/en/about-claude/pricing) gives different multipliers for five-minute writes, one-hour writes, and cache hits. OpenAI’s prompt cache has a separate cached-input rate and documents a cache-write rate for GPT-5.6 and later in its [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching). Google lists cached context separately in [Gemini pricing](https://ai.google.dev/gemini-api/docs/pricing).

## What would a monthly support bot cost?

Under these assumptions, monthly support-bot token charges run from $8.20 to $75 depending on model. Take a support-answer feature with 10,000 tickets per month. Assume exactly one model call per ticket, 2,000 input tokens per call (system instructions, retrieved snippets, and customer message combined), and 350 billed output tokens per call. That’s 20 million input tokens and 3.5 million output tokens monthly.

The 350 output-token assumption includes reasoning if the API bills reasoning in the output count. Assume standard synchronous requests, no cache hits or writes, no retries, no tools billed separately, and no tax or contract discounts.

| Model ID                    | Arithmetic               | Estimated monthly token cost |
| --------------------------- | ------------------------ | ---------------------------: |
| `gpt-5.6-luna`              | 20 × $0.20 + 3.5 × $1.20 |                    **$8.20** |
| `gemini-3.1-flash-lite`     | 20 × $0.25 + 3.5 × $1.50 |                   **$10.25** |
| `claude-haiku-4-5-20251001` | 20 × $1 + 3.5 × $5       |                   **$37.50** |
| `claude-sonnet-5-5`         | 20 × $2 + 3.5 × $10      |                   **$75.00** |

Each multiplier uses millions of tokens: 20 million input tokens × $0.20 per million = $4; 3.5 million output tokens × $1.20 per million = $4.20; total $8.20 for GPT-5.6 Luna. The other rows use the same volumes and their linked vendor rates. This is a billing comparison, not a claim that the models produce equivalent answers. Run the same representative support cases through the candidates and measure quality and usage before choosing one.

For batch-capable offline jobs, calculate again with the listed batch rates. The [Claude model pages](https://platform.claude.com/docs/en/models/sonnet-5-5/overview) list a 50% batch discount on input and output, and Google’s [Gemini Batch API documentation](https://ai.google.dev/gemini-api/docs/batch-api) also says it charges half the standard equivalent-model cost. Don’t apply that discount to an interactive request just because you grouped requests in your own code.

## How much text is 1,000 tokens?

For ordinary English, 1,000 tokens is roughly 600–800 words using the vendor estimates above. It’s a rough size conversion, not a universal rule: code, tables, punctuation, non-English writing, and model tokenizers change the count. A one-page prompt can also contain tool schemas and prior messages that aren’t obvious from the text the user typed.

Before launch, count the actual prompt shape with the provider’s tools: Google’s [token guide](https://ai.google.dev/gemini-api/docs/tokens) describes `count_tokens` for input and usage fields on responses. Do that for several typical and unusually long tickets. Multiply the average and a high-percentile case by expected monthly ticket volume; the high case shows how much headroom your budget needs if long requests are common.

## How do I confirm the estimate against real usage?

Log one record per model request, not just one total per customer conversation. Save a request ID, date, feature or tenant key, model ID, input-token categories, output tokens, and reported cost when present. An agent can make several provider calls for one user-visible answer, so sum every call for the conversation.

Then compare request-level logs with the provider’s own usage and billing view:

| Provider  | Request-level fields to retain                                                                                                | Monthly reconciliation                                                                                                                   |
| --------- | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| OpenAI    | `input_tokens`, `input_tokens_details.cached_tokens`, `output_tokens`, `output_tokens_details.reasoning_tokens` when returned | Organization Usage API and its Costs endpoint (`GET /organization/costs`), or the Usage Dashboard.                                       |
| Anthropic | `input_tokens`, `cache_creation_input_tokens`, `cache_read_input_tokens`, `output_tokens`                                     | Usage and Cost Admin API: `/v1/organizations/usage_report/messages` and `/v1/organizations/cost_report`; requires Admin API credentials. |
| Gemini    | `total_input_tokens`, `total_output_tokens`, `total_thought_tokens`, `total_cached_tokens` where returned                     | Compare response usage with the billing view for the same project and date range. Use `count_tokens` only as a preflight input estimate. |

The schemas and reporting paths are documented in the [OpenAI Usage API reference](https://developers.openai.com/api/reference/resources/admin/subresources/organization/subresources/usage), [Anthropic Messages API](https://platform.claude.com/docs/en/api/messages/create), [Anthropic Usage and Cost API](https://platform.claude.com/docs/en/manage-claude/usage-cost-api), and [Gemini token guide](https://ai.google.dev/gemini-api/docs/tokens).

OpenAI’s reasoning tokens are billed as output even though the API doesn’t expose their text, as described in its [reasoning guide](https://developers.openai.com/api/docs/guides/reasoning); Google explicitly includes thinking tokens in model output pricing. Don’t add a separate reasoning charge on top of an output total that already includes them.

A provider dashboard gives you the provider’s accounting view. A gateway can add per-request attribution across callers, but its number is only as sound as its model rates and usage parsing. LiteLLM documents spend logs and warns when a deployment has no input/output pricing entry in its [cost-tracking guide](https://docs.litellm.ai/docs/proxy/cost_tracking). We build OctoHub at Muvon; it stores every completion with the calling API key, session, model and provider, and usage split into input, output, cache read and write, and reasoning tokens, plus cost where it’s known ([OctoHub LLM proxy overview](/blog/introducing-octohub-llm-proxy-for-observability)). Provider dashboards and other documented proxies are reasonable alternatives if they fit your stack.

## What should I do when the real bill differs?

First separate a token-volume miss from a rate or attribution miss. Compare request counts, average input/output usage, cache buckets, model IDs, and retries for the exact same dates. A gap in request logs usually means calls bypassed your proxy or usage fields weren’t recorded; a gap between estimated cost and the vendor report can mean stale rates, unpriced tools, or a different service tier.

Keep the estimate and observed bill side by side for the first month. Once volume and cost per task are real, the next step is choosing a model and route in our [model-routing guide](/blog/running-one-ai-agent-across-many-models). If you need broader request traces, see our [agent observability notes](/blog/debugging-ai-agents-the-observability-we-wanted) or [lessons from a unified provider layer](/blog/lessons-building-a-unified-llm-provider-layer-in-rust).

— Don

---

_If you spot a mismatch between a provider’s returned usage and its monthly cost report, [open an issue on OctoHub](https://github.com/Muvon/octohub/issues) with the model and field names involved._