Guides / failed call cost
What a failed LLM call actually costs
A failed call still bills for every token the model generated before your code gave up. Timeouts, cancelled streams, truncated structured output and guardrail rejections all produce tokens you pay for and never read. Culpa, a local-first LLM cost, margin, and forecast ledger, meters failed calls alongside successful ones, so the cost of failure stops hiding inside the gap between your numbers and the invoice.
Why this happens
Failure feels free because HTTP taught everyone to expect that. A request that errors costs a round trip and nothing more. Model calls invert that: generation is the expensive part and it happens before your code learns anything went wrong. A twenty-second client timeout on a call that needed twenty-six seconds bills for everything produced in those twenty seconds. The customer got nothing, your logs record an error, and the meter ran the whole time.
What this usually looks like
- Your cost model reconciles well on quiet days and reads low whenever error rates rise.
- Client timeouts are set from a latency target with no reference to what generation costs.
- Streaming responses get abandoned when a user navigates away and nobody counts those tokens.
- Guardrail rejections are logged as safety events and never as spend.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Mistakes that cost the most
| Mistake | Why it hurts | Do instead |
|---|---|---|
| Setting a client timeout below the model's realistic completion time. | You pay for almost the whole response and then discard it, which is the most expensive outcome available. | Set timeouts from a measured completion distribution, and cancel generation server-side rather than just disconnecting. |
| Excluding errored calls from your cost model. | The model then understates spend by your failure rate and is most wrong on the days you most need it. | Record token usage on the error path too. A failure with no usage record is invisible spend. |
| Rejecting output after generation rather than constraining it before. | A guardrail that reads a finished response has already paid for every token in it. | Constrain at the request, with schemas and stop conditions, so bad output costs less to prevent than to reject. |
Run this check tonight
- Check whether your error-handling path records token usage. Most don't, and that's the whole blind spot.
- Compare your longest acceptable latency against your measured p95 generation time.
- Count abandoned streams last month and estimate tokens produced before each abandonment.
- Total guardrail rejections and price the responses they threw away.
- Compare calculated spend against the invoice on your worst error day rather than on a normal one.
A twenty-second timeout on a twenty-six second call
Illustrative example
A call on GPT-5.5 at real rates of $0.005 per 1k input and $0.030 output. The prompt is 6,000 tokens and a complete response runs 1,800 tokens. The client disconnects at twenty seconds, by which point the model has produced 1,400 tokens. Volumes are modelled.
Giving up at 78% of the way through saved 14% of the cost and delivered zero of the value. A timeout bounds latency and does almost nothing about spend.
Every number, with its confidence and source
| Figure | What it means | Confidence | Source |
|---|---|---|---|
| $0.072 | modelled cost of one abandoned call on GPT-5.5 that delivered nothing | calculated | (6 x $0.005) + (1.4 x $0.030) per 1k, using real GPT-5.5 rates from the price book, effective 2026-07-02. Token counts and the abandonment point are modelled. |
| 86% | share of a successful call's cost still paid when the call is abandoned near the end | calculated | $0.072 divided by $0.084, from the teardown arithmetic. |
What a generic answer can’t know
A provider bills the tokens it generated and has no idea your client had already hung up. Separating spend that produced a delivered answer from spend that produced nothing needs the outcome of each call recorded next to its token counts. Culpa keeps both on your infrastructure, where your prompts and responses stay, and counts the calls to run your plan.
Questions founders ask next
Do I pay for an LLM call that timed out?
Yes, for everything generated before the call stopped. Input bills in full the moment the request is accepted, and output bills for whatever the model produced, whether or not your client was still listening when it arrived.
Does cancelling a stream stop the charge?
It stops further generation only if the cancellation reaches the provider. Simply abandoning the connection on the client side can leave the server generating, so the saving depends on cancelling properly rather than just walking away.
How is failed call cost different from retry cost?
A retry is a second attempt you chose to make. A failed call is a single attempt that billed and delivered nothing. Retries multiply the cost of failures, which is why teams usually find both problems in the same week.
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.
Why the bill went up
Example dashboardCalls 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
Most expensive users
Next week forecast
Graded against reality. Accuracy shown as results land.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Keep reading
Sources: OpenAI API pricing. Last reviewed 2026-08-01. Plain text version.