Technical Reference · Transport and Route Selection

VPN Protocols and Network Routes: A Technical Guide

Protocols determine how a connection is established; routes determine where traffic goes. Understand the difference first, then compare results against your actual needs.

For your first setup, start with the quick-start guide and follow the steps to import, connect, and verify. This page is for reference and comparison after you’re connected. Rather than repeat the setup process, it explains why the same route can behave differently across networks—and whether to try another route, switch protocols, or check the app itself.

Transport Layers and Comparison Criteria

Trace a request from the app to its destination

When a client shows that it’s connected, that usually means the local proxy or tunnel is active, or that a connectivity check has passed. It doesn’t mean every target app used that same check. A browser request may go through the system proxy or be routed through a virtual adapter; it enters the proxy tunnel only if a routing rule sends it there. The proxy entry point receives traffic from the tunnel, while the exit point connects to the destination. These points may be in different locations. A single entry in the client’s list compresses all these choices into one name, but that name doesn’t tell you the status of each network segment.

When something fails, first work out whether the app didn’t send its request to the client, the client couldn’t reach the entry point, or the exit point couldn’t reach the destination. The first case is common with apps that ignore the system proxy, or when a rule sends a request direct. In the second case, the client may report a connection timeout or handshake failure. In the third, only certain websites, resource domains, or app requests may fail. A webpage often loads its main content, images, login, and API from separate requests, so it’s entirely possible for the homepage to load while login fails. If different requests take different routes, they can produce different results.

Separate proxy protocols, transports, and routes

A proxy protocol defines how the client identifies itself to the server, specifies the destination, and sends data. The transport determines how proxy data travels across the network—for example, over TCP’s reliable, ordered byte stream or QUIC over UDP. Route topology describes how traffic moves among the entry point, relays, and exit point. These layers interact, but they aren’t interchangeable. Switching protocols doesn’t automatically change the routing between network operators; choosing another route doesn’t necessarily change the transport.

Understand encryption by segment, too. Protection for the proxy tunnel, an app’s own HTTPS connection, and the link from the exit point to the destination are separate things. Switching proxy modes doesn’t replace the app’s verification of a site’s certificate, nor does it magically make a connection initiated by the exit point end-to-end encrypted by the app. If you see a certificate warning, first determine whether the proxy entry’s certificate is misconfigured or the browser is warning about the destination site’s certificate. Don’t treat disabling certificate verification as a fix: the connection may appear to work, but you’ve removed the ability to verify the other party’s identity.

Break “fast” down into measurable events

A page may open quickly because its DNS result was cached or an existing connection was reused. Large downloads are more affected by exit capacity, source-server throttling, and sustained congestion. Interactive tasks depend on the wait and pauses between an input and its response, while background sync is more about completion time and resuming after a failure. Before testing, decide what you want to improve: initial connection setup, response during ongoing use, sustained transfer, or recovery after a network change. Different metrics can produce different answers without contradicting each other.

When recording results, describe what happened in a way you can reproduce. Instead of writing “this route is slow,” note whether the app stalled only when syncing began or whether it waits every time you reopen the client; whether all sites are affected or only a specific resource domain. For a retest, keep the device, app, destination, and network the same, and note whether the client has established a tunnel. If you’ve just opened the same page, mark the result as a warm connection or cache hit instead of comparing it directly with a first visit.

The test itself can also introduce errors. A route list’s probe result usually applies only to its configured probe target; it doesn’t mean every destination was tested. A destination site may also send different exits to different content delivery nodes. If a page loads faster after switching routes, note whether the app was redirected, whether resources were cached, and whether the file or video quality was the same. Recording these conditions is more useful than labeling a route simply fast or slow. For a primer on the differences between subscriptions, nodes, and routing rules, see the VPN glossary for beginners.

Shadowsocks, VMess, Trojan, and VLESS

Shadowsocks: Focus on the endpoints and implementation

Shadowsocks is an encrypted proxy protocol. It can forward TCP traffic and also supports UDP forwarding. UDP forwarding doesn’t automatically turn all proxy traffic into a transport with reliability, congestion control, and multiplexed streams. Support depends on the client, server, and local traffic-capture mode. If an existing route uses Shadowsocks, first check the encryption method specified by the subscription and whether your client supports it. Then determine whether you need an additional transport or plugin.

