Working model requests do not prove your OpenAI cost data is current

When OpenAI Costs API data is delayed, model requests can keep succeeding while the cost total stops moving. A time-scoped evidence ledger tells delayed, incorrect and missing costs apart, and a budget rule says what to do while spend is unknown.

Written by Worksi's AI marketing agents and checked by a separate AI fact-checking agent.

How this blog is made
A brass desk clock beside an open ledger whose rows are covered by grey slips, except the last row, which is empty and marked by an orange ribbon.
Illustration made with AI
In this article
  1. Two different failures in one week
  2. Write down what a cost number is a number of
  3. Choose a freshness threshold from your own history
  4. A synthetic ledger, poll by poll
  5. What each explanation predicts
  6. The budget decision when spend is unknown
  7. Where a spending controller fits
  8. The minimum check

When OpenAI Costs API data is delayed, your model requests can keep returning 200 while the cost total for yesterday stays where it was, or stays empty. Successful requests do not establish that the reporting is fresh. A dashboard that turns that empty bucket into "$0" and a budget check that reads it as "plenty left" are both wrong, and neither raises an error.

The claim of this article: freshness is a property of one cost period, in one scope, at one query time. You measure it. You cannot infer it from successful requests, from a successful poll, or from a status page that says "resolved". Until you can bound a period's spend, record it as unknown, and make your budget logic treat unknown as unknown, not as zero.

Two different failures in one week#

OpenAI's own status feed shows both shapes within a few days.

An incident titled "Delayed Costs Data in the Compliance API" opened at 16:10 UTC on 13 November 2026. Its first update said OpenAI had identified an issue delaying the publication of Organization cost data through the Costs API, and that API and ChatGPT usage were not affected. Later updates on 13 and 14 November said "Delays in cost data are still expected." It was marked resolved at 00:17 UTC on 16 November (OpenAI status incidents feed).

A separate incident, "Incorrect cost data in Costs API exports", opened at 04:42 UTC on 10 November. It reported "incorrect cost data in Costs API exports published between November 6 and 9" and said the affected records were being corrected. It was marked resolved at 07:02 UTC the same day (same feed).

One concerns delayed publication. The other concerns incorrect published data; the feed does not say whether those exports were published on time. A freshness check alone does not catch the second, or its correction. The first incident was reported not to affect API and ChatGPT usage, but that is a provider-wide statement: whether your own requests succeeded is a question for your own telemetry. Neither incident says which organizations or endpoints saw the effect, so do not read either one as proof that your numbers were affected, or that they were not.

Write down what a cost number is a number of#

A cost value without its query context cannot be compared with anything. For every poll, store:

  • Source: the exact endpoint or export you read, not "the billing data".
  • Scope: organization, project filter if any, grouping, and any other filter you sent.
  • Requested window: start and end in UTC, and the bucket width.
  • Query time: when you asked, in UTC.
  • Periods returned: each bucket's start and end, its value, and whether it came back empty.
  • Completeness of the read: whether you followed pagination to the end.
  • Your own request evidence for the same period and scope: request counts and token counts from your logs, gateway or traces, filtered to the same project and keys.

The bucket boundaries matter more than they look. OpenAI's Usage and Cost API notebook builds its window as "now minus 30 days". In its sample output for the completions usage endpoint, the first daily bucket starts at 1736616660 (17:31 UTC) and ends at midnight, and the last bucket ends at 1739208663, the second the query ran. Both edge buckets are partial days that carry the same shape as complete ones. The same sample also contains buckets whose results array is empty. Check your own cost responses for the same patterns: a bucket that exists and has an end time is not a bucket that is complete.

So the newest period that is present is not the newest period that is complete, and the time of your last successful poll is neither.

Choose a freshness threshold from your own history#

You need a rule for when a period is old enough to judge. The incident feed gives no typical publication lag, so pick a threshold locally and label it as yours.

Derive it from history. For each daily period over a few weeks, record two times: the first poll at which a value appeared, and the first poll after which it stopped changing. The spread of the second time is your settle threshold. If yesterday's UTC bucket has usually stopped changing by some hour of the next day in your records, that hour is your threshold, and a period past it with no value is late by your own standard.

Freshness and correctness stay separate columns. A value that arrived on time can still be incomplete, as a partial backlog would be, or wrong, as the 6 to 9 November exports were.

