Configuration Reference · Advanced Guide

Advanced V2Ray Configuration

Start with the quick start guide to import a configuration, connect, and verify it. Then use this handbook to look up individual settings. The desktop guidance focuses on v2rayN; Android-specific differences for v2rayNG and v2flyNG are noted separately.

Subscriptions & FiltersTraffic Routing & DNSOutbounds & Cores

Subscription Groups & Server Filtering

Set the Update Scope by Source

The primary purpose of subscription groups is to control what gets updated, not to classify servers by location. In v2rayN's subscription group settings, add an entry with a recognizable alias and subscription URL. Save it, select the group, and run an update for that group only. Choose an alias that describes the source and its purpose, such as “Lab Remote Access” or “Personal Backup.” If one source provides multiple subscriptions for different purposes, give each a distinct alias. This makes it clear which source to request again when troubleshooting. Server display names, by contrast, identify entries in the list; don't confuse the two.

After updating, check which group received the new entries, then confirm that their protocols and transport types match the source documentation. Entries imported individually from a share link or clipboard aren't valid samples for verifying a subscription update. They may connect successfully without proving that the client received the latest subscription. If you need to keep a manually added configuration temporarily, give it a separate alias. Don't rely on manual edits to entries in a subscription group, since a refresh can replace the entries and their parameters with the versions published by the source.

Filter by Names You Can Verify

If your version of v2rayN has a server filter field, check its description first. If it filters server aliases, don't enter an address, outbound tag, or routing domain. If the interface specifies regular expressions, ^(Office|Test)- matches names that start with either word followed by a hyphen. Test it against one name that should stay and one that should be excluded before saving and refreshing. In a regular expression, parentheses group alternatives and the vertical bar means “or.” Escape a literal period as \. so it isn't treated as a wildcard. Use start and end anchors only when naming conventions are consistent.

Don't infer from the field name whether a match keeps or excludes an entry, or assume filtering only affects what's visible in the list. Test with a temporary group: note representative entries before filtering, apply the condition, and update again. Check whether entries were discarded during import or are simply hidden from view. Use the same group and source before and after filtering so you can attribute any difference to the condition. Changes to source names, whitespace, or capitalization can invalidate an existing condition. To recover, clear the filter, update that group, and then decide how to narrow the match.

Distinguish Request Errors, Parse Errors, and Empty Results

If the update log reports a hostname lookup failure or connection timeout during the request, first check whether the subscription domain resolves, whether the current network can reach it, and whether the client sends update requests directly or through an existing proxy. Server filtering hasn't started yet. If the request completes but parsing fails, check whether the response is a subscription format the client recognizes. It may be a login page or service message rather than server configurations. If parsing succeeds but expected entries are missing, check server naming, filter conditions, protocol support in the client, and whether the wrong group is selected.

On Android, don't look for the same feature under a desktop menu name. Import and refresh through the subscription interface in v2rayNG or v2flyNG, then use the grouping and filtering options that client actually provides. If there's no equivalent field, keeping the original subscription and managing sources separately is more predictable than assuming a desktop regular expression can be used as a mobile client setting. If the same source updates on desktop but fails on mobile, retry under the same network conditions first. Update requests and protocol parsing are independent on each client, so list length alone can't diagnose the problem.

Routing Rules in Practice

Identify the Traffic Entry Point First

Routing rules only handle traffic that has entered the core. With the system proxy enabled, apps that honor that setting can usually send requests to the local proxy. Apps configured to connect directly, using a separate proxy, or handling some connections themselves may use a different path. To test, choose an app where you can explicitly set a local proxy and confirm the client receives its requests before changing rules. If the logs don't show the corresponding inbound request, adding domain rules or changing their order will only obscure an entry-point problem. Desktop systems sometimes have both the system proxy and TUN enabled; for an initial test, use just one traffic-capture method to reduce variables.

Whether a domain can be matched also depends on what destination information the entry point receives. If an app sends the domain to the proxy, domain rules can match it directly. If the app resolves the name first and sends only an IP address, the core won't reconstruct the domain just because a domain rule exists. In some cases, inbound sniffing can recover a destination name visible in the protocol, but results depend on traffic type, encryption, and client settings. If the same site matches different rules in different apps, first check whether the logs show a name or an IP address, then consider adding an IP-based rule.

Put Specific Rules Before Broad Rules

