Technical Reference · Protocols and Routes

VPN Protocols and Network Routes: A Technical Guide

Setting things up for the first time? Start with the Guides to get your subscription, import it into a client, and verify the connection. This page is a reference for users who can already connect and want to work out whether to change protocols or routes—or troubleshoot their local network first. Start with the relevant section.

This article compares general protocol designs; it is not a list of protocols supported by the service. Available protocols and transport options are shown in the route configuration after you import it into your client.

Protocols and Routes: Identify Which Layer Is at Fault

Protocols define how data travels; routes determine where it goes

A protocol defines how the client and server authenticate, encapsulate requests, forward data, and handle errors. A route describes the entry point, transit path, and exit point that data passes through. For example, when the same device opens the same webpage, changing protocols may change the underlying transport—or only the outer encapsulation. Changing routes can alter the entry and exit points, and even the network path between your ISP and the server. Clients often combine these differences into a single selectable entry. If another entry loads the page faster, you can conclude that the combination works better—not that the protocol itself is faster.

A request also involves the application's own connection. Connecting to an entry point does not mean it has connected to the service you need; and even if that service accepts a connection, sign-in, downloads, or playback may still fail. Browsers may reuse existing sessions, while media players may fetch manifests, video segments, and authorization data from different addresses. Sometimes the homepage loads but the page stalls after sign-in because the login API uses another domain, requests take a different route, or the service has yet to respond. When troubleshooting, note which action fails rather than simply writing “the website won't open.”

Turn “slow” into a repeatable symptom

If the first visible response takes a long time after you click, check DNS resolution, handshakes, and application wait time first. If a page opens normally but ongoing transfers are slow, focus on throughput, packet loss, and exit capacity. If a connection stalls mid-task, check whether the network changed, the device locked, or the app went into the background. Another possibility: the request completes, but video calls are choppy. That points to inconsistent packet arrival times; average round-trip time won't tell the whole story. Real-time apps discard data that arrives too late, so a call can't recover even if the same data eventually gets through.

To establish a baseline, choose a repeatable task that doesn't involve personal information, such as opening the same public webpage or downloading the same public file and noting any frequent stalls. Record the device, connection type, route entry, time, and symptoms. When comparing first loads, log the initial visit separately from repeat visits so browser caching doesn't make the latter look faster. For sustained transfers, choose a time when the client has finished starting up and no background sync is running. There's no need to clear account data or change system security settings just to make a comparison. Using other apps during a speed test changes shared queues and makes the results harder to interpret.

Change one thing at a time, and keep a way back

If changing routes while keeping the protocol improves performance, investigate the path next. If changing transport improves performance with the same entry and exit, there is reason to look more closely at how the access network handles the original transport. If you can't control all the variables, record it as a “combination difference.” Account for timing, too: congestion may have cleared while you were changing settings. When possible, switch back to the original setup and repeat the same task. If it has recovered as well, describe the issue as temporary rather than crediting the change with fixing it.

A baseline has limits. A lightweight webpage tests basic connectivity, not whether long uploads or large transfers will be stable. Conversely, a slow download doesn't prove that small requests are unavailable. Use the baseline to locate the stage where the problem occurs, then confirm its impact with a real task. If an issue appears in only one type of app, use that as the next place to investigate: check whether the app actually uses the client and whether it has its own connection policy before changing system-wide settings.

Record what happened: “First load stalled; second worked” is easier to verify than “the route is unstable.” Before making changes, note a working route and its settings so you can restore them if a new problem appears.

Shadowsocks, VMess, Trojan, and VLESS

Shadowsocks: Consider the Encapsulation and Client Mode

Shadowsocks is a forwarding-focused encrypted proxy protocol. The client includes the destination address in encrypted data, and the server uses it to connect to the target. It can forward TCP, and there are also UDP forwarding options. Whether an app can actually hand UDP traffic to the client depends on how the system routes traffic and on the implementation. If a webpage opens through the proxy, that only confirms that the browser's relevant requests got through; a meeting app may still use a separate network path. In that case, check the traffic capture scope and client logs before considering another protocol. Don't assume that because a webpage works, all apps use the same tunnel.