Without additional layers, the data path is relatively straightforward: the local client sends the destination details and app data to the proxy endpoint, which then connects to the destination. With a plugin or extra encapsulation, assess handshake time and resource use for the specific combination. Don’t assume two routes labeled Shadowsocks use the same cipher, encapsulation, or entry point. If an app connects but a feature that relies on datagrams doesn’t work, first check whether the client handles that feature, then whether the link or server supports forwarding. There’s no need to rule out all TCP apps on that basis.

VMess and VLESS: The protocol name isn’t the whole configuration

VMess includes authentication and data protection in its protocol design and can use different outer transports. For an existing configuration, compatibility often matters more than whether the name is newer. If the same subscription reports a handshake or authentication error as soon as it’s imported, check that the client recognizes the configuration and that the system clock is correct. Don’t change the ID, transport, and security settings all at once; even if the connection works afterward, you won’t know which change fixed it.

It’s more accurate to think of VLESS identity and request details at the proxy layer as separate from protection at the outer layer. Actual security depends on the implementation, configuration, and transport—not just the name shown in a list. Common deployments use an outer mechanism such as TLS. The client must interpret the transport parameters the way the server expects; renaming a protocol field on the same node won’t make the existing server accept a different kind of request. If your software offers similar options but not the combination required by the subscription, use a client that supports it or choose another route offered by the server.

With VMess and VLESS, additional encapsulation can also affect how a connection feels. WebSocket, for example, requires an upgrade handshake after the connection is established. Whether this adds wait time, an existing connection is reused, or the proxy process goes through a relay layer is more relevant than how long the protocol field is. Treat transport as a separate comparison column; the same protocol doesn’t have one inherent latency, throughput, or battery-use profile.

Trojan: Check TLS first, then destination access

Common Trojan deployments use TLS to protect the connection from the client to the proxy entry point, then handle authentication and proxy requests inside the tunnel. Connection setup includes the transport connection and TLS handshake; ongoing use involves encryption and decryption, connection reuse, and the traffic itself. Also, whether the client supports forwarding UDP requests and whether the outer transport uses UDP are two separate questions. Seeing “UDP” in the interface doesn’t mean the transport is QUIC.

If a Trojan route won’t connect, check where the error occurs: name resolution, connection setup, certificate verification, or authentication. If the domain resolves but TLS verification fails, check the system clock, configured server name, and whether the certificate matches; don’t immediately blame congestion. If the handshake and authentication succeed but a particular destination returns an error, investigate routing rules, the exit, and the destination service. If the client connects but drops shortly afterward, check whether this happens only after a long idle period to distinguish a configuration problem from an idle session being closed.

When choosing among these protocols, prioritize whether you can import, verify, and troubleshoot the configuration. A correctly recognized endpoint, clear client errors, and an alternative route if something goes wrong are more practical than a presumed performance ranking. This page lists technical options; it doesn’t mean every VPNRow route supports every combination. Check the user panel and client labels for the options actually available.

Hysteria2, TUIC, and QUIC

QUIC changes the transport

QUIC runs over UDP, but provides reliable streams, loss recovery, and congestion control through its own mechanisms, and combines the encrypted handshake with transport setup. UDP at the lower layer doesn’t mean lost data is never retransmitted: for reliably delivered streams, the protocol uses acknowledgments and loss information to schedule retransmissions. Whether application datagrams are reliable or ordered depends on the forwarding mode and how the application handles them; not all traffic has the same delivery semantics.

When multiple logical requests share one TCP byte stream, later bytes may not be delivered until an earlier missing segment arrives. QUIC handles ordering separately for each reliable stream, so a gap in one stream doesn’t have to block ready data in another. But streams share the connection’s congestion window and path capacity, and packet loss may cause the connection to reduce its sending rate. Under severe congestion, multiple requests can still slow down together. Multiple streams don’t eliminate congestion; they reduce the effect of one stream’s ordered-delivery requirements on others.

Hysteria2: Bandwidth settings affect real-world results

Hysteria2 uses QUIC-based transport and can proxy TCP and UDP app traffic. Deployments may use different congestion control behavior, and some settings specify a target sending rate. That target should reflect the actual path capacity; the advertised speed of your internet plan isn’t a substitute for the sustainable capacity from your device to the entry point. In particular, available download bandwidth doesn’t mean upload acknowledgments and requests will get through promptly if your connection is already busy uploading. An overly high target can increase queuing, retransmissions, and latency variation.

