Below are 12 practical techniques, with worked examples using real October 2026 prices, plus how to decide whether a subscription or pay-as-you-go billing is cheaper for you.

Where Claude Code and Cursor money actually goes

Both tools bill you for tokens, the small chunks of text that AI models read and write (see our plain English guide to tokens). Coding agents use far more tokens than chat because every step carries file contents, tool results and the full history of the session.

How that shows up depends on your plan:

• Claude subscriptions (Pro $20, Max $100 or $200, Team seats): no per-token bill, but a five-hour and weekly allowance shared with Claude chat. Wasted tokens mean hitting limits sooner. Usage credits beyond the limit are billed at API rates.
• Claude Console (API): you pay per token at list prices. Anthropic’s cost documentation puts the enterprise average at around $13 per developer per active day and $150 to $250 per month.
• Cursor (Pro $20, Pro Plus $60, Ultra $200): included usage in two pools, then on-demand billing at API rates. Cursor says daily agent users typically spend $60 to $100 a month in total usage.

Here are the Claude rates that matter for the examples below, from the official Claude API pricing page.

All prices are USD per million tokens. For the full rate card, read our Claude API pricing guide.

Step zero: measure your baseline

You cannot cut what you cannot see. In Claude Code, run /usage. API users see the session’s tokens and estimated cost by model, plus a prompt cache line showing what share of input came from cache. Subscribers see plan usage bars and a breakdown that attributes usage to skills, subagents, plugins and individual MCP servers, and flags behaviors such as long context or cache misses when they cause 10% or more of recent usage. /context shows what is filling the context window, and /insights writes a report on how you work.

In Cursor, check the usage page in your account dashboard and note which models drive on-demand charges, especially those billed from the API-priced Other Models pool.

A worked example: one day of Claude Code on the API

Imagine a solo developer’s day in Claude Code: 20 million tokens read from cache (the re-sent conversation and files), 1 million new input tokens written to the 5-minute cache, and 300,000 output tokens.

• Opus 5.5: (20 x $0.20) + (1 x $5.00) + (0.3 x $20) = $4.00 + $5.00 + $6.00 = $15.00
• Sonnet 5.5: (20 x $0.20) + (1 x $2.50) + (0.3 x $10) = $4.00 + $2.50 + $3.00 = $9.50
• Haiku 4.5: (20 x $0.10) + (1 x $1.25) + (0.3 x $5) = $2.00 + $1.25 + $1.50 = $4.75
• Sonnet 5.5 with lean context (cache reads halved to 10 million): $2.00 + $2.50 + $3.00 = $7.50

Over 20 working days, that is $300 on Opus versus $150 on lean Sonnet. On a subscription, the same savings mean your five-hour window lasts roughly twice as long. The techniques below are how you get from the first number to the last.

8 ways to reduce Claude Code costs

1. Make Sonnet your default, not Opus

Claude Code uses Opus 5.5 by default on Pro, Max, Team, Enterprise and API accounts. Anthropic’s own cost guide says Sonnet “handles most coding tasks well and costs less than Opus”. Switch with /model sonnet, or set "model": "sonnet" in your settings file. Keep Opus for architecture decisions and gnarly bugs.

2. Use the opusplan alias for big tasks

The opusplan model alias uses Opus in plan mode, then switches to Sonnet to carry out the plan. You pay Opus prices for the short, high-value thinking and Sonnet prices for the long, token-heavy execution. This is a simple form of model routing built into the tool.

3. Lower the effort level on simple work

Thinking tokens are billed as output, the most expensive token type. Opus 5.5 and Sonnet 5.5 support effort levels from low to max (default medium). For renaming variables, writing docstrings or small edits, run /effort low. On Opus 5.5, cutting 100,000 thinking tokens saves 0.1 x $20 = $2.00.

4. Clear between unrelated tasks

Every message re-sends the whole conversation. A session that has run all day costs usage on every one-line question. Use /clear when you switch tasks (it costs nothing), with /rename first if you want to /resume later. Use /compact with instructions such as “keep only the API changes” when you need continuity, but remember compaction is itself a large request.

5. Do not break the cache

Claude Code caches the start of your conversation. On a subscription the cache lasts an hour; on an API key, or once you draw on usage credits, it lasts five minutes by default. After a break, the first message reprocesses everything. For a 150,000-token context on Opus 5.5, a cache hit costs 0.15 x $0.20 = $0.03, while a rebuild at the 5-minute write rate costs 0.15 x $5 = $0.75, about 25 times more. Changing tool definitions or MCP servers mid-session also invalidates the cache. Group your work into focused blocks rather than returning to a stale session every hour, and see our prompt caching explainer for the mechanics.

6. Keep CLAUDE.md short and move the rest into skills

CLAUDE.md loads into every session. Anthropic suggests keeping it under 200 lines. Move workflow-specific instructions (release steps, PR review checklists) into skills, which load only when used.

7. Trim MCP servers and filter noisy output

Run /mcp and disable servers you are not using; prefer CLI tools such as gh, which add no tool listings. Add a hook that filters test output to failures only, so Claude reads a few hundred tokens instead of tens of thousands. Hand verbose jobs such as log analysis to a subagent set to model: haiku, so only a short summary returns to the main conversation.

8. Avoid agent teams unless you need them

Anthropic says agent teams use approximately 7x more tokens than standard sessions when teammates run in plan mode, because each teammate has its own context window. Our $15 Opus day would become roughly $105. Use them only for genuinely parallel work, keep teams small, run teammates on Sonnet and shut them down when done.

4 ways to reduce Cursor costs

9. Keep routine work in the Cursor Models pool

Cursor’s “Cursor Models” pool, which includes Composer 2.5 and Grok models, gets significantly more included usage than the “Other Models” pool. Claude, GPT and Gemini are charged at their API prices. Use Composer 2.5 for everyday edits and switch to a frontier model only when Composer gets stuck. Our Cursor pricing guide explains both pools in detail.

10. Lean on Tab and inline edits for small changes

Tab completion is unlimited on Pro. A one-line fix with Cmd+K or Tab costs far less than an Agent run that reads half the repository. Reserve the Agent for multi-file work.

11. Plan first, and keep rules lean

Cursor’s Plan mode “creates detailed implementation plans before writing any code”, which prevents expensive rework. Keep .cursor/rules files scoped with globs or set to “Apply Intelligently” so they load only where relevant, rather than always applying large rule sets to every request. Checkpoints let you restore instead of paying for the agent to undo its own mistakes.

12. Pick the right plan, and watch on-demand usage

Once included usage runs out, Cursor bills on-demand usage in arrears at API rates. If you regularly exceed Pro by $40 or more, Pro Plus at $60 is likely cheaper than paying overage. In India, the Start plan (Rs 649 a month, Cursor Models only) suits learners who are happy with Composer. Check the usage page weekly so the bill does not surprise you.

Subscription or pay-as-you-go: which is cheaper?

For Claude Code, compare your expected API spend with plan prices.

Max has weekly limits across all models, so the very heaviest users may still need usage credits. For a team, mix Team Standard seats ($25, or $20 annual) for light users with Premium seats ($125, or $100 annual) only for heavy Claude Code users. Our Claude Pro vs Max guide and AI team plans explainer cover the trade-offs. If you are unsure which tool to keep at all, see Claude Code vs Cursor.

Cheaper models through other providers

DeepSeek offers an Anthropic-compatible API endpoint, and its documentation maps Claude Sonnet and Haiku model names to its deepseek-flash model and Opus names to deepseek-v4-pro. Pointing an Anthropic-format tool at it can cut token prices sharply: Flash costs $0.15 input and $0.60 output per million off-peak. The trade-offs are real, though. Several Anthropic features, including cache_control, are ignored, quality differs from Claude, and you must be comfortable with DeepSeek’s data handling before sending proprietary code. Read our DeepSeek API pricing guide before trying it, and test on a non-sensitive project first.

Common mistakes that waste money

• Leaving Opus as the default for every task.
• Running one session all day across unrelated tasks.
• Letting a 600-line CLAUDE.md or always-on rule files load into every request.
• Installing many MCP servers “just in case”.
• Picking frontier models in Cursor for edits Composer handles fine.
• Paying API rates every month when a flat plan would be cheaper, or the reverse.

Many of the same habits help in the chat apps too; see how to reduce token usage in ChatGPT and Claude.

Frequently asked questions

Next steps: build a cheaper coding routine

Start with the two biggest levers this week: make Sonnet 5.5 your Claude Code default and use /clear between tasks; in Cursor, default to Composer 2.5. Next, trim CLAUDE.md and unused MCP servers, then check /usage or your Cursor dashboard after a week to see what changed. Finally, compare your real spend with plan prices and switch billing if needed. Prices, plans and limits change often, so confirm current rates on the Claude and Cursor pricing pages before you decide.

Related reading: the cheapest AI model for each task and how to use Cursor AI.

The post How to Reduce Claude Code and Cursor Costs appeared first on Digital Tatva.

This guide explains how routing works, the four main routing strategies, worked cost examples using October 2026 prices, ready-made routers such as OpenRouter’s Auto Router, and the pitfalls that quietly erase your savings.

What is model routing?

Most AI apps handle a mix of requests. Some are easy: classify this ticket, extract a date, answer a FAQ. Some are hard: debug this code, write a nuanced reply to an angry client, reason through a contract. Sending everything to a premium model overpays for the easy majority. Sending everything to a budget model fails on the hard minority.

A router sits between your app and the models. For each request, it decides which model should answer, sends the request, and returns the reply. Your users see one assistant; behind the scenes, three or four models share the work.

Routing differs from simply picking the cheapest model for each task once, at design time. A router makes that choice dynamically, request by request, which matters when one endpoint receives both easy and hard inputs.

Why routing saves so much: the price ladder

The savings come from the gap between tiers. Here are current standard prices per million tokens for models commonly used in routers.

The flagship tier costs 100 times more per token than the budget tier. Even moving a request one rung down the ladder typically halves its cost. Full rate cards are in our guides to OpenAI API pricing, Claude API pricing and Gemini API pricing.

The four main routing strategies

1. Rule-based routing

You write simple rules: requests from the “FAQ” widget go to GPT-6 Luna, anything containing code goes to Sonnet 5.5, enterprise customers get Opus 5.5. Rules are free to run, predictable and easy to debug. They break down when the same entry point receives very different requests.

