1 Why Midjourney routing diverges from “pure API or web” LLM guides
Articles that teach Clash split routing for large language models usually emphasize a compact set of vendor hostnames: console pages, documented REST endpoints, and the occasional CDN for static assets inside the same brand tree. The mental model is “authenticate once in the browser, then call APIs that share a predictable suffix.” Midjourney partially fits that story on midjourney.com, but a huge fraction of creative workflows still begin inside Discord: guild navigation, slash-command bots, rich embeds, voice-ready clients, and aggressive WebSocket backbones that behave nothing like a stateless HTTPS call to api.openai.com. When only half of that graph reaches your chosen exit, you see classic split-brain symptoms—the bot acknowledges a job while thumbnails never load, or the desktop app signs in while invite links stall on a different path.
In 2026, treating Discord as “just another website” also fails because native clients do not always honor desktop HTTP proxy settings, and the product’s dependency on low-latency gateway hosts is closer to a communications platform than to a documentation site. That is why this guide groups DOMAIN-SUFFIX rows into coherent policy stories: one cluster for Discord’s core and media edges, another for Midjourney’s own apex and CDN, and a third for subscription flows that may briefly leave both brands—without pretending one keyword rule can stand in for informed suffix coverage.
If you are choosing a desktop build for the first time, start from our download page for maintained installers. Open-source repositories remain the right place for license text and issue trackers, but everyday installs should follow the site flow so “which artifact?” confusion stays out of creative workstations.
2 Three surfaces to model before you touch YAML
Surface one—Discord as community and transport. Whether you use the desktop client, the stable web app, or mobile shells, Discord terminates long-lived sessions on its own registrable domains, serves media through CDN-style hostnames, and resolves short invites on discord.gg. Routing only discord.com while forgetting sibling suffixes is a frequent cause of “connected but broken UI” where chat scrolls but avatars, stickers, or uploads fail silently.
Surface two—Midjourney-owned sites and CDN edges. Account pages, galleries, documentation, and marketing funnels typically live under midjourney.com and related subdomains; image-heavy views may pull assets from hostnames that still roll up to the same suffix in many cases, but you should confirm with logs after each major UI refresh rather than assuming a single apex covers every asset line.
Surface three—plans, receipts, and payment rails. Checkout experiences often involve third-party payment processors (commonly Stripe-backed flows in modern SaaS) and email deep links. If your catch-all rules send “unknown shopping domains” to a different exit than the identity session that created the cart, you can hit confusing CSRF-like failures or three-domain redirects that never complete. A disciplined approach keeps subscription management on a predictable egress alongside the product surfaces you already trust, and adds narrow DOMAIN-SUFFIX rows for payment hosts when logs prove they matter for your bank and region.
3 Discord: suffix-first coverage for client, web, invites, and media
For everyday Discord reachability, a pragmatic baseline on Mihomo-powered Clash profiles starts with suffix coverage for the core product and its compatibility layer: DOMAIN-SUFFIX,discord.com, DOMAIN-SUFFIX,discord.gg, DOMAIN-SUFFIX,discordapp.com (still referenced by older paths and embeds), DOMAIN-SUFFIX,discord.media, and DOMAIN-SUFFIX,discordcdn.com for media-heavy timelines. Short invite links and gateway traffic frequently touch hostnames under those trees; keeping them in one policy group—call it PROXY_DISCORD or merge with your Midjourney group when policy allows—makes logs readable when something regresses after a client update.
Avoid lazy DOMAIN-KEYWORD,discord as a permanent solution: keyword matches collide with unrelated hostnames and age poorly when internal test domains appear in enterprise captures. Prefer suffix-first routing, then add explicit DOMAIN lines only for odd one-off hosts your team observes in production logs. If you adopt a remote rule provider, choose behavior: classical lists you can diff in Git, and pin update intervals so a surprise upstream change does not rewrite your policy during a live stream.
Desktop users on Windows who split traffic by application may also pair these domain rules with process-aware policies after the network path is correct; see process-name routing on Windows for when per-app overrides help—usually after baseline suffix coverage stops the obvious failures.
4 Midjourney official domains: web, docs, and CDN discipline
On the Midjourney side, DOMAIN-SUFFIX,midjourney.com is the maintainable anchor for the brand’s own sites under ordinary DNS—subdomains for accounts, marketing, and help content typically roll up to that suffix. After product updates, repeat a controlled browsing session with logging enabled, export the hostnames your client actually hit, and compare against your YAML. If you see repeated asset hosts on other registrable domains, add narrow suffix rows or extend a private rule provider rather than widening keywords blindly.
Image generation workloads can be bursty; latency and packet loss show up as stuck progress bars before they show up as clean HTTP errors. Once routing is correct, prefer tuning node choice and client timeouts before you chase imaginary DNS bugs—though DNS misalignment can still masquerade as TLS failures, which is why the next section on resolvers matters as much as the rules: block.
5 Payments, invoices, and subscription pages
Stable access to Midjourney is not only “can I reach the bot?”—billing must work too. Checkout pages often load scripts and APIs from Stripe (stripe.com and related infrastructure hostnames) and may send confirmation links through email providers outside either brand. A practical approach is: keep the payment flow on the same broad egress policy as the product session that initiated it unless compliance forbids that, then add explicit DOMAIN-SUFFIX,stripe.com (and any additional hostnames your logs show for 3-D Secure or bank redirects) when invoices fail for routing reasons rather than card reasons.
If your subscription management opens in a separate browser profile or device, align that profile’s Clash policy with the one you use for Discord and Midjourney so OAuth and cookie state stay coherent. Nothing in this article overrides provider terms—routing only solves transport; entitlement errors after connectivity is fixed belong to account settings and support channels.
6 Rule order: explicit rows before blunt catch-alls
Clash evaluates rules: from top to bottom; the first match wins. Subscription bundles often insert early GEOIP or broad MATCH lines that swallow Discord or Midjourney flows before your vendor-specific groups ever see them. Move DOMAIN-SUFFIX and RULE-SET entries for Discord and Midjourney above those catch-alls. When both inline lines and remote providers exist, remember duplicates honor the earlier rule—use that deliberately so local hotfixes win during incidents.
Teams that already maintain per-vendor groups for LLMs should add parallel groups for “communications + image” workloads rather than overloading a single “AI” bucket. The audit story stays clean: logs show PROXY_MJ_DISCORD (or split groups if you must) instead of an opaque category nobody can explain under pressure.
7 Illustrative YAML: groups, providers, and combined rules
The excerpt below is educational. Replace placeholder group names with your real selectors or url-test groups, merge with your subscription’s naming conventions, and validate with your client’s config linter before pushing to shared machines.
# Example only — merge with your full profile
proxy-groups:
- name: PROXY_MJ_DISCORD
type: select
proxies:
- AUTO-BEST
- DIRECT
rule-providers:
mj-discord-baseline:
type: http
behavior: classical
url: "https://example.com/rules/mj-discord-baseline.txt"
path: ./ruleset/mj-discord-baseline.yaml
interval: 86400
rules:
- RULE-SET,mj-discord-baseline,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,discord.com,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,discord.gg,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,discordapp.com,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,discord.media,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,discordcdn.com,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,midjourney.com,PROXY_MJ_DISCORD
- DOMAIN-SUFFIX,stripe.com,PROXY_MJ_DISCORD
If you do not yet trust a remote URL, delete the RULE-SET line and rely on the DOMAIN-SUFFIX rows until your private list matures. Pair the block with coherent DNS: our DNS leak prevention guide explains DoH, FakeIP, and resolver alignment—critical when rules match but TLS still fails because two resolvers disagree about the same name.
stripe.com through the same group as Discord is convenient for checkout, but if you globally proxy Stripe for unrelated shops, consider splitting policy groups once audits require it.
8 Why monolithic GEOSITE alone is a weak default here
Large geosite bundles are convenient for “send overseas SaaS through PROXY,” but they are coarse and opaque when Discord voice, image CDN bursts, and a billing redirect fail for different reasons at the same time. Vendor-specific RULE-SET files or explicit DOMAIN-SUFFIX lines give you a Git-friendly diff; monolithic imports do not. The same reasoning appears in our DeepSeek split rules article: clarity beats list size when on-call engineers must answer “why this host?” at midnight.
9 Mobile: Android VPN mode and Discord’s TLS reality
Phones rarely mirror desktop proxy semantics. Many apps ignore system HTTP proxies entirely; OEM skins differ. On Android, Mihomo-derived clients in VPN mode usually provide the most predictable capture path for Discord and embedded web views because packets enter the tunnel before user-space libraries short-circuit around environment variables. After granting VPN permission, confirm in the client log that connections to *.discord.com and *.midjourney.com hit PROXY_MJ_DISCORD rather than falling through to DIRECT because an older MATCH rule fired first.
For FlClash-style setups, our FlClash Android setup guide walks import paths and permission checks that apply broadly to creative SaaS stacks, not only a single vendor.
10 TUN, system proxy, and desktop creative workflows
System proxy mode helps browsers and well-behaved CLI tools, but Discord’s desktop client and some helper utilities open connections that ignore HTTP_PROXY. For workstations that mix Discord, Midjourney web tabs, and local automation, TUN mode often yields the most consistent story: packets enter Mihomo before user-space libraries apply their own policy. Our Clash Verge Rev TUN guide covers loop avoidance and verification steps that generalize beyond any single app name.
When you prefer proxies without TUN, document the working combination of mixed ports, SOCKS, and NO_PROXY for internal hosts—creative teams lose fewer afternoons to “works in Chrome, fails in the native client” mysteries.
11 DNS, logs, and practical troubleshooting
Split-brain DNS—Mihomo resolving to FakeIP while the OS stub still queries the ISP—remains a top cause of mysterious TLS failures after routing looks “correct” on paper. Align resolvers deliberately, flush stale caches after profile edits, and when testing, change one variable at a time: node choice, DNS mode, then application timeouts. IPv6 surprises persist: if the OS prefers IPv6 first but your policy assumes IPv4-only proxy paths, some sessions may bypass Clash intermittently—either route IPv6 consistently or isolate with a controlled toggle during triage, then implement a durable fix.
Patterns that persist after rules look right. Endless TLS handshakes often mean DNS and FakeIP disagree; half-loaded Discord timelines frequently mean media CDN hostnames still hit DIRECT. Filter logs for discord and midjourney, capture hostnames once per incident, and snapshot working YAML when the issue clears—your runbook stays short and factual.
12 FAQ
- Midjourney loads in the browser but Discord desktop stays flaky: Confirm TUN or VPN mode on desktop if the client ignores system proxy; verify CDN suffixes are not swallowed by an early
GEOIPrule. - I copied OpenAI rules; why is Discord still broken? LLM guides do not include Discord’s gateway and media graph—add the suffix rows in this article or an equivalent audited list.
- Checkout fails with 403 or endless redirects: After routing is clean, inspect payment domains in logs; add Stripe suffixes if your region’s flow requires them, and align browser profiles with the Clash policy used for the account session.
- Can I split Midjourney web from Discord? Yes, with separate policy groups and careful rule order—useful when compliance requires different exits, at the cost of more moving parts.
- Do community Discord lists replace manual suffixes? Treat them as accelerators, not blind truth—review classical lists and keep local overrides for hostnames your own captures validate.
13 Wrap-up
In 2026, stable Midjourney access with Clash on the Mihomo core is a story about three cooperating graphs: Discord’s real-time client and CDN hostnames, Midjourney’s own midjourney.com tree, and the subscription rails—often including Stripe—that must complete without fighting your identity session. A handful of well-placed DOMAIN-SUFFIX lines, optional rule providers for team-maintained lists, and disciplined placement before blunt catch-alls yields auditable logs and fewer “half-working creative stack” afternoons. Compared with guides that only list a vendor API domain, this community-and-CMS shape is closer to how people actually ship images with bots and browsers together.
Among comparable tools, Clash’s readable rules and mature clients fit creators who juggle Discord, web consoles, and occasional automation on one machine. When you need an installer, use our download hub for maintained packages; cite GitHub for source and issues, not as the primary path for everyday readers who only want a trustworthy build.
Once routing stops stealing attention, you can focus on prompts and iteration—the outcome a solid proxy stack should deliver for Midjourney users in 2026.
