OpenAI Replaces Hard Rate Limits With Pay-As-You-Go Credits

OpenAI has replaced hard rate limits on Codex and Sora with a hybrid access model that lets users keep working past their caps by spending down a purchased credit balance — with the decision made in real time, inside the same request. The change addresses a pattern the company says emerged repeatedly over the past year: usage of both products grew faster than expected, and engaged users kept hitting walls.

"We've seen a consistent pattern: users dive in, find real value, and then run into rate limits," OpenAI writes in an engineering post titled "Beyond rate limits: scaling access to Codex and Sora."

The problem is structural. Rate limits smooth demand and protect capacity, but they fail the users a platform most wants to keep: the ones actively getting value. Usage-based billing is flexible, but it charges from the first token and discourages early exploration. OpenAI judged neither model sufficient on its own. Raising limits outright would sacrifice fairness controls and exhaust capacity. Moving entirely to asynchronous usage billing would introduce lag, overages, and reconciliation problems — failures that surface exactly when users are most engaged.

The answer is a real-time access engine that treats credits as another layer in a "decision waterfall" rather than a separate system.

Access as a waterfall, not a gate

The core conceptual shift, according to OpenAI, is reframing the access question itself. Instead of asking "is this allowed?", the system asks "how much is allowed, and from where?" Rate limits, free tiers, credits, promotions, and enterprise entitlements become layers in a single decision stack, evaluated in sequence.

This design maps to how users actually experience the products. "From a user's perspective, they don't 'switch systems' — they just keep using Codex and Sora," the company writes. "That's why credits feel invisible: they're just another element in the waterfall."

The system had to satisfy four requirements: enforce rate limits until they're reached, transition to credits within the same request, make that decision in real time, and track credit consumption with rigorous accuracy and auditability.

That last requirement carries weight beyond consumer convenience. OpenAI's credit support originated with enterprise customers, where billing correctness is a contractual and trust matter, not a nice-to-have.

Why third-party metering platforms fell short

OpenAI evaluated third-party usage billing and metering platforms before building in-house. Those platforms are well-suited for invoicing and reporting, the company says, but failed two critical tests.

The first is real-time correctness. When a user hits a limit and has credits available, the system must know immediately. "Best-effort or delayed counting shows up as surprise blocks, inconsistent balances, and incorrect charges," OpenAI writes. "For interactive products like Codex and Sora, those failures become visible and frustrating."

The second is reconcilability. OpenAI wanted to explain every outcome: why a request was allowed or blocked, how much usage it consumed, and which limits or balances were applied. That capability needed to live inside the decision waterfall rather than in a separate billing platform that only saw one slice of the activity. Full control over correctness, timing, and observability pushed the company toward an in-house solution.

A distributed system built for synchronous decisions

The foundation is a distributed usage and balance system designed specifically for synchronous access decisions. It tracks per-user, per-feature usage, maintains rate-limit windows, maintains real-time credit balances, and debits balances idempotently through a streaming asynchronous processor.

Every request passes through a single evaluation path. The path synchronously consumes from rate limits and, if needed, verifies sufficient credits, then returns one definitive outcome while settling any credit debits asynchronously. OpenAI says the unified path ensures consistent behavior across products and eliminates duplicated logic across teams.

Provably correct billing, by design

The most technically consequential part of the design is OpenAI's claim that its billing is provably correct. The company separates three datasets that drive the system in sequence: product usage events (what the user actually did), monetization events (what OpenAI charges for that usage), and balance updates (how much the credit balance was adjusted and why).

"These datasets aren't a casual by-product; they actually drive the system, with each dataset triggering the next," OpenAI writes. Separating what occurred, what was charged, and what was debited lets the company independently audit, replay, and reconcile every layer.

Several mechanisms enforce that guarantee:

• Every event carries a stable idempotency key, so retries, replays, or worker restarts can never double-debit a balance. The same keys enable offline batch reconciliation to verify the system's work.
• Balance updates run asynchronously but near-real-time. OpenAI tolerates a small delay in balance updates to preserve the audit trail. When that delay causes the system to overshoot a user's credit balance, OpenAI automatically refunds the difference. "We choose provable correctness and user trust over strict enforcement," the company writes.
• The credit balance decrease and the balance update record are inserted in a single atomic database transaction. Balance updates are serialized per account, so concurrent requests can never race to spend the same credits. Each balance update record carries both the debit amount and attribution back to the monetization event that triggered it.

The trade-off is explicit: provable correctness comes at the cost of slightly delayed credit balance updates. OpenAI accepts that latency in exchange for being able to demonstrate it is not misbilling users.

Why it matters

The engineering choices here reflect real commercial stakes. Codex competes in the crowded AI coding agent market, where session interruptions during active work directly push developers toward rivals. Sora faces similar dynamics in video generation, where rendering a single project can consume significant quota. A billing architecture that lets heavy users pay to continue — rather than wait for a window to reset — converts peak engagement into revenue instead of churn.

The design also signals where OpenAI's monetization is heading. The company frames the guiding principle as "protecting user momentum": real-time balances prevent unnecessary interruptions, atomic consumption prevents double-charging, and unified access logic ensures predictable behavior. "Limits and credits disappear into the background," OpenAI writes.

OpenAI is explicit that this foundation is not specific to its two current products. "The same foundation can extend to more products over time; Codex and Sora are just the beginning," the company writes — an indication that purchasable, metered credits could become the default access model across OpenAI's consumer and enterprise lineup.