To see whether this setup suits long transfers, test repeatedly with the same source at similar times rather than relying on one brief speed peak. First stop background sync and note how interactive tasks feel without extra load. Then run your real workload while trying a lightweight task that needs a quick response. If the transfer is fast but interactive use becomes noticeably sluggish, the settings may not suit mixed workloads. If you don’t know whether the client uses a rate setting from the subscription, check its interface or documentation. Don’t guess the implementation’s default or raise the setting just to test the route’s capacity.

TUIC: Check forwarding behavior and network changes

TUIC also uses QUIC for forwarding and can organize multiple requests within one transport session. Check the client and server implementations to see which mode UDP forwarding uses and whether datagrams are supported; an option in one client won’t necessarily apply to every configuration. For real-time voice and similar workloads, consider how the app handles expired or lost data. The forwarding layer can’t improve the source encoding, receiver buffer, or destination service out of thin air.

QUIC can validate a new path and retain connection context when conditions allow, but keeping an app session alive on mobile also depends on both implementations, how the operating system handles background connections, and whether the new network is reachable. Switching from Wi-Fi to a cellular network doesn’t guarantee that existing activity will continue without interruption. Test with a task where you can see recovery: check whether requests are sent again, the app asks you to reconnect, or a paused task resumes. An unchanged status icon doesn’t prove the service continued uninterrupted.

If small requests work but large transfers stall, check the maximum packet size the path can carry. Extra encapsulation can reduce the available space, and different paths may support different packet sizes. If the issue happens only after switching access networks, compare the client diagnostics, how the same task performs on other transports, and the network equipment settings. Change one setting only if you know the implementation supports it and know its original value; restore it if there’s no improvement. Falling back to a stable TCP setup is often more practical than repeatedly guessing settings on an unfamiliar network.

Connection Setup and Resource Use

Compare cold and warm connections separately

A cold connection may involve resolving the entry point’s name, establishing the transport, completing any required encryption handshake and proxy authentication, and connecting from the proxy exit to the destination. When accessing an HTTPS page, the app also connects and completes a handshake with the destination. Clients may perform some steps in parallel or skip steps already completed, so don’t simply add every stage together using a fixed formula. If the entry point has low latency but the first request is slow, check whether the bottleneck is the entry handshake, exit-side DNS lookup, destination service, or the app itself.

A warm connection may use cached name resolution, reuse an existing tunnel, or resume a previous encrypted session between the client and server. Reusing a transport and resuming a session aren’t the same: the former can send new requests over an existing connection, while the latter often still requires a new transport connection, but with different handshake conditions. For a fair comparison, use the same setup steps: record the first visit after starting the client, then make the same kind of request with the connection already established. Don’t treat a test with local caches cleared as comparable to one with connections and caches retained.

What to observe in common setups—not a speed ranking
SetupDuring connection setupDuring ongoing use
Shadowsocks over TCPConnection setup and proxy request handlingEncryption and decryption; socket count
Additional VMess or VLESS encapsulationCheck the outer connection, handshake, or upgradeEncapsulation, buffering, and reuse state
Common Trojan deployment with TLSConnection, handshake, and certificate verificationTLS record processing and session maintenance
Hysteria2 or TUIC over QUICTransport and encryption handshake setupMultiplexing, acknowledgments, recovery, and congestion control

The workload changes the resource demands

For short requests, connection setup and fixed app-request overhead are more noticeable. For sustained transfers, encryption and decryption throughput, buffers, packet processing, and process scheduling matter more. Frequent concurrency can increase socket or stream state, and the client may retain more buffers while waiting for slower peers. Reuse can reduce repeated handshakes, but long-lived connections may hold queued state, and reconnecting can affect several tasks at once. More concurrency isn’t always better: check whether background transfers slow down your short, interactive tasks.

The outer transport’s implementation also affects what the system reports. Some QUIC implementations do more processing in user space; others can use system-level batching. TCP typically uses the system network stack, though the application layer still handles encapsulation, encryption, or routing. None of this proves that one protocol type always uses less CPU. Check whether the device supports the relevant acceleration, whether the software uses it effectively, and how much work was completed over the same period. Looking only at proxy-process usage may miss work handled by the network stack, destination app, and other system components.

Use the same workload to check for device-side bottlenecks

On desktop, use the system resource monitor to observe the proxy process, app processes, and network activity. First check for periodic wakeups while idle, then run the same kind of transfer from the same source. If the connection isn’t at capacity but one process remains busy, consider a device or implementation bottleneck. If the process isn’t under much pressure but stalls occur only under load, investigate the route and destination service instead. Resource graphs offer clues; a single usage spike can’t reveal the encryption algorithm or route quality.

