Why Is ChatGPT So Slow Today?

TL;DR: ChatGPT slows down for seven separate reasons: a long thread resending its whole history each turn; reasoning effort spending invisible tokens before the answer starts; your model and plan tier; a live OpenAI incident; a stalled websocket; browser and extension load; and your network route or region. Check status.openai.com, then open a new chat.

Why is ChatGPT so slow today?

Because "slow" is not one problem. It is at least seven, and they have almost nothing in common except the feeling.

A stalled websocket and a 40-second reasoning pass produce the same experience: you sit there watching nothing happen. But one is a transport failure on your network and the other is the model working exactly as designed. Clearing your cache fixes neither. Upgrading your plan fixes neither.

So the useful question is not "why is ChatGPT slow" but "which of these seven is mine".

Work down that column and you will land on your cause in about five minutes. The rest of this post explains each one, what OpenAI actually documents about it, and what to do.

Is ChatGPT down right now, or is it just me?

Check status.openai.com first. It is OpenAI's own status page and it breaks the service into components rather than giving you a single up-or-down light.

At the time of writing, the board separates Responses, Images, Login, Audio, Files, Search, Sora, Deep Research, Agent, Realtime, Voice mode, Batch, Embeddings, Moderations, ChatGPT Atlas and Codex in ChatGPT Desktop, among others. That granularity matters. Voice can be degraded while text is fine. Login can be broken while active sessions keep working.

OpenAI's help centre points you at the same page in three separate troubleshooting articles, including the one specifically about slow responses. If you want the machine-readable version instead of the dashboard:

# One-line check: is OpenAI reporting an incident right now?
curl -s https://status.openai.com/api/v2/status.json

# Per-component detail, including any open incidents
curl -s https://status.openai.com/api/v2/summary.json

Why does a long ChatGPT conversation get slower every turn?

Because the model does not remember your chat. It re-reads it.

OpenAI's API documentation is blunt about the mechanism: "each text generation request is independent and stateless", and multi-turn conversations are implemented by sending the earlier messages along with the new one. The chat interface hides that from you, but the shape is the same. Turn 200 is not one message. It is 200 messages plus your new one, every time.

That has two costs, and they stack:

1. The model reads more before it writes anything. More input tokens to process means a longer wait before the first visible word.
2. Your browser renders more. A thread with hundreds of turns, code blocks and images is a heavy DOM. Scrolling gets sticky, typing lags, and the tab eats memory.

OpenAI's own troubleshooting guide for slow and unresponsive ChatGPT lists "start a new chat if the conversation is long or has many turns" as a first-line fix, right alongside checking the status page. That is unusually direct for a vendor help article, and it tells you where they think the problem usually is.

They have also been chipping at the rendering half. The ChatGPT release notes for August 21, 2026 describe "faster long conversations on the web", with ChatGPT loading "messages in smaller sections instead of retrieving the entire conversation at once". That helps opening a long chat. It does not change what the model has to read on each turn.

If a long thread is your problem, the fix is not to trim it. It is to leave. Carry the state forward deliberately:

Summarise this conversation into a handoff brief I can paste into a new chat.

Include:
1. The goal, in one sentence.
2. Decisions already made, and the reasoning behind each.
3. Constraints and things I have explicitly ruled out.
4. The current state of the work (draft, code, plan) in full.
5. The exact next step.

Do not include chit-chat, retries, or anything we abandoned.
Output as a single markdown block I can copy.

Paste that brief into a fresh chat and you get the same working context with a fraction of the context window spent. If you want the longer version of why chats lose the plot as they grow, that is a separate problem with the same root cause: why ChatGPT forgets what you told it.

Why does ChatGPT pause for 30 seconds before the first word appears?

Because it is generating tokens you cannot see.

OpenAI's API documentation on reasoning models describes it precisely. Reasoning models "use internal reasoning tokens before producing a response", and "while reasoning tokens are not visible via the API, they still occupy space in the model's context window and are billed as output tokens". On volume, the same page says the models "may generate anywhere from a few hundred to tens of thousands of reasoning tokens" depending on the problem.

Those figures come from the API documentation, describing the model layer. They are not a stopwatch reading for the consumer app, and nobody publishes one of those. But the mechanism is the same one running underneath ChatGPT: work happens, output tokens accumulate, and none of it is on your screen yet.

