Advanced Setup

Advanced V2Ray Setup Guide

Haven’t completed your first connection yet? Follow the Getting Started guide to import a profile, connect, and verify it. If your setup is already working reliably, use this page as a reference: check subscriptions when the node list changes, routing when requests take the wrong path, and DNS when domain and address behavior differ. Move on to TUN, FakeDNS, or custom outbounds only when needed.

For desktop use, start with v2rayN. The GUI instructions below focus on v2rayN, while raw configuration examples identify the applicable core. The core handles connections, routing, and name resolution; GUI switches do not always map one-to-one to core configuration fields. Before making changes, note your working group, active node, and operating mode.

01 Subscription Cleanup

Subscription Groups & Server Filtering

Group by source, then narrow the node list

Create one group per subscription source so each can be updated independently. Don’t copy nodes from different sources into one list and sort them together: matching remarks don’t mean matching connection settings, and updates make it hard to tell which entry to keep. Name groups by source shorthand and purpose, such as “Work Tests” or “Backup Route.” Don’t put account identifiers or subscription URLs in group names. Subscription URLs often contain access credentials, so protect them like account details. When taking screenshots, show only the group name and result—not the full URL.

In v2rayN’s subscription group settings, add or edit a group and enter the subscription URL. Select that group and update only the current subscription. On the first update, leave filtering off. Check that familiar nodes appear, note the general format of their remarks, and verify that the required connection settings are recognized. If the list shows only a few entries mentioning an expiry date or remaining traffic, determine whether these are source-provided notices or actual connectable nodes; don’t judge by the name alone. Choose a known working entry, visit a site you use regularly, and record the result for comparison later.

Confirm what the filter matches and how it works

Server filtering selects nodes imported from a subscription; it does not route traffic to destinations. Check the current interface’s description: does the filter match node remarks, addresses, or another field? Does a match keep or exclude an entry? Is the input treated as plain text or a regular expression? Don’t paste rules from another version without checking. To keep only nodes whose remarks include “Work,” start with that single short term. Check one matching and one non-matching entry before adding more conditions.

A regular expression describes a text-matching pattern. If the filter explicitly supports regex and matches node remarks, ^(办公|备用)- matches remarks that start with “办公-” or “备用-”. Anchoring the pattern at the start prevents entries such as “停用-办公” from matching, but it also misses full-width hyphens, leading spaces, and other prefixes. If the source doesn’t guarantee a naming format, start with a loose rule: accidentally removing a working route is harder to spot than temporarily keeping a couple of irrelevant entries. And don’t treat a region, multiplier, or protocol mentioned in a remark as a property confirmed by the client.

Review the list and active node after updating

Save the filter and update the current group again. Check that your sample nodes are still present, then verify an entry you expected to exclude. Next, confirm the active node: selecting a row in the interface does not always make it the active server, and an update may replace the entry you were using. Don’t clean up other groups or change routing at the same time. If the rule is too restrictive, save the original expression, revert to one condition, and compare results from the same group to identify which part emptied the list.

If the list is still empty with filtering cleared, the expression probably isn’t the problem. Check that you updated the right group, the URL wasn’t truncated, the subscription request completed, and the response contains an importable node format. Being able to open a subscription URL doesn’t guarantee it returns nodes; the service may return a sign-in prompt or an error page. If the URL is reachable only through an existing connection, don’t disconnect it yet. Update the target group separately while the working configuration is active, then test its new nodes. See Common Issues for installation, setup, and troubleshooting advice.

If a source changes node remarks with every update, don’t rely on a full name or number to identify an entry long-term. Prefer a naming fragment the source explicitly promises to keep stable, and preserve the unfiltered update workflow. If you need a temporary node that won’t be replaced by subscription updates, maintain it separately from the auto-updated group and record its original source and when to remove it. Otherwise, when the address or transport settings change, it’s easy to use an outdated manual copy to explain the new list’s connection behavior.

02 Connection Routing

Routing Rules in Practice

Define an outcome you can test

Routing selects an outbound for a connection based on conditions. An outbound tells the core how to hand the connection to its next hop. Before making changes, define three things: what should connect directly, what should use a specific outbound, and what should happen to everything else. For example, send an office console domain direct, route a test site through a test outbound, and leave all other traffic unchanged. Start with a specific, easy-to-identify destination rather than importing a whole rule set. Too many affected sites make it hard to prove a rule is working, even if a page loads in your browser.

