Official Manual / Protocol Guide

Shadowrocket Protocol Guide

Protocol types, settings, and connection performance on iOS

This page is for users who already have their own subscription or server details. Learn how to choose the right type in Add Server, understand its settings, and distinguish protocol issues from network problems. If you’re setting things up for the first time, start with the Getting Started guide to import a configuration and connect. Then use the contents below to understand the reasoning behind the settings.

Shadowrocket is available for iPhone and iPad, Mac (Apple silicon and Intel), Windows, Android, and Linux. The iPhone and iPad app costs $2.99 as a one-time purchase on the App Store. The Mac, Windows, Android, and Linux versions are free. Check the App Store listing for iPhone and iPad system requirements. For download options and installation steps, see Getting the App.

Requires an existing configuration Protocol and transport are different Test before comparing

Protocols and settings: understand the connection layers

A protocol name is not a complete connection setup

Choosing a protocol in Add Server selects the rules a client and server use to exchange requests and data. These rules determine how identity information is sent, how the destination is specified, and whether the protocol encrypts data. But they usually don’t describe the entire connection. For example, VLESS can use plain TCP or WebSocket, with or without TLS. Two configurations don’t become interchangeable just because they use the same protocol. And a transport mismatch doesn’t necessarily mean the server address is wrong.

Break a connection down into four checks: the app makes a request; Global Routing and rules determine which policy handles it; that policy selects a server; then the client connects using the server’s protocol and transport settings. The first two steps determine where traffic goes; the last two determine how it gets there. If a webpage fails, first check whether the request followed the expected policy, then check whether the server completes its handshake. If the request went DIRECT, changing the proxy password won’t affect it.

Check the address, identity, transport, and security layers separately

The server address identifies the host to connect to; the port identifies the service listening on that host. A domain name must be resolved to an address first, and matching ports don’t imply matching protocols. Passwords, UUIDs, keys, and usernames identify the user or client, depending on the protocol. After importing a configuration, compare each field with your server details rather than guessing from how a field looks. A long string might be a password or a public key; putting it in the wrong field will usually result in a generic connection error.

TLS handles authentication and encryption during transport. Server Name is commonly used to specify the server name in the TLS handshake and verify the certificate. The WebSocket Host belongs to the HTTP layer. They may use the same domain, or differ depending on the server setup. Don’t mix them up just because both appear as text fields in the app. If certificate trust or the domain name doesn’t match, check your server details. Skipping verification shouldn’t be the default fix; it removes an important identity check.

A layer-by-layer approach to reading a server configuration
LayerWhat to checkCommon misdiagnosis
Service endpointServer address, port, and name resolutionAssuming an open port means the protocol works
Identity and protocolProtocol type, password, UUID, and keysChanging the type but not the identity fields
TransportTCP, WebSocket, path, and HostPath capitalization or trailing slash doesn’t match
Security layerTLS, Server Name, and certificateMistaking a certificate error for a speed problem

A successful import only means the format could be read

Importing via Subscribe or QR code saves manual entry, but doesn’t confirm that the server is online or that every extended field is set as expected. Sharing formats carry different amounts of information, and older details may omit transport paths or security settings. If something seems wrong after importing, open the entry and check its final settings instead of inspecting only the shared text. Keep the original entry and duplicate it for testing, so troubleshooting doesn’t overwrite a configuration that still works.

There are two different domains to consider: the server’s domain and the domain requested by the app. If the server domain can’t be resolved, the client can’t reach the endpoint. If the requested domain has a resolution problem, the connection may be established while some websites remain inaccessible. When troubleshooting, note which end is failing instead of simply writing “DNS issue.” If you connect to a TLS service by IP address, confirm that Server Name still matches the server’s certificate and setup; replacing the address isn’t an equivalent change.

The settings explained in this guide are tools for understanding a configuration, not a one-size-fits-all template to replace server details. Which fields appear and what values they require depend on the current editor and the server configuration you already have. Change one layer at a time, and record the original value and result. That way, even if you need to import the configuration again, you can tell whether the problem is with the format, identity, transport, or certificate instead of blaming the protocol as a whole.

Shadowsocks: Encrypted forwarding and matching methods

Design trade-off: fewer connection layers