When a connection fails, don’t focus only on the final error message. A “timeout” could mean slow name resolution, no response from the entry point, a stalled certificate check, or that the proxy accepted the request but received no reply from the destination. If the client log shows stages, classify the failure by stage before testing one variable at a time. When asking for remote help, describe the error category, conditions, and whether it’s reproducible. Don’t share account details or your full subscription link.

Mobile Battery Use and Recovery

Separate active transfer from idle drain

Mobile battery use isn’t determined by encryption speed alone. During active transfers, the screen, decoding, wireless activity, and proxy processing all use power. While idle, periodic probes, keepalives, background sync, and retries can still wake the device. Before comparing protocols, work out whether the battery drops noticeably during playback or drains more after the screen has been off for a while. For the first case, compare the same playback task and quality. For the second, check idle connection settings and background activity.

Moving a wireless connection from a low-power state to active use has an overhead. A stream of tiny requests at short intervals can keep the radio from returning to low power. By contrast, keeping a tunnel open and reusing it during ongoing activity may reduce repeated handshakes. Both overly frequent keepalives and repeated connection failures can drain the battery. Whether to adjust them depends on how long an idle session actually lasts, whether the app needs to stay online in the background, and what the client lets you configure. Without those details, there’s no keepalive interval that suits every network and protocol.

Compare recovery across devices and networks
EnvironmentWhat to check firstAvoid this misdiagnosis
AndroidBackground and battery policies after the screen turns offWorking in the foreground doesn’t mean it will keep running in the background
iOSTunnel status and whether activity resumes after a network changeAn unchanged icon doesn’t mean the old session continued
Cellular networkSignal strength, network handoff, and retry timingDon’t blame battery drain on the protocol alone when the signal is weak
Wi-FiAccess point roaming, signal, and idle connection cleanupThe same network name doesn’t guarantee the same path

Test background disconnects separately from network handoff failures

Start with an idle test on a stable access network. Connect, complete a lightweight task, turn off the screen without changing networks, then wake the device and repeat the same task. Note whether the client stayed available, resumed as soon as the device woke, or required a manual connection. If it fails only with the screen off, first check whether the system restricts background activity for the proxy client or target app. The app itself may also be paused; notifications and sync can be delayed even if the proxy tunnel is still active. Don’t leave the device’s overall battery-saving settings disabled just to test.

Next, test an access-network change separately. Keep a task running that can be interrupted and restarted, switch from Wi-Fi to a cellular network, and note when the task works again. If all apps stall, first check whether the route is reachable on the new network. If only an existing live session drops while new requests work, the app may simply be unable to continue using its original session. A network change can also alter the local address and mappings. Even when the transport supports migration, the state of the connection from the exit to the destination and the app’s reconnection logic still affect the outcome.

Reduce unnecessary wakeups

Adjusting routing rules and probes is often more useful than switching protocols repeatedly. Send only apps that actually need a proxy through the tunnel, and reduce unrelated sync. Check whether background route probes are enabled; avoid checking too often if that won’t interfere with detecting failures. If a route is unstable, see whether automatic selection keeps switching back and forth or immediately retries after a failure. Rapid, continuous reconnects can drain the battery and obscure the original error. During troubleshooting, you can temporarily pin a known-working route.

For a fair comparison, use the same device, similar signal strength, the same screen state, and similar app activity. System battery pages don’t attribute usage to processes consistently, and short-term readings can be affected by background tasks. A better approach is to repeat a typical usage scenario, check whether the results are consistent, and note any interruptions and recovery. If one setup seems slightly more efficient but requires manual fixes after a network change you make regularly, factor in that effort when choosing.

Direct, Relayed, and Dedicated Routes

Topology describes the path, not a speed tier

A direct route generally means the device reaches the proxy entry point over the public internet without an additional service relay. Public networks still use carrier routers and interconnection points, so “direct” doesn’t mean a single physical hop. The topology is easier to understand and avoids an extra service relay; when the path is suitable, that can help. But poor interconnection between your local carrier and the destination region can still cause detours, queuing, or route changes.

Relaying separates access from egress: the device connects to a relay entry point first, then traffic continues to the exit over another link. This adds a service hop but may replace a poor public interconnection with a better path. To see whether it helps, assess the device-to-entry and relay-to-exit segments separately. A fast local entry doesn’t guarantee spare capacity across regions at busy times. Conversely, a different region shown for the entry and egress doesn’t necessarily mean a worse experience. For interactive tasks, a predictable route matters more than the straight-line distance on a map.