Routing can handle only connections that reach the core. After you switch the system proxy, apps that honor the system setting may use the client, while apps that ignore it may connect directly. Reproduce the issue with the same app, destination, and operating mode before debugging. A successful browser test doesn’t prove another app follows the same path. If the connection doesn’t appear in the logs at all, check the app’s proxy settings or whether TUN is capturing it. Reordering routing rules usually won’t help.

Put specific rules first and broad rules later

Xray checks routing rules in list order and uses the first match. If a rule specifies both an inbound tag and a domain, a connection must meet both conditions. Within one rule’s domain list, matching any one entry is enough. Don’t put “this domain or this address” into a single rule that combines a domain and an IP, especially if the destination starts as a domain and resolution isn’t enabled. Split independent conditions into separate rules to make it easier to see which one matches.

This is a top-level Xray configuration snippet. When merging it, replace or edit the existing routing object; don’t add a second field with the same name. The direct and proxy values in the example must match outbound tags already in your configuration. Replace the example domain with a destination you can test. full: matches an exact domain, while domain: matches a domain and its subdomains. Put the exact exception first so the broader rule doesn’t take the console connection.

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

This snippet doesn’t add a fallback rule. With raw Xray configuration, traffic that matches no rule goes to the first outbound. In v2rayN’s GUI, also check whether client-generated rules already include a fallback. Note the existing fallback behavior before adding test rules. Don’t move the direct outbound to the top just for convenience—that would also change where unmatched traffic goes. If you use the GUI routing editor, make sure the modified routing profile is selected after saving, then reapply it as prompted.

If a domain rule doesn’t match, check what the core sees

An app may resolve a domain locally and send the proxy only its IP address. In that case, the core sees only the address, and a domain rule may never match. If the logs show only an IP, check whether the app can pass the domain to the proxy or whether the inbound can identify domains from supported connections. Conversely, when the core receives a domain, AsIs doesn’t resolve it to an address for routing, so it’s expected that an IP rule won’t match. Don’t rely on domain sniffing as a fix that works for every app and transport.

If you need to match an IP based on a DNS result, consider IPIfNonMatch or IPOnDemand. The former retries with resolved addresses only if the initial match fails, so a matching fallback rule prevents the retry. The latter triggers resolution when an IP condition is encountered during matching. Before changing the strategy, confirm which addresses the core’s DNS returns; the same domain may match different IP rules on different networks. Create a new connection for a specific destination, a related destination, and an unrelated one to test exceptions, broader rules, and the fallback separately.

When testing, check the outbound tag—not just whether the page loads. A page may also request images, sign-in services, or API domains, so one visit can create multiple connections that match different rules. To pinpoint a rule boundary, reproduce a single request, note the time, and find its destination in the logs. Test with a new connection to avoid reusing an existing browser connection. Restore the previous log detail level when you’re done to avoid retaining access records unnecessarily.

03 Domain Resolution

DNS Setup and Troubleshooting

First identify what’s doing the resolving

DNS translates domain names into addresses. Before adding more public resolvers, identify which program sends the query and which server should answer it. Some browsers use their own secure DNS, while the operating system selects a resolver based on the network interface. When an app sends a domain through a proxy, the query may instead happen in the core or remotely. An address returned by a system lookup proves only what that particular query returned—not that the browser or proxy connection used the same answer.

Choose one ordinary test domain and one destination that should resolve on your local network. Record the system lookup result and the app’s connection result for each. If the public domain works but the internal one doesn’t, check whether the internal query reached a server that can resolve that domain before changing all upstreams. If the system lookup works but the app doesn’t, check whether the app resolves names itself, reused a connection, or routed the destination to an outbound that can’t reach the internal address. Conversely, an address that resolves but won’t connect may point to a listening-port or network issue; changing resolvers won’t fix connectivity.

Where to check each query path
Query pathWhere to look firstWhat the result tells you
System resolutionCurrent network interface and system DNS cacheWhat an app using the system resolver might receive
App-level resolutionThe app’s secure DNS settings and logsWhether the app uses its own resolution path
Core resolutionCore DNS settings and routing logsWhich upstream a core query used

Test the upstream and core configuration separately