Shadowsocks establishes encrypted forwarding between the client and server, relaying the requested destination and subsequent data to the remote end. It was designed as a lightweight proxy, with a focus on a straightforward configuration and forwarding process, not as a full virtual LAN. That distinction matters: selecting Shadowsocks doesn’t automatically provide routes to a remote LAN or decide which websites should use the proxy. Those are controlled by Global Routing and the rules in Config.

Its cryptographic design has evolved to include different encryption methods and key derivation approaches. Newer and older methods may differ in message format, key requirements, and replay protection; similar names don’t make them interchangeable. The client’s Method must match the server. Even with the same password, a method mismatch prevents communication. If your server details specify a method, select it exactly. Don’t change it unilaterally just to use an algorithm that sounds stronger; both ends must support the same method.

Address, Port, Method, and Password

Address and Port identify the server’s listening endpoint. Method specifies how data is encrypted and authenticated, and Password is used to derive the key for that method. Some methods accept ordinary password strings; others require key material of a specific length and encoding. Preserve capitalization and symbols when copying, and watch for leading or trailing spaces, line breaks, and full-width characters. Text that looks the same in an editor may not have the same underlying bytes. In particular, avoid copying quotation marks along with text from a formatted document.

If your server details include an additional transport extension, check it as a separate layer. Selecting Shadowsocks doesn’t mean you can ignore the extension name, the server’s required settings, or whether the client supports that combination. Standard Shadowsocks doesn’t require you to enable TLS separately. Adding a security layer that isn’t in the original configuration can make the handshakes incompatible. Every additional setting should be supported by your server details, not copied from another entry.

Test TCP and UDP separately

Loading a webpage usually tests the TCP path first, but it doesn’t prove UDP works. Voice calls, real-time apps, and some DNS requests may depend on UDP. Whether they work depends on server support, client settings, and network conditions. If webpages load but real-time apps fail, check UDP forwarding separately. A single successful Connectivity Test doesn’t verify every app or transport type.

On iPhone and iPad, fewer outer layers usually mean a more direct connection flow, but that doesn’t prove Shadowsocks is always faster or more power-efficient. Encryption implementation, device hardware, server load, and signal quality all affect the result. On a weak signal, the wireless power used for repeated reconnections may far outweigh differences in encryption overhead. A useful comparison tests the first request, sustained transfer, and recovery from idle on the same network and to the same destination—not just the protocol name.

If the TCP endpoint is reachable but no useful response arrives, check Method, Password, the server’s listening protocol, and any additional extensions in that order. If only one destination fails, first check the matching rule and the destination service. If switching networks restores access to all destinations, investigate transport restrictions or packet loss on the original network. This sequence separates identity errors, network conditions, and destination issues, rather than changing passwords repeatedly without finding the cause.

Choose Shadowsocks when you already have matching server details and need to forward app traffic. If your existing entry is stable, supports your UDP needs, and reconnects as expected, there’s no need to rebuild it just to change the protocol name. If you need access to a remote subnet, tunnel routing, or communication between networks, reconsider the connection model instead of trying to use a single proxy entry as a complete network plan.

VMess and VLESS: combining identity and transport layers

Background and differences: two protocols that aren’t interchangeable

VMess is designed for authenticated data forwarding, incorporating user identity, request information, and data protection, and can be combined with different transport methods. VLESS uses a leaner protocol header and identity model. It doesn’t provide the same data encryption layer as VMess, so common deployments pair it with TLS or another secure transport. Both protocols may use a UUID and appear in similar editing screens, but that doesn’t make them different display names for the same protocol.

Don’t assume that VLESS is “faster because it has one less setting,” or that VMess’s built-in processing means you can ignore the outer settings. Performance depends on the whole setup: protocol identity, underlying transport, security layer, server processing, and network path. Use VMess when your server details specify VMess, and VLESS when they specify VLESS. Changing the type alone won’t make the server recognize a different protocol, even if you leave the UUID, port, and domain unchanged.

UUID, time, and additional identity settings

A UUID here usually identifies a user. It isn’t a server certificate or a label that can be regenerated at will. Use the complete value configured on the server, and check the hyphens, character count, and any extra spaces when copying. VMess authentication depends on time, so a significantly incorrect device clock may cause authentication to fail. Enable a sensible automatic time setting in the system. Correct time rules out only one possible cause; it doesn’t replace checking the UUID, encryption settings, and transport parameters.

