# How to track LLM cost on OpenAI

> A streamed OpenAI call carries no token usage unless you ask for it. What that leaves in your ledger, and the one flag that turns it back on.

URL: https://getculpa.com/track-llm-cost-openai
Last reviewed: 2026-08-02

## Answer
A streamed OpenAI response carries token usage only when the request asks for it, so a streaming app that leaves that setting off records calls with no numbers attached. Culpa, a local-first LLM cost, margin, and forecast ledger, counts what arrives and marks a call with no usage as a floor rather than guessing at it, so the gap shows up as a flag instead of as a quiet zero.

## Why this happens
A non-streamed response carries a usage object and everything downstream works. A streamed one carries usage in a final event that the provider sends only when the request opted in. Miss that opt-in and the stream ends with content and no counts, which leaves any ledger with a call it can identify and can't price. The failure is quiet in the sense that nothing errors, and loud in the sense that the calls arrive flagged, so the tell is sitting in your own data waiting for somebody to sort by it.

## What this usually looks like
- A large share of your calls carry no token counts at all rather than low ones.
- Your streamed features are the ones missing numbers and your non-streamed features aren't.
- Ledger totals sit far below the invoice while the call count looks right.
- Nobody has sorted the ledger by the completeness flag, so the pattern has never surfaced.

## Common mistakes
- Assuming a streamed response carries usage the way a normal one does. Why it hurts: It doesn't unless the request opted in, so the counts you need never arrive. Do instead: Turn the usage option on for every streaming call and confirm the counts land.
- Reading a zero-cost call as a cheap call. Why it hurts: A zero with a completeness flag means unpriceable, and it can sit on top of real spend. Do instead: Split your ledger by the flag before reading any total. Flagged rows are floors, not facts.
- Comparing cached and total input without knowing which contains which. Why it hurts: Prompt tokens already include the cached ones, so counting both double-counts the prefix. Do instead: Take input as prompt minus cached, which is what the ledger stores and what you pay full rate on.

## Self-check
- Count calls with no token usage at all, then check which of them streamed.
- Confirm your streaming requests ask for the usage event, and check one response to be sure.
- Sort last month by the completeness flag and total the flagged rows separately.
- Compare the unflagged total against the invoice. The rest is what the flags are hiding.
- Check that your own arithmetic takes input as prompt minus cached rather than adding the two.

## Three million streamed calls with the usage option off (illustrative)
A streaming product making 3 million calls a month on GPT-5.4 at real rates of $0.0025 per 1k input and $0.015 output, each sending 3,000 input tokens and returning 500. Volumes are modelled.
  Per call with usage present: (3 x $0.0025) + (0.5 x $0.015) = $0.0075 + $0.0075 = $0.015
  Real monthly spend: 3,000,000 x $0.015 = $45,000
  With the usage event never requested, every one of those calls records no counts
  The ledger totals $0.00 for them and flags all 3,000,000 as incomplete
  Turning one request option on moves $45,000 from flagged to priced
The ledger was never wrong, it was empty and said so. Three million flagged rows is the loudest signal in the system, and the fix is a single setting on the request.

## Cost figures
Every figure carries its confidence and its source. No figure on this site is provider-reported.
- $45,000 — modelled monthly spend that goes unpriced when streamed calls carry no usage event [calculated] Source: 3,000,000 calls x $0.015, using real GPT-5.4 rates per 1k from the price book, effective 2026-07-02. Call volume and token counts are modelled.
- $0.00 — what the ledger records for a call with no usage, alongside an incomplete flag [calculated] Source: An absent usage field is stored as missing rather than guessed, so the priced total for that call is zero and the completeness flag carries the meaning.

## FAQ
Q: Why do my streamed OpenAI calls have no token counts?
A: Because a streamed response carries usage only in a final event the provider sends when the request opted in. Without that, the stream delivers content and no counts, so any ledger downstream has a call it can name and can't price.

Q: What does Culpa do with a call it can't price?
A: It stores the call at zero cost and marks it incomplete rather than estimating. The reporting layer then reads that flag as an estimate rather than a calculation, so a floor never gets presented as a measurement.

Q: Do cached tokens count twice?
A: No. Prompt tokens already include the cached ones, so the portion billable at the full input rate is prompt minus cached. That's the subtraction the ledger stores, and doing it the other way inflates your input volume by the size of your cached prefix.

## 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=track-llm-cost-openai&cluster=integration

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.