The Real Cost per AI Session in 2026: Will Your $9 Plan Survive the Token Bill?

Two numbers decide whether an AI product is a business: what one session costs you, and what one user pays you. Most teams watch a third number instead, the price per million tokens, which says almost nothing about either. The calculator above turns your own token counts into the two figures that matter, then shows the point where the margin disappears.

Move the sliders. The presets are three shapes of product, not three vendors. It runs in your browser: no signup, no credit card required.

The plan is priced per seat, the bill arrives per session

Providers meter tokens because tokens are what they buy: compute, memory bandwidth, a slot in a GPU queue. Customers do not shop in tokens. They open an app, ask eight questions, close the tab, and judge the price once a month.

The mismatch has a mechanical cause, and it fits in one sentence.

Every message in a conversation resends the whole conversation.

Turn one carries your system prompt and the user question, call it 1,800 tokens. Turn eight carries the system prompt, seven earlier replies and the new question, which is 3,200 tokens or more once a couple of tool results are attached. The model reads all of it again, at full input price, on every single turn. Output is the smaller half of the bill.

Retries are the other half, and they are invisible in a demo. An agent that calls three tools and fails once does not pay for one message. It pays for four, because every retry carries the same prompt and the same tool schemas. In my own models the retry line lands between 10% and 35% of the total, and it is the line nobody budgets for.

What surprised me, reading the two price sheets side by side, is that neither provider prices a session. Both price a token, a cache write and a batch job. The unit your customers buy does not appear on either sheet.

What the 2026 price sheets actually say

Standard list prices, per million tokens, read on 14 November 2026. No negotiated discount, no committed-use rate, no regional premium.

Read the columns in this order. Output price first, because agent loops and long answers pile up there. Cached input second, because it is the only line a small team can move without switching models. On Sonnet 5.5 a cache hit costs $0.10 against $2.00 for fresh input, which is 95% off the cached prefix.

Then the batch column, which halves both sides and does nothing for a chat product, because batch is asynchronous.

The two providers converge on most rows. That matters for the calculator: the arithmetic is portable, so a model swap is a pricing decision rather than a rewrite.

Three session shapes, three very different bills

The formula is boring on purpose. Cost per session is the turns in the session, times the input and output tokens per turn at their own rates, times one plus the retry overhead. Once that number exists, a plan price becomes testable.

There is a 232x spread between the cheapest and the most expensive session in that table, and none of it comes from a negotiation or a discount. It comes from three choices a founder makes in a week: model tier, conversation length, and how many tools the agent can call before it gives up.

The lower panel of Figure 1 is where flat pricing fails. A user who opens the Opus-shaped agent 20 times a month costs $14.36 in tokens. On a $9 plan that is a $5.36 monthly loss, per user, before Stripe takes 2.9% plus 30 cents. Nothing about that customer looks unusual in a dashboard that tracks monthly active users.

Three price steps that move the bill without changing the model

Claude 4.7 and later models and Claude Mythos Preview use a newer tokenizer that contributes to their improved performance on a wide range of tasks. This tokenizer produces approximately 30% more tokens for the same text. The exact increase depends on the content and workload shape.

Anthropic, Claude platform pricing documentation, model pricing notes, read 14 November 2026

That sentence is the reason a migration can look like a saving and arrive as an increase. Same prompt, better model, 30% more tokens, and the per-token price did not move enough to cover it. If your cost model counts tokens from a 2025 corpus, it is measuring a different string than the one you now send.

The Haiku step at 100,000 tokens is the quieter trap. Paste a whole knowledge base into the context of a support bot and the model crosses the line, then bills 5x on both sides. A cheap model with a full corpus in the prompt can cost more than an expensive model with retrieval in front of it. The step is documented, and the invoice does not flag it.

Meter the tokens your app already spends

Every provider already returns usage counts on the response, so measurement costs nothing but twenty lines of code. Meter the tokens your app really spends, then read the distribution instead of the mean, because the mean is the one number your heaviest user cannot move.

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const meter = { sessionId: crypto.randomUUID(), input: 0, output: 0, calls: 0 };
const history: Anthropic.MessageParam[] = [];

export async function sendMessage(text: string) {
  history.push({ role: "user", content: text });
  const res = await client.messages.create({
    model: process.env.MODEL ?? "",   // model id from your provider console
    max_tokens: 1024,
    messages: history,
  });
  // usage is returned on every response: no proxy, no estimate
  meter.input += res.usage.input_tokens;
  meter.output += res.usage.output_tokens;
  meter.calls += 1;
  return { res, meter };
}

export function sessionCost(inRate: number, outRate: number) {
  return (meter.input * inRate + meter.output * outRate) / 1_000_000;
}

import OpenAI from "openai";

const client = new OpenAI();
const meter = { sessionId: crypto.randomUUID(), input: 0, output: 0, calls: 0 };

export async function sendMessage(history: { role: string; content: string }[]) {
  const res = await client.responses.create({
    model: process.env.MODEL ?? "",   // model id from your provider console
    input: history,
  });
  meter.input += res.usage?.input_tokens ?? 0;
  meter.output += res.usage?.output_tokens ?? 0;
  meter.calls += 1;
  return { res, meter };
}

export function sessionCost(inRate: number, outRate: number) {
  return (meter.input * inRate + meter.output * outRate) / 1_000_000;
}