Some older configuration guides include additional identity settings, such as VMess Alter ID. These settings depend on the compatibility mode used by the server; don’t enter a fixed number based on an outdated tutorial. Some VLESS combinations may also include fields such as Flow. These aren’t general performance switches, but part of specific protocol combinations. If the editor shows these options, follow your existing server details and current support. If your details don’t call for them, don’t copy a value from another entry as a default.

WebSocket, Host, Path, and TLS

WebSocket is a transport, not an identity protocol that replaces VMess or VLESS. When it’s enabled, the client typically performs the relevant HTTP handshake before carrying protocol data over the connection. Path must match the server’s expected path, including capitalization, slashes, and any required query string. Host is used for HTTP; Server Name is used for TLS. They’re often the same, but a front-end proxy may handle them separately, so check both.

An additional transport layer can accommodate different server setups, but it also creates more places for errors and adds handshake steps. On a high-latency network, the first connection may take longer because of the extra round trips. Once a connection is established, sustained transfer performance may be quite similar. If short requests are slow but large downloads work normally, look into connection reuse, name resolution, and outer handshakes rather than concluding that the protocol lacks throughput. Conversely, a fast handshake at the endpoint doesn’t prove there’s no bottleneck between the server and destination.

Key fields to check for VMess and VLESS
ItemVMessVLESS
IdentityEnter the UUID and related settings from the server detailsEnter the UUID from the server details
Data protectionCheck protocol encryption and outer security settingsAuthentication isn’t the same as data encryption
TransportMatch the server’s TCP, WebSocket, or other transportMatch the server’s transport and additional requirements
Primary checksTime, identity, transport, and security layerIdentity, transport, security layer, and protocol-specific fields

How to compare combinations on iOS

To compare battery use on iOS, separate protocol processing from connection behavior. Encryption and encapsulation add processing during sustained downloads; frequent wake-ups add the cost of repeated name resolution, handshakes, and wireless network activity. A leaner VLESS header alone doesn’t prove that every deployment uses less power than VMess. For the same server path, record the screen state, network type, test duration, and request pattern, then compare stability. Results from different servers reflect differences across the entire path.

If an imported entry connects to the endpoint but drops when making a request, first confirm that the outer connection reaches the correct backend. An incorrect Path or Host can route the request to a regular web service that accepts the port but doesn’t return a valid protocol response. If the certificate name is wrong, check the security layer first. Compare the efficiency of protocol combinations only after identity, transport, and certificate settings match. Otherwise, what looks like a “slow protocol” may just be repeated failures from a bad configuration.

Trojan, HTTP, and SOCKS5: connection behavior and trust boundaries

Trojan: TLS as a core component

A common Trojan setup sends identity information and forwards destination requests through a TLS-protected connection. Standard TLS encryption and certificate verification are central to its design, so troubleshooting shouldn’t stop at the password. The server address may be an entry point; Server Name and the certificate together establish the server’s identity. A successful TCP connection only means the endpoint accepts connections. TLS handshake, certificate verification, and subsequent authentication are three separate checks.

Password must match the user configured on the server, and TLS names and the trust chain must also match. An expired certificate, incomplete certificate chain, incorrect device time, or wrong Server Name can cause failure before the password is checked. If your details specify another transport, check those settings too. Blaming everything on the password can miss an earlier handshake failure; turning off certificate verification can hide the identity problem it was meant to catch.

HTTP proxy: CONNECT isn’t the same as transport encryption

Early HTTP proxies focused on forwarding HTTP requests; CONNECT is now commonly used to tunnel a connection to a destination. Distinguish between “accessing an HTTPS website through an HTTP proxy” and “using TLS to connect to the proxy endpoint.” The first describes the destination connection; the second describes the connection from the client to the proxy server. An HTTPS destination doesn’t automatically protect the proxy credentials or every exchange with the endpoint. Check separately whether the proxy endpoint uses TLS instead of inferring it from the website address.

The username and password used to authenticate with a proxy are separate from website login credentials. Use the authentication details you already have for the proxy; don’t try another account’s credentials. Some HTTP proxies allow only certain destination ports, or the server may restrict CONNECT. In those cases, endpoint authentication can succeed while some services remain inaccessible. If a regular webpage works but another app doesn’t, check the proxy’s supported connection methods and destination restrictions rather than assuming the client’s rules are wrong.

