Beyond Rate Limits — How OpenAI Rebuilt Access for Codex and Sora

The Problem With Hard Stops

In the past year, both Codex and Sora saw rapid adoption — with usage quickly pushing beyond what OpenAI originally expected. The pattern was consistent: users dive in, find real value, and then run into rate limits. Rate limits help smooth demand and ensure fair access, but when users are getting value, hitting a hard stop can be deeply frustrating. OpenAI needed a way to let users keep going — without sacrificing system performance or user trust.

The old answer — simply raising limits — stopped working because demand grew faster than any static ceiling could accommodate. So OpenAI did something more fundamental: it rethought the entire access model from scratch.

The Decision Waterfall

At the heart of the new system is what OpenAI calls a decision waterfall. Instead of asking "is this request allowed?", the system asks "how much is allowed, and from where?" When counting usage, the system evaluates in sequence:

• Is there remaining capacity in the user's rate-limit tier?
• If not, does the user have a credit balance to draw from?
• Are there promotions, enterprise entitlements, or other access layers that apply?

From the user's perspective, nothing changes — they just keep using Codex or Sora. That's the point: credits feel invisible because they're just another layer in the same decision stack, not a separate system they have to consciously switch into.

Real-Time, Provably Correct

The engineering challenge was significant. For interactive products like Codex and Sora, delayed or incorrect billing isn't just an accounting problem — it's a product failure. Surprise blocks, inconsistent balances, and incorrect charges become immediately visible to engaged users at exactly the moment they care most.

OpenAI evaluated third-party billing platforms but found they didn't meet two critical requirements: decisions must be made synchronously and in real time, and every outcome must be fully transparent and auditable. So the team built their own dedicated real-time access engine that consolidates usage tracking, rate-limit windows, and credit balances into a single evaluation path.

Credit debits are settled asynchronously through a streaming processor using stable idempotency keys — preventing double-charging while keeping latency low. Every transaction is auditable and reconcilable. The system is designed to be provably correct, not just approximately right.

How Credits Work in Practice

When a user hits their rate limit in Codex or Sora, a banner appears offering the option to add credits. Users can also purchase credits proactively from Settings → Usage in both products. Key details:

• Credits are shared across supported products — credits bought for Codex can be used for Sora, and vice versa
• Auto top-up is available for Plus and Pro users — automatically replenishing the balance when it drops below a chosen threshold
• Credits are valid for 12 months and do not roll over after expiry
• Pricing moved to token-based in April 2026, replacing per-message estimates with direct token-to-credit mapping for more predictable costs

The Bigger Signal

Codex reached 3 million weekly users in April 2026 — up from 2 million just weeks earlier — with OpenAI resetting usage limits at each million-user milestone as a way of signaling momentum. That growth rate is precisely why static limits couldn't hold: they were designed for a product at a certain scale, and the product outgrew them almost immediately.

OpenAI frames this infrastructure as a foundation, not a fix. The same access engine can extend to more products over time — Codex and Sora are described as just the beginning. For the AI platform industry broadly, the model is worth watching: traditional SaaS tiers with hard caps break down when users derive genuine, continuous value from resource-intensive features. Pure usage-based billing discourages experimentation. The hybrid approach — included usage first, credits after, upgrade available — may become the default template for how AI products handle high-demand features at scale.

The Philosophy Behind It

"When users are engaged, the system should help them continue, not get in the way." That line from OpenAI's engineering post is deceptively simple — but it represents a real philosophical stance on product design. Limits and billing disappear into the background. The user just keeps working. Building that experience required treating access, usage, and billing not as three separate systems, but as one — with correctness as a first-class product feature, not an afterthought.