To use the same nodes on a PC and Android phone, the simplest option is to import the same compatible subscription into v2rayN and v2rayNG. Use a QR code to transfer an individual node, and reserve config backups for moving between devices running the same client. This guide covers all three methods, what they sync, which routing and proxy settings must be configured separately, and how to import and verify settings on both devices.
1. Sharing nodes doesn't sync your entire setup
A node contains the connection details needed to reach a server, including its address, port, protocol, credentials, and transport settings. When two devices use the same node, each establishes its own connection; the phone's traffic does not pass through the PC. The phone can connect on its own even when the PC is off. Whether both can connect at the same time depends on the provider's device, concurrent connection, and data limits.
A subscription provides a list of nodes, while Routing determines how the client handles traffic. Using the same subscription won't automatically sync the selected node, system proxy toggle, Android per-app proxy list, or custom DNS settings. Treat matching node parameters and matching local behavior as separate tasks to avoid mistaking a successful import for a complete migration.
| Setting | Subscription or share link | What to do on each device |
|---|---|---|
| Address, remote port, credentials | Usually included | Confirm the same node after importing |
| TLS, SNI, transport path, Flow | Depends on the format and parser support | Check each field in the node editor |
| Currently active node | Usually not included | Select separately on each device |
| Routing rules, DNS policy | Not included in a standard node subscription | Configure and verify separately |
| System proxy, TUN, per-app proxy | Not included | Configure for each operating system |
2. Choosing between subscriptions, QR codes, and backups
For long-term use, the main challenge is updating nodes when server addresses or credentials change. A subscription can refresh the node list; a QR code generally stores just one node as it was when generated; a client backup is better for restoring the app's existing state. These methods can complement one another, but they aren't interchangeable.
The same subscription link
RecommendedEach device independently fetches the node list published by the provider, so you don't have to transfer nodes one by one when they change. This works if the link returns a format both clients can read, rather than a platform-specific full configuration. Even the same subscription URL may return different content depending on request identifiers or provider policies.
Best for: using the same set of nodes on a PC and phone over time
QR code for one node
Import one node at a time, handy for sharing in person. A QR code contains a share link with no update mechanism and doesn't include the client's full routing setup. If the server's port or credentials change, you'll need to share it again.
Best for: one-off imports, a few nodes, or when you don't have a subscription link
Export a config backup
Backups may include groups, nodes, routes, and app preferences, but what's included varies by client and version. A v2rayN config file can't be used as a v2rayNG app backup. To move nodes between platforms, exporting their share links is usually the better choice.
Best for: moving to a new device with the same client or saving settings before an upgrade
If your provider offers separate links for desktop and Android, first check whether they're for the same account and which protocols they return. Don't force a client to parse an unsupported format just to use “the same link.” If no nodes appear, check the subscription format and response before troubleshooting connection parameters.
3. Import the same subscription on both devices
Import the subscription while you're connected to a network that works. The menu labels below are from common Chinese-language interfaces; depending on the version, “Subscription groups” may appear as “Subscription group settings,” and buttons may be in different places. Look for the equivalent feature. Don't enter a subscription URL in the server address field on the node editor.
-
Check the subscription format
Get a subscription link from your provider that works with v2rayN and v2rayNG, and confirm your account allows two devices to connect at once. Links often contain access tokens, so share them through a trusted, private channel—not in public notes or group chats.
-
Add a group on your PC
In v2rayN, go to “Subscription groups” → “Subscription group settings” → “Add” from the main window. Enter a group name and subscription URL, then save. Next, choose “Subscription groups” → “Update all subscriptions (without proxy).” If your current network can't reach the subscription and you already have a working proxy, try the corresponding update option that uses the proxy.
-
Add the subscription on your phone
In v2rayNG, open “Subscription group settings” from the side menu, tap “+” in the top-right corner, enter a remark and subscription URL, then save. Return to the node list and choose “Update subscription” from the top-right menu. Wait for the update to finish, then confirm that the group contains nodes.
-
Select the same node
On your PC, select the node and set it as the active server. On your phone, select the matching node and tap the connect button. When starting the Android VPN for the first time, approve the system connection request. Don't rely on the remark alone: compare the server address, remote port, and protocol.
-
Record the update results
Note when each device updated successfully and how many nodes appeared in each group, then test the same destination on both. If the lists later differ, update both subscriptions again instead of repeatedly scanning an old QR code. Automatic update settings only affect the local device; they can't trigger an update on the other one.
4. Fields to check after sharing a QR code
If you don't have a subscription, select a node in the v2rayN node list, right-click it, and choose “Share server” to display a QR code. In v2rayNG, tap “+” on the main screen and choose “Scan QR code” to import it. Alternatively, copy the share link on your PC and use “Import from clipboard” on your phone. Check the imported fields before deleting the original node.
VMess, VLESS, Trojan, and Shadowsocks use different share formats. Complex transport settings may also be omitted due to differences in how links are generated or parsed. The cards below show which fields to check; they aren't ready-to-use server configurations. Use the values from your original node—don't copy a sample port or path just because it appears here.
VLESS + REALITY checks
- Remote port
- Example: 443. Use the value provided by your service.
- Transport
- Often TCP; some interfaces label it RAW.
- Flow
- For Vision, use
xtls-rprx-vision - Server name
- SNI must match the original node.
- Authentication parameters
- The public key and shortId must match the original node.
- Fingerprint
- For example,
chrome. Check your provider's requirements.
The migration is successful only if the client supports the feature and all parameters are present; importing the UUID alone isn't enough.
VMess + WS + TLS checks
- Remote port
- Example: 443, not the local listening port.
- User ID
- UUID must match the original node on your PC.
- Transport
- WebSocket
- Path
- For example,
/ws. Match the capitalization exactly. - Request host
- Set Host to match the original node.
- TLS name
- Set SNI to match the original node; it may differ from the connection address.
The WebSocket Host and TLS SNI are separate fields. Don't substitute one for the other.
- If a dense QR code won't scan, enlarge it and increase your screen brightness, or use the original share link instead. Avoid unknown online QR code conversion tools.
- If the node imports but won't connect on your phone, check the security, transport, and authentication fields in the node editor—not just the node name.
- QR code screenshots contain access credentials too. Delete unnecessary screenshots and clipboard history after sharing. If credentials are exposed, ask your provider to replace them.
5. Configure Routing and proxy access separately
Once the nodes match, set up similar routing goals on both devices—for example, send local network addresses directly, route specified domains through the proxy, and handle other traffic using your chosen default outbound. Standard subscriptions don't transfer these preferences to another device. Even identical rule text can produce different results if rule resources, DNS resolutions, or rule order differ.
Recommended: share nodes, manage local settings separately
Desktop (v2rayN)
- After importing the subscription, check the active rule set under “Settings” → “Routing settings.”
- Configure the system proxy as needed. Consider TUN only if you need to cover apps that don't respect the system proxy.
- Under “Settings” → “Parameter settings,” check and note the local listening port.
- Confirm the selected core supports the node protocol, then check the startup log after making changes.
Android (v2rayNG)
- Check the routing mode and custom rules under “Settings” in the side menu.
- Make sure the app you're testing isn't excluded from per-app proxying.
- Start the VPN service before testing your browser and target app.
- Check the DNS settings and rule resources, and adjust them for your device.
Sync the routing goals, not every toggle. The desktop system proxy and Android VPN cover different traffic.
For example, the node's remote port might be 443, while the local proxy listening port on your PC might be set to 10808. When you import the same node on your phone, keep the remote port. Don't enter your PC's local listening port as the server port. Because each device runs its own client, their local ports don't need to match.
- Local network access: Check that private network addresses are routed directly, so requests to your router or local devices don't go through the proxy.
- Specific domains: Use the same set of custom domain rules, and make sure specific rules come before broader ones.
- DNS behavior: Decide whether DNS queries should go through the proxy, and distinguish a DNS resolution failure from a remote connection failure.
- Rule resources: The contents of
geositeandgeoipchange over time. Track resource updates on each device; standard node subscriptions don't sync them automatically.
6. Backups are for moving devices, not entire setups across platforms
v2rayN app settings, the Xray runtime config, and a v2rayNG app backup are three different things. Using JSON files doesn't mean their structures are the same. A core runtime config containing inbounds, outbounds, and routing isn't the same as a client backup with subscription groups and interface preferences.
When moving between platforms, use node share links or the subscription import feature supported by both clients. A full custom config is only suitable if you understand exactly what it does: it may hard-code nodes, listening methods, and routing, without preserving the editing and update features of a standard node list.
- Before moving to a new device: Note the client version, core in use, subscription groups, and custom rules. Use the backup or export feature provided by that version.
- Before restoring: Back up the target device's existing settings and check whether the import merges or replaces them. If that's unclear, test with a single node first.
- After restoring: Check the active node, routing mode, DNS, proxy access, and subscription update behavior. Don't stop just because the node list appears.
- Storing backups: Backups contain access credentials, so encrypt them and restrict access. Delete obsolete backups to avoid restoring revoked nodes by mistake.
7. How to check for sync issues and connection failures
For the first test, connect your PC and phone to the same Wi-Fi, select the same node, and visit the same destination. Then switch your phone to mobile data and test again. This helps separate configuration issues from network differences. Don't change the node, routing, and DNS at the same time; if the connection starts working, you won't know which change fixed it.
| Symptom | Check first | Next step |
|---|---|---|
| Different node counts on each device | Subscription group, update time, format compatibility | Update both; check whether only some nodes were parsed successfully |
| Same node name, but the phone won't connect | Server, port, SNI, Flow, transport settings | Compare the node editor fields and check the phone's connection log |
| Each device works alone, but not at the same time | Account concurrency and device limits | Disconnect one device and test again; confirm the limits with your provider |
| Browser works, but an app doesn't | Whether the app is covered or excluded | Check system proxy, TUN, or Android per-app settings |
| Works on Wi-Fi, but not on mobile data | Network reachability, DNS, IPv6, and transport requirements | Keep the config unchanged and compare the error logs from both tests |
| An update restores old settings | Subscription refresh overwrote manual changes | Report the subscription content to your provider; keep temporary nodes in a separate group |
Different latency readings don't necessarily mean sync failed. Clients may test TCP connection time or an HTTP request through the proxy, and their targets, timeouts, and network conditions may differ. More useful checks include whether both devices can open the same destination, whether the logs show errors, whether connections stay stable, and whether Routing selects the expected outbound.
Does my phone need to connect through my PC's local proxy?
No. After importing a node and starting v2rayNG, your phone connects directly to the server. Using your PC's proxy over the local network is a different setup: the PC must stay on, and you'll need to configure its listening address and firewall. That's not node syncing.
Will changes to a node on my PC update it on my phone automatically?
No. Manual edits are saved only in the current client. Share the node again, or have your provider update the subscription so both devices can refresh it. Local edits aren't submitted to the subscription server.
Does updating a subscription sync the selected node and routing rules?
Standard node subscriptions mainly update the node list. Whether the active node is preserved depends on the client, so check it again after an update. Custom routing, per-app lists, and local proxy toggles still need to be managed separately.
For routine maintenance, keep a short record of the subscription group name, update times on both devices, current node address and port, routing mode, and the latest test result. Leave out the full subscription URL, UUID, and password. If something goes wrong, check this record before changing settings one by one. For a fuller troubleshooting workflow, see Troubleshooting; for terminology, see Quick Reference.