Lightweight encapsulation reduces the number of protocol steps; it doesn't shorten geographic distances or prevent retransmissions on a local wireless network. If small webpages load smoothly but uploads frequently stall, first check whether other lightweight requests also slow down during the upload. If they do, queueing on the access network is more worth investigating than header size. If only a specific app fails, check whether proxy mode covers it and whether DNS resolution and data connections use the same route. Don't add plugins or change routing rules during a comparison, or you won't be able to tell whether the difference came from the protocol or from requests taking a different exit.

VMess and VLESS: Don't Attribute Outer-Layer Features to the Protocol Name

VMess handles authentication at the protocol layer and protects payloads according to the implementation and configuration. The outer layer can use different transports, so seeing the same protocol name doesn't mean two route entries have the same handshake or encapsulation overhead. If an authentication error appears immediately after import, first check whether the subscription has been refreshed and whether the client recognizes the server parameters. Also make sure the device clock is syncing normally. With configurations that validate time, clock drift can cause connection failures; changing locations won't fix it.

VLESS is a different proxy protocol. In common traditional configurations, the base protocol layer doesn't encrypt payloads; actual security depends on the version, implementation, and outer-layer protection used. Don't assume a protection method is enabled just because of the protocol name, or that leaner base encapsulation automatically uses less battery. Check that the client correctly recognizes all transport and security parameters supplied with the route. Don't disable certificate verification or remove or replace security settings to test a connection. Compare only configurations that can validate their security parameters correctly.

Trojan: Separate TLS Issues from Application Issues

Common Trojan configurations use TLS to protect communication between the client and proxy entry point. A connection can fail during the underlying connection setup, TLS verification, proxy authentication, or forwarding to the target. If you see a certificate or name mismatch, check the device's date and the server name used by the client first. Also make sure you're on a network that requires a sign-in before access. If the entry point connects successfully but only one target won't open, check its DNS resolution, routing rules, and application response. Changing protocols may also change the exit, so the result alone can't prove that TLS was faulty.

Data carried over a TLS tunnel has its own transport trade-offs. A common TCP outer layer requires ordered delivery: if earlier bytes are missing, later bytes that have arrived may have to wait for retransmission. If the client multiplexes several application requests over one outer connection, that wait can affect requests that aren't otherwise related. On a stable path with a mature implementation, however, multiplexing can avoid repeated connection setup. Whether multiplexing is enabled and how it works depend on the actual configuration; you can't determine that from the names Trojan, VMess, or VLESS alone.

Start with a baseline configuration that the client fully recognizes. When compatibility issues arise, use the stage shown in the client error to guide troubleshooting; don't infer the cause from whether a protocol name sounds newer or shorter.

Hysteria2 and TUIC: What QUIC Can—and Can't—Do

An outer UDP transport doesn't mean the data above it is unreliable

QUIC usually runs over UDP and provides secure handshakes, reliable streams, loss recovery, and congestion control within the protocol. UDP is just the transport: data on reliable streams is retransmitted as needed, and missing data can still delay ordered delivery within the same stream. Different streams don't have to wait for the same ordering gap as they would on a shared TCP byte stream, but they still share path capacity and connection congestion. With sustained packet loss, queueing, or insufficient exit capacity, switching to QUIC can't create capacity out of thin air.

Whether application data is forwarded as reliable streams or datagrams depends on the proxy protocol and client implementation. Datagrams suit content that has no value once it's out of date, but support for datagrams doesn't mean every app can use them. To compare call quality, listen to actual speech and check for brief dropouts. For file transfers, look for repeated stalls and whether the transfer completes. Focusing only on a speed test's momentary peak conflates different delivery requirements and can obscure application buffering and retries beyond the proxy.

Hysteria2: Throughput Goals and Shared Links

Hysteria2 is based on QUIC and designed for proxy forwarding. Some implementations let you configure a target bandwidth; congestion-control behavior varies by implementation and settings. The target bandwidth is an input to the sending policy, not a guaranteed link capacity or a route specification to copy blindly. Capacity on a shared home uplink or mobile network can change. An overly aggressive value may build up queues and make small requests slower during large uploads. Without a reliable capacity baseline, keep the known-working defaults, run the same task, and observe stalls and queueing before deciding whether a change is needed.