An upstream is the DNS service that receives a query and returns a result. Before changing core DNS settings, send a test query from the device running the client to a candidate upstream. For example, if the device has nslookup and the current network has an internal resolver listening at 192.168.10.53, run the command below, replacing the address if needed. Specifying a server tests that query path; it doesn’t change the system’s default server or test the core. If it times out, check whether the upstream is reachable and accepts queries from this device instead of adding more fallback servers.

nslookup example.org 192.168.10.53

This DNS snippet is for a V2Fly raw configuration in the internal-network test setup described above. hosts gives the core a fixed address, letting you test whether the configuration loaded separately from whether the upstream is reachable. The example address is reserved for documentation: check the returned value, but don’t expect a connection to succeed. When merging the snippet into an existing configuration, add the relevant keys to the existing dns object and keep any other settings you need.

{
  "dns": {
    "hosts": {
      "lab.example": "192.0.2.40"
    },
    "servers": ["192.168.10.53"]
  }
}

This setting affects only queries handled by the core’s built-in DNS; it doesn’t create a listening port for system queries on the device. To test the fixed address, have the core perform a lookup—for example, use a routing strategy that requires resolution in a test configuration and check the logs. A different result from a system tool querying the default server doesn’t mean this setting failed. If you configure DNS in a GUI, make sure you’re editing the DNS settings used by the active core. Don’t paste one core’s full object into another core’s server-address field.

Check split DNS, caches, and startup dependencies separately

Keeping internal and public domains on their intended resolution paths are separate tasks. If your setup selects servers by domain, give the internal test destination its own matching condition. Check whether the current configuration tries another upstream if the internal server can’t answer. Some internal names must not be sent to public upstreams; configure fallback behavior explicitly instead of just putting the internal server first. When testing a public domain, don’t rely on a site you visited recently: an old answer may still be cached by the OS, browser, or core.

When an encrypted DNS server is specified by domain, the client must resolve the upstream’s own name first. If the only available resolution path depends on that upstream, a cold start may fail even though things work before a restart. Keep an independently reachable initial resolution path before switching upstreams. Compare speeds only after identifying the app, core, and system resolution paths. Record both the first and repeated lookup; a cache hit doesn’t represent the time needed for an initial lookup. If the problem occurs on only one network, keep the original settings and retest there. It’s easier to isolate the cause than when you change upstreams, caches, and address families all at once.

Check address families separately too: an A record returns an IPv4 address, while an AAAA record returns an IPv6 address. If one record type returns an answer but connections are still slow, check whether that address family works on the current network before restricting queries in a test configuration. Blocking a record type long-term may break services reachable only over that family. Keep a record of successful lookups and connections, then compare after switching networks. Don’t blame one DNS setting for changes in the local network path.

04 Traffic Capture

Configure and Test TUN Mode

First decide whether you need a virtual network interface

TUN is a virtual network interface. The system routes selected packets to it, and a capture component sends the traffic along the appropriate path. Unlike the system proxy, which relies on apps reading proxy settings, TUN uses system routes and interfaces, so it may capture traffic from apps that don’t support proxy settings. The trade-off is a broader system change involving permissions, route recovery, and local network access. If only browsers that use the system proxy need routing, start with your existing setup. Use TUN only after confirming that the target app bypasses the system proxy.

Before enabling TUN, close other tools that modify system routes, or at least note their state. If you need a managed connection for work, don’t disable it just to test; use a device or network where experimentation is allowed. Record the system proxy state, current network interface, default gateway, and a local network address you can test. If you’re managing the device over remote desktop, don’t try TUN without a local recovery option: if a test route overrides the management connection, you may lose the ability to turn it off.

Change only the capture method—not the node or rules

In v2rayN, keep the current working node and routing profile. Find the TUN switch and grant permissions as prompted by the system. For the first test, use an app you know works as a baseline, then try an app that previously bypassed the system proxy. To verify that TUN captures the latter, temporarily turn off the system proxy, if you have a recovery path, establish a new connection, and check the client logs. Don’t enable FakeDNS, change upstreams, or switch nodes at the same time; any one of those changes could make the destination unreachable.

What to check in the system when enabling or disabling TUN
PlatformWhen enabledAfter disabling
WindowsWatch for permission prompts; check whether the virtual interface and routes appearConfirm normal network routing is restored and the system proxy is in the expected state
macOSCheck the permission result and which interface is actually capturing trafficConfirm the network service still uses its original DNS resolution path
LinuxCheck whether the current runtime has permission to create an interface and configure routesCheck that the virtual interface and related policy routes have been removed