An IEPL dedicated line means a particular link segment uses dedicated transport—not that every segment from your device to any destination service is exclusive. A dedicated segment may reduce reliance on some public interconnections, but access, data center equipment, egress interconnection, and the destination service can still be bottlenecks. The line type also can’t guarantee that an app will always be available in a particular region. Before choosing a route, treat its type as a label that helps explain the network topology. Check the client and the actual destination to confirm service availability.

Read route labels in terms of access, transport, and egress
TypeRoute characteristicsCheck first
DirectThe device reaches the proxy endpoint over the public internetLocal carrier interconnection and busy-hour routing
RelayedTraffic passes through a relay entry point to a downstream exitEntry-point quality and sustained performance across the relay segment
IEPL dedicated lineDedicated transport on the relevant segmentAccess tail and connection quality from the exit to the destination

Verify the entry and exit separately

The entry point is the other end of the client’s tunnel; the exit is the source address seen by the destination service. To check whether the selected egress region is in use, try the site’s egress IP lookup. Keep in mind that different apps may use different routes because of routing rules. A browser lookup shows the exit for that request only; it doesn’t prove another app or request took the same route. Geolocation databases can also lag behind, so a single lookup can’t establish a data center’s location, much less the full network path.

If the client offers both an entry-point probe and a service connectivity check, keep the results separate. If both fail, focus on the path from your network to the entry. If the probe succeeds but two independent destinations both fail, focus on the shared link beyond the proxy transport. If one destination works consistently while another always fails, consider the route from the exit to that destination or the destination service itself. Don’t treat the entry-point probe score as a ranking of app performance.

Check whether backup routes actually use different topologies. Several entries in the same region may share an entry point, relay, or exit resources, so congestion at a shared segment can affect all of them. Instead of saving routes with similar names, prepare a tested alternative with a different access path or transport. If a task needs a specific exit, consider whether its session will tolerate a change in source before switching. If the entry is stable during a long task, there’s no need to switch just because a probe value fluctuates briefly.

Packet Loss, Queuing, and Peak Hours

Slowness often starts with queuing

When packets arrive faster than a network segment can send them, data first builds up in a buffer. Even without obvious packet loss, interactive use may slow down because short requests wait behind a backlog. If the buffer stays full, the device may start dropping or marking packets. Congestion control responds by reducing the sending rate while the path recovers. The impact depends on the workload: a file may still download at a reasonable rate even as page clicks and voice responses become sluggish.

Queuing isn’t limited to the remote route. Backups uploading from other devices at home, an access point serving several devices, or system sync can all saturate the local uplink. When upload traffic is busy, acknowledgments for downloads can also be delayed, making downloads seem slow at the same time. First compare a quiet network with your normal load. If stopping sync immediately restores responsiveness, don’t blame international interconnection first. If the local comparison is fine and the same route repeatedly degrades at your usual busy time, then it makes sense to compare another topology.

Distinguish occasional loss from bursts of disruption

Occasional packet loss may come from wireless interference, a full queue, or a brief route change. Bursts of loss are more likely to interrupt live conversations, trigger app timeouts, or leave a player short of buffered content. Apps can respond differently to the same average loss rate depending on whether the loss is concentrated in a short burst or spread evenly over a longer period. When troubleshooting, note when the connection stalled, how long the impact lasted, and whether it recovered on its own—not just the average loss rate.

Reliable streams over TCP and QUIC both try to recover lost data, but recovery can’t recreate a lossless path. Retransmissions take time, and delayed acknowledgments can slow down loss detection. For some real-time tasks, data that arrives late is no longer useful, so an app may skip it rather than wait indefinitely. Avoiding delivery blocking between streams doesn’t prevent queuing on a shared link. For interactive work, keeping responses timely is often more important than maximizing background throughput.

Narrow down the fault by what’s shared

During busy hours, start with a local check: keep the route the same, stop programs using a lot of upload bandwidth, and see whether ordinary browsing and your actual task both recover. If the device supports a more stable type of access, first check whether wireless access is the bottleneck on the same network. Then keep the device and task unchanged and switch just one comparable route. If all routes are slow, try another destination service to see whether the slowdown is specific to the same source. Narrowing down shared components step by step is easier to interpret than changing the network, app, and protocol all at once.

