ChatGPT Not Working With Clash? Fix Timeouts and Access Issues
ChatGPT can fail while other websites continue to work normally through Clash. A timeout does not always mean that the subscription is invalid or that every proxy node is unavailable. ChatGPT traffic may be matched by a direct rule, resolved through a DNS server that is unreachable from the current network, or sent to a proxy group whose selected node cannot reliably reach OpenAI services. Different parts of the ChatGPT experience may also use different hostnames: the login page, API requests, static assets, streaming responses, file uploads, and authentication checks do not necessarily follow the same connection path.
The most efficient troubleshooting method is to check the path in order. First confirm that the request enters the running Clash or Mihomo instance. Then verify the local mode, rule match, proxy group, DNS behavior, and selected node. Only after those checks should you change the client or rebuild the whole configuration. This approach helps distinguish a routing mistake from a node-quality problem and prevents random changes from hiding the original cause.
Identify which ChatGPT path is failing
“ChatGPT does not work” can describe several different symptoms. The website may open but remain stuck on a blank page, the login flow may time out, messages may fail after being submitted, streaming replies may stop halfway through, or file uploads may never complete. The API can also fail independently from the web interface because API requests use different hostnames, authentication behavior, and connection patterns.
Start by recording the exact failure. Test the ChatGPT web page, sign-in, a short message, and—if relevant—an API request separately. Note whether the error is a DNS error, connection timeout, TLS failure, HTTP error, or an application message indicating that the service is unavailable. A page that loads its HTML but cannot send a message often indicates that the initial webpage and the later API or streaming connection were routed differently.
Open the Clash connection log while performing a fresh test. Close the existing ChatGPT tab, open a new private window, and submit a new request so that the client has a better chance of creating new connections. Look for destinations such as chatgpt.com, openai.com, auth.openai.com, api.openai.com, oaiusercontent.com, or other hostnames shown by the current connection log. The precise host list can change over time, so use observed traffic rather than relying on a permanently fixed list.
If no related connection appears in the log, the traffic may be bypassing Clash. Check whether another VPN, browser extension, operating-system profile, or security product is managing the browser connection. If the relevant domains appear but are marked DIRECT, the rule list is probably sending them outside the proxy. If they use a proxy group but fail only with one selected node, investigate the group and node separately.
Verify the active Clash runtime and proxy mode
Before editing YAML, confirm that the client is running the configuration you think it is running. Clash Verge, Clash Verge Rev, Clash for Windows, ClashX, Clash for Android, and Mihomo-based clients may store profiles, overrides, and runtime settings in different places. A visible profile name is not enough evidence: the client may have loaded a generated profile, applied an override, or started a different core than the one expected by an older guide.
Check the client’s current status page and verify that the core is running, the active profile is selected, and the local proxy port is available. If the client provides a core version or runtime log, record whether it is the original Clash core, Clash Meta, or Mihomo. Configuration keys supported by Mihomo are not necessarily accepted by an older core. A configuration that loads successfully but ignores an unsupported field can produce confusing DNS or routing behavior.
Next, check the operating mode. In rule mode, Clash evaluates the rules from top to bottom and sends the connection to the policy named by the first matching rule. In global mode, traffic generally uses the selected global proxy policy instead of the normal rule sequence. In direct mode, traffic bypasses proxy routing. The exact labels and controls vary by client, but the practical test is the same: temporarily use a known proxy policy and observe the connection log.
mode: rule
log-level: info
allow-lan: false
mixed-port: 7890
The example above does not guarantee that your client listens on port 7890, nor does it define a complete configuration. Use the port displayed by the active client. If system proxy is enabled but the browser creates no entries in the Clash log, check whether the system proxy points to the same address and port. A stale port, a second Clash instance, or a browser-specific proxy can make the interface appear enabled while traffic follows another path.
Inspect rule order and the selected proxy group
Rules are evaluated sequentially. A broad rule placed before a ChatGPT or OpenAI rule can capture the connection and send it to DIRECT, a reject policy, or an unsuitable group. Common examples include an early GEOIP,CN,DIRECT rule, a large domain provider with an unexpected category, or a final custom rule inserted above the intended service rule. The rule that looks most specific is irrelevant if an earlier rule has already matched.
For a temporary test, place narrowly targeted domain rules above broad regional, category, or final match rules. The policy name must exactly match an existing proxy group or node. A structural example is:
rules:
- DOMAIN-SUFFIX,chatgpt.com,ChatGPT
- DOMAIN-SUFFIX,openai.com,ChatGPT
- DOMAIN-SUFFIX,oaiusercontent.com,ChatGPT
- MATCH,PROXY
This is an example of routing structure, not a universal list of every hostname used by ChatGPT. Do not copy a random online domain list without checking current connection logs. Some hostnames may be unnecessary, while other required services may be delivered through a changing provider or a third-party infrastructure domain. Add only the domains needed by the observed failure, and keep them above conflicting rules.
Check group members and fallback behavior
A proxy group can exist in the configuration while containing no usable member. It may reference provider names that failed to update, proxy names that were renamed, or nested groups that are unavailable. Open the group in the client and verify that it contains live nodes or a working nested policy. If the group uses fallback or url-test, inspect the health-check URL and interval. A health check may show a node as available even when that node performs poorly with long-lived HTTPS streams or the specific OpenAI route.
For diagnosis, manually select two or three different nodes in the same group. Keep the rule unchanged and repeat the same ChatGPT action after each selection. If all nodes fail in the same way, the problem is more likely to involve rules, DNS, local interception, or service availability. If one node works and another times out, the routing path through the selected node is the leading suspect.
Do not assume that a low latency number means that ChatGPT will work well. A latency probe usually measures a short request to one test URL. ChatGPT may require reliable TLS negotiation, stable upstream connectivity, and support for streaming responses. A node can respond quickly to a ping-like HTTP check while still dropping a long-lived connection or failing to reach the required service region.
Perform a controlled test in Clash
Once the active runtime and rule structure are known, perform a controlled test instead of changing several settings at once. The goal is to create one reproducible request, observe its match, and change only one variable between attempts. Use a private browser window to avoid old cookies and cached application state, but remember that private browsing does not bypass the browser’s proxy configuration.
- Enable the Clash system proxy or the client’s documented browser proxy path. Temporarily disable other VPN applications and browser proxy extensions.
- Confirm the local listening address and port shown by the client. If you are testing with a command-line tool, use the correct proxy protocol rather than assuming that an HTTP port accepts every SOCKS syntax.
- Open the Clash connection view and clear or filter existing entries so that new ChatGPT requests are easy to identify.
- Visit the ChatGPT page, sign in if required, and send a short message. Record every related hostname, the matched rule, the policy, and the final node.
- Repeat the same test after manually selecting a different node in the same policy group. Wait long enough to observe whether the response streams continuously rather than only whether the page opens.
- Temporarily switch the relevant policy to a known working proxy group, if one is available. Do not change DNS, TUN, and rule providers at the same time; isolate the variable that changes the result.
For a local HTTP proxy, a basic command-line check can look like this:
curl -I -x http://127.0.0.1:7890 https://chatgpt.com
curl -I -x http://127.0.0.1:7890 https://api.openai.com
Replace the address and port with the values shown in your client. The first command tests whether the local HTTP proxy can establish an HTTPS request to the web domain; it does not authenticate you or prove that a complete ChatGPT conversation will work. The second command may return an HTTP status that is not a successful API response because authentication and request headers are missing. That is still useful: an HTTP response can show that DNS, TCP, TLS, and proxy forwarding completed, whereas a connection timeout points to an earlier network stage.
If your client exposes a SOCKS5 port instead, use the corresponding syntax:
curl -I --proxy socks5h://127.0.0.1:7891 https://chatgpt.com
The socks5h form asks the proxy to resolve the hostname, which is useful when comparing local DNS with proxy-side DNS. Keep in mind that command-line results and browser results can differ because browsers reuse connections, use HTTP/2 or HTTP/3 behavior differently, and maintain separate certificate, cookie, and DNS caches.
Check DNS resolution and TUN interaction
DNS can fail even when the proxy node itself is usable. If the browser resolves a ChatGPT hostname through a local resolver that is blocked, poisoned, slow, or unable to return a suitable address, Clash may never receive a connection that it can route. Conversely, a DNS mode that sends every request through a remote resolver may introduce delays or fail when the selected proxy cannot reach that resolver.
Inspect the active DNS section and determine whether the client is using system DNS, a fake-IP mode, redirection, or another Mihomo-supported mode. The names and available options differ by core and client. In fake-IP mode, applications may receive synthetic addresses and Clash maps them back to domain names internally. This can improve rule matching for some traffic, but applications or local services that expect real DNS answers may require exclusions. In redirection or enhanced modes, the client may need permissions and correct packet interception to work consistently.
Do not treat a DNS setting copied from another configuration as automatically compatible. Confirm that the configured nameservers are reachable, that the client reports successful DNS initialization, and that the failing hostname can be resolved through the active path. If the connection log shows a domain but the request stalls before TCP or TLS connection establishment, DNS remains a possible cause. If DNS resolves quickly and the connection reaches a node before timing out, focus more closely on the node route and rule policy.
TUN introduces another layer. It captures traffic that does not honor the system proxy, but it depends on operating-system permissions, a virtual interface, routing priorities, and DNS interception. Running system proxy and TUN simultaneously can be valid, but it can also make testing harder if traffic enters through different paths. For diagnosis, use one documented path at a time. First test the browser with system proxy only. Then, if the application requires TUN, disable the system proxy temporarily and test TUN alone.
When TUN is enabled, check whether the relevant domains are excluded by routing settings, whether IPv6 traffic follows a different path, and whether the client has permission to create or control the virtual interface. A configuration may route IPv4 traffic through a working node while IPv6 attempts bypass the proxy and time out. Temporarily disabling IPv6 for a controlled comparison can help identify this condition, but it should be treated as a diagnostic step rather than a universal permanent fix.
Distinguish a bad node from a configuration error
A node problem is more likely when the same ChatGPT request works immediately after selecting another node while the rule and DNS settings remain unchanged. Test several nodes from different regions or providers, not only nodes with similar names. Observe connection establishment time, TLS completion, response streaming, and stability during a longer exchange. A node that loads the homepage but repeatedly drops streaming responses is not reliable enough for this workload.
A configuration problem is more likely when every node fails, when the connection log shows DIRECT, when required domains never appear, or when changing the selected node has no effect. It is also suspicious when ordinary websites work but all ChatGPT-related requests match a reject policy or a regional direct rule. Review the generated configuration rather than editing only the subscription source if the client supports overrides. Subscription updates may overwrite direct edits.
Service-side restrictions and regional availability can also produce confusing results. A proxy may establish a network connection but receive an access-denied response, a challenge page, or an account-related error. Those responses are different from a TCP timeout. Record the status code and visible error, and avoid repeatedly refreshing a blocked endpoint. If the same account and configuration work through a different network path, compare the exit IP, node region, and policy rather than concluding that the local Clash core is broken.
| Observed result | Most likely area | Next check |
|---|---|---|
| No ChatGPT entry in the Clash log | Browser path or local proxy integration | Disable competing proxy tools and verify the active port |
| Entry is marked DIRECT | Rule order or policy name | Move a narrow domain rule above broad rules |
| All nodes time out | DNS, routing, TUN, or service path | Compare system proxy and TUN separately |
| One node works and another fails | Node route or upstream quality | Remove the failing node or adjust group selection |
| Page loads but messages fail | API, streaming, or additional hostname rules | Inspect the later connections, not only the first page request |
Apply a stable fix and keep it maintainable
After identifying the cause, make the smallest durable change. If the problem was a direct match, add a narrow rule to the supported override section and point it to a stable proxy group. If the issue was one unreliable node, remove it from the group or stop selecting it manually. If DNS was responsible, use a resolver arrangement supported by the installed core and verify it after every profile update. If TUN was the source of duplicate or bypassed paths, document whether the client should use TUN or system proxy for this device.
Keep policy names simple and consistent. A rule that references ChatGPT is useless if the group is renamed to AI Services without updating the rule. Check for empty groups after subscription refreshes, because provider changes can remove or rename nodes. Do not place a service-specific rule below a broad MATCH rule, and do not duplicate several conflicting rules merely to make the file look comprehensive.
For troubleshooting logs, record the date, client, core, profile, DNS mode, TUN state, matched rule, selected group, and node result. This information is more valuable than a screenshot showing only that the client is “connected.” Recheck after a subscription update because generated rules and provider contents may change. Once the route is stable, remove temporary test rules, unnecessary domain entries, and diagnostic settings that expose more traffic than needed.
If you still need to verify the client’s installation, port settings, or TUN permissions, use the platform-specific instructions before making further YAML changes.