Xray checks routing rules in array order and uses the outbound associated with the first match. Within a rule, different criteria such as domain and port must all match; candidates in the same domain array are alternatives. The example below shows only a routing object to place in the top-level routing field. Both referenced tags must already be defined in the top-level outbounds field. The first rule excludes only the test hostname; the second matches the example domain and its subdomains. Because the example doesn't rely on rule files, it helps isolate basic matching from rule-resource loading issues.

{
  "domainStrategy": "AsIs",
  "rules": [
    {
      "type": "field",
      "domain": ["full:blocked.example.org"],
      "outboundTag": "blocked"
    },
    {
      "type": "field",
      "domain": ["domain:example.org"],
      "outboundTag": "direct"
    }
  ]
}

If you put the example's second rule first, the first hostname will match the broader domain rule and the exclusion won't run. Likewise, a catch-all rule that sends all regular traffic to one outbound will prevent specific rules from matching. When using a built-in routing preset, make an editable copy first, then review rule order and the outbound ultimately selected. Traffic that matches no rule uses the first outbound by default in Xray. GUI clients may add a fallback rule to the generated configuration, so don't infer the actual route from the order of servers in the interface.

Test Domain Policies and Rule Resources Separately

AsIs doesn't require a DNS lookup just to match routing rules. IPIfNonMatch is useful when no domain rule matches: it then tries IP-based rules using resolved addresses. If a broader rule already matches the connection, don't expect this fallback lookup to happen. IPOnDemand allows resolution when a rule check requires an address, so rule order can affect when a lookup is triggered. These settings determine how routing gets values to match against; they don't select an app's DNS server or guarantee that the outbound uses the same DNS result.

When switching from hand-written rules to geosite: or geoip: matches, also check that the core can load the relevant resource files and that the categories exist. A valid category name doesn't guarantee coverage of every domain a site uses; the main page, login service, and static assets may match different rules. To verify, test one connection that should match and another that should use the default outbound, starting a new session for each and checking the logs. Existing connections won't choose a new outbound just because you edited a rule. For a closer look at inbound, routing, and outbound structure, see Understanding the V2Ray Configuration JSON Structure.

V2Ray DNS Configuration

Separate App DNS from Core DNS

If a domain connection fails, don't start by switching DNS servers. First determine which component made the query. Some apps use the system resolver, some pass the name to a proxy for resolution by the core or outbound, and others send encrypted DNS requests themselves. DNS settings in the client affect only queries handled by that DNS module; they don't automatically rewrite requests made independently by an app. When testing the same domain in an app and in the client, note which path each uses. Getting an address from a terminal query only proves that the terminal's resolver path worked; it doesn't show that proxy DNS rules are active.

Internal hostnames are especially useful for testing boundaries. If a service resolves only on its organization's network, send its name to the resolver designated for that network and confirm that the relevant interface can reach it. Sending an internal name to a public resolver may return no result or disclose the name to a service that doesn't need it. Test one known name managed by the internal resolver and one public name. First confirm that each resolver works on its own, then apply the domain mapping in the core configuration. Different results from two resolvers alone don't prove that split DNS is working or broken.

Configure Resolvers, Match Scope, and Fallback Separately

In Xray configurations that support native snippets, the top-level dns field's servers array defines candidate resolvers. A server object's domains field specifies its match scope. This affects resolver selection; it doesn't automatically route a connection to an outbound with the same name. The example below illustrates matching and fallback: the sample domain that needs core-side resolution is sent to a designated server first, while other queries can use the system resolver. skipFallback keeps the dedicated server out of ordinary fallback. It doesn't prevent that server from being selected for a matching domain, or guarantee that no other server will be queried if resolution fails.

{
  "servers": [
    {
      "address": "223.5.5.5",
      "domains": ["domain:example.org"],
      "skipFallback": true
    },
    "localhost"
  ],
  "queryStrategy": "UseIP"
}

UseIP doesn't restrict queries to a single address family. UseIPv4 and UseIPv6 limit address-family selection on the built-in resolver side; they aren't operating-system network switches. If only some connections are slow or fail, check whether records for both address families exist and whether the resulting addresses are reachable. If you've confirmed that one address family is unreachable on the current network, temporarily limiting queries can help isolate the cause. After troubleshooting, restore a policy appropriate for the deployment instead of carrying a diagnostic change across all networks.