SOCKS5: general-purpose forwarding doesn’t include encryption

SOCKS5 uses a general-purpose request format to specify destination addresses, supports different address types, and defines authentication negotiation and UDP association. It doesn’t guarantee encryption between the client and proxy endpoint; a username and password aren’t a substitute for encryption. Whether it suits a particular environment depends on the endpoint’s network, the protection provided by the application layer, and the security setup available from the server. The number in the protocol name indicates the specification version, not a security or speed rating.

The SOCKS5 specification includes UDP association, but that doesn’t mean every endpoint supports UDP in practice. Server implementation, authentication method, network firewalls, and client handling can all affect the outcome. Where domain names are resolved also depends on the configuration: local and remote DNS problems can both appear as failed access to a destination. Start by testing a known-good destination to verify the basic connection, then check name resolution and UDP needs separately. Don’t change multiple variables in one test.

Identity and protection boundaries for three protocols
TypeKey fieldsWhat else to check
TrojanPassword、TLS、Server NameCertificate chain, transport, and server identity
HTTPEndpoint, port, authentication, and endpoint TLSCONNECT restrictions and destination-port policy
SOCKS5Endpoint, port, and authenticationEncryption boundary, UDP, and where DNS is resolved

Choose based on the deployment, not how complex the name sounds

On iPhone and iPad, a first connection with Trojan usually includes a TLS handshake. The time it takes depends on round-trip latency, session resumption, and server conditions. HTTP and SOCKS5 have more straightforward protocol flows, but that doesn’t make them faster on every network. A distant endpoint, congested path, or strict server policy can outweigh the benefit of fewer protocol steps. For everyday short requests, stable connection reuse and recovery from idle may be more important to observe than a single large-file test.

If your server provides one of these protocols, start with its complete settings to establish a reliable baseline before considering alternatives. HTTP or SOCKS5 may be the right choice for an existing proxy on a managed network; use Trojan when you have a standard TLS endpoint and the required authentication details. This is a comparison of protocol capabilities and trust boundaries, not a service-quality ranking. Any protocol can be well configured, or unavailable due to certificate, permission, or network policy issues.

WireGuard: key identity, tunnel addresses, and routing scope

From app proxying to network tunneling

WireGuard is designed for encrypted network tunnels. It encapsulates IP packets and sends them between peers over UDP. Unlike protocols that proxy requests to a destination address, it’s closer to a controlled layer 3 connection between two endpoints. Its configuration uses concepts such as interface addresses, peers, public keys, and allowed IP ranges. A WireGuard configuration can’t be reduced to “server and password,” and a successful tunnel handshake doesn’t automatically make every remote resource reachable.

WireGuard uses a relatively fixed cryptographic suite to reduce the complexity of negotiating between algorithms. Peer identity is established primarily through key pairs. The client’s private key identifies the local peer; the server’s public key identifies the remote peer. They serve entirely different roles. Putting the server’s public key in the local private key field won’t create a working connection. Copying an entire configuration to multiple devices that are online at the same time may also cause identity or endpoint conflicts, depending on how the server manages peers.

What keys, addresses, and Endpoint mean

Private Key is sensitive identity material. Store it only on devices that need the connection and in controlled backups. Public Key can identify a peer to the other side, but can’t authenticate in place of the private key. If configured, Preshared Key adds shared key material alongside the key-pair mechanism; both sides must use the same value. Don’t remove a value from your existing details just because a field can be left blank. When describing a problem to someone else, don’t paste the full configuration; it often contains information that identifies your device.

Endpoint specifies the remote address and port that can receive UDP packets. Interface Address is the address assigned to the local end inside the tunnel. They belong to different network layers. The tunnel address isn’t a public endpoint and shouldn’t be entered as the server address for a regular proxy. The DNS field usually specifies the resolver used by the connection, but its reachability still depends on routing and server settings. If the tunnel address doesn’t match the client address allowed by the server, the handshake and access to services may behave differently.

AllowedIPs, keepalive, and MTU

