Technical Reference · Connection Options
Technical Reference: Protocols and Routes
For help installing a client, importing a subscription, or checking connectivity, start with the quick-start steps in Guides. This page is for when you’re already connected: why the same protocol can behave differently on different routes, how to tell a slow handshake from slow data transfer or a sluggish app, and what to try first when traveling, joining a meeting, or transferring large files.
Fundamentals · How connections work
How cross-border connections work
When choosing a setup, consider the protocol, route, and app separately. The protocol defines how the client and entry point authenticate, encapsulate, and exchange data. The route determines which networks carry the data, where it is handed off, and which egress point reaches the destination. The app also handles DNS resolution, sign-in, and its own response logic. A connected status in the client only means the connection has reached a working stage; it doesn’t guarantee every app is using that path, or that the remote service has returned usable content.
From your device to the remote service
A request usually starts when an app looks up a domain or checks its cache. The system proxy or virtual network interface then sends matching traffic to the client. The client connects to an entry point over an outer transport; that entry point forwards traffic along the route to the next node, and the exit connects to the destination service. The app sees the result of the entire path, while a node’s probe value in the client reflects only the endpoint and method actually tested. A successful probe and a slow-loading page aren’t contradictory: they measure different things.
How the client handles traffic can also affect the result. A system proxy mainly affects apps that honor the system settings. A virtual network interface can capture more traffic, but routing and exclusion rules still apply. If a browser loads pages but a meeting app can’t join, first check whether the meeting traffic is going through the client. If the app isn’t covered, changing protocols won’t change its route. Conversely, if a problem appears only after changing traffic handling, don’t compare the results as if nothing else changed.
Make “fast” and “slow” measurable
Time to first response measures how long it takes to get useful content after an action, including DNS lookup, connection setup, and server processing. Throughput measures how much data a connection delivers over a sustained transfer. Jitter describes how much latency varies, which matters for voice, video, and input responsiveness. Packet loss means some data doesn’t arrive as expected, but the app may not show an error: reliable transports can retransmit it, leaving only a brief pause. Before choosing a metric, identify the kind of delay that’s affecting your task.
For example, a page title may appear quickly while a download barely moves; the connection setup may not be the problem. Or a progress bar may advance smoothly while every remote desktop click feels delayed—in that case, average throughput isn’t the key metric. When testing a website, distinguish a static homepage from requests made after signing in. For large files, separate a slow start from repeated slowdowns mid-transfer. Don’t treat results from different sites, files, or cache states as directly comparable.
Narrow down the problem
First, reproduce the issue on the same device and in the same app. Note whether it occurs during DNS resolution, the handshake, sign-in, or data transfer. Then cross-check with a similar task. If sign-in fails only on one website, start with its error message and account status. If browsing, downloads, and work apps all fluctuate at the same time, investigate the local connection and shared parts of the route. The goal of initial troubleshooting isn’t to rank protocols; it’s to narrow the issue to something your next test can verify.
Encryption has layers, too. Protection between the client and entry point is separate from HTTPS between the app and destination service. The former doesn’t verify a website’s identity, and the latter doesn’t prove that all device traffic is going through the client. When opening an account page, entering a password, or downloading a file, check the domain and certificate warnings. For tips on protecting passwords and subscription links, see the VPN security guide for beginners. Don’t paste a subscription link into a public speed test or include one in a troubleshooting screenshot.
Protocols · Encapsulation and compatibility
Shadowsocks and VMess
Shadowsocks mainly provides encrypted proxy encapsulation, with a relatively direct exchange between client and server. VMess defines its own authentication, request headers, and data encapsulation at the protocol layer, and deployments can use different outer transports. Both are designed to forward traffic—not to determine which upstream route is available in a given region. A protocol name tells you what capabilities to check; it doesn’t tell you the route’s latency or whether a particular website will work.
Shadowsocks: Check the encryption method
With common modern AEAD configurations, authenticated encryption lets the receiving end check that data hasn’t been tampered with when it decrypts it. A client that supports Shadowsocks may not support the specific method used by the server, or the same extensions. If importing succeeds but the first request always fails, check that the client implementation and method match, and that the destination is still valid. Don’t guess at settings just to make an old client accept them or downgrade to an unsuitable legacy method. Use a subscription entry that the client explicitly supports.
Shadowsocks TCP forwarding is generally suitable for everyday browsing and sustained file transfers. Some implementations can also forward UDP, but the client, entry point, and traffic-handling mode all need to support it. Loading a webpage only confirms that the relevant web traffic works; it doesn’t verify meetings or other real-time services. If a UDP-based app fails, first check whether its traffic is going through the client, then whether the entry supports UDP, and only then investigate the local network or remote service.
VMess: Separate protocol errors from transport errors
VMess authentication depends on time, so an incorrect system clock can cause authentication to fail even when the subscription was imported unchanged. Sync the device clock and try again before reconfiguring credentials. Different outer transports can also have different connection requirements. For example, a configuration that relies on TLS must pass certificate verification; one using WebSocket also needs the outer HTTP upgrade to succeed. If the client reports an outer handshake failure, VMess user authentication may not have started yet.
Read logs in the order failures occur. If a domain won’t resolve, check the entry-point domain and current DNS environment. If the connection times out, check whether the entry-point port is reachable on this network. If the outer response is unexpected, confirm that the client supports the transport specified in the subscription. Narrow the investigation to the clock, identity details, or protocol settings only after the connection reaches authentication. A generic connection-failed message isn’t enough; use the log’s error category instead of repeatedly importing the same entry.
When to try a simpler setup first
In a wired office environment, if your main tasks are browsing documents and transferring files, an entry with consistent settings and no extra outer transport can be a useful baseline. If your existing VMess entry works reliably, there’s no need to switch just to chase a theoretical, marginal difference in encapsulation. For long-lived connections, route congestion, server processing, and client implementation are usually more worth checking than protocol-header differences. You can compare encapsulation changes for startup or sustained transfers only when the route and task remain similar.
When switching devices temporarily, first confirm that a compatible client and entry are available for the operating system. Platform support doesn’t mean every client on that platform supports the same combinations. Keep a known-working entry on the original device. On the new device, import an entry and test a short task, then a sustained transfer, and finally recovery after sleep. If only the new device fails, check traffic permissions and client capabilities. If the old device also fails on the current network, compare entry-point reachability and routes. This avoids changing devices, protocols, and exit points all at once and losing track of the cause.
Protocols · Authentication and encryption boundaries
Trojan and VLESS
Trojan typically authenticates the proxy and carries requests inside a TLS connection. VLESS focuses on straightforward identity handling and proxy encapsulation. The VLESS name alone doesn’t mean the connection is encrypted; check the outer security settings in the configuration. Both types of entry may show the client connecting to a domain, but certificate validation, outer transport, and proxy authentication each have distinct roles and should be checked separately.
Trojan: Certificate validation and proxy authentication
In a typical Trojan deployment, the client establishes an outer connection and validates the TLS peer before checking proxy credentials inside the encrypted tunnel. A certificate name mismatch means the server identity the client expects differs from the identity presented—not necessarily that the credentials are wrong. Check that the server name was imported correctly and the device clock is accurate; then check whether the current network requires completing a captive portal first. Don’t disable certificate validation just to get one successful connection; that removes an important check on the entry point’s identity.
The server name also doesn’t have to match the route name shown in the interface. A route name is a user-facing label, not an identity check; the entry specifies the domain and outer settings used for verification. Keep this in mind when changing regions, replacing a domain with an IP address, or restoring an entry from an old favorite. If the same entry shows a certificate error on just one network, test it on a known-working network and note the error type. Don’t add the certificate returned by that network to your trust list.
VLESS: Check compatibility across the full configuration
When reviewing a VLESS entry, check the identity, outer security, transport, and client support separately. Common entries may be protected by TLS or another mechanism, and the client must also support the corresponding transport and other parameters. A client recognizing VLESS and displaying an entry doesn’t mean it can run the full configuration. If importing clearly reports an unsupported field or transport, use a supported entry or client rather than deleting unfamiliar fields until the error disappears.
If authentication succeeds but access still fails, don’t keep focusing on proxy authentication. Check whether the app’s traffic is being handled by the client, which side resolves the destination domain, and whether the resource requires you to sign in again. If the error occurs on just one website, first test the connection with a webpage that works, then check the website’s app-level status. If all new requests stall, use the logs to distinguish an unfinished proxy stream from a connection that was established but received no response from the destination.
Comparing page loads with long-lived connections
When outer connections are reused, multiple webpage requests may not repeat a full handshake, so results from refreshing a page repeatedly don’t show cold-start speed. By contrast, the first app you open after waking from sleep may need to resolve a domain and establish a connection again; the system may also have reclaimed an existing session. When comparing two entries, measure both the time from a fully disconnected state to the first successful request and performance after connecting. Mixing results from different conditions can make connection reuse look like a protocol advantage.
If webpages perform similarly but long-lived connections don’t, check the idle timeout for the outer transport on the current network and whether the app retries automatically. For example, after sitting idle in the background, an old channel may have expired even though the app still shows its previous state. First see if a new request recovers, then measure how long reconnection takes. Don’t assume repeated authentication failures. Choose a combination that makes errors understandable and recovers reliably on everyday networks, rather than judging only by initial connection speed.
Protocols · UDP transport and flow control
Hysteria2 and TUIC
Hysteria2 and TUIC are both built on QUIC and send data over UDP at the outer layer. Here, UDP is the transport; it doesn’t mean all forwarded data becomes unreliable. QUIC can carry multiple independent reliable streams within one connection, as well as datagrams that don’t require QUIC retransmission. When evaluating a protocol, distinguish how the outer layer sends packets from how a particular type of app traffic is delivered through the proxy.
What QUIC solves—and what it doesn’t
When multiple logical streams share a connection, a stream waiting for missing data usually doesn’t stop other streams from reading data they’ve already received. This can reduce head-of-line blocking between streams, but it doesn’t eliminate all delays: streams still share path capacity, and packet loss can cause the entire connection to reduce its sending rate. QUIC-based entries can still be slow if the local Wi-Fi is unstable or a queue before the entry point keeps growing. Distinguishing cross-stream blocking from shared congestion helps explain why switching protocols may improve only part of the experience.
QUIC combines encryption and transport handshakes, which can reduce the wait before data transfer begins. Whether session resumption is available depends on the implementation, server policy, and whether the session state is still valid. Connection migration during a network change also has requirements: the endpoints and client must support and allow it, the new path must be reachable, and the system must not have ended the process. If the client establishes a new connection after a switch, that doesn’t mean the standard lacks migration; it means the existing session wasn’t preserved this time.
Hysteria2: Sending rates depend on the actual route
Hysteria2 supports congestion control based on bandwidth parameters, as well as adjustment by a controller using feedback from the path. An entered bandwidth estimate isn’t a measured link speed, nor is it a rate the remote end can guarantee. Available bandwidth varies with the connection and time of day, especially on shared uplinks and mobile networks. If the sender persistently exceeds the bottleneck’s capacity, queueing and packet loss can both increase. A download may appear to continue while voice and page interactions become unresponsive.
If the client exposes adjustable bandwidth settings, first check whether they apply to upload or download and what units to use. Keep the original values as a baseline. Don’t enter the advertised speed of your internet plan as if upload and download capacity were symmetrical. After adjusting, use the same device, route, and type of task, then see whether responses are more consistent. If downloads get faster briefly but calls break up more often, that isn’t an improvement for mixed workloads.
TUIC: Test streams and datagrams separately
TUIC also uses QUIC to carry proxy connections. Before choosing it, confirm that the client is compatible with the protocol variant used by the server, then check that both TCP and UDP forwarding work where needed. A successful webpage only tests the part of the route used by that webpage; verify meetings and games with their own connectivity checks. Implementations differ in their support for datagrams and encapsulation, so seeing TUIC in a client’s feature list doesn’t guarantee the same results for every app.
If a TCP entry connects at a given location but two QUIC entries both time out during the handshake, cross-check on another trusted network and keep the TCP entry as a backup. If only one QUIC entry fails, compare the client implementation, entry point, and authentication settings before concluding that the network doesn’t support UDP. If small requests succeed but sustained transfers repeatedly stall, note what changes when the network or load changes, then investigate packet-size limits or queueing along the path. Don’t attribute every failure to the protocol name.
Devices · Handshakes, resources, and battery use
Connection setup and device overhead
Total connection setup time depends on DNS resolution, round trips along the route, transport negotiation, encryption checks, and proxy authentication. Saving one round trip doesn’t guarantee faster performance in a real task: the distance to the entry point, connection reuse, and whether the app needs you to sign in again can outweigh theoretical differences. For frequent short browsing sessions, pay attention to cold starts and the first useful response. For long uploads, check for sustained retransmissions or fluctuating send rates caused by the device struggling to keep up.
Test cold starts, warm connections, and recovery separately
A cold-start test should begin with no reusable client connection. Open a comparable page and note when the content you need first appears. A warm-connection test sends a new request over an established channel and reflects the everyday experience of connection reuse. For a recovery test, lock the screen normally or switch networks, then make a request that contains no sensitive information. Check whether the old connection still works and how quickly the client recovers on its own. Don’t mistake cached page content for a response from the remote server, or blame the protocol for extra load just after startup.
On the same device, processing overhead can come from encryption and decryption, copying data between user space and the system, packet scheduling, and retransmissions. Encryption efficiency depends on processor instructions and implementation; user-space QUIC costs also vary with workload, implementation, and hardware. Similar performance under light load doesn’t mean the two are equal at full load. A busy processor at full load doesn’t mean the device uses the same power while idle in the background. Compare system processes and proxy activity rather than inferring a fixed resource ranking from protocol design.
What to check on mobile devices
| Device environment | What to check first | Common sources of interference |
|---|---|---|
| Windows / macOS | Process usage, recovery after sleep | Sync tasks, automatic updates |
| Android / iOS | Background activity, response after locking the screen | Signal strength, system power-saving settings |
| Linux | Process load, traffic-handling mode | Background services, batch transfers |
Encryption isn’t the only cause of battery drain on mobile devices. Keepalives, reconnections, and frequent small packets can prevent the wireless interface from entering a low-power state. A weak signal can also increase power use on the access network itself. To compare standby drain, keep the screen, app workload, network type, and signal conditions as consistent as possible, and check background activity and reconnection logs. Battery-level changes alone won’t tell you whether the client is draining power or simply handling background transfers for other apps.
If requests only occasionally stall after the screen locks, first distinguish a paused app from an idle channel timeout or the system stopping the client. If opening the client in the foreground restores service, check the system’s background policies and the app’s status. If the client is still running but can’t connect after a network change, check whether the entry point is reachable. More frequent keepalives aren’t always better: they can increase wireless wakeups and server load. Setting them too far apart may let intermediate devices clear the connection. Until you know the cause, the default settings are easier to troubleshoot.
Choose based on repeatable differences
For mobile work, consider heat, recovery from standby, and call stability together rather than comparing only peak throughput. For desktop transfers, let the task run past its startup phase, then check whether resource use changes as speed fluctuates. If a download slows but processor usage doesn’t rise at the same time, check the source site and route first. If the device heats up and slows down similarly on different routes, look at the client implementation and local workload. Matching anomalies to the time of an action is more useful than making a general claim that one protocol uses less power.
Routes · Access networks, backbones, and exits
Direct, relayed, and dedicated routes
Route labels describe how traffic is organized between nodes. A direct route typically has the client connect straight to the remote entry point for the intended service, without a relay specifically configured by the service. A relayed route separates user access from onward forwarding. A dedicated route describes a segment that uses a dedicated transport link. These labels don’t guarantee the quality of the entire path. Queues can build between the client and access point, on an interregional backbone, or between the exit and destination. A dedicated link covering one segment doesn’t change the state of your home Wi-Fi or the remote service.
Consider both extra forwarding and route quality
| Type | Check this segment first | How to compare |
|---|---|---|
| Direct | From the current access network to the remote entry point | Compare fluctuations during quiet and busy periods |
| Relayed | From the user to the relay, then from the relay to the exit | Keep the exit location similar; compare recovery and stability |
| IEPL dedicated line | The segment covered by the dedicated line and access at both ends | Compare sustained performance for the task you need |
A direct route avoids one deliberately configured relay, but that doesn’t mean there’s only one hop in the underlying network. Carrier routing and where networks interconnect determine the actual detours and queueing points. If a direct route responds consistently during normal hours, keep it as a useful baseline. If it fluctuates noticeably only in the evening, try a relayed entry while keeping the destination region and task the same. If the entry point is reachable but the destination service fails, check the destination first, then compare whether a relay changes the exit behavior.
A relay can let the access and onward segments use different routes. Extra forwarding adds processing, but it may also avoid a poor network handoff. Results depend on how each segment performs, not just the number of hops. A low probe value for the relay only means it appears nearby from the current device. If the segment from the relay to the exit is congested, pages and meetings can still stall. Judge a relayed route by whether your task completes reliably, not just by whether the entry’s number is lower.
IEPL stands for International Ethernet Private Line. When you see this label, check which segment uses the dedicated line, and what networks traffic passes through before entering and after leaving it. A dedicated service format and end-to-end performance are different things: interconnection beyond the exit, destination load, and device access can still be bottlenecks. For cross-region meetings or extended remote work, a more practical comparison is whether you still experience interruptions and can recover after a disconnect—not treating the label as a guarantee of end-to-end performance.
Region labels, exit IP addresses, and destination services
The region shown for a node usually helps you find the exit you need. It doesn’t tell you that the entry point is in the same region or guarantee that every app will identify the exit’s location the same way. Use IP check in a browser routed through the proxy to verify the exit for that request. The result doesn’t apply to other apps that aren’t handled by the same rules. If a destination service reports a different region than expected, its account region, app cache, or own IP address database may also be involved.
Some destinations resolve to different edge servers on different networks, so the same request from different exits may reach different instances. To compare routes, keep the task and time of day as consistent as possible, and add an unrelated destination as a control if needed. If only one website has a problem on a particular exit, note the region, route type, and app message. If multiple destinations fluctuate, broaden the investigation to the entry point and route. See the server page for regions and route categories; don’t treat its classifications as measurements from a specific moment.
Troubleshooting · Timing, load, and scope
Packet loss and peak-hour congestion
A common peak-hour problem is too much traffic sharing the same link. When traffic arrives faster than a bottleneck can deliver it, data waits in a queue. Longer queues increase latency; packets may be dropped only when the queue fills up. Interactive apps can feel noticeably sluggish even while throughput numbers look good. Similar symptoms can also come from interference, access-network changes, hardware load, or remote-service rate limits. Narrowing down the issue by when it starts and what it affects is more reliable than assuming the route is oversold every evening.
Rule out delays on the local network first
First note whether the device was uploading, syncing, or updating when the problem occurred. Downloads also need upload acknowledgements. If a long upload fills the uplink, browsing and meetings can become more sluggish even when download capacity remains. Pause large background transfers, keep the same client and route, and try the same interactive task again. If the problem immediately improves, address local queues or competing tasks first; switching exits won’t tell you which part actually improved.
If the issue affects only one room or device, check local Wi-Fi first: move closer to the access point or try a trusted wired connection, then repeat the same task. When comparing home internet with mobile data, use the same device and a similar time of day if possible, and treat them as separate networks. Changing networks may also change DNS resolvers and the route to the entry point. That can narrow down the issue, but it can’t identify a particular router as the cause by itself.
Cross-check probe results against app behavior
Probes and real connections may use different endpoints and transports. An intermediary may give probe packets a lower response priority while forwarding normal application traffic, so a probe timeout doesn’t prove that the hop dropped business traffic. Conversely, a quick probe doesn’t guarantee that a sustained connection has no retransmissions. When judging a route, focus on whether the destination task repeatedly becomes unusable, whether latency changes under heavy load, and whether multiple tasks fail in the same time window.
When a reliable connection encounters packet loss, it may retransmit or reduce its sending rate, so the app appears to pause and then resume. Real-time apps may discard outdated data instead, causing choppy audio or video. A successful download doesn’t prove that real-time traffic is stable. If only one video source loads slowly on a route, try another source. If calls fail only during uploads, stop the upload and test again. Connecting symptoms to the action that triggers them can pinpoint the cause faster than average latency alone.
Keep evidence for each failure stage
If DNS resolution fails as soon as you open the client, note the entry-point lookup issue. If the connection always fails during verification, record the certificate or authentication error category. If it only stalls after connecting, note the load and affected apps. Disconnecting and reconnecting immediately after every failure can remove useful evidence because it resets both the channel state and app request. If the task allows, wait for the issue to recur, record the client status, and then change one condition. Reproducible steps and recovery provide stronger evidence than one lucky connection.
If several routes are unstable during busy periods, look for what they share: local Wi-Fi, the same access provider, the same entry point, or the same destination service. If switching to another route type helps consistently, return to the original entry at another time and repeat the same task to check whether the difference holds. Focus on the conditions under which the original route fails, rather than drawing broad conclusions about all peak hours from one set of results. For help checking service details and refund terms before paying, see the VPN buying checklist.
Practical checks · Choose tests for your tasks
Choose a protocol for the task
Start by deciding what your task can’t tolerate: calls are sensitive to repeated dropouts, remote desktops to uneven input response, large files to prolonged stalls, and interactive tools to slow responses. Then check which entries your client supports, which transports work on the current network, and whether the task requires a particular exit region. Writing down these requirements is faster than comparing protocol names first. The goal is to have a reliable everyday entry and a backup—not one speed ranking for every device, network, and use case.
Work calls, remote desktops, and travel
For meetings, first test joining, listening, and speaking, then check audio and video under normal workload. If the client can diagnose real-time media, confirm that the app is using the required transport. Otherwise, at least check whether continuous conversation and screen sharing are both stable. For a remote desktop, see whether the time from a keyboard or mouse action to the screen response stays consistent, especially after resuming from idle. If a hotel or guest network requires a captive portal, complete that step before connecting, and keep a working TCP entry as a backup. Before traveling, use the short-term business travel guide to prepare for common network environments.
Sustained transfers, streaming, and interactive tools
For uploads and downloads, use the same source to check transfer stability. First make sure the source isn’t throttling you, then see whether the transfer stalls repeatedly in its later stages. If UDP works on the current network and the client is compatible, add Hysteria2 or TUIC for comparison. If they repeatedly fail to connect on the local network, there’s no need to keep comparing peak speeds. For streaming, first check that the service loads the content you’re allowed to access, then test playback and seeking. See the Streaming guide. Video quality also depends on the source, device, and service policies—not just the protocol.
For AI tools, test loading the homepage, signing in, and sending an actual request separately. A visible homepage doesn’t mean a long response won’t be interrupted. Conversely, a slow start to a long response may mean the service is busy rather than the proxy handshake failing. Use a simple task without sensitive information and compare two working routes with the same account. If the app session has expired, sign in again as prompted. If responses often cut off midway, compare the client’s reconnection logs with what happens to other long-lived connections at the same time.
Keep a recoverable setup for your regular devices
YinsiVPN supports Windows / macOS / iOS / Android / Linux, with unlimited simultaneous devices. Choose entries for each device based on the task; there’s no need to standardize on one protocol. A setup tested on a desktop still needs to be tested on mobile after the screen locks or the network changes. Your backup should also differ meaningfully from the main setup. For example, if the main entry uses QUIC, keep a TCP entry that you’ve actually tested on the same access network, rather than just saving another entry name for the same endpoint.
When saving test results, note the client, access environment, entry point or region, route type, protocol, and task. If things slow down later, repeat the simple checks in your notes, then adjust the app, device, and route in that order. Your plan determines billing and available data, not the performance of a single test. To compare monthly subscriptions with data packages based on how often you use the service, see the prices and reset rules on the plans page. If you’re switching clients, return to Guides to check the import steps. Keep your previously tested entry as a fallback until the new setup completes real tasks on your usual networks.