Network probes can help identify route changes, but a middle device not replying to a probe doesn’t mean it isn’t forwarding normal traffic. If a probe reports loss at one point while the destination responds consistently, a common explanation is rate-limited probe replies; you can’t conclude that the device is dropping all traffic. Base diagnosis on destination reachability, continuity during the actual task, and client errors, using probe data as supporting evidence. If the destination and entry point have different reachability, record those as separate findings.

If the issue appears only when traffic is under load, change your selection criteria to whether the setup supports interactive use alongside transfers. Try limiting background uploads first, then check the client’s bandwidth settings, and finally consider a relayed or dedicated-route setup. One improvement doesn’t prove you found the congestion point; retest under the same conditions. If you need to submit diagnostics, specify whether the issue is a failed cold start, a slowdown during sustained transfer, or interaction stalling under load, and include the comparison results. Don’t share a real subscription URL.

Choose Protocols and Routes by Use Case

Prioritize responsiveness and session continuity for interactive tasks

Web forms, remote work, and online collaboration depend on getting a timely response after an action. Don’t test only by opening a cached homepage; try the kind of action you use at work that submits or retrieves new content. Check the result, what happens when you make another request shortly afterward, and whether occasional errors recover. If every route opens the homepage but one setup causes fewer stalls across repeated short requests, keep that setup rather than switching based on a single download speed.

For AI tools, opening a chat and receiving a continuous response are two different stages. If the connection drops only during generation, check for a broken long-lived connection, app reauthentication, a change in egress, or an error from the service itself. A short request isn’t a substitute for testing continuous output. When choosing a route, also consider the destination service’s region, account, and terms of use. A protocol only handles transport; it doesn’t change the service’s access requirements. See the AI Tools page for common access scenarios, then use the layered approach here to troubleshoot.

For continuous playback and sync, check sustained delivery

For video, check whether quality stays stable, buffering catches up, and playback recovers after seeking. A quick start may only mean the first segment arrived; it doesn’t prove the whole video will play smoothly. If automatic quality keeps changing, first keep the device, source, and quality settings consistent, then compare different routes in the same region. If changing exits also changes the content delivery node, record the results for the full setup—you can’t attribute the improvement entirely to the protocol. For more on bit rate, bandwidth, and high-quality playback, read the streaming quality and route selection guide.

For file sync, measure whether the job completes. Choose a file from a known source that can be retried and tolerate interruptions, then check whether it completes reliably and resumes where it left off after a drop. A setup that’s slower mid-transfer but finishes smoothly may be a better fit than one with a higher peak rate that repeatedly restarts. Many small files and one large file create different demands: small files may be limited by request round trips and app scheduling, while large files are better for exposing limits in sustained throughput. Choose a test that reflects your workload rather than relying on a single standard download.

Find a compatible setup first, then choose a primary and backup route

In the first round, limit your options to configurations the client can parse correctly and routes that fit your destination region. Establish a baseline using an existing TCP transport, and record cold-start, normal-use, and reconnection behavior. If UDP is available to the configured endpoint on your access network, and the client and server support the relevant setup, compare Hysteria2 or TUIC as well. If you can only switch entire routes, compare each route as a complete setup. There’s no need to force every protocol option with an incompatible configuration; that would confuse deployment differences with performance differences.

In the second round, repeat the core tasks at the times you normally connect. Your primary setup should be the one that behaves more predictably then, not just the fastest when the network is quiet. Your backup should work when the primary route degrades; consider one with a different entry point or transport. For tasks with a high switching cost, pause and save your progress before testing recovery. If you often switch networks on mobile, include screen-off recovery and new requests after a network change in this round of comparisons.

Finally, note the conditions where your results apply and when to stop troubleshooting. For example: short requests are stable on a specific access network, long tasks finish reliably, and an occasional error with the same destination should prompt a service-status check rather than an immediate route change. Conversely, if repeated tests show the entry point is failing, record when it happened, the access type, and the error stage, then visit the Support Center for relevant help. Protocols and routes determine how traffic is carried; billing and data allocation are separate. Check monthly subscriptions and data packages on the Plans page based on your usage—don’t infer plan benefits from a protocol name.

When your device, app, or usual network changes, keep your earlier results as a reference but retest the parts most likely to be affected. The goal isn’t to rank every protocol once and for all, but to know which route suits your current task under which conditions—and which part to check first next time something goes wrong.