In standard WireGuard configuration, AllowedIPs helps select which peer receives traffic for a destination subnet and restricts the source addresses accepted from that peer. It isn’t simply a list of websites you’re allowed to access. In Shadowrocket’s overall connection model, it must also be considered alongside client policy selection and rule scope: traffic must first enter the expected policy, then satisfy the tunnel and remote routing requirements. Changing just one layer may not change the final route.

Persistent Keepalive can maintain a NAT mapping when needed, which may help peers behind address translation that need to remain reachable. More frequent isn’t always better: excessive keepalives increase network activity and may affect standby battery use, especially on cellular networks. MTU limits the size of packets carried by the tunnel. Encapsulation adds overhead; if the path can’t accommodate it, packets may fragment or be dropped. Don’t copy a fixed value from elsewhere. Make documented changes based on the actual path and server details.

Benefits and limitations in iOS scenarios

WireGuard’s peer model can accommodate some endpoint changes, but recovery after switching from Wi-Fi to cellular on iOS still depends on system scheduling, UDP reachability, and the remote peer. Endpoint update support doesn’t guarantee a seamless transition every time. Test by switching between networks you’re permitted to use, and observe how existing and new sessions recover. Also note whether only domain-based access fails, to distinguish tunnel recovery from DNS recovery.

WireGuard’s address and routing model is useful when you need access to an existing private subnet or have an assigned tunnel configuration. For ordinary app proxying, confirm that you actually need these network features and that the server has forwarding, return routes, and permissions configured. Battery use also depends on keepalive settings, traffic volume, and signal conditions. Cryptographic efficiency doesn’t predict the power consumption of the whole device, so there’s no single battery-life figure that applies to every iPhone.

Hysteria2: QUIC transport and bandwidth estimation

A UDP-based transport option

Hysteria2 uses QUIC for proxy transport, relies on UDP, and uses TLS-related mechanisms for its security handshake. One of its aims is to handle reliable data transfer on networks with packet loss and changing conditions. Distinguish the transport layer from the application layer: even if the destination app uses TCP, the connection from the client to the Hysteria2 server can still use QUIC. A website working over TCP doesn’t prove that the endpoint’s UDP port is reachable.

QUIC can deliver data on separate streams at the transport layer, avoiding a delivery-level block across all streams when data on one stream is missing. But shared connections are still affected by congestion control, available bandwidth, and packet loss. That doesn’t make packet loss harmless or guarantee the same benefit for every type of traffic. If the network restricts UDP, other design advantages can’t replace basic reachability. Check the endpoint before adjusting speed settings.

Authentication, Server Name, and bandwidth settings

Address and Port identify the endpoint that can receive the relevant UDP traffic. Enter authentication details as specified by the server. Server Name and certificate verification still matter; connecting by IP doesn’t automatically remove the need for name verification. If your details include additional obfuscation settings, confirm that both ends use the same method and parameters. These settings can’t fix password or certificate errors. Don’t reuse authentication formats from other generations or protocols just because they look similar; use settings that explicitly match your server.

Bandwidth settings provide information to the relevant transport controls; they can’t create capacity beyond the physical connection. Available rates also change with Wi-Fi signal, cellular network load, device location, and carrier conditions. Values far above the actual bandwidth may cause queueing, packet loss, or slower responses. If the current client and server support automatic estimation or a specific congestion-control behavior, follow the documentation for that setup. A fixed value found online isn’t a universal recommendation.

Measure throughput and responsiveness separately

A large-file transfer measures sustained throughput, but not necessarily webpage response time, voice interaction, or recovery in the background. Saturating the upload during a transfer may also queue acknowledgments and other app requests, making interaction noticeably slower even when the download speed looks good. Evaluate Hysteria2 on the same network using short requests, sustained transfers, and concurrent interactions. Don’t rely on a screenshot of the highest speed, or compare two tests as protocol differences when cellular signal conditions are changing.

On iOS, sustained high throughput increases energy use and heat from wireless activity, encryption and decryption, and app processing. QUIC implementations typically involve user-space processing, and the cost varies by device and implementation. The protocol name alone can’t tell you whether it saves battery. If the device gets warmer over time, later speed drops may also be related to thermal conditions. Record charging state, screen activity, and background tasks; those details explain more than a single momentary speed reading.

When it’s suitable and what to check when it fails