If the switch says TUN is enabled but there are no connection logs, first check that the virtual interface was created and the destination falls within its routed range. If the interface reports insufficient permissions, follow the client’s platform-specific instructions; don’t casually change the device’s overall permission policy. If a connection appears in the logs but fails, compare the actual outbound with the expected one, then check DNS and core errors. Virtual interface, UDP forwarding, and address-family support vary across platforms and runtime modes. A regular webpage loading doesn’t verify voice, real-time communication, or local network discovery.

Distinguish local network capture from outbound loops

If local network access fails, test a known address first, then a device name. If the address itself fails, check whether the capture path is taking over the local subnet. If the address works but the name doesn’t, check whether internal DNS or local name discovery still uses the original interface. When adding exclusions, configure and test actual subnets one at a time—for example, the office subnet first, then the home subnet. Avoid adding an overly broad range all at once. An outbound marked “direct” means the core intends to connect itself; the system still has to send that connection through the correct physical network interface.

If enabling TUN immediately produces repeated connections to the same destination, or the proxy node suddenly stops connecting, suspect an outbound loop: the core’s own connection may be captured again by its virtual interface. Prefer the client’s loop-prevention mechanism and check that it selected the right exit interface. First disable TUN and confirm the node still connects, then review the interface settings. Don’t hide the problem with a rule that excludes only the current node address; the issue may return as soon as that address changes. Retest startup after switching between Wi-Fi and Ethernet or waking the device from sleep.

For regular use, keep a clear recovery sequence: disable traffic capture, restore the original system proxy state, check the default network, then retry with the original node. If only TUN fails, keep that comparison and investigate the capture component. If both modes fail, revisit the node, regular routing, or network connection. This avoids reinstalling the client at the next occurrence and helps distinguish leftover system changes from a failed subscription.

05 Domain Mapping

When and how to configure FakeDNS

It preserves the domain; it doesn’t replace real DNS

FakeDNS returns a synthetic address for matching queries and stores a mapping between that address and the domain in the core. When the app connects to the address, the core can recover the domain and apply domain-based routing—as long as the connection returns to the same core that holds the mapping. This solves the case where an app resolves a name first and only an address remains when the traffic arrives. A synthetic address is not the destination server’s real address and can’t be used directly for connection troubleshooting, location checks, or node latency tests.

Whether you need FakeDNS depends on whether the connection completes the full round trip. If an app passes the domain directly through its proxy settings, adding another mapping layer is usually unnecessary. If another component handles the DNS query, or the app uses a different network interface to reach the synthetic address, the core can’t recover the domain. First use the previous section to verify stable TUN capture, and confirm the test app’s DNS queries and subsequent connections reach the same configuration. Some apps pass addresses to background processes, so check that those processes don’t use a different interface.

Test the full three-step path in an isolated configuration

This IPv4 test snippet is for Xray. It shows how the address pool relates to the core’s resolver; it is not a complete, standalone client configuration. The ipPool subnet allocates synthetic addresses, and poolSize sets the mapping capacity—not the number of available nodes. Before using the example subnet, check whether your physical network, other virtual networks, or existing routes already use it. Don’t overlap with an existing internal service subnet; real internal services could then be mistaken for addresses that need to be mapped back to domains.

{
  "fakedns": [
    {
      "ipPool": "198.18.0.0/15",
      "poolSize": 4096
    }
  ],
  "dns": {
    "queryStrategy": "UseIPv4",
    "servers": ["fakedns"]
  }
}

First is resolution: the test DNS query must be handled by a core configured for FakeDNS. Second is capture: the system must route connections to the synthetic address range back to the handling inbound, not to the default gateway. Third is recovery: the Xray inbound handling the connection must enable the relevant sniffing to identify the destination from connection data. The object below is a snippet to merge into that inbound. If a GUI generates the configuration, use settings appropriate to the capture component in use; don’t assume the TUN entry and Xray inbound are the same object.

{
  "sniffing": {
    "enabled": true,
    "destOverride": ["fakedns"]
  }
}

The test snippet limits core queries to IPv4, making it suitable for testing one address family at a time. It also configures just one synthetic-address server, so don’t copy it straight into everyday use to capture every domain. For real connections, account for internal domains, the node server’s own domain, and apps that need real addresses. Keep a working real-resolution path for each. Client switches may generate additional entries, so check the actual behavior before and after applying them. A query returning an address doesn’t guarantee the outbound can connect: after the domain is recovered, the outbound in use must still resolve and reach the final destination.

