Guides / why did my openai bill go up

Why did my OpenAI bill go up?

Your OpenAI bill went up for one of four reasons: more calls, longer calls, a shift toward a pricier model, or retries you paid for twice. Culpa, a local-first LLM cost, margin, and forecast ledger, prices every call from a versioned price book and names the conversation, feature, and customer behind the increase.

Why this happens

Four variables set your bill, and only four. Call count, tokens per call, the rate of the model that served each call, and the share of calls that produced nothing you kept. A provider dashboard moves all four into one total, so the total tells you the bill changed and nothing about which variable moved. Isolating them is arithmetic, not guesswork, but it needs per-call data the invoice doesn't carry.

What this usually looks like

Call volume looks flat month on month while spend climbs, which points at tokens per call rather than traffic.
The increase starts on a specific day rather than ramping, which usually means a deploy rather than growth.
One feature accounts for most of the delta once somebody finally counts it by hand.
Your calculated spend from token counts sits below the invoice, and the gap is the part nobody has explained.

Free, no card, no account

Run the free Cost Leak Scan

It shows your most expensive conversation before you install anything.

Run the free Cost Leak Scan Start 14-day trial

Mistakes that cost the most

Mistake	Why it hurts	Do instead
Reading the daily total and looking for the day it jumped.	A total tells you when, never what. Two different causes produce an identical-looking step change.	Split the same period four ways: calls, tokens per call, model mix, and retry share. One of the four moved.
Assuming a bigger bill means more users.	Cost per user drifts upward on its own as prompts grow and histories lengthen, with no new users at all.	Divide spend by active users for both months. If that number moved, growth isn't your cause.
Blaming the newest feature because it shipped recently.	Recency isn't evidence, and the real cause is often an older surface whose prompt quietly grew.	Rank features by absolute spend delta, not by ship date, then read the top one.
Fixing the model choice first because the rate card is the visible lever.	If retries or context growth drove the increase, a cheaper model just scales the same waste down slightly.	Find the mechanism first. Change the model only once you know the model was the mechanism.

Run this check tonight

Pull call count for both months. If it moved less than spend did, your problem is per-call cost.
Divide total input tokens by call count for each month. Growth here means prompts or histories got longer.
List spend by model for both months. A shift of even ten percent of traffic to a frontier model moves the total hard.
Count calls that errored or timed out and were retried. Every one of them billed.
Rank features by the change in their spend, not their total. The largest delta is your answer.

The same increase, four possible causes, one arithmetic

Illustrative example

A month that rose from $400 to $600 on GPT-5.4 at real rates, $0.0025 per 1k input and $0.015 per 1k output. Baseline was 40M input and 20M output tokens. Each line below is the single change that would produce the same $200 on its own.

Baseline: (40,000 x $0.0025) + (20,000 x $0.015) = $100 + $300 = $400

Cause A, 50% more calls at the same shape = $400 x 1.5 = $600

Cause B, output up two thirds = $100 + ($300 x 5/3) = $100 + $500 = $600

Cause C, half the traffic moves to GPT-5.5 at $0.005 and $0.030 = ($50 + $150) + ($100 + $300) = $600

Cause D, a 50% retry rate on the same intended work = $400 x 1.5 = $600

Four different failures, one identical bill. Cause A is growth and needs no fix. Cause D is pure waste. The invoice can't tell them apart, and the response to each is completely different.

Every number, with its confidence and source

Figure	What it means	Confidence	Source
$400 to $600	modelled monthly spend before and after, priced at real GPT-5.4 rates	estimated	Baseline (40,000 x $0.0025) + (20,000 x $0.015) using GPT-5.4 rates per 1k tokens from the price book, effective 2026-07-02. Published as a range because the token volumes are modelled.
$0.0025 / $0.015 per 1k	GPT-5.4 input and output rates used throughout the arithmetic	calculated	Culpa price book row for openai/gpt-5.4, effective 2026-07-02, verified against OpenAI API pricing.

What a generic answer can’t know

A provider knows what it billed and nothing about why. It never saw your retry policy, your prompt template, or the deploy that changed either. Separating growth from waste needs per-call data joined to your own features and releases. Culpa reads that on your infrastructure, keeps your prompts and responses there, and counts the calls to run your plan.

Questions founders ask next

How do I tell growth from waste in an OpenAI bill?

Divide spend by active users for both periods. If cost per user held steady the increase is growth, and that's a business outcome rather than a bug. If cost per user rose, something in your system got more expensive per unit of work and that's worth chasing.

Can I work out the cause from the OpenAI dashboard alone?

You can see the total and the model split, which rules some things in and out. You can't see which feature, conversation or customer produced the spend, because none of those concepts exist on the provider's side of the wire.

My call count didn't change but the bill did. What now?

Look at tokens per call first. The usual causes are a longer system prompt, a growing conversation history resent on every turn, or tool definitions added to the payload. All three raise input tokens without touching call volume.

On your infrastructure

Culpa runs on your infrastructure. Your prompts and responses never leave it. Culpa counts calls to run your plan, and it fails open, so if it ever breaks your app keeps running.

How Culpa works

Find the culprit. Not just the total.

Your dashboard shows what you spent. It stops short of who spent it. Culpa shows the conversation, the user and the feature behind it.

Your prompts stay local.

Culpa runs on your own infrastructure. What you send to a model reaches us at no point.

Every dollar has a name.

Follow any charge to the conversation, the user, the feature and the customer behind it.

See the bill before it lands.

Cost your next feature before you ship it. You get the likely bill and the worst case, at best, median, p90 and p99.

Three steps to your first answer.

Change one base URL.

Or drop in the Python or TypeScript library.

Find your most expensive conversation.

In the first session, not the first week.

Cost your next feature before you ship it.

Base URLhttp://localhost:4545/v1Your traffic keeps flowing if Culpa ever stops.

Why the bill went up

Example dashboard

Calls traced

418,209

across 3 projects

Spend this week

$378.41

+ $182 vs last week

Failed calls

312

74% retried, and you paid for all of them

+ $182 this week traced to one culprit

Spend over 14 days

user_384report_generatorconv_91fprompt_v1894,220 tokens3 retries$6.81

Most expensive users

user_384$38.42

user_119$21.07

user_562$14.90

user_204$8.30

user_871$5.10

Next week forecast

Best$180

Median$240

p90$310

p99$395

Graded against reality. Accuracy shown as results land.

Run the free Cost Leak Scan Start 14-day trial

Keep reading

Sources: OpenAI API pricing. Last reviewed 2026-08-01. Plain text version.