# What a failed LLM call actually costs

> A failed call bills for every token generated before your code gave up. Timeouts, cancelled streams and rejected output all cost. The math, shown.

URL: https://getculpa.com/failed-call-cost
Last reviewed: 2026-08-01

## Answer
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.

## Common mistakes
- Setting a client timeout below the model's realistic completion time. Why it hurts: You pay for almost the whole response and then discard it, which is the most expensive outcome available. Do instead: Set timeouts from a measured completion distribution, and cancel generation server-side rather than just disconnecting.
- Excluding errored calls from your cost model. Why it hurts: The model then understates spend by your failure rate and is most wrong on the days you most need it. Do instead: 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. Why it hurts: A guardrail that reads a finished response has already paid for every token in it. Do instead: Constrain at the request, with schemas and stop conditions, so bad output costs less to prevent than to reject.

## Self-check
- 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)
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.
  Input billed regardless: 6 x $0.005 = $0.030
  Output generated before the disconnect: 1.4 x $0.030 = $0.042
  Abandoned call total = $0.072, for nothing the customer ever saw
  The same call completing: $0.030 + (1.8 x $0.030) = $0.030 + $0.054 = $0.084
  At 3% of 800,000 monthly calls abandoned: 24,000 x $0.072 = $1,728 a month
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.

## Cost figures
Every figure carries its confidence and its source. No figure on this site is provider-reported.
- $0.072 — modelled cost of one abandoned call on GPT-5.5 that delivered nothing [calculated] Source: (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] Source: $0.072 divided by $0.084, from the teardown arithmetic.

## FAQ
Q: Do I pay for an LLM call that timed out?
A: 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.

Q: Does cancelling a stream stop the charge?
A: 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.

Q: How is failed call cost different from retry cost?
A: 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.

## Sources
- OpenAI API pricing: https://developers.openai.com/api/docs/pricing

Run the free Cost Leak Scan: https://app.getculpa.com/scan?source=pseo&slug=failed-call-cost&cluster=problem

Machine-readable index of every guide: https://getculpa.com/api/pages
Human-readable index of every guide: https://getculpa.com/guides
Site overview: https://app.getculpa.com/llms.txt

Privacy: 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.