Troubleshoot one observable result at a time

The expected sequence is: a query returns an address from the pool, the app uses it to start a new connection, and the core recovers the original domain and matches the intended route. If the first step fails, check whether the test app uses its own resolver or a cached answer. If the second fails, find which interface captures the address range. If the third fails, check the inbound’s recovery settings and whether the mapping remains in the same instance. If the logs show the recovered domain but the request fails, troubleshoot it as a regular DNS or outbound issue; there’s no need to expand the address pool.

Some apps that require real addresses perform their own network checks and may reject synthetic ones. Preserve real DNS for those apps through capture settings or domain scope instead of repeatedly toggling FakeDNS globally. If the query side still has an old synthetic address cached, restarting the core, switching configurations, or replacing the address pool can invalidate its mapping. After testing, start a new session or clear the relevant cache using the system’s usual method, then query again. If public sites work but internal sites still fail, check that internal domains are going back to the internal resolver instead of just restarting the client.

06 Subscription Maintenance

Managing Multiple Subscriptions and Update Policies

Groups track sources; primary and backup describe their purpose

With multiple subscriptions, you don’t need to combine them into one master list or update every source at the same frequency. Keep one group per source and label each group’s purpose: everyday use, backup, or temporary testing. If one group fails to update, you can troubleshoot it without affecting the other two. If a source includes both everyday and test routes, use separate node filters or independent groups supported by the client. Don’t create multiple groups with the same purpose that all update automatically just for convenience.

A subscription URL is how the client retrieves configuration; a subscription group controls how the client handles that configuration; the active node is the destination currently used by the connection. These are often confused. For example, a successful update to the backup group doesn’t mean the active outbound has switched to the backup. A working node in the primary group doesn’t mean its subscription URL is still reachable. Schedule updates and connectivity checks separately so a source can’t quietly stop updating until the primary fails—only for you to discover the backup list is stale too.

Build a repeatable update and verification workflow

When organizing multiple sources for the first time, perform four actions for each group: confirm the group, update it separately, check familiar nodes, and create a new connection. Before updating, record the active node’s remark and source. Afterward, spot-check one frequently used and one backup entry in the group; don’t rely on the first row in the list. Some services replace connection settings but keep the old remark, so the interface can look unchanged even though a new connection uses different settings. Verify the update with a new connection, not a session established before the update.

Before enabling automatic updates, manually confirm that each subscription reliably returns the expected content. Then set an interval based on how often the source changes and how often you need fresh nodes. Don’t use a high update frequency to compensate for a broken URL, and avoid scheduling every source during important meetings or remote work. If the client can update through an existing proxy, check the dependency first: a source that requires the current node to be reachable can’t help if that node is recoverable only through an update. A separately tested backup path is easier to rely on than automatic retries for both subscriptions.

If you suspect duplicate subscriptions, compare their sources, then check node addresses, ports, protocols, and relevant transport settings. Matching remarks don’t prove entries are duplicates, and matching addresses don’t prove their authentication or transport settings are identical. Likewise, two entries in separate groups aren’t necessarily independent routes; if they rely on the same entry point, they offer limited failover. Before cleanup, check which groups are actually in use, disable unwanted automatic updates one group at a time, then decide what to delete. For more on group updates and remark filtering, see Notes on v2rayN Subscription Groups and Server Filtering.

When switching, verify both the node and the route

When testing a backup group, don’t just pick the lowest number in the latency list. Latency reflects response under particular test conditions; it doesn’t replace testing with the actual app. Compare candidates on the same network and at roughly the same time. Choose one route from each group, visit a familiar destination, test sign-in or a real request, and check whether reconnects work reliably. If public sites load after switching groups but internal services don’t, first check that direct-routing rules are still in place and whether the active core or operating mode changed with the configuration.

To make rollback easy, keep the last known-good active node and setup. Don’t delete the old group, replace a subscription, and change DNS in one pass. If an update empties a group, restore its filter and retry just that group. If it contains nodes but none work, check whether the issue is limited to that group. If every group fails, start with the system network, operating mode, or local listener. Record whether the failure occurred during the “update response,” “list import,” or “connection” stage; that’s more useful than noting only that “all routes are down.”

