What Pay-Per-Token AI Pricing Actually Costs as Your App Grows

Pay-per-token pricing feels harmless when the bill is small. But token use doesn't grow at the same pace as your user count. Conversation history stacks up, agentic workflows multiply steps, and tokenizer changes quietly inflate the math behind prices that look stable. This piece walks through how a manageable early bill turns into a cost structure that can break a bootstrapped app before it ever turns a profit.

Start with the basic unit. A token is a chunk of a word, roughly three-quarters of a word on average, so a 1,000-word document runs about 1,330 tokens. Every major provider splits pricing into input tokens (what you send) and output tokens (what the model writes back), quoted per million tokens. The two are not priced the same: output costs roughly 5 times input at Anthropic and 6 times input at OpenAI, because generating new text takes far more computation than reading a prompt.

Most founders assume a long system prompt is where the expense hides. It usually isn't. A verbose, multi-step response does the real damage, because that's where the pricier output tokens pile up, turn after turn.

Most people compare sticker prices across vendors and call it done. Output pricing across vendors runs from about $0.50 per million tokens at budget providers up to $50.00 per million at frontier models, a 100-to-1 range. At low volume, none of this stings. Dozens of requests a day, short contexts, a bill you barely notice. That gap is why founders don't plan for what comes after.

The cost range created by model choice alone, before usage enters the picture

The spread isn't just between vendors. The spread appears within a single provider's own lineup. At OpenAI, input pricing spans from $0.20 (GPT-5.6 Luna) to $30.00 (GPT-5.5 Pro), a 150x range. Anthropic's spread runs closer to 10x, from Claude Haiku 4.5 up to Claude Fable 5.1.

The rate card most indie apps actually live in, priced per million tokens:

• Claude Sonnet 5: $2.00 input / $10.00 output
• Claude Opus 5: $5.00 input / $25.00 output
• GPT-5.6 Terra: $2.00 input / $12.00 output
• GPT-5.6 Luna: $0.20 input / $1.20 output
• Gemini 3.1 Pro: $2.00 input / $12.00 output
• Gemini 2.5 Flash: $0.30 input / $2.50 output
• Grok 4.6: $2.00 input / $6.00 output
• DeepSeek V4 Pro: $0.66 input / $1.98 output
• DeepSeek V4 Flash: $0.22 input / $0.66 output off-peak, $0.44 input / $1.32 output at peak
• Mistral Large 3: $0.50 input / $1.50 output

Picking the "best" model at launch, without running this math first, is the mistake to avoid. Do that and you lock yourself into a cost structure you can't leave once users expect that level of response quality. Walking a user base back down to a cheaper model after they've felt the good one is a fight most founders lose.

Promotional pricing makes the trap worse. GPT-5.6 Sol's current rate of $4.00 input / $20.00 output is a promotional cut guaranteed only through November 21, 2026. DeepSeek doubles its rates for several hours a day during peak demand. Whatever reads as the budget option on day one might not be the budget option on day 90.

Prices have dropped a lot in aggregate, roughly 80% between early 2025 and early 2026. But falling unit prices don't flatten the spread between models. The ladder just moved down a floor. The rungs are still just as far apart, and picking the wrong rung still costs you the same multiple it always did.

Conversation history and token consumption growth relative to user count

Every provider bills the full context window on each call, not just the new message. So every turn in a conversation resends the entire history as input tokens. This repeats constantly for the length of the session.

The accumulation is steep when you model it out against a realistic coding session. Turn 1 sends 500 tokens. Turn 2 sends those same 500 plus 800 more. By turn 10, cumulative input has climbed to roughly 15,000 tokens per call. By turn 20, it's past 40,000 tokens per call, even though each individual message stayed short.

A 20-step agent loop can burn dramatically more than a naive per-step estimate predicts. Not because the model writes long answers. Because the input keeps re-accumulating at every single step, and the provider bills the whole stack each time.

That flips the usual cost pattern on its head. In ordinary chat, output tokens dominate the bill. In agentic or multi-turn workflows, input tokens outnumber output by a wide margin, and input price is what actually drives the number you pay. For a bootstrapped app, session length and task complexity compound the bill in ways a per-user estimate built at launch never captures. Double your users, and token consumption doesn't just double if sessions also get deeper. It can multiply by a much larger factor, and nothing about your user count told you that was coming.

Agentic workflows and token consumption multiplied per task, not just per user

Agentic workflows don't just push more tokens per turn. They push more turns, period. Agentic coding tasks can consume orders of magnitude more tokens than a simple code chat, with context re-sending as the main driver.

Then there's the reliability tax. A ten-step agent that fails even occasionally burns meaningfully more tokens on retries than a system that never fails a step. Robustness and cost sit in direct tension: the more you harden a workflow against failure, the more it costs to run.

Per-token prices have fallen. Enterprise AI bills have not fallen at the same pace, and about 72% of production AI cost sits outside the model invoice entirely, in orchestration, retrieval, retries, and observability. The rate card you see from the vendor captures less than a third of what actually gets spent.

Uber's internal Claude Code adoption shows the shape of this at scale. Usage classified as agentic coding jumped from 32% in February 2026 to 84% by March, with 95% of engineers using AI tools monthly by spring. By April, the annual AI budget was gone. Monthly API cost per engineer averaged $150 to $250, and power users ran between $500 and $2,000 a month.

For a bootstrapped founder, a fraud-detection agent serving 50 users could run into the low thousands per month. As users multiplied toward 500, cost grew far faster than the user count suggested it would, not scaling linearly with the 10x user growth. Somewhere between a few hundred and a thousand concurrent users, the unit economics flipped, and the project got killed. That's agentic token multiplication meeting per-token billing head-on: cost per user doesn't stay flat as an agentic product scales. It climbs.