Distinguish an Unreachable DNS Server from an Unreachable DNS Result

When using an encrypted DNS endpoint identified by hostname, consider how that hostname is resolved. Requiring an endpoint to resolve itself before it can connect creates a dependency loop. A similar issue arises if the endpoint must connect through a proxy whose hostname can only be resolved by that same endpoint. Provide an independently reachable initial resolver that fits the network, and confirm the endpoint uses the correct hostname. The order of errors in the logs matters: a failed connection to the DNS endpoint happens before an answer for the requested domain is returned. That's different from getting a business address and then timing out while connecting to it.

When changing DNS setups, first disable other experimental options that also intercept DNS. Use a new session to visit a known working domain, keeping in mind that the operating system, app, and core may each cache results. A single successful request may only mean the app reused an existing connection. Verify both a fresh DNS query and a subsequent real connection. For more on combining rule resources, encrypted DNS, and DNS groups, see V2Ray Split DNS Configuration. Complete the basic comparisons in this chapter before adding multiple resolvers.

TUN Mode & Traffic Capture

Compare the System Proxy with a Virtual Interface

The system proxy generally requires apps to follow the proxy settings. TUN uses a virtual network interface and system routes to send eligible traffic to a capture component. Enabling TUN doesn't mean all traffic uses the same outbound. Which destinations use the virtual interface, which apps are excluded, and whether captured traffic is later routed directly are separate decisions. When troubleshooting, describe the issue in terms of the connection the app made, the expected entry point, and the outbound actually observed—not just “it stopped working when I turned it on.” That helps determine whether to check the interface, system routes, or core logs.

On desktop, first establish a known working connection with v2rayN using the system proxy or an app's explicit proxy settings, then test TUN separately. Watch for system prompts requesting permission to create an interface or change routes. On Android, v2rayNG and v2flyNG typically capture traffic through the system VPN service. Follow the status shown by the client and device for permissions, app scope, and conflicts with other VPN services. This isn't the same interface as desktop TUN, and desktop permission steps shouldn't be applied to a phone.

Capture MethodWhat Establishes the Entry PointFirst Thing to Check
Desktop System ProxyApp follows the system proxy or is configured to use a local proxyIs the app sending requests to the local listening address?
Desktop TUNVirtual interface is up and system routes point to itIs the capture component running, and does the test destination use that route?
Android VPN ServiceSystem permission is granted and the app is within the capture scopeConnection status and app inclusion or exclusion list

Prevent Traffic Loops Before Checking the Local Network

Creating the interface is only the first step. The client's own connections to remote servers must still use the physical network interface. If the default route sends those connections back through the same virtual interface, traffic can loop. A common symptom is that the connection works with TUN off, but even a previously working server can't complete a handshake when TUN is on. First check whether the capture component handles outbound bypass or interface binding, then look for route conflicts with other virtual networking tools. Avoid manually deleting system routes as a first step. If issues remain after turning off TUN in the client, confirm the interface state in the system settings and restore settings according to your device's management requirements.

If enabling TUN makes only printers, shared folders, or internal services unreachable, distinguish routing to the destination address from name discovery. If connecting directly to a known service address works but accessing it by device name doesn't, DNS or discovery traffic may not be reaching the right network. If neither works, first check whether the local subnet is being captured. The local address range and default interface can change when you switch networks, so base exclusions on the current environment rather than copying routes from an unknown source. Before changing how organization devices are routed, confirm that the relevant traffic is allowed by your management policy.

Test by Protocol and Network Scenario

A working webpage confirms only that one connection path works; it doesn't cover every UDP app or long-lived connection. If web pages load but a voice app fails, check whether it actually uses UDP and whether the entry point, selected outbound, and remote server all support that traffic. For connections that establish but stall later, investigate factors such as packet size and network changes. Don't lower the interface MTU arbitrarily instead of checking the handshake and routes. Change one setting at a time, keeping startup logs and a repeatable test, so you aren't guessing across multiple variables.

At a minimum, test access with TUN on, confirm service returns with it off, and test again after switching networks. The first two checks cover capture and rollback; the last can reveal routes still pointing to an old interface. If another traffic-capture tool is running on the device, disable overlapping experimental configurations before retrying. If the tools need to coexist, have the environment administrator confirm their respective capture scopes. Establish a working baseline before enabling FakeDNS separately; then you can tell whether a problem comes from the virtual interface or from name mapping.