-- one row per call: session_id, input_tokens, output_tokens, created_at
-- rates below are Claude Sonnet 5.5 list prices; swap in your model
with s as (
  select session_id,
         sum(input_tokens * 2.00 + output_tokens * 10.00) / 1e6 as cost_usd
  from llm_calls
  where created_at > now() - interval '30 days'
  group by session_id
)
select count(*) as sessions,
       round(percentile_cont(0.50) within group (order by cost_usd)::numeric, 4) as p50_usd,
       round(percentile_cont(0.90) within group (order by cost_usd)::numeric, 4) as p90_usd,
       round(percentile_cont(0.99) within group (order by cost_usd)::numeric, 4) as p99_usd
from s;

Sample a hundred real sessions. If p90 is three times p50, a flat plan is being decided by the tail, and no amount of prompt tuning fixes a tail you have not priced.

Cost per session against your plan: what to do with the number

Three moves, in order of impact. Cap the sessions a plan includes, because a cap converts an unbounded liability into a known one. Drop one model tier for the routine turns and keep the expensive one for the hard ones, which is usually a 5x swing on input. Then put retrieval in front of long documents instead of pasting them into the prompt.

If the bill is already surprising you and the workload is reasoning-heavy, the reasoning-token billing breakdown covers where thinking tokens are charged as output and what the 272K long-context cliff costs. The streaming 504 teardown covers the function ceiling in front of the model, and today’s Vercel versus Cloudflare TCO comparison prices the hosting half of the same invoice.

The Honest Catch

The margin column is a ceiling, not a forecast. Cache hits lower the real cost, batch lowers it further, a free tier and trial credits lower it for a while. Payment fees, hosting, support and refunds raise it. To be honest, the calculator ignores all of them on purpose, so a healthy 85% in the box is not 85% in your bank account.

It also treats token counts as stable. In practice the first session after a deploy is longer, the session after a support ticket is longer still, and one power user with a 40-turn debugging habit can outspend a dozen quiet subscribers. That is what p90 is for.

And it uses list prices. A committed-use discount, a regional premium or a competitor’s price cut all move the answer. Re-run it when the sheet changes, not when the invoice arrives.

No first-person production testing is claimed here. The session shapes are modelling assumptions printed beside their inputs, and the build script that generated Figure 1 is checked into the repository so the arithmetic can be re-run.

Who should skip this calculator

Skip it if your product is a thin wrapper sold to teams who log in twice a month, because the number will look wonderful and tell you nothing. Skip it if you already bill per token or per credit, since your unit economics are anchored to the same meter as your bill and the mismatch is smaller.

Skip it if the model is not the cost centre, which is true for most consumer apps whose real cost is storage and support.

Use it if you are a solopreneur or a one-person agency selling an agent feature on a flat monthly plan. That is the configuration where a $0.72 session quietly decides whether the plan is a business or a subsidy. Use it before the pricing page goes live, not after the first invoice.

Frequently asked questions

What does one AI session cost in 2026?

Between $0.003 and $0.72 for the three shapes in Table 2, on list prices and printed assumptions. A chat session on Haiku 5.5 lands near a third of a cent, a copilot session on Sonnet 5.5 near 13 cents, and a 14-turn agent session on Opus 5.5 near 72 cents. Your own number depends on turns per session and tokens per turn more than on the model name.

Why is cost per session different from cost per token?

Because a session is many tokens, and each turn resends the earlier ones. Cost per token is a list price. Cost per session is that price multiplied by a growing conversation plus retries, which is the quantity your plan actually has to cover.

How many sessions can a $9 plan afford?

At $0.7182 per agent session, 12.5 a month. At $0.1345 per copilot session, 67. At $0.0031 per chat session, roughly 2,900. The same price point is generous or suicidal depending on which row of Table 2 describes your product.

Does prompt caching change the answer?

Yes, on the repeated prefix only. On Sonnet 5.5 a cache hit costs $0.10 per million tokens against $2.00 for fresh input, a 95% reduction, and a 5-minute cache write pays for itself after a single hit. It does not help a conversation whose prefix changes every turn.

What is the 100,000-token step on Claude Haiku 5.5?

The published price rises from $0.10 to $0.50 per million input tokens and from $0.50 to $2.50 per million output tokens once a prompt passes 100,000 tokens. That is a 5x step, so a large pasted context can make the cheapest model cost more than a mid-tier one with retrieval.

Should I price per session instead of per seat?

Only if users understand sessions. The practical middle ground is a seat price with a published session cap and a top-up, which keeps the invoice predictable for the customer and the liability bounded for you.

Methodology & Disclosure: Every price in this article was read from the Anthropic pricing documentation and the OpenAI API pricing page on 14 November 2026, and the tokenizer sentence is quoted verbatim with its source. Token counts, turns per session and 10-35% retry overhead are modelling assumptions, not measurements of any account, and the calculator states them as defaults you are meant to replace. The figures are generated by scripts/make_ai_session_cost_figure_20261114.py from the same formula the widget runs, so no number in a table was typed by hand.

No first-person production testing is claimed. This article contains no paid placement; any partner link on this publication carries rel="sponsored nofollow". Review rules live in the Editorial Methodology and verified corrections are logged in the Corrections Log.