Configuration Reference
V2Ray JSON Configuration Guide
For your first install, importing a subscription, and checking your connection, start with the Getting Started guide. If you can already connect and need to look up fields, trace where traffic enters, or adjust rules, use this manual. Examples use a localhost loopback inbound and a standard direct outbound. For terminology, see the quick reference.
JSON Structure Overview
Trace a request through the config
An app sends a request to a local listening port, and the inbound reads the destination address from the request using its protocol. Routing then selects an outbound based on the available destination details, inbound tags, and other conditions. The outbound makes the actual connection, either dialing directly or communicating with a remote server according to its node settings. To work out what a field affects, first place it in the right part of this flow. Changing the listening address does not change the node; changing the outbound address does not make an app that bypasses the proxy start using the inbound.
The top level is a single object—not a list of inbounds, outbounds, and rules. inbounds and outbounds are arrays that can contain multiple entries; routing, dns, and policy are objects with their own structures. Field names are case-sensitive, and array order can affect behavior. In particular, the first outbound is not the same as the first routing rule: the former is the default outbound, while the latter is simply the first candidate rule checked for a match.
Set up a working direct-connection baseline
This is a complete native config file. It opens a SOCKS inbound on the local loopback address and sends incoming traffic to a direct outbound. It does not rely on a subscription, remote account, or geolocation rule set; it is only intended to confirm that an app can pass requests to the core. Before using it, make sure the port is not already in use by another instance. If the destination is unreachable from your network, the direct baseline will not change that—first choose a destination known to be reachable on your current network.
{
"log": { "loglevel": "warning" },
"inbounds": [
{
"tag": "local-socks",
"listen": "127.0.0.1",
"port": 10808,
"protocol": "socks",
"settings": { "auth": "noauth", "udp": false }
}
],
"outbounds": [
{ "tag": "direct", "protocol": "freedom", "settings": {} }
]
}
The baseline deliberately has no routing rules: with just one outbound, unmatched requests already have a clear destination. It also omits built-in DNS and connection policies to keep system resolution, core resolution, and timeout behavior out of the first test. Once the core starts, point an app that explicitly supports SOCKS at the example address. Do not rely only on the tray icon or app status. Before opening a website, you can also test a service hosted locally and accessible to your user to confirm the local path first.
Merge examples at the right level
The code snippets labeled as top-level fragments below are valid JSON, but may not run on their own. To add a top-level field, merge its key and value into the same object as the baseline. To change an existing field, replace its value or add an object to its array. Do not concatenate two files that each have their own outer braces, and do not repeat the same key in one object. Parsers can handle duplicate keys differently; even if a file loads, a parser may use only the later value.
| Top-level field | Structure | First check after editing |
|---|---|---|
inbounds | Array of objects | Confirm the app's protocol, address, and port all match. |
outbounds | Array of objects | Check that the default outbound and the tags referenced by rules are still correct. |
routing | Object | Check that rules are evaluated in the intended order and the destination matches the expected first rule. |
dns | Object | Identify whether the app, routing, or outbound dialing triggered the lookup. |
policy | Object | Confirm the tested connection uses the level associated with the setting you changed. |
Keep a baseline copy and a separate working copy, then compare the results of the same request before and after each change. Standard JSON uses double quotes, has no trailing comma after the last item, and writes booleans as lowercase literals—not strings. A syntax check only tells you whether the file parses. It does not confirm that the current core supports every field or that referenced tags exist. After checking the syntax, check the startup result and then the behavior of a single connection. Keeping these three checks separate makes it easier to find the right layer when troubleshooting.
The minimal file in this guide is intended to run on its own. If a client is already managing the same port, stop the existing instance or choose an unused port. Do not mistake a port conflict between two processes for a configuration syntax error.
inbounds
Check the listening address and app protocol together
Each inbound should answer three questions: which address accepts connections, which port is listening, and which protocol is used to read the data. listen is the bind address, not the destination website the client wants to reach; port is the local entry point, not the remote node's port; and protocol determines which proxy type the app must use. Sending an HTTP proxy request to a SOCKS port—or a SOCKS request to a regular HTTP service—can result in a port that accepts connections but requests that fail.
For apps on the same machine, start with 127.0.0.1. This limits listening to the local machine, though other local processes can still access the entry point. Do not expose an unauthenticated example on all interfaces to fix a connection failure. If the app and core explicitly use the IPv4 loopback, use the same address in both places. Otherwise, the app may resolve localhost to the IPv6 loopback while the core listens only on IPv4. Loopback addresses inside containers and virtual machines belong to their own network environments; they are not substitutes for the host address.
Use separate inbounds for SOCKS and HTTP
This top-level fragment can replace the baseline file's inbounds. It puts SOCKS and HTTP proxies on separate ports and gives each inbound its own tag. Check the app's proxy settings to see which type a browser supports or which option a command-line tool requires. An HTTP inbound accepts requests from apps that support HTTP proxies, including requests forwarded with CONNECT; it is not a web server for arbitrary browser traffic.
{
"inbounds": [
{
"tag": "local-socks",
"listen": "127.0.0.1",
"port": 10808,
"protocol": "socks",
"settings": { "auth": "noauth", "udp": false }
},
{
"tag": "local-http",
"listen": "127.0.0.1",
"port": 10809,
"protocol": "http",
"settings": {}
}
]
}
Tags identify inbounds within the config. Apps specify the proxy type, address, and port; they do not send the tag to the core. Routing can use inboundTag to read this identifier, so separate inbounds can distinguish traffic when App A always uses SOCKS and App B always uses HTTP. If both apps use the same inbound, the tag cannot tell them apart. When changing a tag, search for every reference to it. If you update only the inbound, old rules may never match again.
UDP support and destination detection are separate settings
The example disables UDP support for SOCKS because the baseline only tests ordinary web traffic. To troubleshoot an app that supports SOCKS UDP, confirm that the app actually sends UDP through the proxy, the SOCKS inbound allows UDP, and the outbound can carry that traffic. Enabling the inbound setting alone does not complete the other two parts. Conversely, changing the UDP setting will not help when testing a request that is known to use TCP. Confirm the connection type first, then decide whether to add a separate test.
An app may pass a domain directly to SOCKS, or resolve it locally first and pass only the IP address to the core. In the latter case, a domain-based routing condition may not see the original domain. Some inbounds can use sniffing to detect destination details from supported traffic, but the result depends on the protocol, visible data, and current core implementation. It is not a substitute for clear proxy settings in the app. For troubleshooting, first disable extra detection logic. Compare requests that pass a domain and an IP to the proxy, then decide whether detection is needed.
If local listening fails, first determine whether the address cannot be bound or the port is already in use. For a bind failure, check whether the machine can use the specified address. For a port conflict, identify the process using it before stopping the old instance or changing the port. After changing the port, update every setting that points to this inbound, including browser, terminal, and system proxy settings. Otherwise, the new instance may be healthy while the app still connects to the old port. See how to troubleshoot a local port conflict; do not stop a process just because it is listening.
outbounds
The first outbound is the default; tags are references
An outbound defines what the core does with a destination. freedom connects directly to the destination; blackhole discards traffic sent to it. Neither requires a remote account, making both useful for testing routing rules. Tags can describe an outbound's purpose, but naming one direct does not make it connect directly. Its behavior depends on fields such as protocol. Rules refer to tags, not protocol names or the node remarks shown in a subscription.
If no rule matches, the connection goes to the first outbound in the array. So adding an object and moving an object to the first position are different operations. If the first outbound was direct and you move a discard outbound to the front, ordinary requests that match no rule will also be discarded. Conversely, traffic expected to use a remote node will go direct if a rule is missing and direct is first. Decide on the default behavior before ordering outbounds; do not let the order depend only on which node appears first in the UI.
{
"outbounds": [
{ "tag": "direct", "protocol": "freedom", "settings": {} },
{ "tag": "blocked", "protocol": "blackhole", "settings": {} }
]
}
After replacing the baseline file's outbounds with this fragment, no request will use blocked until you add rules. This fragment is designed to work with the routing example in the next chapter. Give the spare outbound a distinct tag and leave the first one in place. You can then limit a rule test to selected traffic without affecting all ordinary requests. To restore the baseline, first make sure no rules still reference the tag you plan to remove, then delete the spare object.
Check protocol, transport, and security settings separately
For a remote node, the outbound protocol, node address and port, authentication parameters, transport, and security settings must match the server. The protocol defines how the session is structured; settings holds the destination and authentication details required by that protocol; and streamSettings commonly describes the transport and security parameters used to establish the remote connection. The website a proxied request ultimately opens and the remote node address used by the outbound are two separate destinations, and each may require its own DNS lookup.
You do not need to rewrite the entire config to troubleshoot. First compare the current node's hostname and port, then its transport type and associated parameters, and finally its security negotiation settings against the server. If TCP connects but negotiation fails, changing the local listening port is unlikely to help. Do not disable security checks to hide hostname, certificate, or clock errors. Keep the existing security requirements and check that the config matches the connection parameters provided for the node.
A subscription URL, display name, and native outbound in a client list are also different kinds of things. A subscription provides node entries; the client generates the outbound the core needs to run, based on the selected node. Pasting a subscription URL into a remote node address field will not produce the same result, and copying a display label into outboundTag may not work. To verify what was generated, inspect the config loaded by the current instance rather than an earlier export. For help choosing among subscription nodes, see Node Selection.
Narrow down the problem with a controlled comparison
Use the same test destination to make a new request through the normal direct outbound and the remote outbound you are testing. If direct works but the remote outbound fails, the app proxy, listener, and direct path are working for this test; next, check the remote settings and handshake stage. If both outbounds fail, start with the shared inbound, destination reachability, and resolution path. Reconnect after switching. A browser may reuse an existing session, making an old connection appear to reflect the new config.
routing rules
The first match wins; unmatched requests use the default outbound
routing.rules are checked from top to bottom. Once a rule matches, later rules do not select a different outbound for the same request. Conditions within one rule—such as a domain and an inbound tag—must all be met for a match. Multiple alternatives in the same domain condition array generally mean any one of them can match. To express “a specific domain from one inbound,” put both conditions in one rule. To express “one inbound condition or a separate destination condition,” you will usually need two rules.
Put narrow exceptions before broad rules. For example, check “a specific full domain from local SOCKS” before “all requests from local SOCKS.” If the broader rule comes first, the exception will never match. Requests that match no rule do not automatically use the outbound from the last rule; they use the first outbound. Read the rules and check outbound order together, especially when extracting a few rules from a client-generated config.
{
"routing": {
"domainStrategy": "AsIs",
"rules": [
{
"type": "field",
"inboundTag": ["local-socks"],
"domain": ["full:example.com"],
"outboundTag": "blocked"
},
{
"type": "field",
"inboundTag": ["local-socks"],
"outboundTag": "direct"
}
]
}
}
Merge this fragment into the baseline and use the outbound array from the previous chapter, which includes blocked, to compare two domains. When a request comes through SOCKS with the domain passed to the proxy, the exact name example.com matches the first rule; other domains continue to the second. Requests from the local HTTP inbound meet neither rule's inbound condition and use the default outbound. If the app resolves the destination first, the first rule may not match. Check how the destination is represented before suspecting rule order.
Test domain and IP matching separately
full: matches an exact domain. To match a domain and its subdomains, use domain:. A plain string without a prefix matches by substring, so a very short value can include unrelated names. The same routing target can be expressed as a domain or an IP address, but each matches a different form of input. For sites sharing an IP address, an IP rule usually cannot distinguish between domains. If an app has already resolved a destination, a domain rule cannot automatically recover the original name.
domainStrategy controls when routing uses resolution results to evaluate IP rules; it does not make the outbound use the same dialing method. AsIs does not resolve a domain to an IP for routing. IPIfNonMatch tries resolving the domain and checking again if the original information does not match. IPOnDemand can resolve a domain when a rule requires an IP. If a broad rule matches earlier, later rules are never checked; adding a DNS server will not change that.
Give every new rule a positive and a negative test
When adding a rule, keep one request that should match, one similar-looking name that should not, and one unrelated destination. Record the inbound tag, the form of the destination passed to the core, and the actual outbound for each. Before using geoip: or geosite:, confirm that the core can read the required data and that the category exists. Correct rule syntax does not mean the corresponding data is installed locally. To check match order quickly, prefer exact domains or explicit address ranges that do not depend on data files.
Finally, distinguish whether traffic entered the core from how it was routed after entry. The system proxy is one way for some apps to send requests to a local inbound. Routing rules apply only to requests that have already entered the core. Changing routing does not capture terminal traffic that bypasses the proxy, and it cannot replace the system proxy setting. To compare global and split-routing options in the UI, first read System Proxy and Proxy Modes, then check the rules actually generated.
DNS settings
First find out what is making the DNS request
Top-level dns configures the core's resolution capabilities; it does not replace every DNS query made by the system. An app may use the system resolver before connecting, or use its own configured DNS service. If it passes only an IP address to the SOCKS inbound, the core does not need to resolve a domain for that destination. If the app passes the domain unchanged, routing may use built-in DNS to evaluate address rules, and the outbound may also resolve a name to connect. Find out at which step resolution occurs before changing a layer.
This fragment lists the local system resolver as a DNS server option for the core and uses hosts to map two reserved test names to fixed addresses. Merging it into the baseline only defines how the core handles relevant lookups; it does not make the core listen on the local DNS port by default. The test addresses are from a documentation-only range, so they are for checking matching behavior, not serving a real website. A failed connection does not show whether the mapping worked.
{
"dns": {
"hosts": {
"test.example": "192.0.2.10",
"control.example": "198.51.100.10"
},
"servers": ["localhost"]
}
}
Test core resolution with an address-based rule
To distinguish the two mappings above, keep both direct and discard outbounds and replace the routing config with this fragment. Send a request from a SOCKS app that passes the domain to the proxy. When routing encounters the IP condition, it will try to resolve the destination: test.example resolves to an address that matches the discard outbound, while control.example resolves to an address outside the rule and uses the default outbound. Use the current instance's routing or access logs to verify the path. Do not infer that the results are the same just because neither reserved address serves a webpage.
{
"routing": {
"domainStrategy": "IPOnDemand",
"rules": [
{
"type": "field",
"ip": ["192.0.2.0/24"],
"outboundTag": "blocked"
}
]
}
}
The resolution result used for routing is not the same thing as the destination used for dialing. For a direct outbound, if you need it to explicitly use an address supplied by built-in DNS, also check that outbound's domain strategy. For a remote proxy outbound, distinguish between resolving the remote node's hostname locally and passing the website name to the remote server. Both names may appear in the same log. Changing routing.domainStrategy does not guarantee that the remote server sees a different destination form or that the browser uses the core for lookups.
Separate server selection, address families, and caching
dns.servers can contain simple server entries or server objects with domain-matching conditions. Assigning a preferred resolver for certain domains does not force the entire system to use that server. Check the running core's documentation for fallback behavior and supported fields. In a real setup, start with one reachable server and record one domain that should use a dedicated resolver and one that should use normal resolution. Add more entries only when you need split DNS, rather than changing address, domain matching, and fallback behavior all at once.
If some names resolve but connections take a long time to establish, check the address family in the returned records and whether that address is reachable from the local machine. Receiving an IPv6 record does not mean the network has a working IPv6 route. Likewise, do not permanently disable IPv6 because one connection failed. Run a controlled comparison first, confirm which address family is associated with the failure, then adjust resolution or the network. A failed DNS query and a connection timeout after successful resolution are different problems; timestamps in the logs can help tell them apart.
After changing a mapping or resolver, old results may still be cached by the browser, system, or core. Restarting one layer does not necessarily clear the records in another, and existing connections may not resolve again. Test with a new connection and, if needed, a test name you control that has not been queried before. If a regular app and a SOCKS app get different results, keep the difference as evidence instead of immediately changing both apps to use the same DNS settings.
policy
First identify the connection's level
policy configures core connection behavior, such as handshake timeouts, idle time, and some statistics options. It does not select an outbound or replace routing rules. policy.levels is an object whose keys are strings corresponding to user levels, such as "0". When a protocol assigns a level to a connection, the field value is usually a number. A custom level is not applied to every connection just because its name appears in levels; check how the protocol in use assigns levels to connections.
The baseline inbound does not explicitly assign a higher user level, so this example uses level zero as a reference. The example values are in seconds and are intended to show how changing the wait window affects behavior, not to recommend settings for every network. After merging the fragment into the baseline, first confirm that the connection still uses that inbound, then test the policy. If the client generated a different inbound or another protocol assigned a different level, changing level zero will not explain that connection's behavior.
{
"policy": {
"levels": {
"0": {
"handshake": 8,
"connIdle": 180,
"uplinkOnly": 10,
"downlinkOnly": 10
}
}
}
}
Understand handshake, idle, and one-way shutdown separately
handshake sets the wait limit for the relevant proxy protocol handshake stage. It is not the total time allowed for a webpage to load or a universal switch for every underlying connection timeout. connIdle applies to an established connection that has transferred no data for a while. Check it first if connections consistently drop after being established and idle for a similar period. If they never establish successfully, start with the listener, remote address, node negotiation, or network errors.
uplinkOnly and downlinkOnly set the wait windows for the remaining direction when a connection enters one-way shutdown. They are not upload or download speed limits. For example, after an app finishes sending, it may still need to wait for the server's final response data. Setting that window too short can cut off a delayed response. If an upload finishes but no result comes back, distinguish a slow server, a connection closed by an intermediary, and the core ending the connection during shutdown.
| Field | Stage to check | Not suited to explaining |
|---|---|---|
handshake | The relevant protocol establishes a session | Slow transfer long after the handshake succeeds. |
connIdle | A period with no data after the connection is established | The app never connects to the local port. |
uplinkOnly、downlinkOnly | The remaining one-way transfer stage | A domain matched by an earlier routing rule. |
Check the scope of timeouts and statistics
To test timeouts, choose a connection known to establish reliably and record the start time, last successful transfer, and close time. Change one field per test and establish a new connection each time. The app's request limit, system or intermediary idle timeout, or server-side wait policy may expire before the core's limit. If the disconnect still occurs at the app's deadline after you adjust the core value, check the app or remote server instead of extending unrelated policy fields.
Statistics are also split across layers. User upload and download counts under a level are not the same as system-level totals by inbound or outbound. The relevant feature must be enabled, and the current protocol and connection must provide the required statistics. Enabling a policy switch does not mean a client UI will immediately show numbers, nor does it set a traffic quota. You do not need a statistics API to check whether a rule matches on a first run; a request through one inbound to one destination is more direct.
Do not set every timeout extremely high just to suppress errors. Longer waits can delay failure messages and tie up resources for connections that cannot complete. First identify which layer is imposing the limit, then change only the setting responsible for that stage.
If you temporarily extended a wait value for diagnosis, restore the original config once you have verified the cause, or keep only the one change supported by evidence. Record the destination, core, inbound tag, connection level, and timing so you can compare the next occurrence of the same error. Without that context, a screenshot saying “timeout” usually cannot tell whether the proxy handshake failed to finish or an established connection was waiting for data.
Client Configs and Native JSON
Distinguish UI settings, generated config, and the file actually in use
For everyday use, configure the proxy through the client UI. v2rayN is the recommended desktop client; on Android, choose v2rayNG or v2flyNG based on your core requirements. The client downloads page lists options by operating system and architecture. This manual explains the config read by the core. A client may store nodes, subscriptions, routing profiles, and app state in formats other than native core config. A file with a .json extension is not necessarily meant to be run directly by the core.
Subscription updates change node entries, while UI settings affect the config generated for the next run. The core uses the file loaded by the current instance. Direct edits to a temporary file generated by a client may be overwritten when you switch nodes, restart the core, or reapply settings. For a change you need to keep, use the corresponding client setting if available. If you need a native file, keep a separate copy in a mode that supports custom configs, and track which changes the client manages and which you maintain yourself.
| Platform | Client | Check these runtime conditions first |
|---|---|---|
| Windows | v2rayN | Check separately which system proxy the app uses and which endpoint the core listens on. |
| macOS | v2rayN | Distinguish system proxy settings, the app's own network options, and the core that actually started. |
| Android | v2rayNG、v2flyNG | Distinguish system VPN status, included apps, and the core's routing results. |
| Linux | v2rayN | Distinguish desktop network settings from proxy parameters inherited by terminal processes. |
When switching cores, compare effective fields instead of copying the entire config
Xray and V2Fly share some configuration concepts, but specific protocols, transports, security options, and core-specific fields may not be interchangeable. To migrate a config, keep a separate local inbound and direct outbound first, and confirm the minimal file starts. Then add the original rules, DNS settings, and remote outbound one section at a time. Check whether an error points to an unknown field, an invalid field value, or a missing data file. A config working in one client does not mean it will run unchanged in another client or core.
This top-level fragment contains only a local loopback HTTP inbound and a direct outbound. It can help compare these two basic objects across cores. It uses a different inbound setup from the SOCKS baseline in the first chapter, so the app must explicitly use an HTTP proxy on the example port. To compare two cores, run the same file on each in turn and make sure the previous process has stopped. Do not run both configs at once on the same port: that tests for a port conflict, not compatibility.
{
"inbounds": [
{
"tag": "local-http",
"listen": "127.0.0.1",
"port": 10809,
"protocol": "http",
"settings": {}
}
],
"outbounds": [
{ "tag": "direct", "protocol": "freedom", "settings": {} }
]
}
If a native config starts and an explicit proxy test works, but the client-launched instance behaves differently, compare the running file's outbound order, inbound port, routing tags, and DNS policy—not just the node name. If the difference appears only when system proxy or virtual network adapter mode is enabled, check how traffic is being intercepted. Capturing traffic is a client and system-level issue; an outbound in native JSON cannot enable a proxy path that the app was not using.
Share only the data needed to reproduce the issue
If you need help troubleshooting, make a temporary copy of the config and remove subscription URLs, remote credentials, real node addresses, personal directory paths, and identifying access logs. Keep the necessary keys, value types, array order, and references between tags; changing only one side of a tag reference can introduce an error that did not exist in the original. If the issue depends on a remote server, describe the failing stage and relevant error instead of uploading the full runtime file. For the initial setup and node import steps, see v2rayN initial setup.
Before each persistent change, write down which request behavior you want to change and how to undo it. For example, restore the original rule order to undo a routing change, and revert the proxy setting in the app or system settings to undo a system proxy change. Keep separate records for both. A proxy setting that still points to an old local port after the client closes can cause failures unrelated to the core config. In that case, restore the original traffic handling first, then compare config changes.
Layered Testing and Rollback
Confirm the config loads before checking whether requests reach the core
Before troubleshooting, note the client, actual core, listening address, port, default outbound, and test destination. Save a working copy of the config before editing a candidate. If the core refuses to start, look for the earliest error that clearly identifies a field: invalid syntax, wrong type, unsupported protocol, missing rule data, and a port conflict are different issues. Later errors may be consequences of the first failure. Fix the earliest cause, then read the startup log again. Do not change multiple sections at once.
After startup, make a short request from an app explicitly configured to use the proxy. The commands below are for an environment using the baseline file, with curl installed and direct access to the example site. Compare the result with a request to the same site that does not use this proxy. The two SOCKS options differ mainly in which side resolves the destination domain, which is especially useful for comparing routing and DNS. If you use a different listening port, keep it consistent in both commands instead of changing the destination and proxy address at the same time.
curl --socks5 127.0.0.1:10808 --max-time 12 https://example.org/
curl --socks5-hostname 127.0.0.1:10808 --max-time 12 https://example.org/
If the command cannot connect to the local port, first check that the core is running and listening on the same address. If it connects to the port but the proxy protocol exchange fails, check the proxy type selected in the app. If explicit proxying works but normal browser or terminal requests do not, check how the app handles proxying: browser extensions, system proxy settings, and terminal environment variables may each apply to different traffic. Use system proxy troubleshooting to test browser and terminal traffic separately.
Use short-term logs to trace one specific request
If a request reaches the core but you cannot tell where it goes, temporarily increase log verbosity. This fragment replaces the entire top-level log object. It is intended for brief observation in a copy of the baseline and does not specify a persistent log path. How the client receives and displays core output depends on how it runs the core. Higher log verbosity does not guarantee that the UI will show every rule evaluation. Use the request time, destination, inbound-to-outbound entries, and error stage to piece together the full path.
{
"log": {
"loglevel": "info"
}
}
Reproduce the issue once and record the destination clearly. If the destination appears as an IP, do not start by changing domain match expressions. If the log shows the default outbound, check whether any rule matched, whether its tag exists, and whether the first outbound is the one you expected. If the outbound is correct but the connection fails, investigate DNS or dialing. A domain resolution error, connection refused, and connection timeout are not interchangeable: they point to address resolution, the destination's listening state, and the waiting stage, respectively, and call for different next steps.
When comparing old and new configs, keep the destination, app, inbound protocol, network, and selected node the same; change only the file under test. Re-establish the connection for each run to avoid reusing browser connection pools or old client sessions. If the issue appears only after a long idle period, wait the same amount of time in both tests. If it affects only one kind of name, keep a known-good name as a control. When the issue is hard to reproduce, recording the conditions is more useful than reinstalling the client without a specific reason.
Roll back the config and traffic handling separately
If the candidate file fails to start or pass a basic connection test, stop the candidate instance, restore the previous config copy and the local port used by the app, then test a known-good destination. If you temporarily enabled system proxy or virtual network adapter mode during testing, restore its original state too; that is separate from replacing the JSON file. Once the app is back on its normal path, restore the usual log level and remove any extra listeners, fixed host mappings, and dedicated rules added for testing.
Keep three results: whether the app reached the intended inbound, whether routing selected the expected outbound, and whether the outbound reached the destination. Record observable facts only. Before sharing the results, remove any destination details that do not need to be public.
If the issue persists after rollback, stop layering changes onto the candidate file. Repeat the baseline test and confirm that the local port, traffic handling, and network environment are really back to their original state. Then check whether a new process is using the port or an old config file. If you just want to restore everyday use, return to the Getting Started guide and repeat the import, mode selection, and connection checks. Once the basic path works again, use the relevant section of this manual to investigate one field at a time.