FakeDNS & Domain Mapping

Understand the Scope of Synthetic Addresses

FakeDNS stores mappings between domain names and synthetic addresses. An app queries a name and receives a synthetic address, then connects to that address. When the traffic re-enters a core that can read the mapping, the core can restore the target name and use it for routing or outbound selection. The synthetic address doesn't mean the target server is hosted there, nor is it a regular DNS result that can be used independently by another device. If an app bypasses traffic capture and connects directly to that address, the domain can't be restored. Treat it as an address marker within the capture path, not as the final address of a service returned by an ordinary resolver.

This approach is useful when the entry point sees only a destination address but routing still needs to be based on the domain. With a regular system proxy, the app may already send the domain, so start by testing the existing domain rules. If a program needs a real, independently reachable address or passes the result to a service outside the capture scope, keep real DNS resolution for those names. FakeDNS also doesn't automatically turn every encrypted DNS request into a core query. First determine whether the app's own resolver requests pass through the DNS entry configured in the client.

Check the Address Pool, DNS Path, and Traffic Entry Point

To check FakeDNS in a native Xray configuration, examine three areas separately: the top-level fakedns field defines the address pool; the selection in dns.servers determines which built-in queries use FakeDNS; and the entry point receiving subsequent traffic must be able to restore names from the mapping. With a native inbound configuration, check that the inbound's sniffing is enabled and destOverride includes fakedns. A GUI client may generate these fields for you. Verify the actual startup configuration and logs; a single toggle doesn't prove all three parts are configured.

The snippet below defines an address pool only; it doesn't enable FakeDNS by itself. ipPool sets the range for synthetic addresses, while poolSize limits how many mappings the pool can retain. It's not a bandwidth setting. The example subnet may already be in use by a local test environment or another traffic-capture tool, so check existing routes before applying it. If two tools use the same address range, traffic for an address returned by one may be picked up by the wrong interface. Changing the upstream DNS server alone won't resolve that routing conflict.

{
  "fakedns": [
    {
      "ipPool": "198.18.0.0/15",
      "poolSize": 65535
    }
  ]
}

Troubleshoot Query, Return Path, and Mapping Separately

First, check the query. If a test domain returns a real address, confirm whether it should use FakeDNS, then check the client's resolver selection, app cache, and use of any separate DNS service. Second, check the return path. If the app receives a synthetic address but its connection doesn't appear in capture logs, review the app's inclusion or exclusion scope and the route for that address range. Third, check the mapping. If the connection reaches the core but the logs don't show a restored domain, check whether the entry point supports the mapping and whether the same instance handled both the query and the connection. Using one app for both steps makes it easier to correlate evidence than using two separate tools.

After the core restarts, an app may still hold an address from the old session even though the current core no longer has its mapping. Mappings can also be replaced as the pool is used, especially when app cache durations and core behavior are out of sync. Start a new session and have the app query the name again, then check whether it recovers. If the problem consistently affects a particular internal service or older app, restore real DNS for those names and compare domain-based and address-based access again. Don't change the address pool, domain rules, and default outbound all at once; even if the issue goes away, you won't know why.

Managing Multiple Subscriptions & Update Order

Separate Source Changes from Active Connections

Troubleshooting one subscription focuses on a single import; managing several means ensuring each can be updated independently. Give each source a clear group and distinguish active, temporary test, and backup uses. Before updating, note the active entry's group, protocol, and transport type. Refresh only the target group, then check whether the entry remains and whether the source replaced it with a different configuration. The same display name in a list doesn't prove the server address, transport settings, or authentication details are unchanged. If an active connection is important to your current work, verify the backup source before updating the primary one.

Servers with the same display name shouldn't necessarily be deduplicated. Different sources may assign the same alias to their servers; even if they point to the same address, their access rights and transport requirements may differ. To compare sources, check group membership first, then compare only the necessary protocol and transport properties locally. Don't merge entries by name. To make the right entry easier to select, adjust group aliases or the list view rather than bulk-editing subscription-generated entries. The next update may overwrite those edits, making the entries' origins harder to identify.

Confirm the Update Path Before Scheduling Refreshes