To investigate, pause photo syncing, backups, and uploads first. If calls recover when these are paused, but similar stalls occur on every route when they aren't, uplink congestion on the access network is a more plausible factor. If only one configuration keeps slowing down even on an idle network, look more closely at the server path, protocol implementation, and recovery behavior. Not all packet loss is random interference: loss from a full queue often calls for less sending pressure, so blindly increasing it works against the goal.

TUIC: Multiplexing and Network Switching Aren't a Substitute for Testing

TUIC also uses QUIC to carry proxy sessions. To assess multiplexing and forwarding behavior, consider how the client handles app traffic, UDP forwarding, and idle connections. QUIC connection IDs and migration mechanisms can let eligible connections attempt to continue after a path change, but that doesn't guarantee the proxy client, system, and app will preserve a session. The operating system may suspend background tasks, the entry point may require authentication again, or the app may reconnect on its own. Judge by whether the task actually resumes after a network switch, not by which protocol is selected in the interface.

If this kind of route consistently fails to connect on one network but works on another with the same device, keep the original configuration and compare the access conditions first. UDP handling, path MTU limits, and idle mapping behavior on shared networks can all differ. If small webpages load but larger transfers keep stalling, packet size is only one possible explanation; also rule out target-side throttling and local packet loss. For everyday use, keeping a client-supported TCP alternative in the same region is more reliable than changing a string of transport settings without logs.

When a UDP-based connection fails, first compare different access networks on the same device. When a connection works but performs poorly, compare idle and busy network conditions. These are different failure modes and can't be summed up with one performance claim.

Connection Setup, Throughput, and Resource Use

A slow cold start isn't necessarily a slow handshake

Between an app sending a request and content appearing, the process may involve DNS resolution, an underlying connection, session authentication, a proxy-to-target connection, and the target generating a response. Some of these steps can be reused once the outer session is established; restarting an app, switching routes, or waking from network sleep may require a new session. For small requests, these waits can be more noticeable than the transfer itself. For large files, a fast first response doesn't mean the rest will arrive reliably. To compare cold starts, use client logs that show the stages instead of relying on a single “connected” message.

Common TCP-over-TLS setups establish an underlying connection and complete a security handshake. QUIC combines the security handshake with transport setup, but perceived performance also depends on whether the path forwards data promptly, retries are needed, and the client can reuse a session. Session resumption isn't guaranteed to work every time. Early data is also subject to replay risks and application restrictions, so it isn't a general-purpose speed boost for every request. For actions that submit or change data, let the application and protocol implementation determine whether early data is appropriate. Don't submit a request repeatedly to test speed.

How to Interpret Performance Metrics
MetricWhat It Primarily ReflectsWhat It Doesn't Prove on Its Own
Cold-start waitThe cost of establishing a new session and receiving the first responseThat long transfers will necessarily be slower
Response over a warm connectionWait time for application requests after a connection is reusedThat the connection will survive a network switch
Sustained throughputHow well the path and endpoints deliver data during a long transferThat call audio will be uninterrupted
CPU and memoryLocal encapsulation, queueing, copying, and connection-state overheadAvailable capacity at the remote entry point or exit

Compare bottlenecks on the same timeline

Encryption, encapsulation, data copying, timers, and retransmissions all use CPU resources. Active connections and buffers also use memory. When checking load in a system monitor, look at the client and the app doing the work. During video playback, the browser's video decoder may be the resource hog; during file sync, it could be the disk or encryption of an archive. Overall CPU use can look low even if the thread handling proxy reads and writes is busy. Treat local overhead as a leading suspect only when transfers slow down, a specific process's load rises, and the symptom can be reproduced with another implementation.

Multiplexing involves trade-offs. It can spread connection setup costs across many small resources, but the more tasks a session carries, the more of them a single disconnection can affect. Large files and interactive requests may also compete for the same send queue; separate protocol streams aren't guaranteed independent bandwidth. To test this, first run small requests by themselves, then run them alongside a file transfer. If wait times increase noticeably during the parallel test, check local queues and the shared path rather than disabling multiplexing across the board.

