How much does an LLM API cost per month? Five worked examples at October 2026 prices

For the five worked examples below, the monthly bill runs from $113 for a support chatbot on GPT-6 Luna to $2,112 for a ten-person team's coding agent on Claude Sonnet 5.5. One change can move those numbers a lot: the same chatbot on GPT-6.1 Terra costs $1,092, and the image app at high quality instead of medium costs $2,763.

So the real answer is a formula, not a figure. Below are the formula, five examples with every assumption stated, and a Python function to redo them with your own numbers. All prices are list prices in US dollars from each maker's pricing page on 31 October 2026, and a month is 30 days.

The five monthly estimates

The headline output price is rarely the biggest line. The coding agent pays most for resent context, RAG for retrieved chunks that never cache, and transcription and images for minutes and pictures.

How the arithmetic works

Every line on an LLM bill is tokens in millions times the price per million. What changes is which price each token gets.

• Input that misses the cache gets the input price. On GPT-5.6 and later and on Claude, the new part of a cached prompt is a cache write at 1.25x the input price.
• Cached input costs 0.1x the input price on most current OpenAI and Claude models, 0.05x on Claude Sonnet 5.5, Claude Opus 5.5 and GPT-6.1 Sol and Terra, and about 2% on DeepSeek.
• Reasoning tokens are billed as output, though you never see them. GPT-6 Luna defaults to medium effort, Claude Sonnet 5.5 to high, and DeepSeek V4.1 Flash thinks by default.
• Batch halves input and output on OpenAI, Anthropic and Google, for results within a 24-hour window. DeepSeek has no batch discount but halves its prices off-peak.

Per-minute and per-image prices skip the token math: multiply by the unit price.

Support chatbot: $113 a month

The assumptions:

• 2,000 conversations a day with five customer messages each: 10,000 requests a day, 300,000 a month.
• 4,000 input tokens per request: about 2,500 of instructions, policies and tool definitions, plus the conversation so far.
• 70% of input tokens are cache hits. The other 30% are new, and at default settings they're written to the cache.
• 250 tokens of visible reply plus 150 reasoning tokens at low effort.
• No Batch, because a customer is waiting.

GPT-6 Luna costs $0.10 / $0.50, with cache hits at $0.01 and 30-minute cache writes at $0.125.

Without caching, the month would cost $180.00. Claude Haiku 5.5, released on 7 October, has exactly the same list prices ($0.10 / $0.50, $0.01 cache hits, $0.125 five-minute writes), so the same token counts give the same $113.40, though each model's tokenizer counts your text differently.

The reasoning line depends on the API. GPT-6 Luna calls functions through Chat Completions only with reasoning_effort set to none, so a tool-using bot there has no reasoning tokens and costs $90.90. Through the Responses API, low works with tools.

The jump to a mid-size model is where chatbot bills grow: GPT-6.1 Terra ($1 / $5) on the same traffic costs $1,092.00. If only some conversations need it, route those and keep the rest on the small model.

RAG search tool: $1,370 a month

The assumptions:

• A help-center search box answering 3,000 questions a day: 90,000 a month.
• 6,000 input tokens per question: 1,200 tokens of instructions, eight retrieved chunks of 600 tokens, and the question.
• 20% cache hits. Only the instructions repeat; the chunks change with every question.
• 350 output tokens plus 200 reasoning tokens at low effort.
• Embeddings with text-embedding-3-small ($0.02 per 1M): 50M tokens of documents indexed once, 10% re-embedded each month through Batch, and 50 tokens per question.

Claude Sonnet 5.5 costs $2 / $10, with cache hits at $0.10.

Embeddings are a rounding error: indexing the whole 50M-token corpus once costs $1.00. Uncached input is 63% of the bill, so the biggest lever is how much you retrieve. Four chunks instead of eight brings the month to $937.94. The same traffic on GPT-6 Luna costs $69.17.

Put the cache breakpoint after the instructions, not after the chunks. Claude's automatic caching moves the breakpoint to the end of the prompt, which writes every chunk to the cache at $2.50 per million and raises the month to $1,585.94. GPT-5.6 and later also place the default breakpoint at the end of the latest user message; in the Responses API, explicit cache mode with one breakpoint after the instructions avoids that.

Coding agent: $2,112 a month

The assumptions:

• 10 developers, 10 agent tasks each per working day, 22 working days: 2,200 tasks.
• 30 model calls per task: 66,000 requests.
• 50,000 input tokens per call on average, because every call resends the files, tool output and history so far.
• 90% cache hits. The other 10% (new tool output and the last reply) are cache writes.
• 500 visible output tokens (edits and tool calls) and 1,000 reasoning tokens at medium effort.
• No Batch, because a developer is waiting.

Claude Sonnet 5.5 bills five-minute cache writes at $2.50 and cache hits at $0.10.

That's $211 per developer, or $0.96 per task. Cached input is 90% of the tokens but 14% of the bill, so protect the hit rate: at 70% hits (cache entries expiring during slow test runs, for example), the month costs $3,696.00. Effort is next. Sonnet 5.5 defaults to high, and doubling reasoning to 2,000 tokens per call makes it $2,772.00.

