ChatGPT usually "isn't working" because the failure sits between your browser and OpenAI's servers, not inside the model itself. The most common causes are expired login sessions, service outages, rate limits, regional network blocks, browser extension conflicts, and corrupted local cache. The model rarely breaks; the path to it does. That distinction matters because each layer produces a different symptom and demands a different fix. A spinning cursor, a 429 error, and a blank reply point to three different problems, even though they all look like "ChatGPT is broken." This explainer walks through the actual mechanisms, the thresholds that trigger each failure, and the actions that resolve them.

What actually happens when you send a prompt

When you type a message, your browser sends an HTTPS request to OpenAI's edge network. That request carries a session token, a device fingerprint, and your prompt payload. The edge layer validates the token, checks rate limits and abuse signals, and routes the request to an inference cluster. If any link in that chain fails, you get a generic error or a silent spin, because the frontend deliberately hides infrastructure detail.

The session token is the weakest link. ChatGPT issues short-lived access tokens paired with longer-lived refresh tokens. When the refresh token expires or gets invalidated (password change, security event, too many devices), the frontend may still render the input box while every request fails authentication. This is why "ChatGPT not working" often means "logged in visually, unauthenticated functionally." The fix is a hard logout and re-login, not a model-side change.

Inference itself is stateless per request but bounded by context. Each model has a token ceiling (for example, 128,000 tokens on current GPT-4-class models), and the conversation carries prior turns forward. When the running context approaches that ceiling, the system truncates or rejects input, producing a failure that looks like the model is "ignoring" you. Plain language: you've filled the model's short-term memory and it can't hold more.

Quantified failure thresholds

Rate limits are the most misdiagnosed cause. OpenAI enforces per-minute and per-day limits that scale with your plan tier, and free and lower tiers hit them first. A 429 status code is the explicit signal; a silent slowdown is the implicit one. Limits reset on rolling windows, not clock boundaries, so waiting "until the hour changes" often does nothing.

Timeouts cluster around network round-trip latency. Requests that stall past roughly 30 to 60 seconds typically surface as errors rather than late replies, because the client aborts before the server responds. On slow mobile connections or VPNs, that threshold is crossed routinely.

Context limits are hard numbers, not soft ones. Every prior message, attachment, and system instruction consumes tokens. A long document upload plus a multi-turn conversation can exhaust the window faster than users expect. When it does, the API returns a length error, and the frontend sometimes swallows it.

Symptom Likely layer Typical trigger First action
Spinning cursor, no reply Edge or network VPN, DNS, local block Disable VPN, test other network
429 error Rate limit Too many requests in window Wait for rolling reset
Blank page or stuck loader Cached frontend Stale service worker Hard refresh, clear site data
"Unauthorized" or silent failures Auth token Expired refresh token Full logout and re-login
Replies cut off mid-sentence Context or streaming Token ceiling, dropped stream Start new chat, retry
Specific feature missing Plan or region Tier gate, rollout region Check plan and region support

Edge cases that mimic an outage

Browser extensions are an underrated cause. Ad blockers, privacy tools, and script blockers can interfere with WebSocket connections and authentication callbacks. The failure looks identical to a server outage but disappears in incognito mode or a clean profile. Testing in incognito is the fastest triage step because it isolates extensions and stale cookies at once.

Corporate and campus networks frequently block or throttle AI endpoints via DNS filtering or TLS inspection. TLS inspection breaks certificate validation, and the client fails silently. If ChatGPT works on cellular data but not on office Wi-Fi, the network is the culprit, not the service.

Regional availability is a real constraint. OpenAI's services are not uniformly available in every country, and access can change with regulatory action. A VPN can sometimes bridge the gap, but it can also trigger abuse detection, producing the opposite problem. There is no reliable workaround beyond checking official availability.

Account-level issues, including billing failures on paid plans and flagged accounts, produce feature loss rather than total lockout. You can log in and see the interface while premium features quietly return errors.

One counterintuitive detail: the model's answers can degrade without any technical failure. After major updates, behavior shifts and some users read that as "ChatGPT is broken." This is a model-change perception, not a service fault.

Misconceptions worth correcting

"Deleting the app fixes it" is usually wrong. The mobile app wraps the same API, so reinstalling clears cache but doesn't change server-side state. If the problem is auth or rate limiting, reinstall changes nothing.

"ChatGPT is down" is often premature. Outage trackers and OpenAI's own status page are the authoritative check. Social posts spike during high-traffic hours even when uptime is normal, because demand makes failures more visible.

"Clearing cookies always helps" is half true. Clearing all cookies logs you out of everything; clearing only the ChatGPT site data targets the actual problem.

"Paid plans never hit limits" is false. Limits are higher, not infinite, and long-context or heavy-image use burns quota faster.

"VPNs always fix access" is backwards for many users. VPN IPs are shared and flagged more often, so a VPN can cause the exact 429 or auth failure it was meant to solve.

Practical actions, in order

Confirm service status on OpenAI's status page before changing anything locally. Open an incognito or private window and retry. Works there means extensions, cookies, or cache. Hard logout, clear only the ChatGPT site data, then log back in. Disable VPN and test on a different network (cellular vs. Wi-Fi). Start a fresh chat to reset context if long conversations are failing. Check billing and plan status if premium features return errors while login works.

Work through them in that sequence. Each step isolates one layer, so you learn which mechanism is actually failing instead of guessing. If incognito works, you've proven the server is fine. If a new chat works, you've proven context was the ceiling. If a different network works, the block lives in your router or provider.

Comparison: what each fix actually changes

Action What it alters What it cannot fix
Incognito test Extensions, cookies, cache Server outages, rate limits
Full logout Session and refresh tokens Network blocks, context limits
VPN toggle IP path and region Account flags, billing issues
New chat Running context window Auth, rate limits
Billing update Plan entitlements Outages, local network
Network switch DNS, ISP routing, firewall Model behavior changes

Timeline of a typical failure and recovery

Elapsed time What happens User-visible effect
0-5 seconds Request sent to edge Cursor spins
5-30 seconds Auth and rate checks No visible change
30-60 seconds Client abort threshold nears Error or timeout
Minutes Outage or limit window active Repeated failures
15-60 minutes Rolling rate window resets Access returns gradually
Hours Incident resolution Status page updates
Post-update Behavior shifts Answers feel "different"

The timeline matters because users often act during the wrong window. Restarting everything during a 60-second client timeout accomplishes nothing, while waiting four minutes on a rolling rate limit accomplishes everything.

Limitations and what this cannot tell you

This explainer describes stable mechanisms: auth token lifecycles, rate-limit windows, context ceilings, network layering. It does not carry live outage data, current plan pricing, or regional availability lists, because those change too fast to state reliably here. Specific limits, token ceilings, and reset windows vary by plan and product generation, so treat the numbers as representative ranges rather than exact contractual values.

It also cannot diagnose your specific account state. Whether your failures stem from billing, a security flag, or a regional restriction requires checking your own account and the official status page. The mechanisms above tell you where to look; they don't replace direct verification.

If the problem persists across networks, incognito mode, and a fresh login, the failure is almost certainly server-side or account-side, and no local step will fix it. That is the point at which official support, not troubleshooting, is the correct path.