The same paradox shows up from the top down: price per token fell substantially over the year, while total consumption grew by a factor of several times over. Companies moved to newer models, handed agents harder tasks, found new workflows to automate. Cheaper tokens didn't mean lower bills. They meant more reasons to spend.

EY's customer service cost study puts a number on the workflow complexity premium. A simple linear workflow back in 2023, input, retrieval, response, cost about $0.04 per interaction. The 2026 version, orchestrated with tools, reasoning steps, and iterative loops, costs about $1.20 per interaction. Roughly 30 times more, for what looks like the same job on the surface.

Moving from "app with an AI feature" to "AI-first app" is the same move into this territory. Even modest automation trips the multiplier.

The tokenizer inflation problem that makes sticker prices misleading across model generations

In April 2026, shortly after Anthropic shipped Claude Opus 4.7, a Hacker News thread titled "Opus 4.7 to 4.6 Inflation is ~45%" picked up serious traction. Developers were reporting real, specific increases on their bills, running the exact same prompts through consecutive model versions.

The tokenizer produces the mechanism behind this. Newer Claude models use a tokenizer that produces roughly 30% more tokens for identical text. So a headline price cut per million tokens can get partly or entirely wiped out by a higher token count on the same input you were already sending.

That's the quiet trap here. A founder comparing Claude Opus 5's $5.00 input rate against an older Opus version is comparing unequal quantities. The real comparison needs the actual token count on real prompts, run through the new tokenizer, before it means anything.

Bootstrapped teams are the ones most exposed here, mostly because they rarely have the observability tooling to catch tokenizer inflation as it happens mid-cycle. The bill changes even though nothing in the codebase or the prompts changed. One commenter in that Hacker News thread argued inflation at this scale breaks the unit economics for most indie products outright, pushing builders back toward open models or older, more token-efficient versions just to hold the line.

No single number needs to carry this section. The billing unit itself isn't as stable as the price table makes it look, and that's a planning risk no rate card will ever show you.

GitHub Copilot's pricing shift in June 2026 as a signal for the market's direction

On June 1, 2026, GitHub retired flat-rate "premium requests" for Copilot across most plans (existing annual Pro and Pro+ subscribers kept the legacy model until their plans expired) and replaced it with usage-based AI credits.

When the first invoices under the new system landed, some agentic users got a number they weren't ready for. For the heaviest agentic workflows, the gap between expected and actual cost under the new system was severe.

The specific dollar figures aren't the story. The direction is. A major, well-established AI tool moved from predictable flat pricing to consumption-based billing, and for agentic users, the gap between expected cost and actual cost was massive. That pattern generalizes past Copilot: any subscription that converts to usage-based billing exposes users to the same agentic multiplication effect. The bill scales with how complex your workflow got, not with whichever plan tier you thought you signed up for.

Founders building on top of AI infrastructure should read this as a warning. The industry is moving toward billing that surfaces the true cost of agentic work, and the founders who get blindsided are the ones who skipped modeling that consumption from the start.

What the metering structures of AI app builders mean for a growing product

The same dynamic appears in no-code AI builders and all-in-one platforms, just wearing different clothes. It does, just wearing different clothes. The subscription price on the landing page is rarely the real bill. These platforms meter usage on top of a base subscription: credits, tokens, messages, seats, compute units, workload units, app users, updates, generations, depending on the vendor. Whatever the unit, the number on the invoice scales with usage, not with the sticker price you saw at signup.

Paid tiers cluster in a fairly tight band: entry-level plans typically start around $16 a month, climbing toward $25 to $32 a month for mid-tier plans, with per-user pricing common at the higher end.

Free tiers exist to answer one question: does this build what founders want, and nothing more. They're calibrated for validation, not for running a live product at any real scale. The hidden cost rises fast as usage climbs. Every vague prompt, every regeneration, spends credits or tokens somewhere in the background. A $20-a-month plan can quietly turn into a much larger bill. The monthly fee is a floor, not a ceiling.

Give these tools their due. They get a founder deep into a real product, fast and cheap. Screens exist. Data saves. A demo actually convinces someone. For a prototype or an internal tool, that might be the entire job, done.

The gap opens in the last 30 to 40%, and this is where most teams get burned. Real authentication. Tenant isolation that actually holds under load. Permissions that never leak one user's data into another user's view. Integrations that survive a webhook arriving twice instead of once. None of that lives inside a token-metered build environment, no matter how good the builder is at getting you to a demo.

Low-code and no-code tools have seen sharp adoption growth and are increasingly powering new application development. Rapid growth on a credit-metered builder still triggers the same consumption-multiplication problem at the platform layer that a founder would hit at the raw API layer, even after the tooling got easier. The meter is still running. It just has a friendlier interface.

Production-ready infrastructure when the meter is not the model

The fix is building on infrastructure priced by what a business actually uses to run, not by every token a language model touches along the way. When the bill scales with token count, growth itself becomes the risk, because conversation history, agentic steps, and tokenizer changes all multiply against a product at once, invisibly, before a single line of new code ships.

Flat pricing, or usage-based pricing on the business's own terms, hosting, storage, and compute billed against actual infrastructure load rather than the volume of AI conversation happening on top of it, breaks that link. A deeper conversation, a longer agent loop, or a tokenizer update on the model vendor's end stops automatically showing up as a threat to the product's economics. The AI layer can still get more expensive to run. It just stops deciding whether the business survives its own growth curve.

What happens to the bill when usage triples and nobody touched the code: that's the question founders should answer before picking any stack, not which model ranks best today. Founders who work that question out at the infrastructure layer, rather than the prompt layer, are the ones who scale on their own terms. Everyone else finds out the hard way, the way agentic products repeatedly do as user counts multiply.