When choosing a setup, distinguish momentary throughput from time to completion. A transfer that starts slowly but runs steadily may finish sooner than one that starts fast but keeps restarting. For ongoing tasks, note whether progress falls back, a manual retry is needed, and the task completes at all. When comparing clients, keep the target, file source, and network environment the same. If the app supports parallel downloads, keep that setting consistent too, or differences in concurrency may be mistaken for protocol efficiency.

First response, sustained transfer, and task completion are three different things to measure. Choose metrics that match the task to see whether you should optimize the handshake, reduce CPU overhead, or find a less congested route.

Mobile Battery Use, Keepalives, and Network Switching

Low data usage doesn't mean the radio stays asleep

Power use on mobile devices comes from application processing as well as wireless communication and system scheduling. Frequent small packets can repeatedly wake the device or keep the radio active after a transfer ends. Weak signal can amplify this cost through retries at lower layers and frequent reconnects. When comparing protocols, looking only at how much data was transferred misses keepalives, network probes, and reauthentication during idle periods. Shorter protocol encapsulation doesn't mean fewer radio wake-ups, and faster reconnects don't mean fewer reconnects.

One purpose of keepalives is to prevent address mappings and connection state along the path from expiring while idle. Very frequent keepalives can wake the device more often; very sparse ones may let a session drop after sitting idle. Clients may adjust their behavior automatically, and system background policies can change it too. If the symptom is “stable while the screen is on, but slow to resume after locking,” record what happens during recovery and check whether the system suspended the app or proxy before changing a generic keepalive interval you found online.

Separate platform traffic handling from protocol behavior

Observe connection behavior in each system environment
EnvironmentCheck firstHow to compare
AndroidApp traffic handling, background activity, and battery settingsCompare the same request with the screen on and after locking
iOSWhether the connection stays up and the app resumes its sessionAfter returning to the foreground, check both the client and app status
Windows / macOS / LinuxSystem proxy or network traffic handling; recovery from sleepUse the same app to compare before and after sleep, and before and after a network switch

These are troubleshooting starting points, not a ranking of operating systems. Android battery settings can vary by device, and iOS app recovery is not the same as connection recovery. Desktop systems can also see network interfaces change after sleep while an app keeps using an old session. If the client says it's back online but the app is still stuck on an old page, make a new, harmless request in the same app first. If it completes, the old request may no longer be able to continue; the current connection may be fine.

Use comparable tasks to assess battery impact

Split mobile testing into active use, idle standby, and network switching. During active use, keep screen settings and the task consistent. While idle, check whether the connection keeps dropping and reconnecting. When switching networks, note whether the app needs manual recovery. Don't directly compare a plugged-in desktop test with a mobile test away from home, and don't attribute changes caused by video quality, decoding, or sync tasks to the proxy. System battery statistics can help reveal trends, but short-term changes are easily affected by the screen and wireless signal.

For repeated disconnections in logs, first check whether they line up with device sleep, a network switch, or a weaker signal. If they happen only while idle on a shared Wi-Fi network and other networks work normally, an idle connection state may be expiring along the path. If the same device disconnects while locked on other networks too, check system or client background policies first. Before changing a policy, make sure you know whether it affects the proxy client, the app, or the whole device. Don't disable battery restrictions for every app just to keep a session alive.

For mobile work, keep an alternative route that you've already tested on a network you use regularly. Switch before an important call, not repeatedly during it. If most of your work involves reading and short messages, prioritize a setup that resumes reliably from standby. For sustained uploads, work where the signal is stable and watch for heat and background throttling. Rather than looking for one protocol that saves battery everywhere, compare your workflow, signal, and session recovery under the same conditions.

Route Comparison: Direct, Relayed, and IEPL Links

Identify the entry point, transit path, and exit first

The entry point is the first server endpoint your device connects to. The transit path is the segment in between, and the exit is the network location the service uses to reach the destination. A place name usually describes the exit; it doesn't necessarily tell you where the entry point is or which carriers your connection passes through on the way there. Before choosing, check the region and route type in the route list, then test it on your device. Latency depends on more than map distance: it also depends on the actual path, device processing, queueing, and the return route.

