ChatGPT is usually not working today because of a failure somewhere in OpenAI's serving stack, not on your device. The most common causes are a platform-wide outage, an authentication or session problem, a regional network or DNS fault, a client-side cache issue, or a rate limit tied to your account tier. Most incidents resolve within minutes to a few hours once the responsible layer is fixed.
How a Single Prompt Reaches a Model
Every message you send crosses at least five independent layers, and any one of them can fail. Your browser or app first resolves a hostname through DNS, then opens an encrypted connection to an edge or content-delivery node. That edge forwards the request to an API gateway, which validates your session token and checks entitlements. The gateway hands off to an inference scheduler that places your request in a queue for a model server with available GPU capacity. Only then does token generation begin, and the response streams back along the same path.
This chain explains why a "ChatGPT is down" report is often imprecise. A DNS failure looks identical to a dead backend from the user's seat, because both produce a spinner or a connection error. An expired session token can return an authentication error while the model itself is perfectly healthy. A saturated GPU pool produces timeouts and 5xx responses even though DNS, TLS, and authentication all succeeded. Diagnosing which layer broke is the difference between waiting five minutes and wasting an hour reinstalling an app.
The dependency graph is also wider than most people assume. Login flows can rely on third-party identity providers. File uploads, browsing, image generation, and voice features each call separate backend services. That is why a partial outage is common: the core chat may work while uploads fail, or text may stream while voice mode refuses to connect. A single failing microservice can degrade one feature without touching the rest.
What the Error Codes Actually Mean
The status code or message you see is a fingerprint of the failing layer, and reading it correctly narrows the cause fast. A 5xx server error from the platform indicates a backend fault on OpenAI's side. A 401 or 403 signals an authentication or entitlement problem, usually your session. A 429 means you hit a rate limit or the service is shedding load under pressure. A timeout with no response points to network path or queue starvation.
Concrete thresholds matter here. Rate limits are applied per account tier and per model, and they reset on rolling windows measured in minutes rather than at a fixed clock time. Hitting a limit on a high-demand model can persist even when a lighter model responds normally. That asymmetry confuses users who assume one outage covers all models.
Red flag: a persistent 401 after a fresh login usually indicates a session or token problem, not a service outage. Red flag: errors that appear only on one network but vanish on cellular point to DNS or local network filtering. Red flag: failures isolated to a single browser profile suggest cache or extension interference. Red flag: a status page showing all-green while you consistently fail means the problem is likely local. Red flag: sudden 429 responses across models suggests account-level throttling, not a platform event.
Plain language: the code tells you whose problem it is, so read it before you troubleshoot.
Outage Duration and Blast Radius
Platform incidents follow a recognizable time course, and knowing the stages helps you decide when to wait versus act. Detection and acknowledgement typically come first, followed by mitigation, then recovery, then a post-incident review published later. Most partial degradations clear within tens of minutes. Larger incidents that touch core routing or database layers can run for several hours, and full recovery of every feature sometimes lags the initial "resolved" notice.
| Phase | Typical signal | What you should do |
|---|---|---|
| Detection | Status page goes yellow | Check status, stop changing settings |
| Acknowledgement | Incident posted with scope | Identify which features are affected |
| Mitigation | Error rate begins dropping | Retry every 10-15 minutes |
| Recovery | Core chat restored | Test one feature at a time |
| Residual | Minor features still degraded | Avoid non-core features briefly |
| Post-incident | Review published later | Read root cause if curious |
The counterintuitive detail is that recovery is rarely instant and rarely uniform. Engineers often restore service by routing traffic away from a failing component, which fixes most users while leaving a minority on degraded paths. If your neighbor's ChatGPT works and yours does not during an active incident, that is expected behavior, not evidence that you are doing something wrong.
Partial Failures People Misread as Full Outages
Most "ChatGPT is broken" experiences are partial, and misreading them as total outages leads to unnecessary fixes. One common case is model-specific failure: a newer or heavier model may be capacity-constrained while an older model answers instantly. Another is feature-specific failure, where text chat works but file analysis, web browsing, or image generation time out because those call separate services.
A third case is account-specific. Billing states, plan changes, and workspace permissions can silently revoke access to certain models. If your plan lapsed or a team administrator changed your role, the symptom looks like an outage but is actually an entitlement issue. Session expiry produces the same illusion: the interface loads, but every send fails authentication until you sign in again.
Region and network add another layer. Corporate proxies, VPNs, and aggressive firewall rules can block specific endpoints the app depends on. DNS resolvers that cache a stale record can send you to a dead node long after the platform fixed routing. A quick test is to switch networks entirely, for example from Wi-Fi to cellular, and retry. If the second path works, the fault is in the first path, not the platform.
Why "Just Wait" Is Sometimes Wrong
The default advice to wait out an outage is correct for genuine platform incidents but wrong for several local faults that never self-heal. A corrupted local cache, an expired credential, or a misconfigured proxy will persist indefinitely until you intervene. Distinguishing self-healing from persistent faults is the practical skill that saves time.
Timeline of a typical incident and your matching response:
| Elapsed time | Likely state | Recommended action |
|---|---|---|
| 0-5 minutes | Initial errors, no status update | Refresh once, check status page |
| 5-15 minutes | Incident acknowledged | Wait, retry every 10 minutes |
| 15-60 minutes | Mitigation underway | Try alternate model or feature |
| 1-3 hours | Recovery in progress | Test core chat, avoid extras |
| 3+ hours, no status | Possibly local fault | Run local troubleshooting steps |
| Persistent days | Almost certainly local | Clear cache, re-authenticate, contact support |
The professional caveat is that status pages reflect what the provider can see, not necessarily what you experience. Edge cases, regional routing problems, and third-party dependency failures can affect users before they register internally as an incident. Absence of a status update is weak evidence that nothing is wrong.
A Diagnostic Sequence That Actually Isolates the Fault
Work from the outside in, and stop as soon as a step changes the symptom. Start by checking the provider's status page and any official channels, because a confirmed incident ends most troubleshooting. If nothing is posted, refresh the page once and retry a single message. Then open a private or incognito window to bypass cache and most extensions.
Sign out and back in to refresh your session token, and confirm your plan or workspace access is intact. Switch networks, for example from Wi-Fi to cellular, to test DNS and routing. Try a different model or a lighter feature to see whether the failure is model-specific or feature-specific. If a second device on a different network also fails, the problem is almost certainly platform-side, and waiting is rational.
Clear the browser cache and disable extensions, then reload. Re-authenticate fully rather than relying on a saved session. Test on a second device and a second network before concluding anything. Compare a core model against a heavier one to isolate capacity issues. Record the exact error text and timestamp for support if the fault persists.
Threshold for escalation: if failures persist beyond roughly three hours with no status update, and a second device on a different network fails identically, treat it as either a silent platform issue or an account-level problem and contact support with your error details. If only one device fails past that window, the fault is local and warrants deeper client troubleshooting.
Comparison of Alternatives During an Outage
When the primary service is degraded, substitutes differ in cost, latency, and capability, and choosing well depends on what you need.
| Option | Strength | Trade-off | Best for |
|---|---|---|---|
| Wait for recovery | No switching cost | Unknown duration | Short incidents |
| Another hosted model | Immediate availability | Different behavior and limits | Quick text tasks |
| Local model on your hardware | Works offline, private | Needs capable hardware | Sensitive or offline work |
| API access directly | Often more stable than the app | Requires setup and keys | Technical users |
| Mobile app vs. browser | Separate client stack | May lag or lead the web app | Testing whether it is client-specific |
The practical point is that alternatives are not drop-in equivalents. Output style, context limits, and feature sets differ, so treat a substitute as a temporary bridge rather than a replacement. For anything sensitive, prefer a path that keeps your data under your control.
Limits of What You Can Know From Outside
From the user's seat you can observe symptoms but not root cause, and no amount of local troubleshooting reveals what failed inside a provider's infrastructure. Public post-mortems, when published, arrive after the fact and are often summarized rather than exhaustive. Treat any confident claim about the specific internal cause of a given incident as unverified unless the provider states it.
You also cannot reliably predict duration from early symptoms. A cascade that looks minor can deepen, and a dramatic-looking failure can clear in minutes. The honest position is that during an active incident, the best you can do is isolate whether the fault is yours, switch paths if you need to keep working, and retry on a sensible interval. This article describes general mechanisms for educational purposes and cannot diagnose your specific account, device, or network; for account, billing, or access problems, contact the provider's official support channel directly.