Refreshing a subscription and using a server for traffic are separate operations. If a source must be fetched on a particular network, first check its DNS and connection path, and whether the client refreshes through the current proxy. A common dependency loop occurs when all existing entries stop working, leaving a subscription update as the only way to get new ones, but the update itself depends on those old entries. Keep an independent, authorized path for fetching the subscription rather than retrying over the same failed route. Confirm a manual update of one group works before enabling the client's automatic refresh option.

If sources have different request rate limits, set refresh intervals to meet each source's requirements. Don't refresh every group just because one failed, and don't treat automatic updates as a recovery method. An automatic request might run after the device wakes, while the network is roaming, or before the proxy is ready; failure then doesn't contradict a successful manual update. At minimum, record the network state, whether a proxy was available, and the stage where the log stopped. Reproducing the same conditions helps distinguish an environment change from a change to the subscription itself.

Troubleshoot Update Issues by Their Scope

If entries disappear, first check the selected group and filter state, then confirm in the logs that content was fetched and parsed successfully. If multiple entries in a group change at once, the source may have changed or a filter may have become more restrictive. If only one entry is missing, check whether the source removed it. If an update completes but the client still sends traffic to an old server, determine whether an existing connection is being reused or new connections still use the old configuration. End the test connection, reselect the active entry, and connect again; this tells you more than the highlighted state in the list.

When switching sources, keep the old group temporarily as a rollback option, but stop its scheduled updates so it doesn't keep changing during verification. First confirm the new group imports and connects, then use the same traffic test to check that routing and DNS still work as expected. When you no longer need a source, disable scheduled refreshes and check whether any active entries or backup plans still depend on it before deleting the group. Clients may handle deleting a group and its servers differently. Read the confirmation prompt rather than assuming deletion removes only the group label from the interface.

When moving to another device, first confirm the target client supports the same kind of subscription, then import and verify each source separately. Group aliases, proxy settings for updates, schedules, and active entries usually aren't part of the published subscription, so check them individually after moving. Store backups in a local location with access controls; there's no need to paste subscription URLs into a public collaboration document. If you're new to the initial setup or system proxy, use the quick start guide to connect with one group, then return here to plan multi-source updates with a clear rollback point.

Custom Outbounds & Tag References

Start Small to Verify Tag References

Outbounds determine how a connection is handled; routing determines when to use each one. An outbound's tag is an internal configuration reference, and rules point to it with outboundTag. A server alias shown in the client list isn't this kind of reference. Before adding an outbound to an existing configuration, list the tags already in use, choose a unique name, and decide which outbound should handle traffic that matches no rule. Renaming an outbound without updating its routing references—or accidentally placing a new outbound first in the array—can change how traffic is routed.

The example below is a standalone minimal Xray configuration for testing the relationship between a local SOCKS inbound, a direct outbound, and a blocked outbound. It listens only on the local machine and doesn't require a subscription or remote account. Before starting, make sure the port isn't in use by a running client. If you change the port, update the test app's proxy port too. The example doesn't enable the system proxy or TUN, so it won't capture apps that aren't explicitly pointed at this listening port. Don't change the listening address to expose it to other devices during this test.

{
  "log": {
    "loglevel": "info"
  },
  "inbounds": [
    {
      "tag": "local-socks",
      "listen": "127.0.0.1",
      "port": 10808,
      "protocol": "socks",
      "settings": {
        "auth": "noauth",
        "udp": false
      }
    }
  ],
  "outbounds": [
    {
      "tag": "direct",
      "protocol": "freedom"
    },
    {
      "tag": "blocked",
      "protocol": "blackhole"
    }
  ],
  "routing": {
    "domainStrategy": "AsIs",
    "rules": [
      {
        "type": "field",
        "domain": ["full:example.org"],
        "outboundTag": "blocked"
      }
    ]
  }
}

Test Rule Matching, Not Just Internet Access

Configure the test app to send domain names to the SOCKS proxy, for example by using a SOCKS mode that supports remote DNS. First visit the full domain shown in the example, then visit another working public domain. The first should use the blocked outbound; the second doesn't match a rule and will try the first, direct outbound. If the test app resolves the name locally and sends only an IP address to the inbound, this example won't match the full domain. Verify the blocked outbound by checking the selected tag in the logs, not just the browser error. A DNS failure, stopped proxy, or incorrect port can also make the page unavailable.

