Codex 429 Too Many Requests: Complete Fix Guide

The error message “Codex: exceeded retry limit, last status: 429 Too Many Requests” ranks among the most frequently‑reported pain points for developers working with AI coding agents. Numerous GitHub issues and community discussion threads document this recurring failure mode. Fundamentally, 429 errors within Codex stem from three distinct root causes: quota exhaustion under the 5‑hour rolling window or weekly cap, sudden quota compression triggered by concurrent spawned‑agent workloads, and short‑lived server‑side rate‑limiting where quota metrics still display adequate remaining capacity. Each scenario demands different handling workflows. This article walks through diagnostic log interpretation, root‑cause identification, and six actionable mitigation strategies. It also covers BYOK mode configuration for custom API endpoints, helping developers avoid hours of trial‑and‑error debugging.

Four Observable Manifestations of Codex 429 Errors

When Codex encounters rate‑limiting events, logs and user interfaces will present four distinct patterns:

1. exceeded retry limit (most frequent)

ERROR: exceeded retry limit, last status: 429 Too Many Requests, request‑id: 9bd33f31fd269bb1‑HNL

This output indicates Codex has executed multiple internal retries with exponential back‑off. When every retry attempt fails, the client abandons the ongoing request entirely.

2. Direct 429 response returned by the API layer

error‑http‑429 Too Many Requests: Some({
    "error": {
        "message": "You’ve exceeded the rate limit, please slow down and try again after 60.616292 seconds.",
        "type": "invalid_request_error",
        "code": "rate_limit_exceeded"
    }
})

The message field embedded inside error payloads carries suggested waiting duration, which serves as high‑value diagnostic evidence.

3. Quota exhaustion indicator

ERROR: exceeded retry limit, last status: 429 Too Many Requests
2 Usage: 5h limit [……] 100% (resets in 4h 32m)

The UI shows the 5‑hour bucket is fully consumed. This points to quota depletion, rather than temporary server‑side throttling.

4. Confusing scenario: sufficient reported quota yet persistent 429 responses

5h limit: [……] 96% left (resets 17:16)
Weekly limit: [……] 95% left (resets 11:33)

This perplexing case matches server‑side short‑term throttling. The usage counter suggests abundant headroom, but requests still receive 429 rejection responses.

Distinguishing the Three Root Causes

Root Cause 1: Depletion of 5‑Hour Window or Weekly Quota (Most Common)

Starting with its April 9, 2026 update, Codex switched its rate‑limiting framework to count inference time instead of raw token volume. Different subscription tiers allocate distinct available inference time for each five‑hour rolling window.

Data source: OpenAI community post “Understanding the New Codex Limit System After the April 9 Update”, published April 10, 2026

Key observation: Business tier delivers roughly 31% of Plus‑tier inference capacity, despite official descriptions stating “60% less”. Its per‑minute consumption rate runs 3.2 times higher than Plus. Beyond the five‑hour rolling bucket, a hard weekly cap also applies. Repeated full consumption of 5‑hour resources can burn through weekly allocations. Developer reports describe cases where account‑wide quota dropped from 67% remaining down to 45% within a single calendar day, driven by heavy spawned‑agent parallel workloads.

Diagnosis method: Execute /status command and inspect percentage values for 5h limit and Weekly limit. Cross‑verify consumption metrics within the official chat.openai.com usage dashboard.

Root Cause 2: Instant Quota Compression From Concurrent Spawned‑Agents

GitHub issue #9748 (January 23, 2026, with 31 comment threads) documents an extreme real‑world case. When six child agents booted simultaneously for parallel code exploration tasks, the entire Pro‑plan five‑hour quota hit 100% consumption immediately.

This behavior deviates from token‑based billing intuition. Each spawned‑agent reserves inference‑time quota upon initialization, not based on actual completed computation work. Launching six agents in parallel effectively occupies six separate slices of inference budget at startup. OpenAI rolled out partial adjustments for spawned‑agent quota accounting in early‑2026 patches. Even with these fixes, massively parallel agent spawning remains a top trigger for rapid quota exhaustion.

Diagnosis method: Review workflow history before 429 errors. Check whether multiple child agents launched in parallel, and confirm whether task logic invoked spawn_agent or equivalent tooling.

Root Cause 3: Short‑Term Server‑Side Throttling (Adequate Displayed Quota)

GitHub issue #9135 (January 13, 2026) describes this pattern. Near the end of a five‑hour window, Codex begins throwing 429 responses, while metrics still report roughly 61% quota remaining. Each retry waits for about 60 seconds, and the condition persists for 15 minutes until the rolling window refreshes.

Multiple community users reproduced identical behavior: quota indicators show 95%‑96% available capacity, yet 429 errors persist. OpenAI engineering responded that underlying backend mechanisms trigger this effect. Isolated instances still appear in production deployments.

Characteristics for this error variant: short duration (typically 10‑30 minutes), fixed per‑request back‑off intervals (60‑90 seconds), unchanged usage metrics, and automatic recovery after quota window reset. This condition originates from platform‑side peak‑hour traffic governance and bears no relation to individual user quota balances.

Six Practical Solutions For Codex 429 Failures

Solution 1: Wait For 5‑Hour Rolling‑Window Reset (For Quota Exhaustion)

This represents the most straightforward mitigation when inference‑time budget is fully consumed. Run /status within Codex CLI. Output fields show exact timestamps for quota reset events.

# Execute inside Codex
/status

If weekly allocation also approaches depletion, you must wait for the corresponding rolling cycle aligned with your account registration timestamp.