2. Classifier routing

A small, cheap model reads the request (or just its first few hundred tokens) and labels it: simple, standard or complex. The label decides the model. This adapts to messy inputs but adds a small cost and a little latency per request, and the classifier itself can misjudge.

3. Cascades: try cheap, escalate on failure

Every request goes to the budget model first. If the answer fails a check (invalid JSON, a failed test, a low confidence score, a validator model saying “not good enough”), the request is retried on a stronger model. Cascades guarantee you only pay premium prices when needed, but escalated requests are paid for twice, and you need a reliable check.

4. Fallback routing

Fallbacks switch models when something goes wrong rather than based on difficulty: an outage, a rate limit error, or a usage cap. DeepSeek, for example, returns an HTTP 429 error when you exceed its concurrency limit, so a fallback to another provider keeps your app running. ChatGPT does a consumer version of this: on the $200 Pro plan, when you hit the GPT-6 Pro weekly limit, it automatically switches to GPT-5.6 Thinking at Medium.

Worked example: routing a support assistant

Say your support assistant handles 200,000 requests a month, each with about 2,000 input tokens (instructions, help-center snippets and the question) and 400 output tokens. That is 400 million input and 80 million output tokens a month.

Without routing

• Everything on Claude Sonnet 5.5: (400 x $2) + (80 x $10) = $800 + $800 = $1,600 a month.
• Everything on Claude Opus 5.5: (400 x $4) + (80 x $20) = $1,600 + $1,600 = $3,200 a month.

With a classifier router

A GPT-6 Luna classifier reads the first 300 tokens of each request and outputs a one-word label (about 5 tokens).

1. Classifier cost. 200,000 x 300 = 60M input tokens x $0.10 = $6.00, plus 1M output tokens x $0.50 = $0.50. Total $6.50.
2. 70% simple, to GPT-6 Luna. 280M input x $0.10 = $28, plus 56M output x $0.50 = $28. Total $56.
3. 25% standard, to Sonnet 5.5. 100M input x $2 = $200, plus 20M output x $10 = $200. Total $400.
4. 5% complex, to Opus 5.5. 20M input x $4 = $80, plus 4M output x $20 = $80. Total $160.

Total: $6.50 + $56 + $400 + $160 = about $623 a month, 61% less than all-Sonnet, while the hardest 5% of requests get a better model than before.

With a cascade instead

Send everything to GPT-6 Luna first: (400 x $0.10) + (80 x $0.50) = $40 + $40 = $80. If 20% fail the quality check and are retried on Sonnet 5.5, those 40,000 requests add (80 x $2) + (16 x $10) = $160 + $160 = $320. Total about $400 plus the cost of the check. But if 40% escalate, the retries cost $640 and the total reaches $720, more than the classifier router. Cascades win only when the budget model succeeds most of the time.

The hidden costs of routing

Broken prompt caches

Prompt caches belong to one model. If a long conversation hops between models, each switch rebuilds the cache on the new model at full input price. On Sonnet 5.5, cached input costs $0.20 per million versus $2 fresh, so losing the cache on a 100,000-token conversation costs about 0.1 x $1.80 = $0.18 extra per switch. Route once per conversation or per task, and keep shared instructions at the start of the prompt. See our prompt caching guide.

Inconsistent tone and format

Different models write differently. Users may notice a support bot that sounds different from one message to the next. Strict output formats, shared system prompts and examples reduce this.

Classifier and gateway overhead

Classifiers add a few milliseconds to seconds of latency and a small cost. Gateways may add fees; OpenRouter, for instance, charges 5.5% (minimum $0.80) when you buy credits, although it passes model prices through without markup.

Context window and long-prompt pricing

Budget models may have smaller context windows or different long-context pricing. Claude Haiku 4.5 has a 200K context window, while Sonnet 5.5 and Opus 5.5 offer 1M. OpenAI bills GPT-6 requests over 272K input tokens at higher rates. Route long documents to a model that handles them economically; our context window explainer covers the limits.

Ready-made routers and built-in routing

OpenRouter Auto Router