Consider testing Hysteria2 if you already have a matching server, your current network supports stable UDP, and the actual traffic is affected by jitter or packet loss. If your network restricts UDP, or your existing TCP path already meets your needs, don’t rebuild the configuration just for a different protocol name. Both ends must support the setup; a protocol option in the client can’t create a working connection without a compatible server.

If the endpoint doesn’t respond, first check the UDP port, server status, and network path. If the handshake succeeds but authentication fails, check the identity details. If there’s a name or trust error, check the certificate and Server Name. Only after these checks pass should you look at bandwidth estimation, congestion, and long-term stability. If Wi-Fi works but cellular doesn’t, keep the same configuration for comparison and avoid changing settings while switching networks. This order helps distinguish reachability issues from transport tuning.

iOS speed, battery use, and choosing a protocol

Start by defining what needs to improve

Choose a protocol based on a specific problem: does a webpage take too long to open, is sustained download speed low, are real-time apps unstable, or does the connection keep recovering while idle? These symptoms have different bottlenecks. The first request may depend on DNS and handshake round trips; sustained transfers may be limited by bandwidth and congestion; real-time traffic is more sensitive to jitter and packet loss; standby behavior involves system scheduling and keepalives. Asking “Which protocol is fastest?” doesn’t define what to test or explain the result.

A latency test is one measurement of the endpoint or a specific test request, not an end-to-end speed test for every website. The network between the server and destination, destination load, routing rules, and the app’s connection reuse can all affect the experience. A record with lower test latency can still be slower for a particular destination. Before comparing, keep the destination and action consistent—for example, open the same accessible page or transfer the same file—and record the results. Don’t rank measurements from different tasks in the same table.

Compare with repeatable tests, not a single speed test

To establish a baseline, use one device, one network, the same destination, and similar device conditions, starting with a configuration known to work. Change only one protocol combination or server entry at a time, while keeping Global Routing and the rules file unchanged. Repeat each test and note failures and recovery, not just peak speed. If two protocols use different servers, describe the result as “the difference between these configurations on this network path,” not a general rule about every deployment of either protocol.

Keep context when testing on cellular: signal strength, movement, network mode changes, and upload load can all affect results. Wi-Fi isn’t automatically stable either; distance from the access point, interference, and local network congestion can cause fluctuations. After switching networks, wait for the connection to stabilize before testing a new request. If an existing long-lived connection drops but a new request succeeds, treat recovery and session continuity as separate issues. A single app screen that’s still loading doesn’t prove the protocol is completely unavailable.

Choose a protocol based on what you need it to do
ScenarioCheck firstHow to choose
Everyday browsing and short requestsDNS, handshakes, and connection reuseUse an existing, stable, complete configuration
Voice and real-time interactionUDP, jitter, packet loss, and recoveryTest the actual app, not just endpoint latency
Access to a private subnetTunnel address, routes, and remote permissionsConsider WireGuard’s tunnel model
Sustained transfers on a poor connectionPath packet loss, congestion, and UDP reachabilityTest Hysteria2 if you have a compatible server
Standby and frequent network switchingKeepalives, reconnects, and system schedulingFocus on reliable recovery and actual network activity

Battery use depends on how the connection works

On iOS, connections typically use system networking extension mechanisms. Protocol processing is only one part of the total energy cost. Keeping the radio active, transmitting on a weak signal, reconnecting, resolving names, and the app’s own activity can all add overhead. A combination that processes sustained transfers efficiently may still be a poor choice for long standby if it sends keepalives too often. Conversely, a rise in battery use during one test may coincide with system syncing or background app activity; don’t attribute it to the client alone.

For on-demand use, you can configure On Demand after understanding its triggers. Don’t confuse incomplete trigger rules with protocol failures. If the connection doesn’t activate on the expected network, check the triggers first; if it activates but traffic gets no response, check the protocol. For more on Wi-Fi name matching, cellular conditions, and domain triggers, see On Demand connection settings. When testing protocols, check the current connection state to avoid background switching affecting the comparison.

The order: make it work, make it fit, then optimize

First, choose only a protocol your existing server explicitly supports and rule out incompatible combinations. Next, check security boundaries, UDP requirements, and the routing model. Only then compare latency, throughput, and energy use. If a regular proxy meets your app’s needs, there’s no need to add tunnel subnet management for the sake of complexity. If you need access to a private subnet, don’t choose based only on a webpage speed test. Stable, repeatable results are more useful than an occasional high score when deciding whether a configuration suits everyday use.