When adding a proxy outbound to a real configuration, check its protocol parameters, transport settings, and security options against the server's requirements. A share link may include the parameters for one connection, but it can't replace the app's full inbound, routing, and DNS configuration. Start by limiting the new outbound to a dedicated test rule, then verify startup, rule matching, and connectivity separately before expanding its scope. Don't try to convert one outbound protocol into another just by changing the protocol field. Configuration structures vary by protocol; use the definition supported by your core.

Distinguish Client-Generated Files from Manual Configuration

A GUI client may generate a new configuration when you switch servers, change routing, or reconnect. Direct edits to a temporary generated file may work once but can be overwritten on the next update. If you need to use native configuration long term, first confirm that the client provides a custom configuration option, then save both a separate source file and a copy of the last working version. Don't simply replace an active subscription configuration with the example array: doing so may remove existing local inbounds, default outbounds, or tags required by the client. Integrate the changes for the core and runtime you're actually using.

Use a consistent debugging sequence: the configuration loads, the inbound binds successfully, the test request reaches it, the expected tag matches, and the outbound connects. If the first step fails, check the field and nesting level mentioned in the error. If only the final step fails, investigate the selected outbound's network path and server parameters. After testing, lower the log level as appropriate; don't keep detailed logs containing accessed destinations indefinitely. Before sharing diagnostic snippets, remove server identifiers, credentials, and private hostnames, leaving only the field structure and context needed to reproduce the issue.

Switching Cores & Compatibility

Choose a Core Based on Protocol Requirements

The client manages configuration, starts connections, and displays logs; the core interprets configuration and handles traffic. On desktop, v2rayN is the recommended client. Go to the client downloads page and choose an option for your operating system and architecture. The Windows desktop and classic WPF editions differ in interface implementation; that choice alone doesn't tell you which core is in use. On Android, v2rayNG, which uses Xray, is the primary option. Consider v2flyNG when you need a V2Fly core. Don't assume there's always a universal core-switching button in the same Android app interface.

Project V is a good starting point for understanding the V2Ray ecosystem. V2Fly continues the V2Ray project, while Xray shares some of its technical roots; their configuration models haven't evolved in lockstep. Sharing a protocol name doesn't guarantee compatibility: the required transport, security settings, and client support must all match. For example, if a server requires REALITY, choose a core and configuration interface that support it. Keeping the same server address and port isn't enough to migrate. For protocol differences, see A Comparison of Four Proxy Protocols and Their Use Cases.

Check What Can Be Preserved at Each Layer

Before switching, note the active protocol, transport, traffic-capture mode, and working routing and DNS behavior. In v2rayN, choose a supported combination based on the entry types and core settings the interface actually offers. Whether you can select a core for an individual entry depends on the client's current configuration format. Test the new combination with a separate entry rather than changing your only working configuration. After startup, check the logs to confirm which core launched and whether it parsed the entry. If an option is available in the interface but missing from the active configuration, check whether it applies only to another inbound or configuration type.

During migration, similar concepts can invite misleading comparisons. Both cores may support routing, DNS, or sniffing, but parameter names, accepted values, and resource categories may differ. Rebuild a minimal configuration by layer: inbound capture, traffic outbound, routing rules, and DNS policy. First make sure one entry point and one destination work, then restore routing and DNS rules one at a time. Don't paste an entire native configuration from another core, or delete every unrecognized field just to make the configuration start; some fields may support existing outbound behavior, and removing them can silently send traffic down the default path.

Verify with Repeatable Tests and Keep a Rollback

A verification run should answer three questions: Did the client start the expected core? Which outbound handled the test connection? Did the app get the expected DNS result or connect successfully? Start with one app and a known destination, then test traffic that should match a specific rule and traffic that should use the default route. If you need UDP capture or access to internal services, test those after basic connectivity works; one webpage can't stand in for every use case. For meaningful comparisons, use the same network, device, and test app to avoid mistaking network fluctuations for migration issues.

Troubleshoot failures by stage. If the core won't start, check the installation package and CPU architecture, then review the initialization error. If it starts but the handshake fails, check that protocol and transport settings meet the server's requirements. If the connection works but routing is wrong, return to the routing and DNS sections. If your environment isn't ready, see the download page for system requirements and FAQs. To roll back, restore the original entry, routing setup, and capture mode, then verify with a new session; switching back only by core name isn't enough. Keeping the full working combination until verification is complete is more useful than remembering a few individual toggles.