Perplexity.ai Stuck Loading? Split perplexity.ai and CDN Domains in Clash

1. Name the failure: spinners are usually partial routing

Perplexity failures rarely announce themselves as HTTP error pages. More often you see a polished layout with an endless progress indicator, a search that never returns, or a first answer that streams and then stalls when follow-up tools try to fetch citations. Those symptoms overlap with generic congestion, yet experienced Clash users recognize a different signature: some requests succeed at line speed while others time out, which points to inconsistent policy selection rather than universal packet loss.

Before you touch node lists, separate three questions. First, does the application you are using actually send traffic through Clash, or is it bypassing the system proxy entirely? Second, when the core resolves a hostname, does the resulting IP and rule path match what you intended, especially under fake-ip? Third, are asset and API hostnames covered by the same policy group, or does an early provider rule send one chunk of the session through a domestic path while another chunk exits overseas? Answering those with log evidence saves hours compared with rotating every server in a subscription.

If YAML still feels opaque, spend ten minutes with our subscription import tutorial so you know where provider rules land relative to your own additions. The rest of this article assumes you can edit rules without breaking profile validation.

2. A checklist that delays “try another node”

Node hopping is emotionally satisfying and occasionally useful, yet it is the wrong first move when DNS or visibility is wrong. Follow this sequence instead.

1. Confirm whether you rely on system proxy or TUN, then verify the browser or desktop client honors that mode for both tabs and background workers.
2. Open the live connection log, reproduce the spinner, and read the policy column for every hostname that appears. Unexpected DIRECT rows are the smoking gun.
3. Audit DNS: resolver reachability, fake-ip behavior, and optional nameserver-policy for Perplexity-related suffixes.
4. Expand split rules to cover the app shell, APIs, and CDN hosts you collected—not only the apex perplexity.ai label.
5. After the path is coherent, choose stable nodes for interactive search and avoid hyperactive auto-switching that flaps mid-session.

For YAML typos, port conflicts, and core startup errors, keep the general Clash troubleshooting guide nearby. Here we emphasize multi-endpoint AI products where a single missing suffix masquerades as a product outage.

3. System proxy versus TUN for browser-first AI search

System proxy remains the gentle default when your workflow is mostly Chromium or Safari tabs and those browsers inherit OS settings faithfully. Perplexity’s web client fits that pattern when nothing else on the machine fights the proxy. The failure mode is familiar: the site loads because the document request succeeded, but a helper worker, extension, or subprocess still uses a direct path, so one asynchronous call never completes and the UI spins.

TUN mode pushes routing down into the operating system stack so fewer executables can accidentally skirt the proxy. The trade-off is operational complexity—permissions, route tables, and occasional conflicts with other VPN-class software. If you already stepped through our TUN mode guide, re-open it while debugging Perplexity specifically, then re-check the connection log to ensure no residual flows labeled DIRECT should not be there. TUN is not mandatory for everyone; it is the right experiment when evidence shows stubborn bypass despite correct YAML.

Regardless of mode, confirm the GUI points at the profile you edited. Editing the wrong file while another snapshot remains selected is a classic way to manufacture phantom regressions that have nothing to do with Perplexity itself.

4. DNS, fake-ip, and why AI sites feel fragile

Clash’s fake-ip mode improves some browsing scenarios by answering quickly with synthetic addresses, yet it also couples DNS tightly to rule evaluation. When the resolver and the rule engine disagree about what a name “means,” you can observe TLS retries, half-open HTTP/2 sessions, and SPAs that never leave the loading state. AI search exacerbates the problem because a single page fans out across dozens of hostnames in the first few seconds.

A practical mitigation has two parts. First, ensure your upstream DNS servers are reachable through the same policy path you expect for general browsing, and avoid resolver chains that intermittently blackhole international queries. Second, consider targeted policies—commonly nameserver-policy in Mihomo-compatible cores—for suffixes such as perplexity.ai and any recurring CDN roots you observe in DevTools. Exact keys differ between releases, so verify against the documentation bundled with the version you ship rather than copying decade-old forum snippets.

When DNS fixes clear most symptoms without changing proxy groups, you have strong evidence the bottleneck was resolution, not bandwidth. That distinction matters because it tells you whether to invest in resolver hygiene or in node stability next.

5. How to collect hostnames you can trust

Static rule posts age poorly because CDNs and feature flags shift. Treat any published list—including examples below—as a starting hypothesis, not scripture. Instead, build a personal inventory whenever Perplexity updates its front end.

Open your browser’s developer tools, switch to the Network tab, enable preserve log, then reload the Perplexity tab and run a query that reproduces the spinner. Sort by domain and export mentally (or literally) the distinct hostnames you see for document requests, XHR or fetch calls, scripts, styles, fonts, and websocket upgrades. Pay attention to third-party analytics only if blocking them is non-negotiable in your environment; otherwise, incomplete telemetry sometimes gates UI state in ways that look like censorship but are actually partial blocking.

For desktop wrappers or companion apps, repeat the same idea with whatever packet capture or connection log your platform provides, then reconcile those names with the Clash connection table. If a hostname appears in the browser but never in Clash, you still have a visibility problem rather than a rule-depth problem.

