Why “Connecting…” is not a single network problem
Telegram clients in 2026 still stack several kinds of traffic under one turquoise icon. There is the familiar TCP traffic to well-known registrable domains used for account state, updates, and many HTTPS-shaped calls. There is the long-running session fabric people colloquially associate with MTProto: resilient, multiplexed conversations with data-center oriented endpoints that may present as bare IPs or rotating hostnames in your logs. There is also a growing share of CDN-style fetches for media previews, animated stickers, voice notes, and channel attachments—often different AS paths and caching goals than a low-latency control channel expects.
When readers search for Clash Telegram routing, they usually already enabled a tunnel. The failure mode is narrower: something in that mix is silently failing DIRECT, hitting the wrong policy group, or resolving a name to an address your rule stack never matches the way you imagine. A single oversubscribed catch-all group makes every symptom look like “bad node,” when the truth is often “wrong bucket.”
This article complements our Discord voice and CDN split guide—same discipline, different vendor envelope. If you need routing vocabulary first, skim custom routing rules for beginners, then return here for Telegram-specific ordering and DNS traps.
For client context, the Clash official home page links builds that expose readable logs and stable policy editors—the prerequisites for any split profile you maintain yourself.
Three buckets: web and control plane, MTProto-shaped data paths, CDN delivery
Think in observable flows rather than mythology. The first bucket is control-plane and web-shaped HTTPS: telegram.org, t.me, desktop.telegram.org, core.telegram.org, and similar surfaces your installer or browser might touch. These names benefit from consistent policy and predictable TCP behavior. They are also the ones community rule-sets sometimes mark as domestic or foreign in ways that accidentally fight your intent.
The second bucket is what operators traditionally discuss alongside MTProto proxy tutorials: long-lived client-to-coordinator traffic that may not look like “one pretty hostname per message.” Clients discover endpoints through bootstrap data you cannot fully hard-code from a three-year-old forum post. That is why a static YAML snippet without verification is fragile; treat every hostname you adopt as provisional until your own Mihomo log lines prove it.
The third bucket is CDN delivery and large objects: cached media segments, progressive downloads, and regional edges that appear when you scroll busy channels or replay voice notes. Throughput matters more here than sub-50 ms jitter. If you starve this bucket of bandwidth because it shares a latency-obsessed exit with interactive control traffic, you still perceive the app as broken even when the session technically stays up.
Clash matches what it can see—DOMAIN and IP classifiers, sometimes process-aware paths—not what you wish were neatly labeled “MTProto.” Separation therefore means carving policy groups first, then proving with logs which bucket each connection actually entered.
Policy groups: intentional homes for unlike workloads
A readable pattern is three dedicated groups. Name them however you like; separation matters more than branding. Example mapping: TELEGRAM_WEB for verified control-plane and installer hostnames, TELEGRAM_DC for long-lived session flows that logs tie to Telegram data paths (even when the literal hostname surprises you), and TELEGRAM_CDN for media-heavy edges once your captures show repeated large-object hosts.
Inside each group, keep two or three exits that you trust for that workload shape—not necessarily the global “fastest” node in a speed test. Data-center paths may tolerate different loss than bulk CDN fetches. Rotating every bucket simultaneously when something hiccups erases the diagnostic value of having separate groups.
Some networks merit DIRECT for the CDN bucket when local peering already delivers media well, while only steering the control bucket through a tunnel. Encode that deliberately in YAML, not by accident via a broad GEOIP line that steals a hostname before your explicit Telegram rules. Geography-based shortcuts are exactly how people end up with “Connecting…” loops while the rest of the browser appears fine.
Rule shape: specificity and order before optimism
Mihomo-class cores evaluate ordered rules top-down; first match wins. Place explicit DOMAIN and DOMAIN-SUFFIX lines for verified Telegram families above community RULE-SET imports and aggressive GEOIP shortcuts. A well-meaning “domestic DIRECT” strip is a frequent root cause of partial connectivity: one critical hostname obeys DIRECT, while the companion path expected a tunnel, and the client never finishes handshakes.
Below is illustrative YAML only—expand, rename groups, and verify names in your own logs before relying on it:
# Illustrative only — confirm every suffix in your Mihomo logs this week.
rules:
- DOMAIN-SUFFIX,telegram.org,TELEGRAM_WEB
- DOMAIN-SUFFIX,t.me,TELEGRAM_WEB
- DOMAIN-SUFFIX,desktop.telegram.org,TELEGRAM_WEB
- DOMAIN-SUFFIX,core.telegram.org,TELEGRAM_WEB
# Append media or CDN suffixes your captures prove (examples vary by region):
# - DOMAIN-SUFFIX,cdn.telegram.org,TELEGRAM_CDN
- MATCH,FINAL
Notice the deliberate gap: MTProto data-center hosts are not copy-pasted here because they drift. After you run a short reproduction—open a busy channel, start a voice note, attach a photo—copy the repeating candidate suffixes from logs into the middle of that strip. Keep this inline block above heavy remote sets so a refreshed provider cannot outrank your session-critical lines overnight.
If you maintain remote rule providers, our rule providers tutorial explains refresh cadence and safe ordering—skills you will need the moment a Telegram CDN hostname changes quietly.
DNS, fake-ip, and the split-brain Connecting spinner
Misaligned resolvers still masquerade as mystical Telegram bugs. If the OS asks the ISP resolver while Mihomo expects tunnel-anchored answers (or fake-ip maps domains differently than your mental model), clients may race connections your rules never classify consistently. Symptoms include endless Connecting, login banners that never progress, or chats that partially hydrate.
Work methodically: query the same hostname through the resolver chain your profile actually uses and through a plain upstream; divergent answers implicate DNS before any outbound rotation. Pay attention to encrypted DNS inside browsers or “secure DNS” toggles that bypass system settings when you refuse TUN capture.
IPv6 deserves honesty. If IPv6 leaks around the tunnel while IPv4 obeys policy, some paths may still look “mostly fine” until a media edge prefers the wrong family. For the classic green-status-yet-dead-tabs pattern, reuse the discipline from connected status with no loading; the same log-first steps apply to mint-colored messengers.
System proxy, manual SOCKS, and TUN capture on desktop and mobile
Desktop Telegram is not guaranteed to honor OS proxy variables the way your browser does. If only the browser works, you may be seeing split capture, not node failure. TUN mode aligns more IP-layer traffic with Mihomo, which is why many teams standardize on it for stubborn Electron-style clients. For stack-level detail, read the TUN mode guide alongside this walkthrough.
Mobile clients add VPN permission and battery-optimization caveats. On iOS stacks such as Stash, per-app profiles interact with domain rules in ways that reward the same bucket strategy: keep explicit Telegram names near the top of the profile, then verify with the client log export rather than guessing. Our Stash on iPhone guide walks import and tunnel behaviors that pair with ordered rules.
Some users experiment with a dedicated MTProto proxy entry inside the Telegram app. That is orthogonal to Clash routing: it can coexist, bypass, or double-encrypt depending on how you stack transports. If you enable it while also tunneling globally, read the combined path carefully; otherwise you may troubleshoot the wrong layer.
UDP, QUIC, and when media stalls are transport problems
Not every Telegram stall is a hostname mismatch. Some networks shape or deprioritize UDP in ways that surface as stuck voice notes or half-buffered video while text still trickles. Others race HTTP/3 where middle boxes behave poorly. When text chat works but rich media fails, compare a plain TCP-only site with the media attempt, then glance at whether your exit or ISP path is punishing UDP.
For broader transport literacy—including tests that distinguish QUIC from classic TCP failures—see the QUIC and HTTP/3 guide. The headline symptom differs from endless Connecting, yet the debugging instinct is shared: confirm the outer protocol before you declare the service down.
Common misroutes and what to inspect first
| What you notice | What to inspect first |
|---|---|
| Spinner on Connecting, other HTTPS apps work | Early GEOIP or domestic DIRECT steal on a control-plane hostname; DNS answers splitting paths |
| Chats sync but photos, circles, and downloads crawl | CDN bucket still on the wrong group; missing DOMAIN-SUFFIX for a new media edge |
| Desktop app broken, web Telegram okay | Capture mode mismatch—enable TUN or verify the native binary is steered |
| Issue appears only on cellular or one Wi-Fi | Resolver differences, captive portals, or carrier IPv6/UDP policies |
| Started after importing a large community ruleset | Rule order drift—move verified Telegram lines above remote RULE-SET matches |
DIRECT, one unrelated foreign site that must follow your default foreign group, and one Telegram hostname you just saw in Mihomo for each active bucket. If any leg disagrees with your intent, fix ordering or DNS before you rewrite the rest of the profile.Self-check checklist before you blame the data center
- Reload the profile and confirm explicit Telegram lines sit above noisy
GEOIPshortcuts. - Reproduce one failure with logging enabled; capture hostname, matched rule, and policy group—watch for surprise
DIRECT. - Compare resolver answers on working versus broken networks; disable conflicting encrypted DNS while testing.
- Validate TUN or system-proxy coverage for the exact client binary you use—not only the browser.
- When media fails but text works, test UDP health and try a QUIC-off experiment where practical.
- Revisit groups after client updates; bootstrap lists and edge domains shift more often than core home pages.
Terms, regions, and realistic expectations
Routing discussions intersect with platform policies, sanctions, and local telecommunications law. This guide is for readers who legitimately operate tunnels for privacy, roaming stability, or path optimization—not as encouragement to evade abuse prevention, fraud checks, or purchase restrictions. If Telegram surfaces a moderation or security challenge, treat it as a trust-and-safety workflow rather than a cue to rotate randomly through commercial exits.
No amount of YAML creates bandwidth that does not exist. What disciplined Clash Telegram routing delivers is clarity: you separated control, session, and CDN evidence, aligned DNS with fake-ip, and ruled out self-inflicted misrouting before blaming MTProto itself.
Closing: make Telegram traffic legible again
Telegram remains a demanding customer of modern split stacks because it blends durable sessions, chunky media, and certificate-backed web calls. Give each bucket its own policy group once logs justify the split, keep DOMAIN specificity ahead of broad geography shortcuts, and rehearse short DNS checks whenever the UI stalls on Connecting. That workflow survives hostname churn far better than static lists copied from outdated threads—and it stays analytically distinct from messaging guides written for voice-first RTC stacks.
Compared with one global toggle, deliberate Telegram split rules trade a few careful YAML lines for calmer troubleshooting and clearer Mihomo logs. When you want installers aligned with the same documentation style, the Clash download page stays the right first stop before you dive back into profiles.