V2Ray Advanced Setup Guide
For your first install, importing a subscription, or testing your connection, start with the quick-start guide. This page covers configuration changes after your connection is working. Jump to the relevant section based on what you’re seeing: if the list is empty, check your subscription; if only some domains fail, check routing and DNS; if things work only when TUN is off, check the traffic capture scope.
v2rayN is the recommended desktop client. Choose an installer for your system on the client downloads page. The steps here focus on v2rayN menus; Android-specific notes are called out separately. Before making changes, keep a restorable copy of your working configuration and change one setting at a time.
Subscription Groups and Server Filtering
Confirm what you’re updating before checking the server list
In the v2rayN main window, open “Subscription Group,” choose “Subscription Group Settings” to add a group, and save the subscription URL. Then return to “Subscription Group” and update it. Adding a group only saves the information needed to fetch the configuration; it doesn’t immediately add the URL’s servers to the list. If the menu offers “Update Current Subscription” and “Update All Subscriptions,” select the new group for the first import and update only that group. This makes it easier to match the request, parsing result, and list changes in the log to the correct URL, instead of guessing which URL caused an issue when several groups update at once.
After the update finishes, clear the server list search box and switch to the relevant group. The client may remember the last filter you used. If the status says the update completed but the list is empty, a search term may still be active, or the view may be showing an old group. Switch to “All” to confirm whether any servers were imported, but return to the source group to verify that a particular subscription imported correctly. Seeing a server with the same name under “All” is not proof that this update succeeded, especially when multiple sources use the same naming scheme.
Distinguish list searches from update filters
The list search narrows the current view; clearing it should show the existing entries again. Filters in subscription settings may determine which entries are accepted during an update, and clearing the search won’t restore entries those filters excluded. If you changed a group’s filter before updating, temporarily remove it, update that group alone, and compare the results. Filter fields and syntax vary between builds. If the settings clearly say a field supports regular expressions, try ^办公- to check whether it matches aliases by prefix, and confirm whether the field keeps or excludes matches. Don’t use a regular expression in a field that only documents support for plain keywords.
Start with a stable, short prefix or a clear category word. Don’t rely on flags, brackets, spacing, or temporary numbers in aliases. If a source renames its entries, an overly strict match can exclude the entire group on the next update. Test with two recognizable samples: one that should match and one that shouldn’t. After changing the rule, check both entries in the current group, then make sure other categories weren’t caught by mistake. Testing only one expected match won’t reveal whether the filter is broad enough to include unrelated entries.
Troubleshoot fetching, importing, and connecting separately
If the update log reports a request timeout, certificate error, or access denied, check the fetch path, device time, and whether the subscription is still valid before changing server ports. If the request succeeds but the content format isn’t supported, the response may be a web page, a login prompt, or entries the client doesn’t recognize. Checking the supported format with the subscription provider is more useful than repeatedly trying to import it. If the menu offers updates through or without a proxy, and you already have a working connection, try each option once and note the results. During initial setup, there’s no working outbound yet, so updating through a proxy can’t replace basic network checks.
Once the servers appear, move on to connection testing. Select an entry and run “Test real connection latency,” set it as the active server, then send a request from an actual app using the connection testing steps. The test tool and your app may use different entry points or connect to different targets, so a test result doesn’t guarantee every app will work. When contacting support, provide the error category, time it occurred, affected group, and client type. Remove subscription URLs, account parameters, server addresses, and any log lines that may contain them from screenshots.
Routing Rules in Practice
Identify where the rule takes effect
In v2rayN, open “Settings” and select “Routing Settings.” First, confirm that the plan you want to debug is selected under “Routing” at the bottom of the main window, then edit that plan. Apply the changes when prompted, and use “Restart service” if needed to reload them. Routing only affects traffic that reaches the relevant core. If an app doesn’t use the system proxy, explicitly point to the client’s listening port, or get captured by TUN, changing a route won’t affect its connections. That’s why one browser may behave differently while another app is unaffected. Confirm the entry point first, then inspect the matching rules, and finally check whether the selected outbound is actually available.
For standard Xray or V2Fly rules, check them from top to bottom: the first matching rule applies. Put specific exceptions before broader rules. For example, if a test subdomain should use a particular route but the parent domain should connect directly, put the subdomain rule first. Don’t use a rule that looks specific but only performs substring matching in place of a proper domain boundary. full: matches an exact domain, while domain: matches that domain and its subdomains. A bare string matches more broadly and isn’t suitable as a boundary for an important allowlist.
Check rule order with two domain rules and one IP rule
The snippet below is part of the core JSON routing configuration. Use it to check rule precedence in a configuration that already has proxy and direct outbound tags; it isn’t a complete client configuration. The example domains illustrate matching boundaries. For testing, use targets you’re authorized to access and can verify. If the graphical interface has separate fields for rules, enter the domain or address, outbound tag, and order in their respective fields. Don’t paste the entire object into a domain field.
{
"routing": {
"domainStrategy": "AsIs",
"rules": [
{
"type": "field",
"domain": ["full:status.example.com"],
"outboundTag": "proxy"
},
{
"type": "field",
"domain": ["domain:example.com"],
"outboundTag": "direct"
},
{
"type": "field",
"ip": ["192.168.0.0/16"],
"outboundTag": "direct"
}
]
}
}
When the request arrives with a domain, the first rule handles the exact host and the second handles other requests matching the parent domain. When an app submits an IP address directly, the IP rule applies. AsIs means the routing stage won’t resolve a domain to an IP address solely to match IP rules. So a rule that sends private IP addresses directly won’t necessarily match every domain that ultimately resolves to a private address. Decide whether your policy should use the domain received by the client or the resolved address before considering options such as IPIfNonMatch. If you add resolution, also check which resolver is used, which address families it returns, and what happens when resolution fails.
Different match fields in the same rule are usually combined as conditions. For example, if both a domain and a port are specified, the rule won’t match when the domain is correct but the port is outside the specified range. To match “this domain or this IP range,” create two rules and assign them the same outbound. Also check what happens when nothing matches: in a standard core configuration, unmatched traffic uses the first outbound, and the client may add fallback rules of its own. If the fallback differs from what you expect, inspect the configuration that actually loaded rather than assuming an outbound shown in the interface is the default.
Geo data and test cases
Broad rules can reference GeoSite domain collections or GeoIP address collections, but the available categories come from the local database. They aren’t a real-time policy list and don’t replace specific exceptions. If the core reports that a category doesn’t exist after you update the data, first check that the file is readable and the collection includes that category, then adjust the rule syntax. See the GeoIP and GeoSite database guide for database locations, updates, and category usage. Before changing a large collection, record one test case that should connect directly, one that should use a proxy, and one that should follow the default route. Reconnect for each test and check all three results; a homepage loading doesn’t prove the whole routing setup is correct.
DNS Configuration
Identify which component is resolving names
In v2rayN, open “Settings” and select “DNS Settings” to review the current configuration. Also confirm which connection mode is active. DNS requests may come from the system resolver, an app’s own encrypted resolver, or the client core. With a system proxy, some apps send the domain to the proxy, while others resolve it locally and send the resulting address. A browser with its own secure DNS enabled may also behave differently from the system resolver. In these cases, note the test app and its DNS settings before changing system servers.
Use the symptoms to decide what to check next. If a domain is reported as nonexistent immediately, check its spelling, resolver, and records for the relevant zone. If the request times out after a long wait, check whether the resolver is reachable. If the expected address is returned but the connection fails, investigate routing, the outbound, address family, or the server instead of switching DNS servers again. A domain can resolve to multiple addresses, and a successful lookup doesn’t mean every address is reachable. Corporate networks may use internal resolvers that return private addresses; an empty response from a public resolver isn’t necessarily a fault, and switching to public DNS may make internal services unavailable.
Configure servers, matching scope, and address families
The snippet below is an Xray- or V2Fly-style core DNS object with a single resolver, useful for isolated testing to rule out resolver selection issues. The public address is only an example; replace it with a DNS service that’s accessible and permitted on your network. This section defines the core’s query server; it doesn’t change the operating system’s DNS settings or determine which outbound carries DNS traffic. If the interface offers simple and custom modes, first check whether the input expects a server address or complete JSON. They aren’t interchangeable.
{
"dns": {
"servers": ["1.1.1.1"],
"queryStrategy": "UseIP"
}
}
UseIP doesn’t restrict queries to a single address family. If a new network fails only over IPv6, compare results with UseIPv4. Note that this affects only queries handled by this DNS module; it can’t disable IPv6 in the system or in apps. After troubleshooting, restore a policy suited to your network rather than restricting address families as a default fix. Some networks and internal services require IPv6. When using multiple resolvers, first specify which private domains must use an internal server, then choose the default resolver for other domains. Don’t combine multiple server addresses into one comma-separated string; list each server as a separate array entry.
If you switch to an encrypted DNS endpoint identified by a domain name, check how the client resolves that endpoint at startup and which route its connection uses. For example, if reaching the resolver requires a working proxy, but the proxy server’s own domain depends on that same resolver, startup can deadlock while each waits for the other. Keep a startup resolution path that works independently, and limit its scope. Encrypted DNS protects part of the query path; it doesn’t mean the client can intercept every query from every app or guarantee that all queries leave through the same route.
Use repeatable comparisons to distinguish caching from rule issues
Keep one public test domain and one internal domain you’re authorized to use. Test each with the original configuration, after the change, and after restoring the original configuration. If nslookup is available on Windows, macOS, or Linux, use the commands below to compare default resolution with a query to a specific server. Otherwise, use your platform’s built-in diagnostic tools. A query to a specified server shows whether that tool can get a response; it doesn’t prove other apps use the same server or show which outbound the proxy core selected. Consider app, system, and core caches, as well as existing connections, separately. Test with a new connection after making a change, and restart the relevant component if needed, rather than clearing everything at once and losing your comparison.
nslookup example.com
nslookup example.com 1.1.1.1
TUN Mode and Traffic Capture
Establish a baseline with the system proxy before enabling TUN
First confirm that the active server and basic routing work with the system proxy or an explicitly configured proxy, then enable TUN. TUN uses a virtual network interface to receive packets routed by the operating system. It’s useful for apps that ignore system proxy settings, but it doesn’t guarantee that every network adapter, protocol, or process will be captured. Capture behavior depends on system routes, exclusions, address families, and the core in use. Before enabling TUN for the first time, note the “System Proxy,” “Routing,” and “TUN Mode” states at the bottom of the main window, and keep a working test path available with TUN off.
On Windows, close v2rayN if it’s running without elevated privileges, then relaunch it as an administrator. Follow the interface prompts to check TUN settings and permissions, then enable “TUN Mode” at the bottom of the main window. Authorization on macOS or Linux depends on the installation method and system policies; follow the client and system prompts rather than running every component with elevated privileges indefinitely. On Android, v2rayNG and v2flyNG usually connect through system VPN authorization. This isn’t a one-to-one copy of the desktop controls, so don’t apply desktop interface names and permission steps directly.
| Environment | Check first | If there’s a conflict |
|---|---|---|
| Windows | Process permissions, virtual interface, and startup logs | Close other traffic-capture tools, then test TUN by itself |
| macOS | System authorization prompts and current network service | After switching networks, check the default route and local services again |
| Linux | Virtual interface permissions, routes, and system resolver | Check whether policy routing sends return traffic or upstream connections back through the virtual interface |
| Android | System VPN authorization and per-app scope | Check whether another VPN is using the connection and whether the test app is excluded |
Verify capture scope and common conflicts
For an initial test, choose a browser that already works with the system proxy, then choose an app that you know ignores that setting. To isolate variables, note the original state, turn off the system proxy, leave only TUN enabled, and start a new connection from each app. If both the system proxy and TUN are enabled, a working browser only proves that at least one path works; it doesn’t prove the virtual interface is capturing traffic. Don’t rely on an already-open page as your only test: connection reuse can leave old and new paths active at the same time. If app or subnet exclusions are enabled, test one target that should use TUN and one that should be excluded.
If every connection fails as soon as TUN is enabled, turn it off to restore the previous path. Then check the logs to see whether permissions are insufficient, interface creation failed, or the interface is ready but there’s no working upstream. The last case often occurs when the proxy server connection is routed back through the virtual interface, creating a loop. Check upstream bypass, the physical interface, and the default route using the options supported by your client. If only printers, shared folders, or internal services fail, check the LAN subnet, system firewall, and DNS first. Don’t allow every private address just to restore access to one office service: different networks may reuse the same subnets, and a broad exception can change the path for other traffic.
Check sleep, network changes, and protocol differences
TUN working immediately after you enable it doesn’t guarantee that routes will remain correct after waking from sleep, switching Wi-Fi networks, or connecting to another VPN. After a network change, test the upstream connection, then an internal service and a public site. If the problem only occurs after switching networks, note the interfaces before and after the switch and when the error occurred; don’t mistake a state recovery issue for an invalid subscription. If websites work but calls or real-time apps don’t, check UDP, address families, and the app’s network requirements separately. A successful web request only confirms that TCP works, not UDP. If the system retains an abnormal network state after exit, turn off TUN and close the client normally. Confirm that the system proxy and DNS settings have returned to their previous state before the next test.
FakeDNS Mapping and Scope
First check whether the domain context is being lost
FakeDNS is useful when an app first queries DNS and then connects to the returned address, but the transparent capture entry point can only see the address, not the domain the user requested. With FakeDNS enabled, queries it handles can receive mapped addresses from an address pool. If the subsequent connection passes through the same capture and mapping mechanism, the core may be able to resolve the address back to the domain, then route it by domain and connect to the real destination. FakeDNS doesn’t improve authoritative DNS accuracy and isn’t a general replacement for the system resolver.
First compare the regular DNS setup with your current connection mode. If an app already sends the domain directly to the proxy and your rules match it, there’s no need to add address mapping just for its own sake. Conversely, FakeDNS can’t recover a domain that was never provided: an app may use a hard-coded address, bypass the managed resolver, or use its own encrypted resolver to obtain and cache the real address. Check two things: did the app’s query pass through the resolver that provides the mapping, and did its connection enter a component that understands the same mapping table?
Check the address pool, DNS selection, and entry point
For Xray custom configurations that support this feature, the fakedns object below shows how to define an address pool. It’s only one part of the configuration and can’t provide the full working path on its own. You also need to select FakeDNS in the relevant core’s DNS settings and configure the capture entry point with the required recognition features. When the client generates a TUN configuration, another component may handle DNS capture. Check the running core and interface to see which fields are available and where they belong; don’t paste this object into a different configuration format.
{
"fakedns": [
{
"ipPool": "198.18.0.0/15",
"poolSize": 4096
}
]
}
ipPool is the subnet used for mapped addresses, not the address of a remote DNS service. poolSize sets the capacity of the mapping pool; it doesn’t indicate the number of servers. Before choosing a subnet, check for overlapping routes in your LAN, test networks, corporate VPN, and other virtual interfaces. If ranges overlap, a real address could be mistaken for a mapped address, or a mapped connection could be sent over a physical network. Seeing an answer from the pool only suggests that a query may have been handled by the mapping resolver; it doesn’t prove that the subsequent connection will be restored and forwarded correctly. Apps may also reject reserved ranges, making the mapped answer unusable.
Start by keeping internal business domains, LAN devices, and client upstream addresses on their normal resolution paths. Then test mapping with a small number of domains. Internal services may need real addresses to verify subnets or discover devices. An upstream that depends on a capture path that hasn’t been established may also create a startup loop. Check DNS and outbound rules separately; they aren’t the same table. Excluding a domain from FakeDNS only means it won’t receive a mapped address. The final connection still depends on routing policy.
Handle stale mappings, dual-stack connections, and restart differences
After enabling FakeDNS, record the query answers and the routing results for subsequent connections. After disabling it, start a new app session and refresh app and system DNS caches if needed. Restarting the client may clear the mapping table while an app still has an old address cached; connections to that stale mapping can fail even though new DNS queries are working again. If you configure IPv4 mapping only, also check whether the app prefers another address family. Otherwise, a test may happen to use a different path and lead to the wrong conclusion. Retest one internal domain, one ordinary domain, and one direct IP connection. If only the second case fails, focus on domain mapping. If all three fail, restore basic TUN and check the capture entry point instead of expanding the mapping scope.
Managing Multiple Subscriptions and Update Strategies
Assign maintenance responsibility by source, not by temporary use
Once you can update a subscription by itself, create separate groups for different sources in v2rayN’s “Subscription Group Settings.” Name each group to indicate who provides it, the environment it’s for, and when it shouldn’t update automatically—for example, keep work testing separate from everyday use. Don’t use a subscription URL, account details, or a link with parameters as a group name; these can easily leak through the main window, screenshots, or exported lists. If you need two uses for the same source, distinguish them with the active server and routing plan. Create separate configurations only when you genuinely need different update conditions or import scopes.
Two entries with the same alias aren’t necessarily the same configuration, and choosing either one won’t necessarily reproduce the same issue. Check the source group, protocol, and configuration details shown by the client; entries with the same alias may use different transport settings. Conversely, if a source renames a server, a new-looking list entry doesn’t necessarily mean its network behavior changed. Keep these roles distinct: groups identify the source, filters help find entries, and routing determines where connections go. That way, you won’t add a subscription to fix a routing mismatch or use routing rules to clean up duplicate names.
Update in batches and keep a known-good baseline
Update one group at a time. Confirm that the log shows a successful fetch and parse, check that the expected entries are present, and then test whether the active server still works. A source may remove old entries or change their parameters, so test the connection even if the menu still shows a familiar alias. If you plan to schedule updates, first confirm that your client build supports the option, then schedule groups that are critical to your work for a time when you can verify them manually. Don’t update multiple sources at once and restart immediately; if something breaks, it’ll be hard to tell whether the cause was a group change, an interrupted session, or a routing reload.
Keep manually entered test entries in a group separate from automatic subscriptions so you don’t mistake subscription-generated entries for locally maintained configurations. Before saving an export or backup, note the client, connection mode, routing plan, and update time. Store backups containing subscription URLs somewhere access-controlled. Before importing, check whether the backup contains the full configuration or only a server list; restoring a list won’t restore DNS, routing rules, or system proxy settings. If the backup contains an expired subscription, a successful restore doesn’t guarantee it can still update. Check separately whether the source remains authorized.
Diagnose update failures by their scope
If only one group fails, check that group’s URL, fetch path, and response format first. If several groups fail at once, check the device clock, certificate trust, proxy status, DNS, and recent network changes. If a group updates but connection tests all fail, investigate the active server and core protocol support instead of repeatedly refreshing the URL. If another group starts behaving differently after an update, check whether the active server or default route changed, and whether both groups depend on the same underlying connection. For comparisons, keep the network, target, and client entry point the same before and after the change.
When moving to Android, check the subscription format, core support, and system VPN authorization in v2rayNG and v2flyNG separately. Migration means re-importing authorized sources, reviewing key policies, and testing the setup; desktop routing tables, TUN exclusions, and update schedules don’t carry over automatically. Start with one small group and confirm it works in the target client before moving the rest. If a work service is only accessible from the desktop environment, check its access requirements instead of copying the entire desktop configuration to a phone. For groups you no longer use, disable updates first and check whether any workflow still depends on them before removing them according to your maintenance plan.
Custom Outbounds and Tag References
Plan the match before choosing how to edit it
Custom outbounds specify which requests use which route; they’re separate from subscription updates. First write down three things: which targets should match, which outbound they should use, and what should happen to everything else. For example, while troubleshooting an internal domain, route one authorized test domain directly and leave all other requests on the existing configuration. This makes it easier to verify that the custom rule works and keeps unexpected changes limited to one specific target. Don’t reorder every outbound just to test a new rule.
For standard routing on desktop, use “Routing Settings” and the existing outbounds. Only use a custom configuration entry point supported by the client, or maintain a complete core configuration in an isolated environment, when you need an outbound the interface can’t express. The graphical interface may regenerate the runtime configuration based on the active server and settings, so changes to a temporary generated file usually won’t persist. Keep a separate backup and identify which file is the actual source of configuration. After switching to a custom configuration, recheck the listening entry point, system proxy, DNS, and default route; don’t assume it inherits every option from the standard server configuration.
Connect rules to existing outbounds with tags
The example adds a named direct outbound to an existing Xray- or V2Fly-style configuration, then references it from an exact-domain rule. In your configuration, append the single object from outbounds to the existing array and insert the rule in the right place among the existing rules. Keep all other entries and the default outbound. Don’t use this snippet to replace the client’s complete configuration or as a substitute for protocol settings from your service provider.
{
"outbounds": [
{
"tag": "site-direct",
"protocol": "freedom"
}
],
"routing": {
"rules": [
{
"type": "field",
"domain": ["full:status.example.com"],
"outboundTag": "site-direct"
}
]
}
}
Tags are internal configuration references, so keep them unique, stable, and case-sensitive. The alias shown for an entry in the interface may differ from its core tag. When renaming a tag, also search for routing rules and chained configurations that reference the old one. If a rule is correct but points to a nonexistent tag, startup may fail or the problem may only surface when you connect, depending on the core and version. A successful match only confirms that an outbound was selected. Direct outbounds still require the system to reach the target, while proxy outbounds need their server protocol, transport, and handshake settings checked separately.
Before adding a block rule, confirm that the exact target should be denied, then test an unaffected target to make sure the rule isn’t too broad. A block can look like an ordinary timeout, so check the core logs to see which outbound was selected rather than relying on a page error. Also check whether DNS requests are handled separately; blocking an app connection doesn’t mean no DNS query was made for that domain. For advanced features such as interface binding, chaining, or selecting among multiple outbounds, first confirm that the current core explicitly supports the relevant field. Start with one outbound instead of adding several interdependent ones to a production configuration at once.
Deploy with positive and negative tests, then confirm rollback
After loading the new configuration, check the logs to confirm it was read and that there are no port conflicts. Use a new connection to test an exact matching target, then test a non-matching target to confirm that the default behavior is unchanged. If the logs show only an IP address and no domain, check what the entry point is sending to the core rather than changing tags again. If the new rule changes every connection, first check whether you changed the first outbound or placed a broad rule too high in the list. Keep the original file and a note of your changes after testing. To roll back, restore the configuration and reload it, then use the same test cases to confirm traffic is back on its original path.
Core Selection and Configuration Testing
Choose a core based on the protocol and configuration format
The client stores subscriptions, presents settings, and generates the runtime configuration. The core handles protocols, routing, and connections. On desktop, v2rayN can manage different cores; available options depend on the installer and configuration type. On Android, v2rayNG primarily uses Xray, while v2flyNG is an alternative based on V2Fly. The cores have similar configuration conventions, but that doesn’t mean every protocol parameter, DNS field, and entry recognition option can be transferred unchanged. If only one subscription entry fails, first check whether its protocol and transport combination is supported by the current core. For background on VMess and VLESS, read the VMess vs. VLESS comparison, then check the actual configuration.
Before switching, note the active server, routing plan, system proxy, and TUN state, and keep the original configuration. Use the core type or configuration entry point listed by the client; don’t load another core’s JSON as though it used the same settings. After switching, turn off extra traffic capture and advanced DNS options, then test a known working connection. Once the basic connection works, re-enable routing, DNS, and TUN one at a time. If an advanced option prevents startup, this makes it easier to identify which change caused the failure. If the core won’t start, check the first meaningful error in the log. Subsequent connection errors are often just a result of the service not starting.
Compare each layer from entry point to destination
First check the entry point: did the client start, is the listening port used by the app available, and are the system proxy or TUN settings active? Then check DNS: did the app send a domain or an address, and did the lookup return the expected result? Next, check routing: which rule matched the test case, and was its outbound loaded? Finally, check the upstream connection: did the handshake succeed, and did the target service return the expected response? A browser error isn’t enough to identify which layer failed. The client’s “Test real connection latency” also tests only one case; it doesn’t prove that every app protocol works.
If needed, briefly increase log verbosity, make one request, and match its failure time to the relevant log entries. Restore the original log level when you’re done. Some logs may include destination URLs, internal hostnames, service parameters, or subscription request details. Before sharing, keep only the lines needed for troubleshooting and redact sensitive information. You can also verify the change by restoring the old configuration, closing any reused app connections, and testing the same target over the same network. If the original result returns after the rollback, that’s evidence the configuration change caused the issue rather than an upstream service that happened to recover.
FAQ: Keep a Minimal Reproducible Configuration
Why doesn’t the listening port work after switching cores?
Check the startup log to distinguish unrecognized configuration fields, missing data files, and port conflicts. If the client’s standard server configuration starts but the custom configuration doesn’t, return to the standard configuration as a baseline and add the custom settings one section at a time. If neither starts, check which processes are running and whether a port is actually listening. Don’t assume the core has started just because the window is open.
Why is just one app still failing after I restore the configuration?
The app may still have an old connection open, cached DNS or mapped addresses, or its own proxy and resolver settings. Quit and reopen the app, then check whether it uses the same entry point as your other apps. If the issue only happens after waking from sleep or switching networks, record the capture state at that time and repeat the test with the same target. This is more likely to narrow down the cause than reimporting an entire subscription group.
To rebuild from a basic setup, return to the quick-start guide. Get a connection working with one group, one active server, and one connection method, then restore settings one section at a time using this guide. If you can verify each step independently, you only need to undo the most recent confirmed change when something goes wrong.