How to Choose a Proxy Protocol: Trojan, Shadowsocks, and V2Ray Protocols Compared

Compare VMess, VLESS, Trojan, and Shadowsocks encryption, transport options, and client support, with practical guidance for everyday browsing, mobile networks, and multiple devices.

At a glance

If you already have nodes, first check that your client core supports the full configuration. If you have several options, compare them against your needs. This guide is for users moving configurations between desktop and Android. It explains authentication, transport, and connection security, and provides repeatable testing steps.

Encryption and transport: how the four protocols differ

A protocol determines how a client authenticates with a proxy server and encapsulates requests. Transport determines how that data reaches the server, while TLS can secure the connection between the client and proxy server. HTTPS on a webpage is a separate connection. A subscription link delivers node details; it is not a proxy protocol, nor does it guarantee that every node in the subscription works with your current core.

ProtocolAuthentication and encryptionCommon transports and what to check
VMessIdentifies users with a UUID. Modern VMess uses AEAD to authenticate the header; the data encryption method is set separately in the configuration.Common combinations include TCP and WebSocket. Check the transport type, path, TLS setting, and system clock.
VLESSIdentifies users with a UUID. Common configurations use encryption=none; connection security comes from an outer layer such as TLS or REALITY.Check the transport, security type, and flow control. Vision is a flow-control option, not a transport type.
TrojanUses password authentication; standard configurations rely on TLS to secure the connection.Commonly uses TCP with TLS. Check the server name and certificate. Both ends must support any extended transport.
ShadowsocksBoth sides must use the same encryption method and key material. Legacy AEAD and AEAD 2022 are not interchangeable.Basic implementations can carry TCP and UDP separately. If a node requires a plugin, check that the client supports it and configure it separately.

Seeing the same protocol name after importing a node only means the client recognized its type. For a WebSocket node, the address and port specify where to connect, the WebSocket path specifies which endpoint to request, and the server name used with TLS affects the handshake and certificate validation. These three fields may use the same domain or serve different purposes; don't copy the address into each field.

Choosing a protocol for everyday browsing, mobile networks, and multiple devices

Everyday browsing: stick with a proven setup

Recommendation

If your VMess node is stable, there's no need to reconfigure the whole connection just to switch protocols. When getting started, if the server offers a standard Trojan node and your client supports it, check the address, port, password, and TLS server name, then test the websites you use most. Switch only if an alternative performs better under the same conditions.

Best for: everyday browsing, a regular office network, or taking over an existing configuration

Mobile networks: test recovery after switching

If you're choosing between VLESS and Shadowsocks, test both on the same Android device: resume after the screen has been off, and make a first request after switching from Wi-Fi to mobile data. Existing connections may drop when the network changes; recovery depends on the client, operating system, and server, not the protocol name. Test voice or other UDP traffic with the actual app you use.

Best for: commuting, switching hotspots, and intermittent use

Multiple devices: prioritize fields every client supports

On each device, first check support for the required transport, encryption method, and security type; then decide whether to share a subscription. If the desktop client supports a server-defined extension but the mobile client can't parse it, assign a compatible node to the mobile device. Don't remove the extension from the desktop configuration and reuse it as-is.

Best for: sharing a subscription between desktop and Android, or managing devices individually at home

Bottom line: test the most limited device first

Before sharing a configuration, import it and test real access on the device with the fewest supported cores or versions. Then distribute the tested setup to your other devices.

Client support: check the running core and import results

On each device, first compare the same node's address, port, transport, and security type. Also check whether the server limits concurrent devices and allows separate credentials for each one. Individual credentials make it easier to revoke access for a single device; if everyone shares one password, a leak on one device may require updating them all. Hide passwords, UUIDs, and subscription URLs in troubleshooting screenshots.

Connection tests: distinguish remote ports, local ports, and test count

443
Common remote port for TLS nodes; use the value in the node configuration
10808
Common local listening port in v2rayN; check the settings
5 requests
Suggested requests per candidate node
  1. In v2rayN, go to Settings → Parameter Settings to check the local listening port, then confirm that your browser is using the intended proxy entry point. The remote port comes from the node; don't paste the local listening port into the node's port field.
  2. Keep the device, network, destination website, and proxy mode unchanged. Test each candidate five times in a row, recording the number of successful requests and the median response time for successful requests. To compare initial connections, prevent the app from reusing an existing connection and record the first request separately from subsequent ones.
  3. Repeat the tests on mobile data and record the time from switching networks to the first successful request. Compare failures first, then response times for successful requests. If nodes are in different data centers, the results can help you choose a node but can't isolate the protocol's effect.

Import failures, handshake errors, and pages that won't load

The subscription updated successfully. Why won't one node connect?

In the node editor, check the failing node's transport, security type, and flow control, then look at the first error in the runtime log. If a field isn't supported, check the running core and its version. If a field is blank after import, compare it with the parameters provided by the server and import the node again.

Trojan reports a certificate name mismatch. Can I turn off validation?

Keep certificate validation enabled. First check the TLS server name in the node configuration and the domain covered by the server's certificate. Even if the node's connection address is an IP, don't change the TLS server name to that IP; use the name specified by the server operator.

VMess worked yesterday. Why can't it connect after importing today?

First distinguish a parsing error from a connection error. If the node doesn't appear in the list, check the subscription format. If it appears but fails to connect, correct the device clock, then check the UUID, transport path, and TLS settings. Change one setting at a time and keep the original node for comparison.

The speed test succeeded. Why can't my app load webpages?

A successful test request only confirms that particular request path works. First check whether the app follows the system proxy settings, then look in the runtime log for a connection to the app's destination. If a connection appears but matches a direct-connection rule, check the routing rule order and outbound tags. If no connection is logged, check the traffic entry point first.

Download v2rayNWindows / macOS / Android / Linux