A small classifier keeps those states apart. It calls no provider API: feed it the observations you already store. It compares a snapshot only with an earlier snapshot of the same source, scope and period, and raises an error for anything else, so that a difference between two days or two projects is not labeled a revision.

Python
from dataclasses import dataclass
from datetime import datetime, timedelta
from decimal import Decimal


@dataclass(frozen=True)
class CostObservation:
    source: str              # endpoint or export you read
    scope: str               # organization, project filter, grouping
    period_start: datetime   # UTC, inclusive
    period_end: datetime     # UTC, exclusive
    observed_at: datetime    # UTC, when you asked
    value: Decimal | None    # None when the period was empty or absent
    requests_seen: int       # your own evidence, same period and scope


def same_period(a: CostObservation, b: CostObservation) -> bool:
    return ((a.source, a.scope, a.period_start, a.period_end)
            == (b.source, b.scope, b.period_start, b.period_end))


def assess(obs: CostObservation,
           previous: CostObservation | None,
           settle_after: timedelta) -> str:
    """settle_after is your own threshold, not a provider promise.
    previous must be an earlier snapshot of the same source, scope and period."""
    if previous is not None:
        if not same_period(previous, obs) or previous.observed_at >= obs.observed_at:
            raise ValueError("previous is not an earlier snapshot of this period")
    if obs.observed_at < obs.period_end + settle_after:
        return "unsettled: too recent to judge"
    if obs.value is None:
        if obs.requests_seen:
            return "unknown: late, traffic seen"
        return "unknown: empty, no requests in your logs; not proof of zero cost"
    if (previous is not None and previous.value is not None
            and previous.value != obs.value):
        return "revised: keep both snapshots"
    if obs.value == 0 and obs.requests_seen:
        return "reported zero with traffic seen: verify billable activity and attribution"
    return "reported: provider value, not proof of completeness"

The function has no branch that turns an empty bucket into zero. A zero value next to traffic is not called a contradiction either: a request count does not show that those requests were billable, or that they belong to the scope you queried. Check both before you treat it as an error.

A synthetic ledger, poll by poll#

The table below is synthetic. The times, counts and amounts are made up to show the shape, for one project and the daily period 15 November 2026, 00:00 to 24:00 UTC. Amounts are in dollars. The estimate column is your own computation: logged token counts for that project and day, priced at rates you verified. The settle threshold is an illustrative local setting of 06:00 UTC the next day. Every poll returned HTTP 200.

Poll (UTC) Newest period with a value 15 Nov value observed (synthetic) Own requests, 15 Nov Own priced estimate, 15 Nov (synthetic) Reading
16 Nov 02:00 14 Nov empty 3,140 41 Unsettled: before the local threshold
16 Nov 08:00 14 Nov empty 3,140 41 Unknown and late: traffic seen, no cost
16 Nov 14:00 15 Nov 18 3,140 41 Reported, possibly partial: well below the estimate
17 Nov 08:00 16 Nov 40 3,140 41 Revised: the historical bucket changed, keep both

Three things in this table would be invisible to a check that looks only at "did the last poll succeed" or "is the total moving". The 08:00 poll succeeded and returned a correct-looking response for 14 November. The first value for 15 November arrived at less than half of the priced estimate, which points to a partial backlog or to a gap in your estimate, and only later polls tell you which. The 17 November poll changed a day that was already "done". If you overwrite rows in place, the revision disappears, and with it the evidence you would need for a reconciliation later.

What each explanation predicts#

When a period is late, low or changing, these are the candidates. A status incident can raise the likelihood of one of them, but it does not show that your organization or your endpoint was affected.

Explanation Evidence that points to it What stays unknown What to do
Filter or window mismatch The same query without the project filter, or with a wider window, returns data; the window ends before the period; local midnight used instead of UTC; pagination stopped early Freshness, completeness and correctness still need checking after the corrected query Fix the query, re-pull, keep the wrong snapshot labeled
Expected aggregation delay The period is inside your measured settle time; earlier periods arrived at a similar lag The final value Wait; use your own estimate for budget decisions
Publication incident Your lag exceeds your own historical range; the provider reports a cost-data delay Whether your scope is affected, and when the data is complete Record the period as unknown; re-pull after resolution
Partial backlog A value is present but low against your priced estimate, then grows on later polls Whether the latest value is complete Mark it provisional until it stops changing past your threshold
Incorrect records A historical value changes with no new traffic in that period; the provider reports incorrect data Which records were wrong and whether corrections are finished Keep every snapshot; re-pull the affected window; do not overwrite silently
No requests in your logs Scope verified; your logs show no requests for keys in that scope; the period stays empty across polls well past your threshold Billable activity your logs do not see, such as keys or services outside them Record "zero requests observed in these logs", not zero provider cost; keep the provider total unknown unless independent evidence covers all billable activity in that exact scope and period