When you maintain team documentation, paste the hostname list into an internal wiki with the capture date. Future you will thank present you when a CDN cutover suddenly makes yesterday’s YAML incomplete.

6. Example buckets: from apex to CDN edges

After collection, group hosts so your YAML stays readable. A typical breakdown includes the primary product domain, API or edge subdomains, static asset delivery, authentication helpers, and occasional short-link infrastructure. Names drift; verify before you paste.

The figure below reuses the standard blog artwork as a visual anchor; the alt text states the intent for accessibility.

7. Rule snippets: explicit coverage and clean ordering

YAML fragments illustrate steering traffic to a proxy group named PROXY. Rename that token to match your real policy label and insert these lines before broad provider rules that might prematurely return DIRECT for “domestic” CDNs.

# Example only — replace PROXY with your policy group name
rules:
  - DOMAIN-SUFFIX,perplexity.ai,PROXY
  - DOMAIN-KEYWORD,pplx,PROXY
  - DOMAIN-SUFFIX,example-cdn.example,PROXY

The placeholder example-cdn.example is deliberate: paste the CDN suffixes you measured rather than imaginary domains. If your subscription injects aggressive geo rules, consider duplicating critical lines in a user-controlled section that loads late, or merge providers thoughtfully so your exceptions retain precedence. When you need experimentation, clone the group as PROXY_SEARCH and point only Perplexity-related rules there so aggressive load balancing on video traffic does not starve interactive queries.

Remember that DOMAIN-KEYWORD matches substrings anywhere in the host label, which is powerful and risky. Prefer DOMAIN-SUFFIX when you can express the intent precisely, and fall back to keywords only for noisy vendor patterns you cannot enumerate.

8. Node strategy: smooth sessions beat leaderboard latency

AI search is not a speed-test workload. Short bursts of brilliant RTT mean little if the tunnel drops every ninety seconds and forces TLS rebuilds. Perplexity’s interface interprets that instability as sluggish retrieval even when average throughput looks fine on paper.

Pin interactive search to providers that hold steady for minutes, reduce flappy auto failover on those destinations, and avoid chaining multiple tunnel products that re-encapsulate the same flow. If you must separate traffic, do it with deliberate policy groups rather than hope.

For background on transports under loss, see Shadowsocks vs Trojan vs Hysteria2. The goal is not to declare a winner globally but to pick a stack that matches your packet-loss profile for long-lived HTTPS sessions.

9. GUI workflow: logs are the source of truth

Desktop clients such as Clash Verge Rev expose live connections, DNS panes, and rule editors side by side. When Perplexity misbehaves, filter connections for substrings like perplexity or pplx and read the chosen policy per row. If anything sensitive shows DIRECT while similar hosts use PROXY, you have a precedence or bypass issue to fix before swapping servers.

If the baseline install still feels unfamiliar, walk through the Clash Verge Rev setup guide to confirm ports, subscriptions, and first launch before you chase AI-specific ghosts.

10. How this differs from other AI routing guides

Our DeepSeek routing article focuses on a different provider graph and API habit, while the ChatGPT piece spends more time on OpenAI console splits. Perplexity sits closer to a consumer search surface that leans on web delivery, which means CDN breadth and analytics adjacency show up sooner in diagnostics. Keep the mental model: collect hostnames first, align DNS second, order rules third, then tune nodes. Skipping straight to “which country flag loads fastest” discards information the connection log already volunteered.

Enterprise readers should remember that TLS inspection and split-horizon DNS can make overseas AI sites look broken even when Clash is perfect. If only identity or CDN domains fail while unrelated HTTPS succeeds, involve the network team with HAR excerpts rather than assuming the proxy core is misconfigured.

11. Extensions, competing VPNs, and mobile caveats

Browser extensions that inject their own proxies or “privacy” filters sometimes reorder connection priorities in ways Clash cannot see. Disable them briefly during triage. Likewise, running two VPN-class products simultaneously invites routing loops that masquerade as application bugs.

On mobile, per-app VPN implementations differ from desktop TUN; verify whether your client supports equivalent split rules and whether the browser you use actually honors the VPN tunnel. The hostname collection strategy still applies, but the tooling to inspect it may move from desktop DevTools to remote debugging or on-device logging.

Automation enthusiasts should remember that scripts calling Perplexity APIs from servers or CI runners inherit none of your laptop’s Clash settings unless you explicitly configure proxy environment variables or run those jobs inside a routed network namespace. The symptom pattern is identical—timeouts with no UI—but the fix belongs in deployment configuration, not browser YAML.

12. Close with evidence, not superstition

Perplexity spinners are maddening because the product looks polished even when the network path is fractured. Treat every endless loader as a prompt to open the connection log, read policies row by row, and reconcile DNS with the hostnames your browser actually requested. Split rules for perplexity.ai and its CDN neighbors are the mechanical layer; calm, stable nodes are the polish once the path is honest.

Compared with ad hoc VPN toggles, a maintained desktop client with Mihomo integration keeps diagnostics visible and reduces YAML foot-guns when AI products iterate weekly. → Download Clash for free and experience the difference