GPT-6.1 Sol has the same list prices as Sonnet 5.5. Claude Opus 5.5 costs exactly double ($4,224.00). DeepSeek V4.1 Flash costs $117.81 off-peak or $235.62 at peak, and its off-peak hours cover the whole US working day; the DeepSeek V4.1 Flash post has the windows and the data-storage caveat. For cost per finished task, see Claude alternatives for coding.

Transcription pipeline: $580 a month

The assumptions:

• 4,000 recorded calls a month, 30 minutes each: 120,000 minutes.
• Transcription with gpt-transcribe at $0.0045 a minute. It doesn't support Batch.
• A summary of each call from Claude Sonnet 5.5, sent through Batch overnight: 6,000 input tokens (the transcript plus instructions), 500 output and 300 reasoning tokens.
• No caching, since every transcript is different.

Audio is 93% of this bill, so the summary model barely matters. Batch still does: the same summaries sent live cost $80.00.

If you need speaker labels, OpenAI's diarization model (gpt-4o-transcribe-diarize, $0.006 a minute) shuts down on 26 February 2027. Google's Gemini 3.5 Transcribe includes diarization at $2 per 1M audio tokens in and $12 per 1M text tokens out. At Google's rates of 25 audio tokens a second and about 175 text tokens a minute, 120,000 minutes cost $360 + $252 = $612.

Image app: $748 a month

The assumptions:

• 2,000 images a day: 60,000 a month, all 1024×1024 at medium quality, with no reference images.
• 300 text tokens of prompt per image (the user's text plus a style template).
• 30% of images are bulk jobs, such as product backgrounds, sent through Batch at half price.
• GPT Image 2.5 Flare: $5 per 1M text input tokens and $30 per 1M image output tokens. The cost formula in OpenAI's image-generation guide works out to 439 output tokens for a 1024×1024 medium image, about $0.013.

Quality moves this bill most. The same 60,000 images cost $376.38 at low (196 tokens each) and $2,763.18 at high (1,756 tokens each). Both GPT Image 2.5 models default to auto, which picks a quality from the prompt, so an app that never sets quality has no fixed cost per image.

Google's Nano Banana 2.1 charges $0.0336 per 1K image ($0.0168 in Batch) plus $1.50 per 1M input tokens. The same workload comes to $1,736.55, before any text or thinking tokens it returns.

A cost calculator you can copy

The function takes per-request token counts and per-million prices, and returns the month's breakdown. Pass the cache-write price as price_miss for models that charge for writes.

def monthly_cost(requests, input_tokens, output_tokens, price_in, price_out,
                 reasoning_tokens=0, price_cached=None, price_miss=None,
                 cache_hit=0.0, batch_share=0.0, batch_discount=0.5):
    """Estimate one month's bill in US$.

    requests          requests per month
    *_tokens          tokens per request (reasoning is billed as output)
    price_*           US$ per 1M tokens, from the provider's pricing page
    price_cached      price of a cache hit (defaults to price_in)
    price_miss        price of an input token that misses the cache: the
                      cache-write price where writes cost extra, else price_in
    cache_hit         share of input tokens read from the cache (0 to 1)
    batch_share       share of requests sent through a Batch API (0 to 1)
    """
    price_cached = price_in if price_cached is None else price_cached
    price_miss = price_in if price_miss is None else price_miss
    m_in = requests * input_tokens / 1e6           # millions of input tokens
    lines = {
        "input": m_in * (1 - cache_hit) * price_miss,
        "cached input": m_in * cache_hit * price_cached,
        "output": requests * output_tokens / 1e6 * price_out,
        "reasoning": requests * reasoning_tokens / 1e6 * price_out,
    }
    factor = 1 - batch_share * batch_discount     # batch requests cost less
    lines = {k: v * factor for k, v in lines.items()}
    lines["total"] = sum(lines.values())
    return {k: round(v, 2) for k, v in lines.items()}


# The support chatbot above, on GPT-6 Luna
print(monthly_cost(300_000, 4_000, 250, price_in=0.10, price_out=0.50,
                   reasoning_tokens=150, price_cached=0.01, price_miss=0.125,
                   cache_hit=0.70))
# {'input': 45.0, 'cached input': 8.4, 'output': 37.5, 'reasoning': 22.5, 'total': 113.4}

# The image app: 439 image tokens per image, 30% through Batch
print(monthly_cost(60_000, 300, 439, price_in=5.00, price_out=30.00, batch_share=0.30))
# {'input': 76.5, 'cached input': 0.0, 'output': 671.67, 'reasoning': 0.0, 'total': 748.17}

Don't guess the token counts: run a day of real traffic and read them from the usage block. In OpenAI's Responses API, output_tokens includes reasoning_tokens, so subtract to get the visible part:

u = response.usage
cache_hit = u.input_tokens_details.cached_tokens / u.input_tokens
reasoning = u.output_tokens_details.reasoning_tokens
visible = u.output_tokens - reasoning
print(u.input_tokens, round(cache_hit, 2), visible, reasoning)

On Claude, the equivalents are usage.cache_read_input_tokens and usage.cache_creation_input_tokens.

Settings that keep the bill predictable

• Cap output, reasoning included: max_output_tokens in OpenAI's Responses API, max_completion_tokens in Chat Completions, max_tokens on Claude. A request that hits the cap is still billed and can return no visible text, so log those.
• Set reasoning effort on every request instead of inheriting the default.
• Put the stable part of the prompt first, cache it on purpose, and keep dates and request IDs out of it.
• Send anything that can wait up to 24 hours through Batch. The cheapest way to use the OpenAI API covers Batch and Flex.
• Set image quality and size explicitly.
• Keep a tested fallback model in config, and route easy requests to the small model by default.

In code, the first three look like this:

from openai import OpenAI
import anthropic

question = "How do I change the email on my invoices?"
instructions = "You answer billing questions for Example Co. ..."  # stable part; caching
# needs at least 1,024 tokens of it on GPT-6 Luna and 512 on Claude Sonnet 5.5

r = OpenAI().responses.create(
    model="gpt-6-luna",
    reasoning={"effort": "low"},       # defaults to medium
    max_output_tokens=1_000,           # includes reasoning tokens
    input=[{"role": "developer", "content": instructions},
           {"role": "user", "content": question}],
)
if r.status == "incomplete" and r.incomplete_details.reason == "max_output_tokens":
    print("Hit the cap; this request was still billed")

m = anthropic.Anthropic().messages.create(
    model="claude-sonnet-5-5",
    max_tokens=4_000,                  # thinking plus reply
    output_config={"effort": "medium"},  # Sonnet 5.5 defaults to high
    system=[{"type": "text", "text": instructions,
             "cache_control": {"type": "ephemeral"}}],  # cache only this part
    messages=[{"role": "user", "content": question}],
)
print(m.usage.cache_read_input_tokens, m.usage.cache_creation_input_tokens)

Then put a ceiling on the month. Providers cap at different levels:

Check tier caps against your estimate before launch. The coding agent's $2,112 is over Anthropic's $1,000 Build cap, so on that tier the team is cut off about halfway through the month. The Gemini transcription option ($612) would pause on a $250 Tier 1 account about 12 days in. OpenAI and Google both say spend can run slightly past a limit before requests stop. Setting an OpenAI API key spending limit covers the OpenAI side.

The same five bills through Aight

Aight is one OpenAI-compatible API for 126 models, priced in US dollars at the maker's list price for most of them. A $100 recharge costs $103 with the 3% processing fee and adds $110 of balance with the 10% extra, so $1 of list-price usage costs about $0.94.

Where direct costs less, it's said plainly:

• Aight's API reference documents chat completions, embeddings and the model list, so the transcription and image steps go direct and nothing gets the Batch discount. For the transcription pipeline, direct is the lower-cost route: $80.00 of live summaries against $40.00 in Batch.
• Claude Haiku 5.5 isn't on Aight's models page yet. Claude Haiku 4.5 is, at $1 / $5, ten times the price, so use GPT-6 Luna for the chatbot. GPT-6.1 Terra isn't listed either.
• DeepSeek V4.1 Flash on Aight is a flat $0.30 / $1.20 (cached input $0.006), DeepSeek's peak price. The coding agent on it costs $220.63 through Aight against $117.81 direct off-peak, and Aight's catalog lists a 128K context window for it.
• Aight's reference lists model, messages and stream as the chat completion fields. Test reasoning_effort and max_completion_tokens with your own key before you size a cap around them.

What Aight adds is the cap layer at a finer grain: a monthly cap on each key, a list of allowed models per key, and an expiry date. Give each app its own key with a cap about 1.5x its estimate, and a runaway job stops at its own limit without touching the others. Balance is prepaid, doesn't expire, and unspent paid balance is refundable. The aggregator comparison sets Aight's $0.94 per $1 against other gateways, and one API key for every model covers setup.

Whichever route you take, check the estimate against the first week's real charges.

Sources

• OpenAI, Pricing: GPT-6, GPT-6.1, GPT Image 2.5, transcription, embeddings, Batch
• OpenAI, Prompt caching, Reasoning models, Batch API, Spend limits
• OpenAI, Image generation (output-token calculator) and Speech to text
• OpenAI model pages: gpt-6-luna, gpt-transcribe, gpt-image-2.5-flare, text-embedding-3-small
• Anthropic, Pricing, Models overview, Release notes (Claude Haiku 5.5, 7 October)
• Anthropic, Prompt caching, Effort, Rate limits and spend limits
• Google, Gemini API pricing (Gemini 3.5 Transcribe, Nano Banana 2.1) and Billing (spend caps)
• DeepSeek, Models and pricing
• Aight, Models and pricing, API reference, Refund policy

Checked on 31 October 2026.