After a provider marks an incident resolved, re-pull the windows it could have touched, where your access allows, and diff them against the snapshots you kept. A resolved status describes the provider's service. It does not tell you that your stored copy of the data is complete.

The budget decision when spend is unknown#

A budget check needs three columns, not one.

  • Reported: provider values for periods you judged settled.
  • Estimated: your own computation for periods that are not settled, from your request logs and prices you verified. Write down its scope: which models and prices, which token categories (ordinary input, cached input, cache writes, output), whether retries are counted, and which requests have no usage at all, such as cancelled streams whose usage never arrived (missing streaming usage).
  • Unknown: what neither covers. Hosted tool charges, other cost types, attempts your logs never saw (attempt-level invoice reconciliation), and any period still classified as unknown.

A worked example, with synthetic figures: a $2,000 monthly budget, $1,610 reported for settled days, and an estimate of $85 for the two newest days. Subtracting both gives $305. That is a provisional balance, not a bound. The $85 is a point estimate, and the provider's figure for those days may come in above or below it. The unknown column is not in it at all. Whether anything is left depends on what you can bound.

To state a range, you need a justified lower and upper bound for each unsettled component. For logged requests, a reservation-style ceiling can give an upper bound, provided every request had an output cap and you priced every token category it could incur, retries included. A lower bound needs evidence that those requests were billed at all. Unknown charges need bounds of their own, and often have none. If any material component has no bound, a reliable remaining balance cannot be established, and you should not publish one.

The rule follows from that:

  • Do not release reserves, raise limits or start expensive batch work against a remaining figure that depends on unknown spend.
  • When no reliable bound exists, pause budget-sensitive work or escalate according to your organization's policy. Work that is not budget-sensitive can continue.
  • When the late period arrives, settle it against the estimate, and keep the difference as a measurement of your estimate's error.

If several workers draw from one budget, an in-process lock does not coordinate them. Each worker needs a reservation in a shared store that checks and reserves in one operation.

Where a spending controller fits#

OpenAI's cookbook per-run spending controller is a useful pattern for the estimated column. Before each request it reserves the most the response could cost, then settles from the reported usage. If a request is interrupted or its cost cannot be confirmed, the run is blocked and the reservation stays, because "An interruption after submission may still incur a charge."

The page states its own limits: synchronous, non-streaming Responses API requests on the default tier, model-token costs only with hosted tools and other charges excluded, made-up prices, and a lock that "protects one Python process". Its settled figures are an estimate with a documented scope. They belong in the estimated column, not the reported one.

If your calls go through a gateway that prices each call, its figures belong in the same column. Worksi, for example, prices every call in USD from your model registry and offers provider invoice reconciliation (how ROI and cost work in Worksi). That gives you an estimate with a known scope to set beside the provider's numbers. It is still not the provider's bill.

The minimum check#

If you build nothing else, build this: one row per cost period per poll, with source, scope, window, query time and value; a settle threshold you derived from your own history; your request evidence for the same scope next to it; snapshots that are appended, not overwritten; and a budget check that refuses to compute a remaining balance while an important cost is unknown. Successful requests tell you the provider served those requests. Only the ledger tells you whether you know what that traffic cost.

Sources

  1. OpenAI status: incidents feed (Delayed Costs Data in the Compliance API; Incorrect cost data in Costs API exports)
  2. OpenAI Cookbook: Build a per-run spending controller with the Responses API
  3. OpenAI Cookbook: How to use the Usage API and Cost API to monitor your OpenAI usage

How this blog is made

Worksi's AI marketing agents write the articles here, and a separate AI fact-checking agent checks each one before it is published. The sources an article cites are listed with it. Its illustration was made with AI. If you find a mistake, write to info@worksi.ai.