When moving to a new device, re-enter the sources you still need from trusted channels, then check whether automatic updates and overly restrictive filters are enabled. Exported client configurations may contain original subscription URLs and connection credentials. Store them only in a location with access controls, and make a separate version without URLs before sharing instructions with coworkers. If you no longer use a source, remove its old group, manually added nodes, and unnecessary scheduled tasks too; otherwise, stale remarks and lists can complicate future troubleshooting.

07 Outbound Extensions

Custom Outbounds: Setup and Rollback

Add an outbound only when you need a specific next hop

Custom outbounds are useful when you need to send a small number of connections through a specific next hop. For example, you might have a local test proxy and want only experimental sites to use it while everything else keeps its existing default outbound. First confirm the outbound protocol and the next hop’s listening address and port, then decide which routing conditions should reference it. If you only need to send a site direct or block it, and the existing configuration already has the right outbound, changing the rule is usually enough. Don’t define another outbound of the same kind just to give it a nicer name; it makes logs harder to interpret later.

The tag is the name routing uses to refer to an outbound. It doesn’t select a system network interface or automatically create a chain. Give each new tag a unique, descriptive name, such as lab-http. A regular outbound with a tag won’t receive traffic just because its name includes “test”; a routing rule has to reference it. Conversely, moving the new outbound to the top of the list may change the default destination for unmatched requests. For the first test, keep the original first outbound and fallback behavior, and route only the test destination explicitly to the new tag.

Route a local HTTP proxy with a specific rule

This is a snippet to merge into a raw Xray configuration. It assumes a trusted test HTTP proxy is already listening at 127.0.0.1:18080 on the same device as Xray, accepts local connections, and supports the request methods needed for your test. This configuration won’t create the listening service. First use an HTTP-proxy-capable test tool to check that the port is reachable and the destination can be accessed through it. Then add it to Xray to separate next-hop failures from routing-match failures.

{
  "outbounds": [
    {
      "tag": "lab-http",
      "protocol": "http",
      "settings": {
        "servers": [
          {
            "address": "127.0.0.1",
            "port": 18080
          }
        ]
      }
    }
  ],
  "routing": {
    "rules": [
      {
        "type": "field",
        "domain": ["full:example.org"],
        "outboundTag": "lab-http"
      }
    ]
  }
}

When merging, add the lab-http object to the existing outbounds array and leave the original first outbound in place. Insert the specific rule into the existing routing.rules before any broad rule that would match the domain first. The example contains only additions: don’t replace either array or add another top-level field with the same name. If the rule’s tag is misspelled or duplicated, correct the configuration structure based on the startup message before testing connections.

Before using this snippet with v2rayN, confirm that the active core supports it and that the editing area accepts raw configuration. Client-generated configuration and manually customized configuration are separate records; changes to an auto-generated file may be overwritten the next time you switch nodes. Save a separate test copy and load it using the method provided by the current client. If you’re only testing routing behavior, keep the stable configuration as another option. Don’t mix subscription updates with manual configuration edits.

Test startup, rule matching, and connection separately

After startup, first check that the core can read the configuration without field, protocol, or tag errors. Then create a new connection to a domain covered by the rule and confirm in the logs that it selected lab-http. Also test a destination that shouldn’t match and confirm it keeps its original route. If the tag matches but the connection fails, check whether the next-hop proxy received it. A refused connection usually means the listener isn’t running or the address or port is wrong. If the next hop receives the connection but can’t reach the destination, check its own DNS, connectivity, and access requirements.

The next-hop proxy must not send the same request back to the current client entry point, or the connection may loop back to the local machine. During testing, trace the entry and exit points on both sides, and confirm that the test proxy hasn’t inherited a system proxy setting that points back to the local client. Don’t use a successful regular HTTP request to assume every transport will work: the outbound protocol, app transport, and next-hop capabilities must be compatible. If the target app needs UDP, an HTTP outbound that loads webpages doesn’t prove the UDP use case will work.

To roll back, switch to the original configuration, or remove the rule that references the tag before deleting the test outbound. Don’t remove the outbound while leaving a rule that points to it. Verify recovery with a destination that worked before, then confirm the test destination is no longer routed through the local proxy. Finally, record which entry point you used, which conditions refer to which tag, and where unmatched traffic goes. That makes the scope of future changes clear. For option definitions, see the Glossary—there’s no need to experiment with the whole configuration just to clarify a term.