1. Connection layers: protocols, transports, security and local traffic handling
A node name isn't a connection setting
Each node in a client is a set of connection parameters passed to the core. Its name is just a label; it plays no part in the handshake. The address and port identify the server endpoint. The proxy protocol defines how the client authenticates and requests a destination. The transport carries that data, while the security layer determines whether a protected session is established and how the server is verified. A subscription label such as “high speed” or “dedicated line” tells you nothing about the protocol, security layer or server capacity. Renaming a node won't change how it connects; changing its protocol can leave the server unable to interpret the client's data.
For example, in a VMess configuration over WebSocket, VMess is the proxy protocol and WebSocket is the transport carrying it. If TLS is enabled, the connection first establishes TLS, then upgrades to WebSocket, and finally VMess handles the proxy request. The endpoint hostname, the server name used for the TLS handshake and the Host header in the WebSocket request can all be the same, but they serve different purposes. Copying one value into all three fields may seem simpler, but it can send certificate validation to one domain while routing the application request to another site. If the server uses a reverse proxy, enter the values according to the mapping provided by the node provider.
A client may label direct transport as TCP or RAW, while some sharing formats retain older terminology. The same label in two interfaces doesn't guarantee identical settings, especially when either side uses additional transport parameters. To check a configuration, first identify the transport family used by the server, then check which fields the client actually retained. A WebSocket path cannot be used as a gRPC service name, and a gRPC service name is not the TLS server name. If the provider hasn't specified a value, keeping the matching server default is safer than adding one that only seems universal.
| Layer | Common values or settings | Check these first if they don't match |
|---|---|---|
| Proxy protocol | VMess、VLESS、Trojan、Shadowsocks | User ID, password, encryption method or flow control |
| Transport | Direct, WebSocket, gRPC | Transport type, path, Host header or service name |
| Connection security | TLS, REALITY or no additional security layer | Server name, certificate validation or corresponding key parameters |
| Local traffic handling | System proxy, per-app proxy, TUN | Whether the app uses the client and whether a rule matches |
Route app traffic through the core before troubleshooting the protocol
System proxy and TUN determine how this device passes traffic to the client; they don't determine the protocol used by the remote server. Browsers may follow the system proxy, while some command-line tools and apps may ignore it. TUN uses a virtual network adapter to capture traffic, but once traffic enters the client, routing rules still determine whether it goes direct, through a proxy or gets blocked. Enabling TUN doesn't mean all traffic uses the same node, nor does it guarantee that the server supports the relevant UDP forwarding. If only one app fails, first check whether its traffic reaches the client, then check the matching rule and outbound route. Don't jump straight to changing the remote protocol.
Troubleshoot by identifying where the failure occurs. If the endpoint hostname won't resolve, the client hasn't reached the server. A port connection timeout doesn't prove the server is listening for the expected service. If the security handshake fails, check the security layer. If the transport connects but proxy authentication fails, check the identity fields. Conversely, connecting to the endpoint port doesn't prove the destination website is reachable; the request must still pass through server-side resolution, outbound routing and the destination's response. When logs show only a generic timeout, correlate endpoint reachability, handshake logs and the time of the app request rather than guessing from a single error.
2. VMess and VLESS: Similar identifiers, different protocols
VMess: authentication and encryption built into the protocol
VMess evolved alongside the Project V ecosystem. It was designed to package user authentication and proxy requests in one protocol while allowing the underlying transport to change. Its user ID is usually a UUID. VMess authentication depends on the system clock being accurate. A different displayed time zone doesn't mean the clock is wrong; what matters is whether both systems have the correct time. Check the clock after a computer resumes from sleep, a virtual machine resumes from suspension, or automatic time is disabled on a mobile device. If the only reported problem is a timeout, the clock is just one possibility to investigate; it doesn't rule out an endpoint or outer-handshake issue.
VMess encryption settings are part of the protocol and are separate from TLS at the transport layer. When an interface shows “Auto,” first check which setting it applies to; it doesn't necessarily mean the client will try every security layer. Older subscriptions may also contain an extra ID field. It's typically zero in VMess AEAD configurations, but for legacy nodes, follow the server parameters and the core's supported options. Copying a value from an old guide into a current client may not restore compatibility, and it shouldn't be the first fix for an ordinary timeout. Keep the original node and create a copy so you can compare the results of changing its fields.
VLESS: Keep the protocol header separate from the outer security layer
VLESS is designed to keep the proxy protocol itself lightweight, with connection protection configured separately through a specific security mechanism. Common configurations also use a UUID, but a VMess UUID doesn't prove that the same server port accepts VLESS; the server must have the corresponding inbound configured. Traditional VLESS configurations often use encryption=none. This describes the value of that protocol field; it doesn't mean outer TLS or REALITY is disabled, nor is it advice to turn off outer protection. Likewise, seeing TLS in a node's label doesn't prove that the security layer was imported correctly. Open the node details and check the protocol fields and outer security settings separately.
Some VLESS configurations also include a flow control field. For example, xtls-rprx-vision in the Xray ecosystem has specific requirements for the core, transport and security layer. A client that can create a VLESS node can't necessarily use the same flow control with every transport. If the source specifies a flow control option but it doesn't appear after import, check the parser and core support first. Don't add it for performance reasons if the source doesn't specify it. A missing flow control field may not become apparent until you make a request; simply saving the node or testing the endpoint port won't catch it.
Migration order: Get the new endpoint before changing the client
If your VMess connection is stable and the server has no plans to provide a new endpoint, there's no need to change the existing node just to use a newer protocol. When migrating, first confirm that the server provides a new configuration you can test independently, then give the test node a clear local name. Test it on the same device, with the same destination and local traffic-handling mode, then compare handshake failures and sustained transfers. If the new setup uses a different server or path, any difference reflects the entire route, not VLESS alone. Performance testing only makes sense once both configurations work independently.
If the same imported node behaves differently on two devices, compare three things: the original node configuration, the settings actually saved by the client, and the current core logs. The first confirms what the server expects, the second reveals whether the sharing format lost fields during parsing, and the third shows what the core accepted at runtime. For VMess, check the system clock, encryption mode and legacy fields. For VLESS, check the security layer, flow control and required transport. Checking only one of these can make a parsing problem look like a protocol failure. If a field is unfamiliar, look it up in the glossary, then check it against the node rather than trying every possible combination.
3. Trojan and Shadowsocks: Different authentication boundaries
Trojan: From the standard TLS handshake to proxy authentication
Trojan's basic design carries proxy authentication and requests inside a TLS connection. A typical configuration uses a password to identify the user, while the server certificate is verified at the outer TLS layer. These serve different purposes: the password lets the server identify the client; certificate validation lets the client confirm it's connected to the expected server. A correct password won't fix an expired certificate, and a trusted certificate won't replace proxy authentication. If the client reports a server name mismatch, check the name covered by the certificate and the TLS server name specified in the node. Don't start by changing the password or telling the client to ignore certificate errors.
Trojan is commonly used where domain names and certificate management are already in place. Some core and server deployments add transport options, but not every Trojan implementation supports every extension. If a node works on one device but fails on another, first find out whether the server uses basic transport or an extended setup. Then check the imported security layer, transport and any additional parameters. Opening the server domain in a browser may show that a site is reachable or a certificate can be verified. It doesn't prove that the browser request reached the proxy inbound, let alone verify the proxy password.
Certificate errors can also result from an incorrect system clock or differences in certificate trust between devices. If failures occur intermittently after a certificate update, note which devices are affected and when, then check whether they're connecting to the same endpoint address. A single domain may resolve to multiple addresses, and their deployments may not be in sync. Confirm the endpoint is the same before comparing certificates and client errors. This helps distinguish an endpoint that hasn't been updated from a trust issue on the current device, without rebuilding every node.
Shadowsocks: The encryption method and key must match
Shadowsocks, often abbreviated to SS, is designed to relay connections with a relatively lightweight protocol. Modern configurations commonly use authenticated encryption to protect data within the protocol. Not having a separate TLS layer by default doesn't make SS equivalent to plaintext, and an SS key isn't a TLS certificate. The client must know which encryption method the server uses. Even if the password looks the same, using a different method to interpret the key or process data won't work.
Legacy configurations, common AEAD setups and newer Shadowsocks 2022 variants don't all use the same methods, key formats or implementation support. Some methods require a specific key encoding and length; a random text string isn't necessarily a compatible password. If a reserved character gets truncated while parsing a share link, the node may still appear in the list but fail as soon as you use it. When migrating, ask the provider to confirm the full method name and required key format. Don't replace one encryption method with another based on the vague claim that both “support SS.”
Some SS nodes also require a plugin and plugin parameters. A parameter accepted by one client isn't necessarily supported by another. After importing, confirm that the plugin name and options are still present, and check whether the current core actually starts the required connection. If the base configuration works but the plugin setup doesn't, treat it as a compatibility issue between the deployment and client implementation, not proof that the whole protocol is unusable. For a long-running node, it's enough to note the method and whether a plugin is required; don't put passwords or share links in ordinary troubleshooting notes.
What to consider: maintenance and existing endpoints
If you already have a mature certificate workflow and all your devices support the same TLS configuration, Trojan can fit easily into your existing maintenance process. If you already have a standard SS endpoint and every device supports the same encryption method, keeping SS usually means less migration work. If you need UDP, check local traffic handling, core implementation, server support and the destination network separately; the protocol name alone can't tell you whether an app will work. A successful website request only proves that the tested request reached its destination, not that voice calls, games or other traffic will work. Test the apps you actually use before changing nodes.
4. TLS and REALITY: Both provide connection security, but their parameters aren't interchangeable
Traditional TLS: Verify the server name and certificate chain
With TLS, the endpoint address can be a domain or an IP specified by the node provider. The server name is used separately in the TLS handshake and determines the identity against which the client checks the certificate. The address determines where to connect; the server name determines the name used to establish and verify the session. They don't have to match. Connecting directly to the endpoint IP in a browser may also produce a different result than using the client. If the endpoint hosts multiple services, the server name may affect certificate or backend selection, so a reachable IP alone doesn't prove that the TLS settings are correct.
ALPN negotiates the application protocol used above TLS; the appropriate value depends on the deployment. It doesn't indicate connection quality and shouldn't be copied at random from another node. If TLS succeeds but the WebSocket upgrade fails, check the HTTP request path, Host header and reverse proxy configuration. For gRPC, check the transport requirements and service name instead. Calling every failure a TLS problem can hide the actual point of failure. Note whether the error occurs before the secure session is established or afterward, when the application layer returns an error; the fixes are different.
REALITY: Confirm the client is interpreting the same configuration
REALITY is a connection security mechanism developed in the Xray ecosystem. It's commonly configured with VLESS, but it's not a proxy protocol alongside VLESS. A provider may refer to the whole node as a “REALITY node,” but in the client you should still identify the proxy protocol first and then check the security fields. Parameters for standard certificate-based TLS can't replace the corresponding REALITY settings. Even if two nodes use the same proxy protocol, port and server name, you can't assume they use the same handshake parameters.
Common client parameters include the server name, client-side parameters corresponding to the server's key pair, a short ID and any handshake settings required by the deployment. Sharing formats and interfaces may use different field names. Check the original specification and the current client's field descriptions instead of guessing from abbreviations. The server's private key must never be given to client users. A short ID is not a UUID; don't enter the VLESS user ID there. Whether a field can be left blank depends on the deployment. A field omitted from a share link and one intentionally left blank may look the same in the client, but they require different troubleshooting steps.
| Setting | TLS | REALITY |
|---|---|---|
| Server name | Use the name specified by the deployment; it must match the certificate for name validation | Use a name allowed by the server and specified by the node parameters |
| Client verification material | Trusted certificate chain and expected server identity | Verification parameters required by the server configuration |
| Compatibility | Still subject to transport and application-layer settings | Also depends on core support and the specific transport combination |
How to investigate handshake errors
First confirm that the node is running on a core that supports the combination, then check whether the subscription importer changed the server name or node parameters. If behavior changed after an update, keep a copy of the original configuration and compare the endpoint, security fields and transport. If only one node fails, focus on its endpoint, server-side changes and import results. If every node of the same type fails after switching cores, check the core startup logs and supported configuration options. Reconnecting won't restore missing fields, and deleting and reimporting everything may erase useful comparisons.
To choose between TLS and REALITY, start with what the server actually provides and whether all your devices can represent the required parameters. If you already have a stable domain and certificate workflow, TLS failures are often easier to diagnose. If the server is explicitly configured for REALITY, use clients that support the same setup instead of forcing TLS for a consistent-looking configuration. Neither is universally faster: results can change with connection setup, long-lived connection reuse and server deployment. First choose a setup you can maintain, then test how it performs in practice.
5. V2Fly and Xray: Core families and configuration compatibility
The interface manages settings; the core runs them
Project V laid the foundations for the early V2Ray ecosystem. V2Fly continues development of the V2Ray core and its community projects, while Xray has developed its own core along a related technical path. They share some concepts and configuration structures, but their features have evolved separately. A graphical client is another layer: it organizes nodes, handles subscriptions, generates configurations and starts the core. An option in the interface only shows that the client recognizes the concept; it doesn't prove that the selected core accepts it or that the import retained every parameter.
For desktop, start with v2rayN. Available cores and node options depend on the release package you installed and its actual settings. If you need an Xray feature, confirm that the node is assigned to a core that supports it; don't infer that from the installer name alone. On Android, consider v2rayNG, which uses Xray as its core. If the server setup is known to work better with V2Fly, consider v2flyNG. The mobile clients may support some of the same node types, but that doesn't mean they can seamlessly restore each other's backups, routing settings or full core configurations.
Core support shouldn't be treated as a permanent list of protocols. A core may support a protocol's basic transport before it supports a particular flow control option, extension field or forwarding mode. When looking up compatibility, distinguish “this core supports the protocol” from “this build supports every field in this node.” Pay close attention to which core family a guide covers; don't apply one core's JSON directly to another. If you're unsure about support, create a minimal test node in the client's native editor. It's easier to get a clear result than by migrating an entire legacy configuration.
Three levels of compatibility: parsing, startup and connectivity
The first level is parsing: can the subscription parser turn a record into fields in the interface? The second is startup: can the generated core configuration pass validation, bind a local listener and run? Only then comes connectivity: when the client makes a real request, does the server accept the combination and reach the destination? Unknown fields may be ignored during parsing; others may cause an error only when the core starts. Even a running core can fail because traffic never entered the proxy, a rule sent it elsewhere or the server rejected the handshake. Checking all three stages helps pinpoint where the problem lies.
A full configuration is harder to migrate than a single outbound entry. It may include local listeners, DNS servers and resolution policies, routing tags, outbound selection, rule data files and log paths. Copying an outbound entry carries over only the tags it references; its dependencies don't come along automatically. Copying the entire configuration can also create a port conflict with a listener created by the new client. File paths and permissions shouldn't be copied unchanged to another system either. When changing cores, first test one node with the default local settings. Once the protocol works, restore DNS, routing rules and other dependencies one at a time.
Confirm the test setup with one local request
On Windows, you can use the following command in PowerShell to test the local HTTP proxy. First check the local HTTP or mixed listening port in v2rayN. The example uses 10808; use it only if an HTTP proxy is listening there, otherwise replace it with the actual port. curl.exe explicitly specifies the proxy, so this test doesn't depend on whether your browser uses the system proxy setting.
curl.exe --proxy http://127.0.0.1:10808 --max-time 15 --silent --show-error --output NUL --write-out "HTTP %{http_code}\n" https://example.com/
If the first error is that the local connection was refused, check whether the client listener is running and the port is correct. Don't change the remote protocol yet. If you get a status code from the destination, check the client logs to confirm that the request used the expected outbound; a direct-connection rule can return a normal response too. If the request times out, use the logs to see whether it stalled during local traffic handling, the remote handshake or access to the destination. This command tests one HTTPS request only; it doesn't test every app, routing rule or UDP forwarding.
6. Subscription formats: Downloading data doesn't guarantee that nodes can be recreated
Know the difference between subscription URLs, share links and core configurations
A subscription URL retrieves a set of nodes or a configuration intended for a particular client. A single share link contains one node's parameters and is commonly imported from the clipboard or a QR code. A full core configuration may also define local inbounds, outbounds, routing and DNS, so it covers more than a single node. Calling all three “subscriptions” can lead you to the wrong import option: a web address won't work in a clipboard parser for individual nodes, and an importer that reads share links may not handle a full configuration. Before importing, confirm what kind of content the provider supplied and choose the corresponding action.
Common share link schemes include vmess://, vless://, trojan:// and ss://. One common VMess link format encodes JSON in the link; other formats put fields in the address and query parameters. Implementations differ in how they handle optional fields, defaults and aliases from older formats. A subscription response may contain one link per line or be wrapped in another encoding. Base64 is a way to represent data, not encryption. Being able to decode a subscription response only confirms that you can read its contents; it doesn't prove the client understands the nodes or extension fields inside.
A server may return a structured configuration for a particular client rather than a generic list of links. A successful response doesn't necessarily mean you received node data: if a subscription has expired or access conditions aren't met, the response body may be a login page, an error message or an empty list. If an update completes but adds no nodes, check the update log to distinguish a request failure from a parsing failure, then confirm the expected response format and access status. Don't assume a client can import something based only on its URL suffix, file extension or whether it opens in a browser.
When an update fails, keep a working copy for comparison
Test a new subscription in a separate group first. Before updating, note the existing group's node count and key fields from one working node; don't overwrite the original group straight away. If the updated group is empty, check that you selected the right group and didn't enable filters, then see in the logs whether the response was parsed. If the count drops, the provider may have changed the contents, the client may not recognize some links, or filtering or deduplication may have removed nodes. Check whether a known node is still present; that often tells you more than comparing totals alone. If a manually imported link works but the group update doesn't, focus on the subscription wrapper format, request requirements or group settings.
If only some nodes fail after import, compare a basic setup with one that uses extension fields. Check that the protocol, address, port, transport, security layer and flow control match the source. Reserved characters in paths, escaped query parameters, empty fields and duplicate fields can all change during conversion. Don't manually decode a whole link and paste it back into the import field; that can break the field boundaries. Ask for the original format intended for your client. For organizing groups and applying filters, see Managing multiple subscription groups.
A minimal record for cross-device migration
Keep a credential-free note for each commonly used node: its source, target client, required core family, transport, security layer and any extensions it depends on. Migrate one basic node and one representative node with extensions first. Once both pass a real request test, migrate the remaining groups. Don't post a full subscription URL in a public support thread or enter it into an unknown conversion tool. Subscription URLs usually contain access credentials, and share links may include authentication details. For screenshot-based troubleshooting, the node label and failure stage are often enough. If you need to compare formats, use a sample you made yourself with no valid credentials.
Before replacing an old subscription, consider how updates work. When the client updates a group, manually edited fields may be overwritten by the source data. If you need to keep a temporary fix, separate the test copy from the subscription group if the client allows it. After the provider fixes the data, update the group and test again. This separates “the local fix works” from “the source subscription is fixed” and reduces the chance that an automatic update brings back the same problem.
7. Performance and battery life: Understand what each measurement captures
Connection speed is more than one metric
Network round-trip time to the endpoint, establishing the transport and secure session, the first app response and sustained transfers are different things to measure. A ping may measure the network round trip to the endpoint, not an app request through the node; some endpoints don't answer that kind of probe even when normal connections work. A client's real connection latency depends on how it tests and what it targets, so numbers aren't directly comparable across clients without that context. Download tests are also affected by the test server's rate limits, concurrent connections and test duration. For an explanation of the values shown in the client, see Understanding v2rayN latency tests.
The first request may need to resolve a domain, connect to a port, complete the security handshake and initialize the transport. Later requests may reuse the connection and avoid some of that overhead. Compare protocols by looking separately at the first request after a cold start and successive requests after the connection is warmed up. Don't compare one request immediately after switching to a new node with an old node that has been connected for a while. Alternate between the two configurations within the same time window, and record typical results, unusually slow requests and failures. The fastest result is one sample, not a measure of everyday reliability.
Extra encapsulation and encryption add processing overhead, but whether you'll notice depends on the device's processing power, encryption implementation, network round-trip time, packet size and traffic pattern. A lightweight protocol header can't make up for congestion at the remote exit. A setup with more handshake overhead may spread that initial cost over a long-lived connection. If tests use different servers, describe them as a comparison of two working endpoints, not a protocol benchmark. If both protocols use the same machine and route, remember that their server processes may have different loads or rate limits.
Desktop resource use: Compare idle, sustained traffic and concurrent requests
At idle, check the memory used by the client and core processes and whether there's frequent background activity. During sustained transfers, look at CPU usage and effective throughput. For several apps making requests at once, check peak usage and how quickly it recovers. The interface and core may run as separate processes, and debug logs or a speed test page also use extra resources. Keep the software state consistent when comparing. TUN also passes more system traffic to the core, so comparing its total resource use with system proxy mode used only by a browser can't tell you anything about the remote protocol.
Higher CPU usage during a download doesn't necessarily mean the setup is worse; it may simply be transferring more data in the same amount of time. Match the destination, concurrency and data volume before comparing completion time and load. A brief memory increase that later drops may be due to caching or connection lifetimes; growth that continues over time calls for a closer look at the logs and connection count. Exclude the test tool itself, active logging and background downloads to get a comparison that better reflects everyday use.
Mobile battery use: Watch reconnects, not protocol labels
On mobile devices, battery use often depends on wireless radio wake-ups, background network activity and reconnect frequency. With a weak signal, repeated dropouts and retries can drain power even when no obvious download is running in the foreground. Frequent probes, subscription updates and keep-alive settings can also change background wake-up behavior. To compare two configurations, keep the network and app usage consistent. Observe a period of screen-on use and a period of screen-off standby, keeping the battery range, screen settings and background activity as similar as possible. Record Wi-Fi and mobile network results separately.
If standby drain is high but foreground speed tests look normal, first check whether the client keeps retrying in the background, restarts repeatedly after the system stops it, or routes more app traffic through its traffic-handling mode. Adjusting probe frequency and routing scope to fit your needs is usually easier to investigate than switching protocols at random. The system battery page can help show trends, but the client's battery attribution may not include all network hardware usage. Don't use it to promise a fixed battery saving for any particular protocol.
8. Choosing a setup: Narrow it down using server requirements and test results
First connection: Choose a setup that imports completely
If you just want to connect to a service that's already been provided, the server has already answered part of the protocol question. First confirm the node type and required core, then choose the client and local traffic-handling mode. For desktop, start with v2rayN; on mobile, follow the provider's guidance to choose v2rayNG or v2flyNG. If an existing configuration works, stick with it instead of changing protocols just to compare. After importing with the quick-start guide, test a local request and the app you actually use with one node. Only then consider additional rules and traffic coverage. Changing DNS, proxy mode and protocol all at once before confirming connectivity makes it hard to identify the cause of a failure.
If you can choose between several server endpoints, first rule out setups that your devices can't configure completely. A well-maintained legacy VMess endpoint can remain in use. VLESS with the corresponding security layer suits deployments where the required settings are already in place. Trojan fits existing standard TLS workflows, while Shadowsocks calls for careful matching of the method, key and extensions. These are deployment considerations, not a quality ranking. If you maintain several devices, a basic setup verified on all of them is usually easier to manage than a complex one that works on only one device.
Multiple apps and switching networks: Define traffic coverage first
If only a browser or a few apps that support proxy settings need access, start with the system proxy or the app's own proxy settings. Consider TUN only if several apps ignore the system proxy and you need to cover them. Before enabling it, note the system proxy status and current DNS behavior. Afterward, test destinations that should use the proxy and those that should remain direct, then confirm that local networking recovers when you exit the client. If you already use another virtual network adapter or system networking tool, check for routing or DNS conflicts first. For details, see Understanding v2rayN TUN mode.
For devices that often switch from Wi-Fi to a mobile network, focus on whether requests recover, not the lowest latency before the switch. After switching, check that the endpoint hostname resolves again and local traffic handling has recovered, then see whether the app can make a new connection. An existing connection dropping when the network changes doesn't mean the client is unusable. If new connections also fail, test each network separately to see whether the issue occurs only during the switch or persists on one network. If only background apps are affected, check the system's background restrictions for the app and client.
Everyday routing and updates: Change one thing at a time
Routing rules match domains, addresses or other conditions. If a domain goes direct in one client but through a proxy in another, the rule order may differ or the clients may have received different destination information. For example, a request made using a domain may not match the same domain rule as an app connecting directly to an IP address. Don't blame the node protocol for a routing difference. Use the logs to confirm the matched condition and final outbound, then check the rule order and destination type in Domain and IP routing rules.
Before changing a core or subscription, keep a working copy of a node, the current traffic-handling mode and any essential routing notes. After the change, check in order that the core starts, the local listener responds, the request uses the expected outbound and the destination returns content. Once verified, restore other groups or rules. If the test fails, switch back to the known-working setup and test each stage again. Don't delete the original configuration as soon as you switch nodes; otherwise, it's hard to tell whether the new setup is wrong or the endpoint, network or destination changed during testing.
When asking for help, note the client you actually use, its core family, protocol and transport combination, whether the failure happens during import or connection, and whether it behaves the same on different networks. Include the relevant error lines with sensitive details removed. If every node fails, first check the local listener and traffic handling, then shared parsing and network conditions. If only one group fails, focus on its subscription and source. For certificate or handshake errors, check the security layer separately. For installation help and common errors, see the Help Center.