Protocol Reference Route Selection and Troubleshooting Guide
VPN Protocol and Route Technical Reference
Slow initial connections, mid-session dropouts, and peak-hour lag may have different causes. This guide separates protocols, routes, and devices so you can trace symptoms and use controlled tests to decide what to change.
Haven't finished setting up your client? Start with the Quick Start Guide to import your subscription and verify the connection. Once you're connected, come back here to compare your options.
How to Measure
How to Compare Connection Speeds Fairly
Separate Initial Wait from Ongoing Wait
The time you tap Connect, the time the client reports a connection, and the time a destination site becomes usable are different milestones. A client may report success as soon as the tunnel is up, while the app still needs to resolve a domain, connect to the destination, and wait for its response. If you track only the client status, a slow destination can be mistaken for a slow protocol. When recording results, define the starting point: measure tunnel setup from the moment you initiate the connection, and end-to-end experience from the moment you open the page. With collaboration tools in particular, seeing the page frame doesn't mean its content and editing state are synced. Use a clearly observable action as the endpoint.
Throughput measures how much data arrives over a period; it doesn't tell you whether each interaction is responsive. Web browsing and remote desktops often suffer from round-trip delays and latency spikes. Downloads depend more on sustained data delivery, while calls are especially sensitive to consecutive packet loss and queuing. A route can show a strong average download speed and still struggle with screen sharing if its available upload capacity differs from its download capacity. Before testing, write down the action that's causing trouble, such as “the document takes ages to appear after I switch to it.” That's more useful than a blanket rating of everything as fast or slow.
Measure New and Reused Connections Separately
A cold connection starts from scratch when there's no usable session on the path. A warm connection may reuse an existing tunnel or restore a session, reaching a usable state sooner. Repeatedly refreshing the same page can also hit the browser cache, so a faster second load doesn't prove the handshake was shorter. For comparisons, use the same test entry point and distinguish reconnecting the client from reopening the browser. If you can't reliably clear the cache, label the result as a warm connection rather than comparing it with a first visit. If the client retries automatically, record whether it retried before succeeding instead of attributing the entire wait to a single handshake.
When comparing protocols, keep the device, access network, destination, rule mode, exit, and test time as consistent as possible; change only the protocol. When comparing routes, keep the protocol fixed instead. If each protocol can only be paired with a different exit, record them as “Setup A” and “Setup B” and acknowledge that you can't isolate the protocol's individual contribution. Don't test every sample during the day and compare them with a different setup tested only at night. Alternating tests can reduce bias from a gradually busier access network, but watch for interference such as another device starting a backup or a site loading a large batch of content.
Match Resource Measurements to a Real Task
Idle resource use and resource use during sustained transfers are not the same. At idle, check whether the client frequently wakes up or repeatedly reconnects. During transfers, look for sustained CPU activity, memory growth as concurrent connections increase, and whether data is delivered at the expected rate. If the device heats up without delivering much data, encryption, packet handling, or copying may be consuming resources. If the CPU appears idle while transfers take a long time, the network may simply be slow to deliver data. Systems sometimes attribute network extension or virtual network adapter overhead elsewhere, so monitoring only the client process can miss the device's overall load.
Keep a record you can reproduce: access method, test time, protocol and exit, whether you just reconnected, target app, and any unusual behavior. Note not only how long successful connections took, but also attempts that failed to open, loaded incompletely, or reconnected after returning to the foreground. One unusually fast result only tells you that it performed well once; if results vary widely, look for shared conditions. To clarify terms like nodes, subscriptions, and rule modes, see VPN Terms for Beginners and use consistent terminology in your test notes.
The most useful result isn't the name of the “fastest” option. It's knowing what changed, on which network and at what time, and whether that fixed the action that was getting stuck.
Proxy Fundamentals
Shadowsocks and VMess
Shadowsocks: Simple Doesn't Always Mean Faster
Shadowsocks is commonly used to send app traffic to a configured proxy, which then connects to the destination. Modern implementations typically use authenticated encryption. In a common TCP setup, the proxy layer doesn't need to complete a separate TLS negotiation before sending its first data, but the underlying TCP connection still has to be established, and the destination's own TLS connection still works as usual. Skipping a proxy-layer negotiation makes the flow more direct; it doesn't guarantee that a whole page will load faster. If the access route is circuitous or the destination responds slowly, the time saved may be hard to notice.
It's also important to distinguish app connections from proxy connections. When an app opens many short connections, the client may connect upstream for each one, spending resources on repeated setup and data handling. A large file sent over one persistent connection puts more of the load on processing data as it arrives. On less powerful devices, effective use of system or hardware encryption can matter more than the protocol name. A configuration that looks identical may also add plugins, another transport layer, or different routing rules. If you change those conditions at the same time, you can't attribute all the improvement to Shadowsocks.
A client supporting Shadowsocks doesn't mean the current connection can carry every kind of traffic an app needs. For example, a browser may load webpages while a calling app's media streams fail to establish as expected. Check the app's routing rules, the client's UDP forwarding support, and the proxy configuration separately. Also distinguish browser proxying from system-wide routing: a working browser doesn't prove that a standalone app uses the same path. If media fails, note whether it happens when joining a call or when sending and receiving audio or video. Don't conclude that the protocol is incompatible based on a single symptom.
VMess: Separate Proxy Authentication from Outer Transport
VMess defines authentication and data encapsulation between client and server at the proxy layer. Deployments may wrap it in different outer transports. If the outer layer uses TLS or an HTTP-based transport, include its negotiation, encapsulation, and implementation overhead in your connection budget. Conversely, a slow VMess connection doesn't prove that protocol authentication is taking too long. The entry address may resolve slowly, the outer connection may be established repeatedly, or round-trip times along the route may simply be higher. Recording the transport shown in the client is more useful than noting only the protocol label.
If authentication fails, first distinguish between being unable to reach the entry point and being rejected after connecting. The first may indicate an unreachable endpoint or a timeout. For the second, check whether the subscription needs refreshing, whether the client can parse the entry, and whether the device clock is set automatically; VMess authentication involves time, so clock drift can cause rejection. Keep only the error category shown by the client in public troubleshooting notes. Never share credentials or a complete subscription. If the same configuration works on another device, compare clock sync, client implementation, and the network at the time instead of rebuilding the whole account setup.
Choosing Between These Two Options
If you already have a stable Shadowsocks setup and mainly browse in short sessions or run lightweight background connections, use it as a baseline and observe cold-start time and idle overhead. If you already have a VMess setup and your team's devices support the same transport combination, test it with real tasks; there's no need to migrate just to reduce encapsulation. If it fails only on a particular office network, don't rely on repeatedly switching protocols. First check that the device has access to the local network, that the app's traffic is actually routed through the client, and whether the same destination also fails on a backup route. What matters is whether the setup can reliably complete tasks on the devices you need, recover after switching networks, and reconnect after suspension—not just which letters appear in the settings screen.
A proxy name doesn't tell you how it's transported. Recording the “protocol, outer transport, and rule mode” helps separate authentication issues from route issues.
Transport Layers
Trojan and VLESS
Trojan: Know Which Certificate Is Being Checked
A typical Trojan connection first establishes an underlying connection to the proxy entry and negotiates TLS, then handles proxy authentication and forwarding within that connection. This verifies the identity of the proxy entry. When a browser visits an HTTPS destination, it still verifies a separate certificate for that destination. If you see a certificate error, first check whether it came from the client or the browser. If the client reports an error as soon as it connects, check that the entry hostname matches what the client expects, that the system clock is correct, and that the certificate chain is trusted. If the browser reports an error only on one site, don't change the proxy entry configuration without evidence.
Breaking down connection setup makes TLS overhead easier to understand. A new session usually requires negotiation before a stable data channel is ready. Whether an app can keep using the same underlying session depends on the implementation and connection mode. Repeatedly creating fresh sessions also consumes computing resources, which may be more noticeable on low-power devices handling many short tasks. During a sustained large-file transfer, handshakes make up a smaller share of the total time, so encryption processing, route throughput, and packet loss matter more. A short webpage load that shows little difference doesn't prove that the same route will perform identically during a long transfer.
VLESS: The Name Doesn't Specify the Outer Protection
VLESS separates proxy-layer session identification and data carriage from the outer transport. Common deployments rely on a paired transport layer for link protection. The name alone doesn't tell you the encryption method, authentication properties, or resource use, and a proxy-layer identifier is not encryption. When choosing a setup, check that the complete combination in the subscription is parsed by the client, and keep verification settings from a trusted source. If you keep only the protocol name and omit outer-layer parameters, the client may still create an entry on import, but that doesn't mean it can establish the connection as intended.
Different outer transports can make connections with the same protocol name behave differently during retries and in apps. When multiple tasks share a reliable, ordered transport channel within an upstream connection, later data may have to wait for missing data to be retransmitted. This is easier to notice when image and text loads share a channel with a real-time session. On the other hand, establishing a separate connection for each task may reduce shared waiting, but adds handshake and connection-state overhead. Both approaches have trade-offs; connection reuse isn't a simple performance switch.
| What to Check | Trojan | VLESS |
|---|---|---|
| Initial Connection | Typical setups require a TLS handshake | Depends on the configured outer transport |
| Fails After Import | Check the entry address, clock sync, and certificate verification | Check that all transport parameters were recognized |
| Sustained Transfer | Check for retransmissions along the route and CPU use | Check the outer transport and whether connections are reused |
Decide Whether to Switch Based on Where It Fails
After importing, confirm in the client that the selected entry is the combination you intend to test, then compare a cold connection with a sustained connection to the same destination. If the new setup fails during connection establishment while the original works, check the outer handshake and access conditions. Don't disable certificate verification just to make it “connect.” If both establish successfully but one stalls only during long transfers, investigate queuing on the transport path, connection reuse, and device processing load. If both slow down only on a particular service, check the destination's response and the route from the exit to that service first. Separating these possibilities makes it easier to reach a reproducible conclusion than clicking through protocols until one happens to work again.
Datagram Paths
Hysteria2 and TUIC
Start by Checking Whether UDP Can Send and Receive Reliably
Common implementations of Hysteria2 and TUIC are built on QUIC. QUIC runs over UDP and integrates encryption and transport negotiation into connection setup. It can also manage multiple data streams over one connection. Reliable data still needs acknowledgments and retransmissions. One advantage of QUIC is that a data gap in one stream doesn't have to block other streams based on byte order across the entire connection, but all streams still share the same network path and congestion budget. If the overall link is saturated, multiple streams can slow down at once. First check whether UDP can send and receive consistently over your access network, then consider whether these setups might help.
In practice, a new connection has to complete the necessary negotiation, while session recovery depends on the implementation and connection state. When switching access networks, QUIC may be able to migrate a connection under suitable conditions, but this isn't guaranteed across all clients and routes. The new path may need validation, and the system may first restart the device's network extension. If you only watch the client status in the foreground during testing, you may miss the time it takes for the app to recover. A more useful test is to switch networks during the same session and see whether the task continues immediately, resumes after a brief pause, or has to start over.
Hysteria2: Don't Extrapolate from Peak Speed-Test Results
Some Hysteria2 configurations let you specify expected bandwidth and use that value to set the sending strategy. Check which direction the setting refers to and which strategy the client and server ultimately use. Without those details, don't assume every setup named Hysteria2 uses the same congestion control. If the configured sending rate exceeds what the path can sustain, packets may queue at the slower access link or exit and eventually be dropped. Sending more data repeatedly won't increase the path's capacity. If the subscription manages the active settings, choose a suitable configuration rather than setting a rate above the measured peak.
To check whether a connection is “sending too aggressively,” look for two symptoms at the same time: traffic surges when a download or upload starts, while lightweight interactions on the same network take longer; then those interactions recover soon after the transfer pauses. If this pattern repeats across alternating tests, queuing is worth investigating. Rather than chasing a higher peak, check whether tasks can be completed consistently under normal load. Wireless interference on some access networks can cause similar symptoms, so verify with a different access method before deciding whether the issue is on the local path or at the exit.
TUIC: Distinguish Streams from Datagrams by Workload
TUIC also uses QUIC connections to carry proxy traffic. Reliable streams and UDP datagrams used by apps shouldn't be lumped into a single speed result; forwarding behavior, congestion control, and buffering depend on the actual client and server implementation. For real-time apps, data that arrives too late may as well not arrive. For file transfers, missing data must be retransmitted. A file download doesn't tell you enough about call quality, and one smooth meeting doesn't prove that large-file throughput is good. If you only need a reliable byte stream, test the relevant tasks. There's no need to add unrelated tests just to showcase a protocol feature.
If both QUIC-based options go from timing out to working when you switch the same device to another access network, investigate UDP routing, temporary session state, or access quality on the original network before concluding that one option is more stable. If only one configuration fails, first check whether the entry supports the client and can complete negotiation. Keep a TCP-based option as a control. Where UDP performance varies, a connection that completes tasks consistently is more useful than one that occasionally reaches a higher throughput. Don't change the destination region and network interface at the same time, or the results will describe the difference between whole setups rather than one factor.
QUIC can't add capacity that the network path doesn't have. It changes how connections are established, streams are organized, and packet loss is recovered.
Device-Side Checks
How to Assess Battery Use on Mobile
Test Background Keepalives Separately from Foreground Transfers
Battery drain on mobile devices isn't determined by encryption alone. Screen use, wireless signal quality, scheduled background wake-ups, and frequent reconnects can all affect the result. Even small keepalive messages can wake a wireless connection from a low-power state. If the interval is poorly chosen, the data counter may barely change while battery life drops. Conversely, a large file transfer may draw more power at a given moment but finish sooner and let the device return to idle. Comparing locked-screen standby with active use is more reliable than inferring that a protocol is power-efficient from a single battery change.
For standby comparisons, use the same device with similar signal strength and consistent power-saving settings. First rule out system updates, photo syncing, and background backups. Note the route in use before locking the screen, then check whether the existing session still works and whether the client repeatedly reconnected. If repeated reconnects happen only with one setup, check whether the network switched while the screen was locked so you don't mistake a connection drop during a network change for a keepalive failure. If an app moves up the system's battery-use list, also check whether total foreground app use changed; a higher relative share alone doesn't prove increased power consumption.
Check Recovery After Switching Networks
After leaving your home Wi-Fi, the existing session may continue briefly or need to reconnect because the device's address has changed. What matters is whether the app task can resume: can a page reload, can a voice call recover, or does an upload have to start over? A setup that starts quickly but consistently fails to recover after a network switch may not suit commuting. Repeat the same action across two networks that both work normally. Avoid changing networks and switching protocols at the same time, as the interface may still be in the process of switching. Note whether recovery happens in the client or the app so you know which side to adjust.
Manually changing the keepalive interval also has trade-offs. Too frequent, and the device wakes more often; too infrequent, and an intermediate device may clear the idle session, making reconnection slower when you return. For everyday use, keep the existing client and subscription settings. If you consistently lose the connection after locking the screen, make one change at a time using the options supported by your client. System battery and background-app rules may also pause the app. Turning off every restriction can increase power use across other apps without showing which rule caused the original issue.
| Environment | What to Check | Common Misinterpretation |
|---|---|---|
| Android | Connection state and recovery after locking the screen | Background policies vary by system and device manufacturer |
| iOS | Whether app sessions recover after a network switch | The foreground display may not reflect tunnel status |
| Windows、macOS、Linux | Wake-ups and resource use during reconnects and sustained transfers | Process readings may not include system network processing |
Compare battery use for the same workload, not just a momentary reading
For foreground comparisons, define the actions and workload. For example, open the same set of pages at the same screen brightness, or transfer the same file over the same type of network. Check whether the task finishes, whether the device heats up, and whether retries make it take longer than expected. Short tests can be obscured by the system's battery-reporting granularity, while long tests with inconsistent conditions can magnify errors. It's more reliable to alternate comparisons during times similar to your normal use and base your decision on results that repeatedly point in the same direction. For the initial setup, follow the platform instructions in the Quick Start Guide. Don't mix power-use comparisons with your first import attempt.
Understanding Routes
Direct, Relayed, and Dedicated Routes
Map the Path from Device to Destination
Break the path into observable segments: device to access network, access network to proxy entry, entry through any relay or dedicated segment to the exit, then exit to destination. The region shown for a route in the client usually identifies its exit, not necessarily where the device first connects. The destination may also be in another region or served through a content delivery network. Two routes shown under the same region can still have different entry points, upstream networks, and paths to a specific site. Conversely, exits in neighboring regions aren't guaranteed to have similar round-trip times from your device.
Here, a direct route means the device connects to the remote proxy entry without a service-side relay. It doesn't mean “direct connection” in routing rules, which usually means the device accesses a destination over its original network without a proxy. If you mix up these two meanings during testing, a webpage opening successfully could lead you to think the selected route is working when it isn't. First confirm traffic flow using the same rules as your actual workload. If you use IP Lookup to check the exit, remember that it shows the exit for that lookup request, not necessarily for every app or domain. Verify routing with the client status and test destination together.
An Extra Relay Can Still Make the Route More Direct
With a relay, the device first connects to an entry point, then a relay segment carries traffic to the exit. The extra processing and queuing can add wait time. But if the entry is close to the user's access network and the onward interconnection is better, the overall path may still work better than a direct route across the public internet. Hop count alone doesn't tell you whether a route is good: traceroute hops may not include service-side forwarding, and they don't show actual propagation distance, detours, or congestion at busy interfaces. Compare consistent performance to the same destination over the same access network at different times to assess the difference.
IEPL is a type of international Ethernet private line. The route label describes how one segment is carried; it doesn't mean the entire path from device to destination is dedicated, or guarantee latency or speed. An international dedicated segment may offer a more controlled path, but the device-to-entry segment is still affected by local wireless and access networks, and the exit-to-destination segment still depends on interconnection and destination load. Even if the dedicated segment is working normally, a local backup can saturate the upload and cause delays. Identify which segment has the problem before deciding whether to try a different route type.
| Route Type | Path Characteristics | Check First |
|---|---|---|
| Direct | The device connects directly to the proxy entry | Check whether interconnection between the access network and entry is stable |
| Relay | Traffic passes through a relay before reaching the exit | Check whether detours and peak-time queues are reduced |
| IEPL Dedicated Line | The path includes a dedicated-line segment | Check for bottlenecks outside the dedicated segment |
Narrow Down Options with the Route List
When choosing candidates from the server route list, start by finding an exit region that suits your workload, then compare route types within that region. Each time you switch routes, make sure the client hasn't automatically selected a different region, then repeat the same action. If the exit is unchanged but results differ, record the entry, route label, and time of the issue. If only one exit fails for a particular service while other services work normally, investigate the path from that exit to the destination. Region labels help narrow things down, but can't replace end-to-end testing. In particular, an entry that worked before may not be suitable after a change in your local access network.
Peak-Time Troubleshooting
Packet Loss and Peak-Hour Congestion
Congestion Often Shows Up as Queuing First
When data arrives at an interface faster than it can be sent onward, the extra data waits in a buffer. While the queue isn't full, packets may not be lost, but round-trip times can rise and fluctuate. Once the buffer fills, some data is dropped. This can happen when home devices back up photos at the same time, an office network uploads heavily, or an access-network interconnection is busy. Peak hour is a clue, not a diagnosis: local wireless contention and remote service load may also increase at the same time. Compare performance under load and without load to find evidence.
With reliable transports such as TCP, lost data triggers recovery and congestion feedback may reduce the sending rate. Real-time media apps may discard outdated data to limit delay. As a result, a file transfer may continue with intermittent slowdowns, while a voice call may simply drop a few words. Bursts of packet loss from wireless interference may make the experience unstable even when the average looks normal. Note whether the issue is continuous or intermittent and whether it coincides with an upload. That's more useful for finding the affected part of the path than just writing “severe packet loss.”
Check the Local Network First, Then Separate Entry and Destination Issues
While the problem is happening, check whether ordinary tasks on the same network are also slow. See whether pausing background uploads, moving closer to the wireless access point, or switching to a wired connection helps. If changing the access method makes a clear difference, address the access network first. If local tasks are normal, compare the same destination through another entry or exit. If multiple destinations are slow across different routes, first investigate shared access or local load. If one destination is slow on the same route even after changing exits, the destination service or its public upstream is also a possible cause.
When checking round-trip time, distinguish idle measurements from measurements under load. Normal latency at idle that rises sharply during a transfer may indicate queuing along the path. High latency in both cases could mean the path is long or circuitous, or that another device is continuously using the network. Diagnostic probes and real app traffic may not follow the same handling rules. Some routers limit how often they respond to diagnostic packets, so a hop that doesn't reply doesn't mean it is dropping forwarded traffic. Unless the final destination also shows signs of trouble, don't blame the first nonresponsive hop in a trace.
Not Every Interruption Is Caused by Insufficient Bandwidth
If only large responses or sustained uploads stall while small requests succeed, check the maximum packet size the path can carry and the extra overhead added by encapsulation. If one segment can't carry some packets and the relevant feedback doesn't reach the sender, small packets may get through while large ones repeatedly stall. Similar symptoms can also come from the destination app or device, so don't change the MTU based on symptoms alone. First check whether the client offers a recommended setting for this mode, then test the same destination again. If the issue clears, record which change helped. If not, revert it to avoid accumulating unrelated changes.
If daytime and evening comparisons repeatedly show the same pattern, keep a backup route that's been tested during the evening for your common tasks. If the issue doesn't happen at a particular time, preserve details of the access network, app, and error type from when it occurred. Use a consistent observation window to record successes, slowdowns, and interruptions; don't count manually switching routes as an unexpected disconnect. To track successful connections and disconnections over time, see How to Compare Connection and Disconnection Rates. Make one reversible change at a time instead of switching every protocol at once.
A short probe working at idle doesn't rule out queuing during a transfer. A hop that doesn't respond to a probe doesn't mean app traffic can't reach its destination.
Selection Checklist
Choose Protocols and Routes by Task
Rule Out Unsuitable Options Based on Your Workload
Define the goal before choosing how to test. For everyday browsing and AI tools, first confirm the destination service's regional requirements, account status, and whether the exit is what you expect. Then check whether you can keep using the service after signing in. Loading the homepage doesn't prove that a long request won't be interrupted; test with the same kind of chat or document action you normally use. A webpage may also rely on multiple domains. If routing rules send some requests over different paths, results may differ from a full-device test. Before changing rules, note where the failure occurs. Don't move apps that already work reliably just to make the settings uniform.
For calls and remote interaction, focus more on upload performance and latency variation. Test during the times you normally work, using actions that reflect real workloads, such as speaking, sharing your screen, or dragging a remote window. See whether queuing adds to interaction delays. For streaming, first confirm that the service is available under the conditions of the selected exit, then check for repeated buffering or quality drops during playback. For long downloads or backups, focus on sustained throughput and recovery rather than letting a single short peak-speed test decide the whole setup. Different tasks need different evidence; there's no need to force a single ranking that applies to everything.
Keep a Primary Route and an Independent Backup
Your primary route should reliably complete tasks on your usual access network. A backup should address a specific problem you've encountered, such as an entry point that gets congested only in the evening or unreliable UDP sessions on a particular access network. Choosing two entries with different names on the same path may leave both vulnerable to the same issue. If possible, choose a different entry point or outer transport for the backup, then test it against the same destination. For tasks with regional requirements, make sure the backup meets the same exit conditions. Don't wait until something fails to verify it.
If you need to support both desktop and mobile devices, you don't have to put every device on the same route. A desktop on a fixed connection can prioritize long-running use, wake-up behavior, and throughput. A mobile device that frequently switches networks may need more attention to recovery time, locked-screen behavior, and repeated reconnects. Before comparing devices, confirm that their rules and exits match. Otherwise, an app going direct on one device and through a proxy on another may look like a performance difference when the paths are simply different. When reporting an issue, include the device, network, and task so the comparison starts from the same point.
Separate Configuration Choices from Billing Choices
A plan determines billing and data allocation; it doesn't explain a network issue. If your monthly usage is fairly consistent, compare monthly subscriptions on the Pricing page; data resets monthly from the activation date. If usage is concentrated in short-term projects with long periods of inactivity, compare data packages that last until used and never expire. Choose a billing option based on how often you use the service, then choose a route based on your working hours and access conditions. Even with data remaining, troubleshoot account status, client import, routing rules, and the route itself before treating a purchase or upgrade as a fix.
Finish with a short note: your primary setup on your usual access network, a backup suited to the same task, what should trigger a switch, and what to check next time. Use an observable condition such as “the call still doesn't recover after a network switch, but the backup works,” not “switch if it doesn't feel fast enough.” If performance is stable, keep the tested configuration. Repeat the relevant comparisons if you change networks, devices, or workloads. If you still can't identify the cause, use the Help Center to find the right section for connection, speed, or account issues. Describe the symptoms and tests you've already completed, but don't include subscription links or account credentials.