Solution 2: Reduce Reasoning Effort to Lower Per‑Request Consumption

Reasoning effort settings directly determine inference‑time consumed for each API round‑trip. Adjust values inside ~/.codex/config.toml.

[model]
reasoning‑effort = "low" # available options: low / medium / high / xhigh

Switching from xhigh down to medium preserves acceptable quality for most everyday coding assignments, while cutting resource consumption by approximately 60‑70%. Alternatively override parameters for individual invocations:

codex --reasoning‑effort low "rewrite this function"

Solution 3: Cap Concurrent Spawned‑Agent Quantity

When workflows need multiple child agents, restrict parallel concurrency to 2‑3 agents maximum, or adopt sequential execution patterns.

# Sequential‑processing example
Split this module. Process one sub‑task at a time. Launch the next agent only after prior subtask completes.

If parallel execution remains mandatory, embed explicit constraints directly within task prompts:

Use no more than 2 concurrent spawned agents for the following assignment.

Solution 4: Passively Await Automatic Recovery For Server‑Side Throttling

When /status confirms ample remaining quota but 429 errors persist, avoid manual aggressive retry loops. Typical recovery takes 10‑30 minutes. Codex already implements built‑in exponential back‑off logic. Manually spamming retry requests will worsen server‑side penalization and extend throttling duration.

Solution 5: BYOK Mode: Bring‑Your‑Own‑Key Custom API Endpoint

Codex supports Bring‑Your‑Own‑Key configuration. This bypasses subscription‑plan quota limits and routes traffic toward alternative API providers. Configure inside ~/.codex/config.toml.

[model]
model = "deepseek‑v4‑pro"
provider = "custom"
[providers.custom]
base_url = "https://your‑provider‑domain/v1"
api_key_env_var = "CUSTOM_API_KEY"

Supply credentials at launch via environment variable:

export CUSTOM_API_KEY="sk‑your‑key‑here"
codex

Teams that require unified access to diverse domestic and international large‑model families can leverage 4sapi, an API gateway delivering consolidated endpoints for DeepSeek, Kimi, GLM, MiniMax and further models. One single API key grants access to multiple model back‑ends, serving as a viable fallback option when Codex subscription‑based rate‑limits block productivity.

Solution 6: Decompose Long‑Running Assignments, Avoid Over‑Length Single Chat Sessions

Codex’s quota accounting accumulates consumed inference time tied to each chat session. A continuous four‑hour conversation burns identical quota as four independent one‑hour conversations. However, independent sessions release consumed budget after each task finishes, whereas long‑lived monolithic sessions hold quota resources persistently.

Recommended operational pattern:

# Check quota status before launching large‑scale jobs
/status
# Split work into multiple phases. Re‑check quota metrics between stages.

Self‑Diagnosis Workflow: Root‑Cause Determination Within 30 Seconds After 429 Occurs

1. Run /status to fetch quota metrics.
2. If 5h‑limit or Weekly‑limit show 100% consumption: wait for window reset (Root Cause 1).
3. If usage metrics remain above 50%: review recent agent‑spawning activity. Limit parallel agent count (Root Cause 2).
4. If quota values remain high without concurrent agents running: expect server‑side throttling. Pause operations for 10‑30 minutes (Root Cause 3).

Frequently Asked Questions

Does Codex automatically retry 429 responses?

Codex implements exponential‑backoff retries internally. It repeats attempts until hitting maximum retry thresholds, then emits exceeded retry limit. Users do not need to manually relaunch jobs for transient failures. Repeated 429 reports indicate exhaustion of allowed retry cycles.

Can Pro‑tier users still encounter 429 errors?

Yes. Even with its generous 4000‑minute five‑hour budget, Pro accounts hit rate limits when running extremely heavy parallel spawned‑agent workloads. Massive parallel agent spawning can rapidly exhaust any tier’s inference‑time allowance.

Why 429 still appears when usage metrics report plenty of quota left?

OpenAI implements two‑tier rate‑limiting: user‑level quota buckets (5‑hour / weekly windows), plus global service‑side QPM/RPM throttling. Global traffic constraints can throttle requests for individual tenants with unused personal quota. This condition usually resolves within 10‑30 minutes without user intervention.

Will switching model versions resolve 429 blocks?

Model changes modify per‑minute consumption coefficients. For example, GPT‑5.3 consumes inference time slower than GPT‑5.4. Switching models may extend available runtime, yet it cannot eliminate hard quota boundaries.

Conclusion

Codex 429 Too Many Requests errors map to three fundamentally different conditions. Quota depletion requires waiting for rolling‑window resets. Bursty spawned‑agent parallelism demands concurrency constraints. Server‑side throttling calls for short passive waiting periods. Practitioners should first run /status for rapid classification before applying fixes. Since the April 2026 update, Codex measures consumption in inference time rather than token volume, which creates counter‑intuitive quota‑burn behavior for agent‑heavy workflows. BYOK custom endpoints via gateway services such as 4sapi offer an alternative escape path when subscription‑based rate‑limits block progress.

Developers building agent‑based coding pipelines should embed quota‑check points between major workflow phases. This practice prevents partial‑job failures triggered by mid‑work quota exhaustion.

Sources & Reference Materials

• GitHub Issue #9748 (concurrent spawned‑agent quota compression)
• GitHub Issue #9135 (429 responses with remaining quota)
• OpenAI community post “Understanding the New Codex Limit System After the April 9 Update”, April 10 2026
• OpenAI Codex official documentation and error‑code reference materials

Learn more：https://4sapi.com