What Route Labels Mean and What to Verify
TypeTypical setupWhat to test in practice
DirectThe client connects directly to the service entry point, with no additional product-level relayConnectivity between the local network and the entry point
RelayedTraffic reaches a front-end entry point first, then travels over an intermediate linkEntry point reachability and performance when the downstream segment is busy
IEPL linkAn international Ethernet private line carries traffic between the relevant sitesAccess, exit, and server-side queueing outside the private-line segment

“Direct” doesn't mean there is only one network hop; it means the product topology has no additional front-end relay. With good peering, removing a forwarding layer can reduce extra delay. But a direct route may not be shorter if the public path takes a detour or peering links are congested at peak times. A relay can let your device connect to a more suitable entry point and take a different path to the exit, but it also adds another point where queueing or failures can occur. If direct and relayed entries share the same service exit and both slow down only for the same target, investigate the downstream exit and service as well.

IEPL describes a transport method between specific sites; it doesn't mean the entire path from your device to the destination uses a dedicated link. Your device still has to reach the entry point, traffic still has to connect to the service network beyond the exit, and the server still has to handle it. The private-line segment may deliver traffic differently from a public route, but a route label isn't an end-to-end performance guarantee. If an IEPL route and a relayed route to an exit in the same city perform similarly, the access segment or destination may be a shared bottleneck. Check from another access network before assuming the label is wrong.

Check both directions; don't draw conclusions from traceroute hop counts

Outbound and return traffic can take different networks, so slow uploads and normal downloads aren't contradictory. Local uploads may be using the uplink, the return path may be congested, or the target service may process uploads slowly. Some home networks prioritize downloads, making congestion show up only in the sending direction. Pause background tasks, then run the same type of upload or download separately. If only one service is slow, check its processing workflow and whether the app retries requests in parallel.

Path probes can reveal route changes, but intermediate devices may give probe responses a lower priority. A hop that doesn't reply doesn't mean application packets are being dropped there. Probes may also take a different path from the app, especially when a proxy is involved. Before interpreting a result, confirm whether the probe targets your local gateway, the proxy entry point, or the destination, then compare it with when the task succeeds or fails. If one hop doesn't respond but later hops do and the app works, don't assume there's a fault.

The same region doesn't mean the same route. Choose the exit region that suits the service, then compare entry points and transit paths in that region. For long-term use, record performance at your most common usage times rather than relying on a single result from an idle period.

Packet Loss, Jitter, and Peak-Time Congestion

Queueing often starts before an obvious disconnection

When more data enters a section of a link than it can currently send, the data waits in a queue. While there's room, packets may eventually arrive, but with longer delays. Once the queue is full, new data may be dropped. At peak times, shared access equipment, carrier interconnections, or exits can get busy as multiple users transfer data, and queueing changes with the requests in progress. Pages may load smoothly for a while, then stall. Slower performance at peak times is a useful troubleshooting clue, but the time of day alone can't tell you which network is congested.

Congestion doesn't always show up as a poor speed test. A link with large buffers may still deliver good throughput while small requests wait behind large transfers. You may notice delayed clicks, echoes, or choppy speech. Compare responsiveness when the network is idle with responsiveness during sustained uploads. If pausing a local upload restores performance on the same route, reduce competition for the uplink first. If the problem also occurs while idle, check whether it affects only one exit or access network.

Distinguish wireless errors, path congestion, and service-side delays

Wireless interference or an unstable signal can also cause packet loss. Access points often retry at the wireless link layer, so the main symptom seen by apps may be latency jitter rather than an outright error. Move the device to a location with a stronger signal, or compare using a wired connection if practical. If several local tasks all recover over wired Ethernet, troubleshoot the wireless network before reinstalling the client. If both wired and wireless connections are slow through the same broadband exit but another access network works, check the shared local exit and upstream path.

Server-side delays are another possibility. A destination may be generating content, queueing sign-in requests, or rate-limiting certain types of requests. If general public tasks work but a specific action fails even after changing routes, check the service status, browser errors, and app-specific limits first. Conversely, if several unrelated destinations slow down at once and the symptoms change with the entry or exit, investigate the route further. Don't repeatedly submit the same form or payment request to test speed; use a page that won't change service data.