Traffic readings on the Data page can confirm that data is being transferred, but they don’t directly measure battery cost or replace server billing records. Differences in what’s counted and in encapsulation overhead may affect the totals. See Understanding traffic statistics on the Data page for details. For useful records, include the network, destination, protocol combination, failure symptoms, and recovery steps. That makes retesting easier and helps avoid relying on speed results from outdated network conditions.

Routing rules, connection checks, and troubleshooting

First, understand the three Global Routing modes

In Shadowrocket, Config, Proxy, and Direct are the starting points for understanding a connection path. Config applies the rules in the current configuration file; Proxy sends applicable traffic through the current proxy path; Direct connects directly. These aren’t encryption protocols and don’t change what types the server supports. Before comparing protocols, check which mode is active. Under Direct, a successful or failed connection doesn’t tell you whether the proxy identity settings are correct, because the request may not have used that server at all.

Rules in Config are usually matched from top to bottom, with specific rules placed before the fallback. DOMAIN-SUFFIX matches domain suffixes; DOMAIN-KEYWORD matches keywords in a domain; IP-CIDR and IP-CIDR6 match address ranges; FINAL handles requests that didn’t match earlier rules. Domain rules and address rules depend on different conditions, and DNS results may affect later matching. After editing rules, confirm that you’re using the active file, not just an edited copy that isn’t enabled.

[Rule]
DOMAIN-SUFFIX,example.com,PROXY
IP-CIDR,192.168.0.0/16,DIRECT
FINAL,DIRECT

The example above shows syntax and ordering, not a complete configuration for general use. example.com is a documentation domain; PROXY and DIRECT are policy keywords. For an actual setup, check the current policy and server selection. Custom policy names must have a corresponding definition in the configuration. Don’t replace your existing file with the example. And don’t assume that DIRECT is the right fallback for every situation just because it appears at the end; the fallback should suit your traffic and management requirements.

Pinpoint the stage where the connection fails

Stage 1: Check the endpoint. Can the server domain be resolved? Are the address and port correct? Can the current network reach the required TCP or UDP service? Stage 2: Check the security handshake, including TLS name, certificate trust, and device time. Stage 3: Check protocol identity: password, UUID, keys, method, and additional settings must match the server. Stage 4: Check the destination request, matched rule, remote DNS resolution, and exit path. This order ties each change to a specific hypothesis.

Use Connectivity Test alongside real app requests. If the test fails, first confirm what that test actually measures. If it succeeds but a webpage fails, check the rules, destination domain, and transport used by the app. If only some destinations are affected, start with the destination and matched policy; if all are affected, check the endpoint and identity; if only UDP traffic fails, investigate UDP support and the network path. For more detailed steps, see the connection timeout troubleshooting checklist and connection diagnostics FAQ.

Subscription updates, records, and reversible changes

Updating Subscribe changes the server list; it doesn’t fix every local setting. After an update, check that the entry you’re using still works, that your manual edits weren’t overwritten, and that Global Routing still points to the expected path. If only the subscription update fails while existing entries still work, troubleshoot fetching the list and connecting to a server as separate processes. For update steps and common causes, see Subscription updates. Don’t delete all working entries before you start troubleshooting.

When documenting a problem, note the protocol, network type, stage of failure, whether all destinations are affected, and the individual changes you’ve already tried. Before sharing screenshots or logs, redact passwords, UUIDs, private keys, subscription URLs and their access parameters. Be careful with server details and personal activity records too. Change one thing at a time, verify the result, then decide whether to keep or revert it. If you need to rebuild an entry, save a controlled backup first. These notes are usually more helpful for finding a shared network or settings issue than repeatedly switching protocols.

The right way to choose isn’t to search a protocol list for one permanently best option. Check the existing deployment, verify security and transport boundaries, observe real-world behavior, then use repeatable tests to decide whether to make changes. For your first setup, follow the main steps in the Getting Started guide. See the Getting the App page for app downloads and system permissions. Keep settings, rules, and network conditions documented separately so you can quickly identify what changed after switching networks, updating a subscription, or moving to another device.