OpenRouter gives one API for models from many labs. Its Auto Router (model id openrouter/auto) classifies each prompt into about 30 task types and ranks models by what OpenRouter users spend on that task type over the last seven days. OpenRouter says “there is no additional fee for using the Auto Router”: you pay the selected model’s normal rate. You can restrict choices with allowed_models (for example anthropic/*), exclude models, set a cost_tier from low to max, and cap price with provider.max_price. The response’s model field tells you which model answered. Details are in the official Auto Router docs.

Self-hosted gateways

Open-source proxies such as LiteLLM put many providers behind one interface and track spend by key, and Anthropic’s Claude Code documentation notes that several large enterprises use LiteLLM for this. You write the routing logic yourself, which gives full control and no gateway fee, at the cost of running the service.

Routing inside the tools you already use

• Claude Code: the opusplan alias uses Opus for planning and Sonnet for execution, and subagents can be set to Haiku for simple jobs. See our guide to reducing Claude Code and Cursor costs.
• Cursor: its own models (Composer 2.5, Grok) sit in a pool with much more included usage, while Claude, GPT and Gemini are billed at API rates, which rewards routing routine work to Composer.
• Bolt.new: its docs say “Bolt handles model selection behind the scenes” across its Standard and Max agents.

How to build a simple router in five steps

1. Collect real requests. Export 200 to 500 recent prompts and tag each as simple, standard or complex by hand.
2. Define a quality bar. Decide what a good answer looks like: valid JSON, a correct label, a passing test, or a rubric score.
3. Test each tier. Run the sample through a budget, mid and premium model. Record pass rate and cost per request. Use the Batch API at 50% off to make these tests cheap.
4. Start with rules, then add a classifier. Route obvious cases by rules. Add a cheap classifier for the rest and check its accuracy on your tagged sample.
5. Monitor and adjust. Log which model handled each request, its cost and any user complaints. Revisit monthly, since prices change; Gemini 3.8 Flash, for example, doubles in price on 1 January 2027.

When routing is not worth it

• Low volume. If your API bill is $20 a month, the engineering time costs more than the savings.
• Uniformly hard tasks. If every request needs a premium model, routing adds overhead with nothing to save.
• Strict compliance needs. Sending data to several providers multiplies the vendors you must vet. Our AI data privacy guide explains what to check.
• When batching or caching would do more. For predictable workloads, prompt caching and the Batch API may cut costs further with less complexity. Try those first.

Frequently asked questions

Verdict: route by difficulty, measure by outcome

Model routing is one of the most effective ways to cut AI API costs once you have real volume. Start simple: send obvious easy requests to a budget model such as GPT-6 Luna, keep a mid-tier model such as Sonnet 5.5 as the default, and reserve Opus 5.5 or a flagship for the hardest few percent. Route per conversation to protect your prompt cache, measure cost per successful task, and stack routing with caching and batching. Model prices change often, so confirm current rates on each provider’s pricing page before you set your rules.

Related reading: DeepSeek API pricing and GPT-6 models explained.

The post Model Routing: Send Each Task to the Cheapest Capable AI appeared first on Digital Tatva.

If you use ChatGPT, Claude or Gemini in the browser, tokens explain why long chats slow down and why you run out of messages. If you build with an API, tokens are literally your bill. This guide explains tokens in plain English first, then shows the real prices and the arithmetic behind them.

What is a token in AI? The plain English version

Think of a token as a Lego brick of language. Before a model reads your message, a tool called a tokenizer breaks the text into these bricks. Common short words like “the” or “cat” are often a single token. Longer or rarer words get split into several pieces, so a word like “unbelievable” might become two or three tokens.

Spaces, punctuation and numbers count too. A comma can be its own token, and a long number may be split into several. That is why the word count of your text and its token count never match exactly.

The model also writes its answer one token at a time. When you watch ChatGPT or Claude “type” a reply, you are watching it produce tokens in sequence. Each new token is a prediction of what should come next, based on all the tokens before it.

Quick conversions you can use

These are OpenAI’s published rules of thumb for English. They are estimates, because sentence and word lengths vary.

Why tokens matter even if you never touch an API

Most people meet tokens through a chat app, not code. ChatGPT, Claude and Gemini do not show you a per-token bill on subscription plans, but tokens still shape what you get in three ways.

1. Usage limits are really token budgets

Anthropic is open about this. Its help center says the Pro plan allows “around 45 messages every five hours” for short conversations, and that the real number depends on message length, attachments, conversation length and model. A 20-page PDF and a long chat history are just a lot of tokens, so they use up your allowance faster. Our guide to Claude usage limits explains how the five-hour window works, and the same logic applies to ChatGPT limits by plan.

2. The context window is measured in tokens

The context window is how much text a model can consider at once: your instructions, the conversation so far, any files, and its reply. On paid Claude plans the base chat context is 200K tokens, rising to 1M tokens on models such as Opus 5.5 and Sonnet 5.5. OpenAI’s GPT-6 models accept 1,050,000 tokens through the API. When a conversation outgrows the window, older parts get dropped or summarized. For the full picture, read our context window explainer.

3. Every message resends the conversation

This is the part most people miss. A chat model has no memory between turns on its own. Each time you send a message, the app sends the whole conversation (or a trimmed version of it) back to the model. Your tenth message costs far more tokens than your first, even if it is one line long.

Input tokens, output tokens and the other types

Once you look at a pricing page, you will see several kinds of tokens. Here is what each one means.

• Input tokens: everything you send to the model. That includes the system prompt (hidden instructions), the conversation history, uploaded documents and your actual question.
• Output tokens: everything the model writes back. These cost more because generating text takes more computing work than reading it.
• Cached input tokens: input the provider has seen recently and stored. If the start of your prompt is identical to a recent request, those tokens are billed at a steep discount. Our prompt caching guide covers how to set this up.
• Reasoning tokens: internal “thinking” that reasoning models do before the visible answer. OpenAI confirms these count toward output usage and billing, even though you do not see them.
• Audio and image tokens: media is also converted to tokens. OpenAI’s gpt-realtime-2.1 charges $32 per million audio input tokens and $64 per million audio output tokens, far more than its text rates. Google’s Gemini text-to-speech counts audio at 25 tokens per second.

How much do tokens cost? Real prices per million

API providers quote prices per 1 million tokens (often written as “per 1M” or “per MTok”). Here are current Standard-tier rates for popular models as of 30 September 2026.

Claude’s cached price shown is the cache read rate. Anthropic also charges a cache write fee of 1.25x the input price for a 5-minute cache. For the full rate cards, see our breakdowns of OpenAI API pricing, Claude API pricing and Gemini API pricing, or check the official OpenAI pricing page and Anthropic’s pricing docs.

Worked examples: turning tokens into dollars

The formula is simple: (input tokens / 1,000,000 x input price) + (output tokens / 1,000,000 x output price). Here it is applied to everyday jobs.

Example 1: writing a 1,000-word blog draft

Say your prompt with a brief and outline is 500 words (about 667 tokens) and the model writes 1,000 words (about 1,333 tokens).

• GPT-6.1 Sol: (0.000667 x $2) + (0.001333 x $10) = $0.0013 + $0.0133 = about $0.015 per draft.
• Claude Opus 5.5: (0.000667 x $4) + (0.001333 x $20) = $0.0027 + $0.0267 = about $0.029 per draft.
• GPT-6 Luna: (0.000667 x $0.10) + (0.001333 x $0.50) = about $0.0007 per draft.

Even the premium option costs about 3 cents per draft. Tokens only add up at scale, which is why APIs suit agencies running hundreds of drafts. Our guide on writing blog posts with AI covers the quality side.

Example 2: summarizing a 50-page report

A 50-page report of about 25,000 words is roughly 33,000 tokens. You ask for a 400-word summary (about 533 tokens) using Claude Sonnet 5.5.

• Input: 0.033 x $2 = $0.066
• Output: 0.000533 x $10 = $0.0053
• Total: about $0.071

Notice that input dominates here. When you send big documents, the input side of the bill matters most.

Example 3: a support chatbot at 1,000 chats a day

Each chat sends 2,000 input tokens and gets 500 output tokens back. That is 2M input and 0.5M output tokens per day.

• GPT-6 Astra: (2 x $10) + (0.5 x $50) = $45 per day
• GPT-6.1 Sol: (2 x $2) + (0.5 x $10) = $9 per day
• GPT-6 Luna: (2 x $0.10) + (0.5 x $0.50) = $0.45 per day

Same traffic, a 100x difference in cost. Model choice is the biggest lever you have, which is why we wrote a full guide on picking the cheapest AI model for each task.

How to count tokens yourself

You do not have to guess. Each major provider gives you a way to count tokens before you send anything.

1. Use a web tokenizer. OpenAI’s Tokenizer tool shows exactly how a piece of text splits into tokens, with each token highlighted in a different color. Paste in a typical prompt to see its real size.
2. Use a library in code. OpenAI publishes tiktoken, an open-source library that counts tokens for its model encodings.
3. Use Anthropic’s free counting endpoint. Claude’s API includes a token counting call that is free to use (with its own rate limits). It returns an estimate, which can differ slightly from the final count.
4. Read the usage data. Every API response reports the input and output tokens it used, and each provider’s dashboard totals them. Check these numbers in your first week of real traffic.

Example: counting Claude tokens in Python

This uses Anthropic’s official SDK. The response is a small JSON object with the input token count.

import anthropic

client = anthropic.Anthropic()

response = client.messages.count_tokens(
    model="claude-opus-5-5",
    system="You are a helpful marketing assistant.",
    messages=[{"role": "user", "content": "Write 5 subject lines for a Diwali sale."}],
)

print(response.json())  # e.g. {"input_tokens": 31}

Example: a simple cost estimator

Once you know your token counts, a few lines of code turn them into money. Prices are per 1 million tokens.

PRICES = {
    "gpt-6.1-sol":       {"input": 2.00, "output": 10.00},
    "claude-sonnet-5-5": {"input": 2.00, "output": 10.00},
    "gpt-6-luna":        {"input": 0.10, "output": 0.50},
}

def cost(model, input_tokens, output_tokens):
    p = PRICES[model]
    return (input_tokens / 1_000_000) * p["input"] + (output_tokens / 1_000_000) * p["output"]

daily = cost(  # 1,000 chats a day, 2,000 tokens in and 500 out per chat
    "gpt-6.1-sol", 2_000 * 1_000, 500 * 1_000)
print(f"${daily:.2f} per day, ${daily * 30:.2f} per month")  # $9.00 per day, $270.00 per month

For a full planning method, including traffic assumptions and safety margins, read how to estimate AI API costs before you build.

Common myths about AI tokens

“One token equals one word”

Not quite. In English a token is about three-quarters of a word on average, so 1,000 words is closer to 1,333 tokens. Code, numbers, URLs and non-English text can use many more.

“Only my question counts”

Every request includes the system prompt, earlier messages and any attached files. In a long chat, your new question may be a tiny fraction of the tokens sent.

“A bigger context window is always better”

A larger window lets you send more, but you pay for everything you send. On OpenAI’s GPT-6 and GPT-5.6 models, requests over 272K input tokens are billed at 2x the input rate and 1.5x the output rate for the whole request. Sending only the relevant parts is cheaper and often gives better answers.

“Short answers are always cheap”

With reasoning models, the hidden thinking tokens can far exceed the visible reply. Lower the reasoning effort for simple tasks.

Practical ways to use fewer tokens

Whether you pay per token or work inside a subscription limit, the same habits help. We cover them in depth in our guide to reducing token usage in ChatGPT and Claude, but here are the essentials.

• Start a new chat for a new topic. This stops old messages being resent every turn.
• Upload only the pages you need. Paste the relevant section, not the whole PDF.
• Ask for the format you want. “Five bullets, under 100 words” uses fewer output tokens than an open request.
• Put reusable instructions in a project or system prompt. Anthropic says documents uploaded to a Claude Project are cached and count less against your limits than new content.
• Write clearer prompts. A precise first prompt avoids three rounds of corrections. Our prompt engineering guide has 12 techniques.

Frequently asked questions

Next steps: put tokens to work

Tokens are just the unit AI uses to measure text. Once you know that 1,000 words is about 1,333 tokens, that output costs more than input, and that every chat message resends the history, both subscription limits and API bills start to make sense. The next step is choosing the right model for each job and trimming what you send.

Token prices change often, so always confirm current rates on each provider’s official pricing page before you budget.

The post What Are Tokens in AI? A Plain English Guide appeared first on Digital Tatva.

Why does it matter? On subscription plans like ChatGPT Plus or Claude Pro, tokens decide how quickly you hit your usage limit. On the API, tokens are your bill. This guide gives you practical techniques for both, with worked examples using real per-million-token prices.

Why ChatGPT and Claude use more tokens than you expect

A token is a chunk of text, roughly three-quarters of an English word (our plain English guide to AI tokens explains the basics). What surprises most people is not the size of a token but how many get sent.

Chat models do not remember earlier turns by themselves. Each time you press send, the app sends your new message plus the conversation so far, plus any system instructions, memory and attached files. So your 20th message carries the weight of the previous 19.

The arithmetic of a long chat

Imagine each turn (your message plus the reply) adds about 400 tokens. Turn 1 sends 400 tokens. Turn 2 sends 800. Turn 20 sends 8,000. Over 20 turns, the total input is 400 x (1 + 2 + … + 20) = 400 x 210 = 84,000 tokens.

Now suppose that at turn 10 you ask for a 500-token summary and start a fresh chat with it. Turns 1 to 10 send 400 x 55 = 22,000 tokens. Turns 11 to 20 each carry the 500-token summary plus the new turns: (10 x 500) + (400 x 55) = 27,000 tokens. The total is 49,000 tokens, about 42% fewer.

On the Claude Opus 5.5 API at $4 per million input tokens, that is $0.336 versus $0.196 for one session. Inside a subscription, it means the same work uses far less of your five-hour allowance.

8 ways to reduce token usage in the ChatGPT and Claude apps

These techniques work on Free, Plus, Pro, Max and Team plans. They are most useful if you regularly run into the caps described in our guides to Claude usage limits and ChatGPT limits by plan.

1. Start a new chat for every new topic. Do not use one endless thread for an email, then a spreadsheet formula, then a blog outline. Each unrelated message drags the old context along. New topic, new chat.
2. Summarize and restart long threads. When a working session gets long, ask: “Summarize the decisions, facts and open questions so far in under 200 words.” Paste that into a new chat and carry on. The example above shows why this saves so much.
3. Edit your message instead of adding a correction. If a reply misses the point, edit the original prompt and regenerate rather than sending “No, I meant…”. Editing replaces the failed turn instead of stacking another one on top.
4. Put several questions in one message. Anthropic’s own advice is to “group them in a single message” rather than sending separate ones. Five small questions in one message resend the history once, not five times.
5. Upload only what is relevant. Anthropic lists file attachment size as a factor in usage. If you need feedback on chapter 3, paste chapter 3, not the full 200-page manuscript.
6. Use Claude Projects for files you reuse. Anthropic says “When you upload documents to a project, they’re cached for future use”, and cached content counts less against your limits. Caches expire after a period of inactivity, so this works best when you use the project regularly. Our guide on how to use Claude Projects shows the setup.
7. Ask for the length and format you need. “Give me 5 bullets, under 80 words” produces far fewer output tokens than “Tell me about…”. You can also add a standing instruction, such as “Be concise unless I ask for detail”, to your custom instructions or project instructions.
8. Pick the lightest model that does the job. Use the flagship only for hard reasoning. For rewriting, summarizing and quick questions, a smaller model is fine and stretches your allowance much further.

How much difference does model choice make?

OpenAI publishes rough Codex limits per 5-hour window for ChatGPT Plus and Business, and they show the effect clearly. ChatGPT and Codex share the same usage limits.

The ranges are wide because heavy tasks use more tokens per message. The pattern is the point: the cheaper the model per token, the more work fits in your window. On Claude, the same logic applies to choosing Sonnet or Haiku over Opus for routine work.

Reduce token usage in Claude specifically

Claude’s usage resets in five-hour sessions, and Anthropic estimates “around 45 messages every five hours” on Pro for short conversations on less compute-heavy models. Longer conversations, bigger attachments and heavier models lower that number. Claude and Claude Code share the same allowance, so a long coding session also eats into your chat budget.

• Use chat search and memory instead of pasting old context. Paid users can search previous conversations and reference them in new chats, which avoids copying huge blocks of history.
• Plan the conversation. Anthropic suggests deciding up front what specific help you need. A clear first prompt avoids several rounds of back and forth.
• Keep Claude Code sessions focused. Clear or compact the context between unrelated coding tasks so the agent is not rereading old files and logs.
• Know when to upgrade. If you still hit limits daily after these changes, compare plans in our Claude Pro vs Max guide. Max 5x costs $100 a month and Max 20x costs $200.

Reduce token usage in ChatGPT specifically

OpenAI does not publish exact ChatGPT message caps, and its help center notes that Plus may still hit caps at peak times. Token habits matter just as much here.

• Use projects and custom GPTs for repeat work. Put standing instructions in one place instead of retyping a long brief in every chat.
• Review what memory and custom instructions add. Long custom instructions are included with your messages. Keep them short and specific.
• Save Astra for the hard problems. Plus includes GPT-5.6 Sol with Medium and High thinking. Use the lighter thinking level for everyday tasks.
• Consider the right plan. If you are a daily heavy user, our ChatGPT Plus vs Pro comparison explains when the Pro tiers at $100, $200 or $500 a month make sense.

How to reduce token usage on the OpenAI and Claude APIs

On the API, every token is billed, so savings show up directly on your invoice. Here are the techniques with the biggest effect, each with the arithmetic shown.

1. Cache your fixed prompt prefix

If every request starts with the same system prompt, product catalog or style guide, caching lets you pay a fraction of the input price for that part. OpenAI caches automatically when the start of the prompt is identical and at least 1,024 tokens long. Anthropic lets you mark what to cache, with a 5-minute cache write at 1.25x the input price.

Worked example (Claude Sonnet 5.5): a 10,000-token system prompt sent with 2,000 requests a day is 20M input tokens. Uncached: 20 x $2 = $40 a day. Cached reads at $0.20: 20 x $0.20 = $4. Add, say, 50 cache writes a day (0.5M tokens at $2.50 = $1.25) and the total is about $5.25 a day, roughly 87% less. Our prompt caching guide covers prompt layout and expiry rules.

Here is a minimal Claude request that marks a long system prompt for caching. Check Anthropic’s pricing docs for current cache rates.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=300,  # cap output length
    system=[
        {
            "type": "text",
            "text": LONG_STYLE_GUIDE,  # same text on every request
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": "Rewrite this product title: ..."}],
)

2. Cap output length

Output costs five times more than input on GPT-6.1 Sol ($2 versus $10) and Claude Opus 5.5 ($4 versus $20). Set a maximum output token limit and ask for tight formats. Example: 1,000 requests a day on GPT-6.1 Sol with 800-token replies is 0.8M output tokens, or $8 a day. Cutting replies to 300 tokens makes it 0.3M, or $3 a day, saving $150 a month.

3. Trim conversation history in your app

If you run a chatbot, do not send the full transcript every turn. Keep the last few turns verbatim and replace older ones with a short summary.

def build_messages(history, summary, keep_last=6):
    """Send a running summary plus only the most recent turns."""
    recent = history[-keep_last:]
    messages = []
    if summary:
        messages.append({"role": "user", "content": f"Conversation summary so far: {summary}"})
        messages.append({"role": "assistant", "content": "Understood."})
    return messages + recent

4. Route easy work to cheaper models

Send classification, tagging and short replies to a budget model, and escalate only hard cases. GPT-6 Luna costs $0.10 input and $0.50 output per million tokens, 20 times cheaper than GPT-6.1 Sol. Our guide on choosing the cheapest AI model for each task has a full routing table.

5. Lower reasoning effort

Reasoning models generate hidden thinking tokens that are billed as output. GPT-6 Astra supports low, medium, high, xhigh and max effort. Start low and only raise effort when a task fails, because each step up can multiply the hidden output.

6. Batch anything that can wait

OpenAI, Anthropic and Google all offer Batch processing at 50% off. A nightly job of 20M input and 2M output tokens on GPT-6.1 Sol costs (20 x $2) + (2 x $10) = $60 on Standard and $30 through Batch. See our Batch API guide.

7. Stay under long-context thresholds

On OpenAI’s GPT-6 and GPT-5.6 models, requests over 272K input tokens are billed at 2x input and 1.5x output for the whole request. Send only the relevant chunks of a document instead of the full file. Our context window explainer covers chunking.

Token saving techniques at a glance

Common mistakes that waste tokens

• Pasting the same brief into every chat. Put it in a project, custom GPT or system prompt once.
• Asking the model to “explain your reasoning” by default. That multiplies output tokens. Ask only when you need to check the logic.
• Uploading screenshots of text. Paste the text itself when you can. Images are converted to tokens too.
• Vague first prompts. Three rounds of corrections cost far more than one precise request. Our prompt engineering guide shows how to get it right first time.
• Never checking usage. On the API, read the token counts in each response and your dashboard. Anthropic’s token counting endpoint is free to use, so you can measure prompts before you send them.

Frequently asked questions

Next steps: build better token habits

You do not need to become a developer to save tokens. Start with the three habits that give the biggest return: a new chat per topic, short structured answers, and a lighter model for everyday tasks. If you build on the API, add caching, output caps and batching, and check your usage data weekly. For full rate cards, see our Claude API pricing breakdown and OpenAI API pricing guide.

Usage limits and token prices change often, so confirm the current numbers on OpenAI’s and Anthropic’s official pages before you plan around them.

The post How to Reduce Token Usage in ChatGPT and Claude appeared first on Digital Tatva.

The catch is that caching only works when the start of your prompt is byte-for-byte identical, and some providers charge extra to write the cache. This guide explains how prompt caching works on each platform, shows the real arithmetic with September 2026 prices, and gives you code you can copy.

What is prompt caching and how does it work?

Every call makes the model process your entire prompt. If most of it is the same instructions you sent a minute ago, that work is repeated. Prompt caching stores the processed prefix so the next request can skip ahead.

A cache write is the request that stores the prefix, sometimes billed slightly above the input price. A cache read (cache hit) is any later request that reuses it, billed at a steep discount. If you are new to how input and output tokens are counted, our plain English guide to tokens covers the basics.

The prefix rule

All three major providers match caches on the beginning of the prompt, and the cached section must be exactly identical. One changed character near the top breaks the match for everything after it.

So order your prompt from most stable to least stable: tools and system prompt first, then shared documents, then conversation history, with the new user message last.

Cache lifetime

Caches do not last forever. Anthropic offers a 5-minute and a 1-hour cache. OpenAI keeps cached entries on GPT-5.6 and later models for 30 minutes after the last write or reuse. Gemini’s explicit caches default to a 1-hour time to live (TTL) that you can change. If no request uses the cache before it expires, the next call pays for a fresh write.

Prompt caching prices on Claude, OpenAI and Gemini

Here are the current rates in USD per 1 million tokens for the models most people use. Cache prices are expressed as a multiple of the model’s normal input price.

Gemini 3.8 Flash prices apply until 31 December 2026. From 1 January 2027 the input price doubles to $1.50 and caching to $0.15, so budget for that if you are planning next year. For full price lists, see our guides to Claude API pricing, OpenAI API pricing and Gemini API pricing.

How Claude prompt caching works

Anthropic gives you the most control. You mark where the cacheable section ends with a cache_control block, and Claude caches everything up to that point. You can add the field once at the top level of the request for automatic caching, which places the breakpoint on the last cacheable block, or set up to 4 explicit breakpoints on individual blocks.

Minimum length and lifetime

• Minimum cacheable prompt: 512 tokens on Opus 5.5, Sonnet 5.5 and Fable 5.1, but 4,096 tokens on Haiku 4.5. Shorter prefixes are simply not cached.
• 5-minute cache: the default. Writes cost 1.25x input and break even after one read.
• 1-hour cache: set "ttl": "1h". Writes cost 2x input and break even after two reads.
• Lifetime starts at the beginning of the request. A response that takes 4 minutes to generate leaves only about 1 minute on a 5-minute cache.

Example: caching a system prompt in Python

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": LONG_SUPPORT_PLAYBOOK,  # 10,000 tokens of fixed rules and FAQs
            "cache_control": {"type": "ephemeral", "ttl": "5m"}
        }
    ],
    messages=[
        {"role": "user", "content": "Can I change my delivery address after ordering?"}
    ]
)

u = response.usage
print(u.cache_creation_input_tokens, u.cache_read_input_tokens, u.input_tokens)

Check the three usage fields on every response while you test. cache_creation_input_tokens shows a write, cache_read_input_tokens shows a hit, and input_tokens is the uncached part after the last breakpoint. If reads stay at zero on the second identical call, something in your prefix is changing.

What breaks a Claude cache

Claude builds the cache in a fixed order: tools, then system, then messages. A change at one level invalidates that level and everything after it. Editing a tool definition clears the whole cache. Editing the system prompt clears system and messages. Changing tool_choice, adding or removing images, or changing thinking or effort settings clears at least the messages section.

How OpenAI prompt caching works

OpenAI caching is automatic. You do not mark anything in the request: if the start of your prompt matches a recent one and the prefix is at least 1,024 tokens long (on GPT-5.6 and later), the matching part is billed at the cached rate.

On GPT-5.6 and later models, cached reads cost 0.1x the input rate, and GPT-6.1 Sol goes further at 0.05x ($0.10 per million). These newer models also charge a cache write at 1.25x the normal input rate, which earlier models did not. Cached entries stay valid for 30 minutes after the last write or reuse, which is friendlier than Anthropic’s 5-minute default for apps with uneven traffic.

Use prompt_cache_key for multi-tenant apps

If you serve many customers from one prompt template, the optional prompt_cache_key parameter separates cache accounting by customer or user. Here is a minimal example:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    instructions=SHARED_INSTRUCTIONS,   # same text on every call, placed first
    input="Summarize this ticket: " + ticket_text,
    prompt_cache_key="tenant-acme"
)

If you build OpenAI-powered chat features, our guide to adding an AI chatbot to your website shows where this fits in a real deployment.

How Gemini context caching works

Google calls the feature context caching and offers two modes.

Implicit caching

Implicit caching is on by default for Gemini 2.5 and newer models, and Google passes the savings on automatically when a request hits the cache. The minimum is 4,096 tokens on Gemini 3.8, 3.7, 3.6 and 3.5 Flash and on 3.1 Pro Preview (2,048 on the older 2.5 models). Google’s advice matches the prefix rule: put large, common content at the start of the prompt and send requests with a similar prefix close together.

Explicit caching

For guaranteed reuse, create a cache object through the generateContent API, then reference it by name. You pay the reduced cached-token rate on each use plus storage for as long as the cache lives. The TTL defaults to 1 hour if you do not set one.

from google import genai
from google.genai import types

client = genai.Client()

cache = client.caches.create(
    model="gemini-3.8-flash",
    config=types.CreateCachedContentConfig(
        system_instruction="You answer questions about our product manual.",
        contents=[manual_file],
        ttl="3600s"
    )
)

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="How do I reset the device to factory settings?",
    config=types.GenerateContentConfig(cached_content=cache.name)
)

Storage is cheap at small sizes. A 10,000-token manual cached on 3.8 Flash for 24 hours costs 0.01M x $0.50 x 24 = $0.12 in storage. Note that the newer Interactions API supports implicit caching only.

Worked examples: how much prompt caching saves

The numbers below use list prices. For a general budgeting method, see our guide to estimating AI API costs before you build.

Example 1: a support bot on Claude Sonnet 5.5

Each request sends a 10,000-token support playbook, a 200-token customer question and gets a 300-token answer. The bot handles 1,000 requests a day. To stay conservative, assume the 5-minute cache expires 50 times a day during quiet periods, so you pay 50 writes.

• Without caching: input 10.2M x $2 = $20.40, output 0.3M x $10 = $3.00. Total $23.40 a day (about $702 a month).
• With caching: writes 0.5M x $2.50 = $1.25, reads 9.5M x $0.20 = $1.90, fresh input 0.2M x $2 = $0.40, output $3.00. Total $6.55 a day (about $197 a month).

That is a 72% cut in the total bill and an 83% cut in input cost, from one configuration change. If you are choosing a support platform rather than building one, compare options in our roundup of AI customer support tools.

Example 2: the same bot on OpenAI GPT-6.1 Sol

GPT-6.1 Sol has the same $2 / $10 list price as Sonnet 5.5, but a cheaper $0.10 cache read and a 30-minute lifetime. Assume only 20 writes a day: writes 0.2M x $2.50 = $0.50, reads 9.8M x $0.10 = $0.98, fresh input 0.2M x $2 = $0.40, output $3.00. Total $4.88 a day, versus $23.40 uncached.

Example 3: questioning a 200,000-token contract on Opus 5.5

A lawyer asks 10 questions about one long contract over an afternoon. Without caching, each question resends the document: 10 x 0.2M x $4 = $8.00 in document input. With a 1-hour cache, the first call writes it at $8 per million (0.2M x $8 = $1.60) and the next nine read it at $0.20 (9 x 0.2M x $0.20 = $0.36). Document input drops to $1.96, a 75% saving. Opus 5.5 has a 1M context window with no long-context surcharge, which our context window guide explains in more detail.

Example 4: Gemini 3.8 Flash with implicit caching

Run the Example 1 workload on Gemini 3.8 Flash. Uncached: 10.2M x $0.75 = $7.65 input plus 0.3M x $3.75 = $1.125 output, so about $8.78 a day. If 900 of the 1,000 requests hit the implicit cache: hits 9M x $0.075 = $0.675, misses 1M x $0.75 = $0.75, fresh input 0.2M x $0.75 = $0.15, output $1.125. Total about $2.70 a day. Implicit hits are not guaranteed, so measure your real rate.

How to structure prompts for a high cache hit rate

1. Freeze the top of the prompt. Put tool definitions, the system prompt and reference documents first, in the same order every time. Store them as constants, not strings you rebuild per request.
2. Push variables to the end. User names, dates, order numbers and the question itself belong in the final message.
3. Clear the minimum. Make sure the stable prefix is longer than the threshold: 512 tokens on Claude Opus 5.5 and Sonnet 5.5, 4,096 on Haiku 4.5 and Gemini 3.x Flash, 1,024 on OpenAI GPT-5.6 and later.
4. Match the lifetime to your traffic. Steady traffic suits Claude’s 5-minute cache. Bursty work with gaps of 10 to 60 minutes suits the 1-hour cache or OpenAI’s 30-minute window.
5. Measure hits. Log the cached token counts the API returns on every response and alert if they drop to zero after a deploy.

Good prompt structure also makes outputs more consistent. Our prompt engineering guide covers how to write a stable system prompt worth caching.

When prompt caching is not worth it

• Short prompts below the minimum length.
• One-off requests where the prefix is never reused within the cache lifetime. On Claude you would pay the 1.25x write and get nothing back.
• Workloads where output dominates the bill. Caching only discounts input, so if your app writes long answers, look at shorter outputs or a cheaper model first. Our guide to picking the cheapest AI model for each task helps here.

Does caching help in the Claude and ChatGPT apps?

Indirectly, yes. Anthropic says content in Claude Projects is cached and counts less against your usage limits when reused, so uploading core documents to a project instead of pasting them into each chat stretches your plan further. Our guide to using Claude Projects walks through the setup, and our explainer on Claude usage limits covers other ways to make your allowance last. For more chat-side tactics, read how to reduce token usage in ChatGPT and Claude.

Frequently asked questions

Next steps: turn on caching this week

Prompt caching is the highest-return cost fix for most AI apps because it needs no change in model or quality. Start by moving every dynamic value to the end of your prompt, enable cache_control on Claude or confirm your prefix clears 1,024 tokens on OpenAI, then log cache hits for a few days. Read the official Claude pricing page, the OpenAI prompt caching guide and Gemini API pricing for the full details. Cache prices and minimums change often, so confirm current rates on each vendor’s site before you set a budget.

The post Prompt Caching Explained: Cut API Costs on Repeated Prompts appeared first on Digital Tatva.

Below: how batch works on each platform, real batch prices, worked cost examples, and the limits and mistakes to avoid.

What is a batch API and why is it 50% cheaper?

A normal API call is synchronous: you send a prompt and wait a few seconds for the reply. A batch API is asynchronous. You bundle many requests into a single job, the provider processes them when it has spare capacity, and you collect the results later.

OpenAI’s docs describe a “50% cost discount compared to synchronous APIs”. Anthropic offers “a 50% discount on both input and output tokens”, and Google lists a “50% cost reduction” for Gemini batch mode. Only the timing changes.

If tokens are new to you, read our explainer on what tokens are in AI first. Every price in this article is per 1 million tokens, and as a rough guide one token is about four characters or three quarters of an English word.

Batch API prices for OpenAI, Claude and Gemini (October 2026)

Here are the standard and batch prices for the models most people use, read on the official pricing pages on 1 October 2026. All figures are USD per 1M tokens.

Sources: the OpenAI API pricing page, Anthropic’s pricing docs and the Gemini API pricing page. For the full standard price lists, see our breakdowns of OpenAI API pricing, Claude API pricing and Gemini API pricing.

Worked example: 10,000 product descriptions at standard vs batch prices

Imagine an online store that needs fresh descriptions for 10,000 products. Each request sends about 800 input tokens (instructions plus product attributes) and gets back about 300 output tokens (roughly 225 words).

Total tokens for the job:

• Input: 10,000 x 800 = 8,000,000 tokens, or 8M.
• Output: 10,000 x 300 = 3,000,000 tokens, or 3M.

Now multiply by the price per 1M tokens. On GPT-6.1 Sol at standard rates: 8 x $2.00 = $16.00 for input, plus 3 x $10.00 = $30.00 for output, so $46.00 in total. In batch: 8 x $1.00 = $8.00, plus 3 x $5.00 = $15.00, so $23.00.

Two lessons jump out. First, batch halves every row, so the absolute saving is biggest on premium models: $115 on GPT-6 Astra versus about $1 on GPT-6 Luna. Second, model choice matters even more than batch. Moving from Opus 5.5 to Haiku 4.5 saves more than batching Opus does. For product copy, a budget model in batch mode is often good enough, which is the kind of trade-off we map out in our guide to the cheapest AI model for each task.

Indian sellers pay these API bills in USD. To see the rupee figure, multiply the dollar total by the exchange rate on your card statement, and remember that banks often add a foreign currency markup.

Stack batch with prompt caching for even bigger savings

Most batch jobs repeat the same long instructions in every request. That repeated block is perfect for prompt caching, which charges a fraction of the normal input price when the start of a prompt matches something the provider has already processed. Our guide to prompt caching covers the mechanics in depth.

OpenAI: cached input in batch is listed directly

OpenAI prints batch cached-input prices on its pricing page. For GPT-6.1 Sol, normal input is $2.00, batch input is $1.00, and batch cached input is $0.05 per 1M tokens.

Say each of your 10,000 requests starts with the same 3,000-token style guide. That is 30M tokens of repeated prefix.

• Standard, no cache: 30 x $2.00 = $60.00.
• Batch, no cache: 30 x $1.00 = $30.00.
• Batch, if nearly every request hits the cache: 30 x $0.05 = $1.50.

Hit rates are never perfect, and on GPT-5.6 and later the first cache write costs 1.25x normal input, but the gap is still huge. The minimum cacheable prefix on GPT-5.6 and later is 1,024 tokens, so very short instructions will not cache.

Anthropic: discounts stack, hit rates vary

Anthropic’s batch docs say “the pricing discounts from prompt caching and Message Batches can stack”. They also note typical batch cache hit rates of 30% to 98%, depending on traffic patterns. Because batch requests run in parallel and in no fixed order, some will miss the cache. Use the 1-hour cache option (written at 2x base input) for long batches, since the default 5-minute cache can expire while the batch is still running.

Gemini: caching works in batch too

Google confirms that context caching is supported for batch requests. Gemini’s implicit caching is on by default for 2.5 and newer models, but the minimum is 4,096 tokens on Gemini 3.5 to 3.8 Flash and 3.1 Pro Preview, so only long shared prompts benefit.

How batch processing works on each platform

The three providers follow the same pattern but with different limits. This table compares what matters when you plan a job.

OpenAI

You upload a JSON Lines file (one request per line, each with a custom ID) and create a batch against an endpoint. Supported endpoints include /v1/responses, /v1/chat/completions, /v1/embeddings, /v1/completions, /v1/moderations, and the image generation and edit endpoints. A big bonus: batch usage does not consume your standard per-model rate limits, and you can create up to 2,000 batches per hour.

Anthropic

You POST to /v1/messages/batches with a list of requests, each holding a custom_id and normal Messages API params. Batches support vision, tool use, system prompts, multi-turn conversations, extended thinking and caching. Streaming and Fast mode are not supported. You only pay for requests that succeed: errored, canceled and expired requests are not billed.

Google Gemini

Small jobs can be sent inline. Larger jobs go in a JSON Lines file of up to 2 GB. Jobs that stay pending or running for more than 48 hours expire, and results stay downloadable for six weeks.

How to run your first batch job

The UI and SDK calls differ by provider, but the workflow is the same everywhere.

1. Pick a job that can wait. Good fits: rewriting a product catalog, tagging support tickets, summarizing call transcripts, translating help articles, scoring leads, or running test prompts against a new model.
2. Test the prompt synchronously first. Run 20 to 50 requests through the normal API and check the output. A batch with a bad prompt just wastes money faster.
3. Build the request file. Write one request per line in JSON Lines format. Give each one a unique custom ID, such as your product SKU, so you can match results back later.
4. Put shared instructions first. Keep the long, identical part of every prompt (instructions, examples, style guide) at the very start and the variable part at the end. This is what makes caching work.
5. Submit and record the batch ID. Upload the file or send the request list, then save the batch ID the API returns.
6. Poll for status. Check every few minutes. Anthropic reports in_progress, canceling and ended. OpenAI and Gemini have similar states.
7. Download and reconcile results. Results may not come back in the order you sent them. Join them to your data by custom ID, then retry any that errored or expired in a new, smaller batch.

When not to use the batch API

Batch is not a free lunch. The discount comes from giving up speed, so it is the wrong choice whenever a person is waiting.

If you need cheaper real-time calls, look at the other levers instead: shorter prompts, smaller models and caching. Our guide on how to reduce token usage in ChatGPT and Claude lists the techniques that work for interactive apps.

Flex processing: the middle option

OpenAI and Google also sell Flex processing, priced the same as batch (half of standard). Flex keeps the normal request style but may be slower at busy times. At the other end, OpenAI’s Fast mode (renamed from Priority processing on 30 July 2026) costs more than standard for quicker responses, so check that nobody on your team has it switched on for background jobs.

Common batch API mistakes that cost money

• Forgetting output tokens. Output is 5x the input price on most of these models. Set a sensible max output length so a runaway response cannot inflate the bill.
• Ignoring reasoning tokens. Reasoning models think before answering, and those hidden tokens are billed as output. For simple tasks, use a lower reasoning effort or a non-reasoning budget model.
• Sending huge contexts. On GPT-6 and GPT-5.6 models, any request over 272K input tokens is billed at 2x input and 1.5x output for the whole request. Gemini 3.1 Pro also costs more above 200K tokens. Our guide to the context window explains how to stay under these thresholds.
• Changing the prompt prefix. Putting a date or customer name at the top of every prompt breaks caching. Move variable details to the end.

Before you commit to a big job, run the numbers with our step-by-step method to estimate AI API costs before you build. If the batch feeds marketing content, our guide to AI for ecommerce shows where bulk generation pays off, and how to measure AI ROI helps you prove the saving to a client or boss.

Frequently asked questions

Our verdict: batch everything that can wait

If a task does not need an answer within seconds, there is little reason to pay full price for it. Batch mode halves your bill on every major provider, keeps the same model quality, and on OpenAI even sits outside your normal rate limits. Combine it with caching and a right-sized model, and a job that looks expensive on paper often costs a few dollars.

Start small: move one recurring background job (nightly summaries, weekly content refreshes or tagging) to batch this month and compare the invoice. If you run an agency, our guide to AI for marketing agencies has more ideas for bulk work worth batching. Prices and limits change often, so confirm current batch rates on each vendor’s pricing page before you run a large job.

The post Batch API Guide: Save 50% on OpenAI, Claude and Gemini Requests appeared first on Digital Tatva.

This guide explains every Claude limit Anthropic has published as of 1 October 2026, the difference between usage limits and length limits, and ten practical ways to make your allowance last, with worked examples.

Claude usage limits by plan

Anthropic describes usage as multiples of the Pro plan rather than fixed message counts. Here is everything it publishes.

For Max, Anthropic’s help center gives a rough estimate of at least 225 to 900 messages per five-hour session depending on tier and usage. Treat that as a guide. Sources: Anthropic’s Pro plan usage article and Max plan usage article, checked 1 October 2026. Full plan details are in our Claude pricing guide.

Usage limits vs length limits

Claude has two kinds of limits, and they need different fixes.

• Usage limits cap how much you can use Claude across all conversations over time. When you hit one, Anthropic says you need to “wait for it to reset, upgrade your plan, or purchase extra usage”.
• Length limits cap how much a single conversation can hold, set by the context window. When you hit one, “start a new conversation or use features like projects”.

The context window on paid plans is 200K tokens by default and 1M tokens on Fable 5.1, Opus 5.5, Opus 5, Sonnet 5.5 and Sonnet 5. When a chat nears the limit and code execution is on, Claude summarizes earlier messages to make room. Our context window explainer covers how this works across ChatGPT, Claude and Gemini.

What uses up your Claude allowance

Anthropic lists these factors: message length, file attachment size, current conversation length, tool use (Research and web search), model choice, effort level, Artifact creation and use, and multi-step tasks. Paid users can see progress bars for the five-hour session and the weekly limit under Settings, then Usage.

Why long chats drain limits fastest

Claude processes the full conversation every time it replies. That makes the cost of a long thread grow much faster than the number of messages. Here is the arithmetic for a chat where each exchange adds about 1,000 tokens:

• Message 1: Claude reads about 1,000 tokens.
• Message 30: Claude reads about 30,000 tokens.
• Total over 30 messages: 1,000 + 2,000 + … + 30,000 = 465,000 tokens.
• The same 30 questions split into six fresh chats of five messages each: 6 x (1,000 + 2,000 + 3,000 + 4,000 + 5,000) = 90,000 tokens.

That is about a fifth of the processing for the same number of questions. If you are new to tokens, our guide on what tokens are in AI explains them in plain English.

10 ways to make Claude limits last longer

1. Start a new chat for each new task. As the example above shows, splitting long threads can cut processing by around 80 percent. Ask Claude for a short summary before you switch, and paste it into the new chat.
2. Put core documents in a Project. Anthropic says project content “is cached and counts less against your limits when reused”. Load your brief, style guide and reference files once. Our guide on how to use Claude Projects shows the setup.
3. Work in focused bursts. Project caches expire after a period of inactivity, after which content counts fully again. Doing related work in one sitting gets more value from the cache.
4. Batch related questions. Combine “write the intro”, “suggest five titles” and “draft the FAQ” into one message. Anthropic recommends exactly this.
5. Use Sonnet 5.5 for routine work. Model choice affects usage. Keep Opus 5.5 for hard reasoning, complex code and final passes.
6. Lower the effort level when you can. Effort level is on Anthropic’s list of usage factors. Simple edits rarely need the deepest thinking.
7. Trim attachments. Upload the chapter you need, not the whole book. Large files count against usage every turn they stay in the conversation.
8. Use memory and chat search instead of repeating context. On paid plans, both let Claude recall earlier work without you pasting it again.
9. Be specific and review before sending. A clear prompt avoids follow-up corrections. Our prompt engineering guide and Claude prompts for writing give you efficient templates.
10. Separate Claude Code sessions from chat-heavy days. Both draw from the same pool, so a long coding session can leave little for chat in the same window.

Usage credits: paying for extra Claude usage

If you keep hitting the wall but do not want a bigger plan, usage credits let you keep going. They are available on Pro, Max 5x and Max 20x, billed at standard API rates, and work in both chat and Claude Code. You turn them on under Settings, then Usage, and can set a monthly spending cap or leave it unlimited, with a daily redemption cap of $2,000.

Here is what extra usage might cost, using Anthropic’s API rates: Opus 5.5 at $4 per 1M input tokens and $20 per 1M output tokens, and Sonnet 5.5 at $2 and $10. Say you send 50 more messages after hitting your limit, each processing 10,000 input tokens and producing 1,000 output tokens:

Real costs depend on how long your chats are, and the long-chat effect above can multiply input tokens quickly. Still, if you only overflow a few times a month, credits are usually cheaper than the $80 jump from Pro to Max 5x. The per-token rates are covered in our Claude API pricing guide.

Should you upgrade from Pro to Max?

Upgrade when you hit the five-hour limit most working days, not once or twice a week. Max 5x at $100 per month gives five times Pro’s per-session allowance, priority during peak traffic and higher output limits. Max 20x at $200 suits people running Claude Code for most of the day. Remember that Max still has a weekly limit across all models.

• Stay on Pro if: you hit limits occasionally, mostly write or research, and can wait for a reset or use credits.
• Choose Max 5x if: you use Opus 5.5 or Claude Code for several hours daily.
• Choose Max 20x if: Claude Code is your main development tool and 5x still runs out.
• Choose Team Premium if: you are on a team and only a few members are heavy users; give them Premium seats and everyone else Standard.

Our Claude Pro vs Max comparison walks through the decision in more detail, and our Claude review covers what you get beyond usage.

Frequently asked questions

The bottom line on Claude usage limits

Claude’s limits feel tight mainly when chats run long, files are large or Opus does work Sonnet could handle. Fix those three habits, keep core documents in Projects and batch your requests, and most Pro users stay within their five-hour sessions. If you still overflow, try usage credits with a spending cap before moving to Max. Anthropic adjusts plans and limits regularly, so check the official Claude pricing and help pages for the current rules.

Related reading: ChatGPT limits by plan and how prompt caching cuts API costs.

The post Claude Usage Limits Explained and How to Make Them Last appeared first on Digital Tatva.

Below is every limit OpenAI has published as of 1 October 2026, what happens when you hit one, and nine practical ways to stay under the cap without upgrading.

ChatGPT limits by plan (October 2026)

This table combines what OpenAI states across its help center articles. Where OpenAI does not publish a number, we say so instead of guessing.

Sources: OpenAI’s GPT-5.6 and GPT-6 Pro help article and the ChatGPT Business models and limits page, both checked on 1 October 2026. For prices and features on each tier, see our full ChatGPT pricing guide.

Five-hour windows: Business and Codex estimates

For Business Standard seats, OpenAI publishes estimated message ranges per 5-hour window. It stresses that “actual usage varies by model and task”, so treat these as ranges, not promises.

Codex, OpenAI’s coding agent, works the same way. OpenAI’s Codex pricing page gives Plus and Business estimates of 5 to 45 messages per window on GPT-6 Astra, 15 to 160 on GPT-6.1 Sol and 350 to 3,000 on GPT-6 Luna, and says Pro currently has no 5-hour limit. ChatGPT and Codex share usage, so an afternoon of coding reduces what you can chat.

The pattern matters more than the exact figures: on Business Standard, the low end of the GPT-5.6 Luna range (250) is 50 times the low end for GPT-6 Astra (5), and the high ends differ by about 44 times (2,000 vs 45). The flagship model uses far more of your allowance per message than the smallest one. Choosing the model deliberately is the single biggest lever you have.

File upload and project limits

Uploads have their own caps, separate from messages. According to OpenAI’s file uploads FAQ:

• 512 MB hard limit per file, with text documents capped at 2M tokens per file.
• Spreadsheets around 50 MB and images 20 MB.
• Up to 80 files every 3 hours; Free users are limited to 3 file uploads per day.
• Files per project: Free 5, Go and Plus 25, Pro, Business, Enterprise and Edu 40.
• Storage cap of 25 GB per user and 100 GB per organization.

If you analyze spreadsheets often, our guide on using ChatGPT for Excel and data analysis shows how to prepare files so one upload does the work of several.

What happens when you hit a ChatGPT limit

ChatGPT tells you when you reach a limit and shows the reset time in the app. What happens next depends on the limit:

• Tool limits on Free: the tool pauses until it resets. For GPTs, OpenAI says access “pauses until the limit resets”.
• GPT-6 Pro on Pro 200: ChatGPT switches automatically to GPT-5.6 Thinking at Medium until the weekly limit resets.
• Other caps: you can switch to another model or wait for the reset.

Two details save frustration. First, “OpenAI Support does not reset ChatGPT or Codex usage limits”, so contacting support will not help. Second, upgrading resets your usage rates immediately: the Free tier FAQ says usage resets when you move to Plus, Pro or Business.

9 ways to avoid hitting ChatGPT limits

1. Match the model to the task. Use GPT-5.6 Luna for rewrites, summaries and quick questions, and save GPT-6 Astra or GPT-6 Pro for hard reasoning. Based on the Business ranges above, one Astra message can use as much allowance as dozens of Luna messages. Our guide to the cheapest AI model for each task has a cheat sheet.
2. Start a new chat for each new task. Every reply processes the whole conversation, so a 60-message thread costs more per turn than a fresh one. Paste a short summary into the new chat instead of dragging the history along.
3. Batch your questions. Ask for five headline options, a meta description and an outline in one message rather than three. One well-structured prompt counts as one message.
4. Write tighter prompts. Clear context, format and constraints up front mean fewer follow-ups and regenerations. Our prompt engineering guide covers the techniques that cut back-and-forth the most.
5. Use projects and custom GPTs for repeat context. Store your brand voice, product facts and instructions once instead of pasting them every time. See how to create a custom GPT.
6. Trim uploads before you send them. Remove appendices, duplicate tabs and images you do not need. A 20-page excerpt is faster and lighter than a 300-page PDF.
7. Avoid busy hours for heavy work. OpenAI says Plus caps apply “especially during high demand”. Run long research jobs early or late in your day if you keep seeing limit messages.
8. Keep coding and chat separate in your head. Because ChatGPT and Codex share one allowance, schedule big Codex sessions when you do not also need heavy chat.
9. Keep a backup assistant. A free Claude, Gemini or Perplexity account handles overflow tasks. Our list of free ChatGPT Plus alternatives ranks the best options.

When the API is cheaper than upgrading

If you hit Plus limits on a few predictable, repetitive jobs (such as classifying leads or rewriting product descriptions), the API can be far cheaper than jumping to a $100 Pro plan. API usage is billed separately from any ChatGPT subscription and has no weekly message caps, only rate limits and per-token costs.

Here is a worked example with GPT-6 Luna at $0.10 per 1M input tokens and $0.50 per 1M output tokens. Say you process 1,000 product descriptions a month, each with a 2,000-token prompt and a 500-token reply:

• Input: 1,000 x 2,000 = 2,000,000 tokens, so 2 x $0.10 = $0.20
• Output: 1,000 x 500 = 500,000 tokens, so 0.5 x $0.50 = $0.25
• Total: about $0.45 per month

The same job on GPT-6.1 Sol ($2.00 input, $10.00 output per 1M tokens) costs 2 x $2.00 + 0.5 x $10.00 = $9.00. Even the flagship GPT-6 Astra ($10.00 and $50.00) comes to 2 x $10 + 0.5 x $50 = $45, still under half the price of Pro 100. Our OpenAI API pricing guide lists every model, and the Batch API guide shows how to halve those numbers again for jobs that can wait up to 24 hours.

Frequently asked questions

The bottom line on ChatGPT limits

Most people never hit a hard wall on Free or Go for everyday chat, and the limits that do bite are on uploads, images and the premium models. On Plus, the smartest move is to pick lighter models for routine work, keep chats short and batch requests before you think about Pro. If a predictable workload keeps hitting the cap, the API is often far cheaper than a bigger plan. OpenAI changes plans and limits frequently, so confirm the current numbers on the official ChatGPT pricing and help pages before you decide.

Related reading: what tokens are in AI and how Claude usage limits compare.

The post ChatGPT Limits by Plan and How to Avoid Hitting Them appeared first on Digital Tatva.

This guide explains how context windows work, lists the official sizes for ChatGPT, Claude, Gemini and other models as of 1 October 2026, shows what long context really costs with worked examples, and gives practical ways to work within the limit.

What is a context window, in plain English?

Think of the context window as the model’s working memory for one conversation. Everything the model can “see” when it writes the next reply must fit inside it. That includes the system instructions, your messages, any documents you upload, the model’s own earlier answers, and the new reply it is about to write.

The window is measured in tokens, the small chunks of text models read. OpenAI’s rule of thumb for English is that “1 token is approximately 4 characters” and “100 tokens are approximately 75 words”. Other languages, including Hindi and other Indian languages, can split into tokens differently, often using more tokens for the same meaning. Our guide to what tokens are in AI explains this in detail.

Context window vs max output

Models have two separate limits. The context window is the total the model can handle. The max output limit is how much it can write in a single reply. GPT-6 Astra, for example, has a 1,050,000-token context window but a 128,000-token max output. Reasoning models also produce hidden “reasoning tokens” before the visible answer, and OpenAI says these count toward output usage and billing.

What happens when you go over

In the API, a request that exceeds the window is rejected or must be trimmed. In chat apps, older parts of the conversation are dropped or summarized. Claude, for example, summarizes earlier messages to make room when a chat nears the limit and code execution is turned on. That keeps the chat going, but fine details from the start of the conversation may be lost.

Context window sizes in 2026: API models

These are the official figures from each vendor’s model documentation, checked in late September and early October 2026.

Word estimates use OpenAI’s three-quarters-of-a-word rule, so 1,050,000 x 0.75 = 787,500. If a printed page holds about 500 words, 750,000 words is roughly 1,500 pages. Sources include the OpenAI API pricing and models docs and Anthropic’s models overview.

Open models you run yourself are usually smaller. Gemma 4 on Ollama, for instance, lists 128K tokens for its edge variants and 256K for the 12B, 26B and 31B versions. See our guide on how to run an LLM locally if privacy matters more than size.

Context windows in ChatGPT, Claude and Gemini apps

The context you get in a chat app is often smaller than the API maximum, and it can depend on your plan.

OpenAI does not publish a per-plan context window for ChatGPT, and none of the official help pages we checked on 1 October 2026 list one. A third-party table estimates around 27K tokens on Free, 54K for instant models and 256K for reasoning models on Plus, and more on Pro, but treat those as unconfirmed. The Pro plan page only promises “maximum memory and context”. If context size is critical, test with your own documents or use the API. Our Claude review covers long-document work in more depth.

What long context really costs (worked examples)

In the API you pay for every input token, every time. That makes context the biggest cost driver for document-heavy apps. Pricing rules also change above certain sizes.

Example 1: one 300,000-token document, 2,000-token answer

OpenAI’s surcharge applies to the full request once input passes 272K tokens on GPT-6 and GPT-5.6 models. So the same document on GPT-6.1 Sol costs about twice as much in one piece as it would below the threshold. Splitting it into two 150,000-token requests, each with a 2,000-token answer, costs 2 x (0.15 x $2 + 0.002 x $10) = 2 x $0.32 = $0.64.

Example 2: asking ten questions about the same document

Resending a 300,000-token document ten times on Claude Sonnet 5.5 costs 10 x 0.3 x $2 = $6.00 in input alone. With prompt caching, you pay once to write the cache (5-minute write at $2.50 per 1M: 0.3 x $2.50 = $0.75), then cache hits at $0.20 per 1M for the other nine (9 x 0.3 x $0.20 = $0.54). Total input: $1.29, about 78 percent less. Our prompt caching guide shows how to set this up, and how to estimate AI API costs helps you model your own workload.

Is a bigger context window always better?

No. A large window is a capability, not a target. Three reasons to send less:

• Cost. As the examples show, input tokens add up fast, and some vendors charge more above a threshold.
• Speed. More input means longer processing before the first word of the answer appears.
• Accuracy. In everyday use, models are more reliable when the relevant passage is easy to find. Details buried in a huge, mostly irrelevant input are easier to miss than the same details in a focused excerpt.

Long context shines when the task truly needs the whole thing at once: comparing clauses across a full contract, tracing a bug across many files, or synthesizing a long research report. For question-and-answer over a big library of documents, retrieval (searching for the relevant chunks first and sending only those) is usually cheaper. Tools like NotebookLM do this for you; see how to use NotebookLM for study and research.

7 ways to work within any context window

1. Send only the relevant part. Cut appendices, boilerplate, duplicate pages and images the model does not need.
2. Start fresh chats for new tasks. Old messages fill the window and are reprocessed every turn.
3. Summarize before you continue. Ask the model for a tight summary of decisions so far, then start a new chat with just that summary.
4. Put stable material first. Instructions and reference documents at the start of the prompt make caching possible in the API, since caches match on an identical prefix.
5. Chunk very large jobs. Process a long book chapter by chapter, then combine the summaries in a final pass.
6. Use projects for reusable files. Claude caches project content so it counts less against your limits when reused.
7. Count tokens before you send. OpenAI offers a web tokenizer and the tiktoken library, and Anthropic’s token counting endpoint is free to use. More tactics are in our guide to reducing token usage.

Frequently asked questions

The bottom line

Context windows have grown to around 1 million tokens across the top API models, which is enough for most real documents and many codebases. The limit you actually feel is usually your app plan, your usage allowance or your budget, not the model. Send focused inputs, cache what you reuse, and choose Claude 4.6 or later when you truly need very long prompts without a surcharge. Vendors update models, context sizes and prices often, so confirm current figures on the official pricing and documentation pages before you build.

Related reading: Claude API pricing and OpenAI API pricing.

The post Context Window Explained: How Much Text Can AI Handle? appeared first on Digital Tatva.

This guide gives you a repeatable AI API cost calculator method, real October 2026 prices for OpenAI, Anthropic and Google models, and three worked examples with every step of the arithmetic shown.

The AI API cost formula

AI APIs bill by the token, a chunk of text roughly four characters long. OpenAI’s rule of thumb is that one token is about three quarters of a word, so 100 tokens is about 75 English words. Other languages, including Hindi and other Indian languages, can split into tokens differently, so always measure real samples. If this is new, start with our explainer on what tokens are in AI.

Prices are quoted per 1 million tokens, with separate rates for input (what you send) and output (what the model writes). Output usually costs about five times more than input. The monthly formula is:

Monthly cost = requests per month x [(input tokens x input price) + (output tokens x output price)] / 1,000,000

That is the whole AI API cost calculator. Everything else in this guide is about feeding it accurate numbers.

Current API prices to plug into your estimate

These standard prices were read on the official pricing pages on 1 October 2026. All are USD per 1M tokens.

Check the live OpenAI pricing page, Anthropic pricing docs and Gemini API pricing before you finalize a budget. For deeper dives, see our guides to OpenAI API pricing, Claude API pricing and Gemini API pricing.

How to estimate AI API costs in 7 steps

1. Define one unit of work. Pick the thing you will be billed for repeatedly: one support conversation, one blog draft, one document summary, one classified email. Estimates fail when the unit is vague.
2. Write a realistic sample prompt. Include the full system prompt, any examples, retrieved documents and the user input. Do not estimate from a one-line test prompt if production will send three pages of instructions.
3. Count the input tokens. Paste the sample into OpenAI’s web Tokenizer or count it with the open-source tiktoken library. For Claude, the Messages API count_tokens endpoint is free to use and returns a figure like {“input_tokens”: 14}. Anthropic notes the count is an estimate and can differ slightly.
4. Measure the output tokens. Run 10 to 20 real requests and read the usage figures in each response. Average them. Output length varies more than input, so use real data rather than a guess.
5. Multiply by monthly volume. Estimate requests per day, multiply by 30, then plug everything into the formula. Model a low, expected and high case.
6. Add the hidden extras. Reasoning tokens, tool calls, retries and surcharges (covered below) can add a lot. List each one explicitly.
7. Apply discounts you will actually use. Caching and batch processing can cut costs sharply, but only include them if your design supports them.

Worked example 1: a website support chatbot

Chatbots are where most estimates go wrong, because every turn resends the earlier conversation. Here are the assumptions:

• System prompt (instructions and FAQs): 1,500 tokens.
• Each user message: 100 tokens. Each bot reply: 250 tokens.
• Average conversation: 6 turns.
• Volume: 3,000 conversations per month (about 100 a day).

Step 1: input tokens per conversation

Turn 1 sends the system prompt plus the first message: 1,500 + 100 = 1,600 tokens. Each later turn also resends the previous exchange of 350 tokens (100 + 250). So turn 2 sends 1,950 tokens, turn 3 sends 2,300, and turn 6 sends 3,350.

Adding all six turns: (6 x 1,600) + 350 x (0 + 1 + 2 + 3 + 4 + 5) = 9,600 + 5,250 = 14,850 input tokens per conversation. The user only typed 600 of those.

Step 2: output tokens per conversation

6 replies x 250 tokens = 1,500 output tokens.

Step 3: monthly totals

Input: 14,850 x 3,000 = 44,550,000 tokens (44.55M). Output: 1,500 x 3,000 = 4,500,000 tokens (4.5M).

Step 4: price it

Step 5: apply prompt caching

The 1,500-token system prompt is sent on every turn: 6 x 1,500 x 3,000 = 27M tokens a month. On Claude Sonnet 5.5, those cost 27 x $2 = $54 at the normal rate, or 27 x $0.20 = $5.40 as cache hits. If traffic is steady enough to keep the cache warm, the monthly bill falls from $134.10 to about $134.10 minus $54 plus $5.40 = $85.50, before small cache-write charges. Our guide to prompt caching explains cache lifetimes and write fees.

Building this bot? Our walkthrough on how to add an AI chatbot to your website covers the setup, and our roundup of AI customer support tools compares ready-made options if you would rather pay per seat.

Worked example 2: generating blog drafts

A content team wants 100 long-form drafts a month. Each request sends a 1,000-token brief and gets back a 2,000-word draft. Using the 0.75 words per token rule, 2,000 words is about 2,000 / 0.75 = 2,667 output tokens.

• Monthly input: 100 x 1,000 = 100,000 tokens (0.1M).
• Monthly output: 100 x 2,667 = 266,700 tokens (about 0.267M).

On Claude Opus 5.5: 0.1 x $4 = $0.40 input, plus 0.267 x $20 = $5.33 output, so about $5.73 a month. On GPT-6 Astra: 0.1 x $10 = $1.00, plus 0.267 x $50 = $13.33, so about $14.33. On GPT-6.1 Sol: 0.1 x $2 = $0.20, plus 0.267 x $10 = $2.67, so about $2.87.

Content generation is cheap per piece, even on premium models. The real cost is editing time. If you plan to write with AI, our guide on how to write a blog post with AI covers the workflow that keeps drafts usable.

Worked example 3: summarizing long documents

A legal or research team summarizes 500 contracts a month. Each contract is about 60,000 tokens and each summary is 800 tokens.

• Input: 500 x 60,000 = 30M tokens. Output: 500 x 800 = 0.4M tokens.
• Claude Sonnet 5.5: 30 x $2 = $60.00, plus 0.4 x $10 = $4.00, so $64.00.
• Gemini 3.8 Flash: 30 x $0.75 = $22.50, plus 0.4 x $3.75 = $1.50, so $24.00.
• Same job in batch mode (50% off): $32.00 on Sonnet 5.5, $12.00 on Gemini 3.8 Flash.

Input dominates this budget, which is typical for summarization. Since nobody needs the summaries within seconds, this is a perfect fit for the techniques in our batch API guide.

Hidden costs most API estimates miss

Reasoning tokens

Reasoning models think before they answer, and OpenAI confirms those internal tokens count toward output usage and billing. You cannot see them in the reply, but they appear in the usage data. Measure them on real samples. For planning, it is sensible to model a high case where output is two or three times the visible answer, then refine once they have data.

Long-context surcharges

On OpenAI’s GPT-6 and GPT-5.6 models, any request with more than 272K input tokens is billed at 2x the input rate and 1.5x the output rate for the full request. Gemini 3.1 Pro Preview jumps from $2 / $12 to $4 / $18 above 200K tokens. Claude 4.6 and later models have no long-context surcharge. Our guide to the context window explains how to keep prompts lean.

Tools and grounding

• OpenAI web search: $10 per 1,000 calls, plus search content tokens at the model’s rate.
• Anthropic web search: $10 per 1,000 searches. Code execution: $0.05 per hour after 50 free hours per day.
• Gemini Grounding with Google Search: 5,000 free requests per month across Gemini 3.x models, then $14 per 1,000.

Regional processing

OpenAI’s data residency adds 10% for models released on or after 5 March 2026. Anthropic’s US-only inference costs 1.1x on all token categories for 4.6 and later models. If your client requires either, multiply the estimate by 1.1.

Retries and failed calls

Timeouts, malformed outputs and retries all burn tokens. Add a buffer of 10% to 20% until real logs show your actual rate. That buffer is an editorial rule of thumb, not a vendor figure, so replace it with measured data as soon as you can.

How to cut the estimate before you build

• Pick the smallest model that passes your tests. In example 1, GPT-6 Luna costs about one twentieth of GPT-6.1 Sol. Our list of the cheapest AI model for each task helps you shortlist.
• Trim conversation history. Summarize older turns or keep only the last few. In example 1, history added 5,250 tokens per conversation.
• Cap output length. Output costs about five times input, so ask for concise answers and set a maximum.
• Cache shared prefixes. Put static instructions first so they hit the cache.
• Batch background work. Anything that can wait gets 50% off.

Our guide on how to reduce token usage in ChatGPT and Claude covers more techniques, and if you want to start for free, Gemini Flash and Flash-Lite models are free of charge on Google’s API free tier, with limits shown in AI Studio.

Set spending guardrails

Google’s Gemini API caps Tier 1 billing accounts at $250 until you have paid $100 and waited three days to reach Tier 2. Whatever provider you use, set budget alerts in the console so a bug cannot run up a surprise bill.

Indian teams are billed in USD for these APIs. Convert your final estimate at the rate on your card statement, and allow for any foreign currency markup your bank adds.

Frequently asked questions

Next steps: build your estimate today

Pick one unit of work, count its tokens on three real samples, and price it on two or three models in a spreadsheet. Then add reasoning, tools and a buffer, and decide which discounts your design supports. Once the product is live, compare the estimate with real usage every month and adjust. Our guide on how to measure AI ROI shows how to turn those numbers into a business case. API prices change frequently, so confirm current rates on each vendor’s pricing page before you commit to a budget.

The post How to Estimate AI API Costs Before You Build appeared first on Digital Tatva.