Compare peak and off-peak conditions without creating congestion yourself

During a time when the issue usually occurs, test the same public task on the original route and an alternative. Then repeat off-peak. Before each test, make sure no other speed test or download is running. To see how the network behaves under load, add one controlled transfer separately and label that run as a busy-network comparison. This helps distinguish existing network load from load you introduce. When something fails, note whether DNS timed out, authentication failed, the first response was slow, or the transfer was interrupted; each points to a different troubleshooting path.

If client logs repeatedly show a failure at the same stage, troubleshoot that stage first: check DNS and request routing for resolution failures; check the active configuration and device clock for authentication failures; and check load and packet loss for intermittent stalls after connection. If there is no specific error, record the time, access type, route name, and steps to reproduce for future support. You don't need to share a full subscription URL or credentials to describe a problem. If submitting logs, first remove information that could identify your account, device, or browsing activity.

Same time, same task, and change one thing if possible. If several protocols all get worse on the same access network, investigate the shared access and path before comparing protocol details.

Choose Protocols and Routes by Use Case

Video Calls and Interactive Apps: Prioritize Consistency

Late-arriving data is hardest to recover from on a call. Before a meeting, choose a route already tested on a network you use regularly. Have a short conversation to check for choppy audio, and make sure screen sharing or sync uploads aren't saturating the uplink. Prefer a protocol the client fully supports and that connects reliably on that access network. If UDP works well, compare QUIC-based setups without changing the entry point at the same time. If UDP connections often fail to establish, keep an alternative that connects more reliably. Don't switch away from a working call route based only on higher throughput in a speed test.

If lag appears only when video or screen sharing is on, turn off the extra upload and test audio and sharing separately. This helps distinguish the meeting's added load from an existing connection problem. Make route choice a priority only if even a lightweight conversation stalls and other public tasks slow down at the same time. Before a meeting, also confirm that a backup network is available, but switching may require a new session. Avoid relying on a network switch as an instant fix during an important conversation.

Files and Streaming: Check Whether the Task Completes

For downloads and sync, look at sustained transfer and recovery. Use the same source, keep parallel settings consistent, and check for long stalls or whether a transfer has to start over. A tool with application-level resume can help with brief interruptions, provided both the destination and client support it; reconnecting the proxy can't replace file-level integrity checks. For streaming, distinguish startup delay, playback buffering, and content availability. Choosing the right exit region doesn't guarantee that a platform offers a title, and network quality can't change content licensing. For more on regional restrictions and route selection, see the guide to anime and streaming routes in Japan.

If you have a lot of files to transfer, try one representative task you can repeat during a typical usage period; there's no need to saturate the link repeatedly. If backups can be scheduled, avoid times when you're on local calls or other people at home are uploading. Before choosing a plan, visit the pricing page and estimate your data needs: monthly subscription data resets monthly on the activation date, while data packs never expire and remain available until used. Billing options help you plan data usage; assess network quality separately by entry point, exit, and task results.

Mobile Work and First-Time Setup: Keep a Recoverable Baseline

For mobile work, you need to keep working after reopening your laptop or switching networks. Test the same task on your regular Wi-Fi network and your regular mobile network; if possible, also record the first request after an idle period. A session expiring after a long pause doesn't necessarily mean the route has failed—the app may refresh authentication by design. What matters is whether you can continue after recovery and whether you need to intervene manually. If results differ between devices, check app traffic handling and client settings before assuming the same route is unstable on every device.

For first-time setup, follow the Guides to get your subscription, import it, and verify the connection. To follow the expected screens step by step, see the first-day setup guide. Keep a short baseline: routes tested on your regular networks, an alternative setup, and a task you can use to verify them. When a problem occurs, reproduce it with the baseline, change one thing, and test again. If the improvement isn't repeatable, restore the original setup. State your findings with the conditions—for example, “On my usual Wi-Fi, the alternative route has fewer upload stalls”—rather than ranking protocols for every place and task.

A useful choice should guide what you do next: when to change the entry point, keep the protocol, or pause local uploads first. Using your regular networks, real tasks, and ability to recover as evidence is more practical than chasing a one-size-fits-all fastest setup.