In the ChatGPT interface this is exposed as a reasoning control. Per OpenAI's help centre article on GPT-5.6 in ChatGPT, eligible paid plans get a slider with Instant, Medium, High, Extra High and Pro, powered by GPT-5.6 Sol, with Sol Pro behind the Pro setting. Free and Go users get GPT-5.6 Luna, and a Think option that also runs on Luna.

Here is the part that catches people out, quoted from that same article:

On eligible paid plans, ChatGPT can automatically use more reasoning for complex requests while Instant remains selected. To turn automatic reasoning on or off, go to Settings > General and adjust Higher intelligence.

There is a second-order effect too. OpenAI notes that if you hit a reasoning limit, "ChatGPT may continue with another available reasoning model". So a session can quietly change its speed and its character partway through, without an error.

Does my plan or model tier make ChatGPT slower?

Yes, but not in the way most people assume. The plan does not throttle your text chat. It decides which model answers and how much reasoning you can buy.

Sources for that table, since they are three different pages: model and reasoning availability comes from the help centre article on GPT-5.6 in ChatGPT, the Free, Go, Plus and Pro speed language comes from the ChatGPT pricing page, and the Enterprise line comes from the ChatGPT Work and Codex pricing documentation. All checked August 26, 2026.

Read the table carefully, because it cuts against the obvious conclusion. OpenAI describes Luna as "the fastest and lowest-cost model in the GPT-5.6 family". The free tier's default model is the fast one. Free and Go users also get "unlimited everyday text chats, subject to abuse-prevention safeguards", per the help centre.

Where the plan genuinely buys speed is narrower than the upgrade prompts suggest: faster image generation on Pro, priority request processing on Enterprise, and higher allowances everywhere so you fall back to a different model less often. Plus is $20 a month and Pro starts at $100 a month, with the $200 tier giving 20x Plus usage rather than 20x Plus speed. Those are OpenAI's published figures, checked August 26, 2026.

If you are on a paid plan and things feel slow, the model picker is a better lever than the billing page.

Why does ChatGPT freeze on "Thinking…" and then show the whole answer at once?

That is a transport problem, not a model problem, and it has a specific fingerprint: the answer is complete when you reload the page. If the text was there all along, the model finished. The stream just never reached you.

ChatGPT uses secure websockets alongside ordinary HTTPS. OpenAI's network recommendations article names the destinations directly:

And it spells out what goes wrong: "If your organization blocks WebSocket traffic by default, some features may stall, disconnect, or fail to stream updates correctly." The article asks IT teams to allow websocket traffic over TCP port 443 and to permit the standard "Upgrade: websocket" handshake.

Three failure modes hide in that paragraph, and they behave differently:

• The handshake is blocked outright. You get one of the documented errors, such as "An error occurred while connecting to the websocket" or "A network error occurred".
• TLS inspection rewrites or prematurely closes the connection. OpenAI explicitly asks networks running SSL decryption or proxy enforcement to confirm they do not do this.
• The connection opens, then dies quietly. OpenAI's guidance: "If sessions connect but later stall or disconnect, check idle timeout and maximum frame or message-size policies for WebSocket traffic." A long reasoning pass can outlast a short proxy idle timeout, which is exactly why the slowest answers are the ones that freeze.

Could it be my browser, my extensions, or my machine?

Often, and it is the cheapest thing to rule out.

OpenAI's slow-response article puts cache and cookies at number one: if performance was normal before and suddenly is not, stale cache is the most common cause. The follow-on steps are a hard refresh with Cmd or Ctrl plus Shift plus R, an incognito window with extensions disabled, a different browser, and closing unnecessary tabs and programs to free system resources.

The extension check deserves its own moment, because it separates three variables at once. Incognito disables most extensions by default, so a clean incognito session tells you that your account, your network and OpenAI are all fine and the problem lives in your browser profile.

Script blockers, ad blockers and privacy tools are named repeatedly across OpenAI's troubleshooting articles as the usual suspects. So are VPNs, proxies and secure DNS services like Web Protect.

Does my region or network route change ChatGPT's speed?

Partly, and this is where most articles on this topic start inventing numbers.

OpenAI does not publish consumer response times by country. I looked. If you find a blog post with a tidy per-country millisecond table, ask where the measurements came from, because it is not from OpenAI. Treat it as someone's afternoon, not as data.

What is documented affects speed in three concrete ways:

1. Bandwidth. OpenAI's help article states plainly that "using mobile data may result in lower bandwidth, which can cause slower ChatGPT response times". Obvious, but it is the thing people forget when they are on a train.
2. Route. VPNs and proxies change the path your traffic takes, and OpenAI's troubleshooting steps ask you to disable them when diagnosing slowness or errors. A VPN endpoint on another continent is a real latency tax you chose.
3. Inference residency, for managed workspaces only. Enterprise and Edu customers can pin GPU execution to a region. OpenAI's data residency article lists Europe, the United States and the United Arab Emirates as supported inference regions, and notes that UAE inference residency currently supports only GPT-5.2 in ChatGPT. If your workspace is configured that way, you may be talking to a different model than a colleague in another office.

For everyone else, "region" mostly resolves to "network path", and the phone-hotspot test above measures it better than any speculation.

How do I work out which cause is mine in five minutes?

Run these in order. Each step is chosen to eliminate a whole category, so stop as soon as one of them changes the behaviour.

CHATGPT SLOWNESS: 5-MINUTE DIAGNOSTIC

1. status.openai.com
   Red or degraded?  -> Declared incident. Nothing to fix. Wait.
   Green?            -> Continue.

2. Open a NEW chat. Paste the same prompt.
   Fast now?         -> Conversation length. Migrate with a handoff brief.
   Still slow?       -> Continue.

3. Set the model picker to Instant. Resend.
   Fast now?         -> Reasoning effort. Check Settings > General >
                        Higher intelligence for automatic reasoning.
   Still slow?       -> Continue.

4. Reload the page mid-freeze. Is the answer already complete?
   Yes               -> Websocket or proxy. Test on phone hotspot.
   No                -> Continue.

5. Incognito window, all extensions disabled. Resend.
   Fast now?         -> Browser profile, extension, or stale cache.
   Still slow?       -> Continue.

6. Phone hotspot, off the office network. Resend.
   Fast now?         -> Corporate network, VPN, proxy, or secure DNS.
   Still slow?       -> Different device. Then contact OpenAI Support
                        with a HAR file, console errors, timestamps,
                        the model used, and the conversation URL.

That last line is not padding. OpenAI's support articles ask for exactly that bundle, and a ticket without it goes nowhere.

What actually makes ChatGPT faster, rather than just less slow?

Four of the seven causes are outside your control on any given day. An incident is an incident. A blocked websocket belongs to your IT team. Your plan is a billing decision. Your network is your network.

Two of them are entirely yours, and they are the two that compound: how many turns a task takes, and how long your threads get. Those are the same problem wearing different clothes.

Watch how a normal session goes. You write six words. ChatGPT asks what you mean. You clarify. It produces something in the wrong format. You correct the format. It loses the tone. You paste an example. Nine turns later you have your answer, and the thread is now carrying nine turns of correction that get re-read on every subsequent request.

A complete first prompt collapses that. Not a longer prompt, a specified one:

ROLE
You are a [role] writing for [audience].

TASK
[One sentence. The actual deliverable.]

CONTEXT
[Only what is needed to do this. Facts, constraints, prior decisions.]

FORMAT
[Exact structure. Length. Headings. Whether code, table, or prose.]

CONSTRAINTS
- [Thing to avoid]
- [Non-negotiable requirement]

TONE
[Two or three adjectives, plus one example sentence in the target voice.]

If anything above is ambiguous, state your assumption and continue.
Do not ask me clarifying questions.

That last line does more for perceived speed than any browser setting. It converts a clarify-and-wait loop into one round trip.

This is the honest version of the pitch: prompt engineering does not make the servers faster. It makes you need fewer turns from them, which keeps threads short, which keeps every subsequent turn cheaper to process. That is a real speed gain, and it is the only one on this list you own outright.

If you want the mechanics of building those prompts, start with how to write better ChatGPT prompts, and if your answers are wrong as well as slow, why your ChatGPT answers are bad covers the other half. If you would rather not assemble the structure by hand every time, our free prompt enhancer does the Role, Task, Format, Constraints, Tone pass for you in under two seconds, on the free plan, with no API key.