Core Configuration · Field Reference

V2Ray Configuration Reference

Explore inbounds, outbounds, routing, DNS, and connection policy by JSON structure, then see how they work together in a minimal configuration.

Setting up a subscription or system proxy for the first time? Start with the quick-start guide. It covers the steps to get connected; this reference explains the fields the core actually reads. Use the contents to jump straight to details on ports, outbound tags, or DNS results.

01 Configuration Structure

V2Ray Configuration File: JSON Structure

Client Settings Aren’t the Same as Core Configuration

For desktop use, start with v2rayN. On Android, choose v2rayNG or v2flyNG based on the core you need; see the client downloads page. In a graphical client, subscription URLs, selected nodes, system proxy settings, and interface preferences are usually managed by the client. It then generates or loads a core config based on the selected node and global settings. A name shown in the interface may not match a JSON tag, and client data files may not be readable directly by the core. Before comparing fields, confirm which core is running and which config file it actually loads.

You usually don’t need to write a complete JSON config for everyday connections. Create a separate config only when you’ve confirmed the interface can’t express the behavior you need, or when you want to isolate a problem. Changes to a file generated by the client may be overwritten when you reconnect, switch nodes, or update a subscription. Conversely, editing a copy that isn’t loaded won’t change the connection. To verify a change, check startup results and observable behavior—such as listeners and outbounds—not just the file’s modification time.

Root Object, Object Arrays, and Protocol Settings

The root is an object. Inbounds and outbounds are arrays because a single process can have multiple entry and exit points; each item in an array is an individual inbound or outbound object. Routing, DNS, policy, and logging each have their own root-level object. A field in the wrong place may pass JSON syntax checks and still be ignored by the core. For example, the listening port belongs to an inbound object, while authentication goes inside the SOCKS inbound’s settings object. Don’t put fields at the same level just because they appear in the same settings window.

{
  "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": {} }
  ]
}

This complete minimal config accepts local SOCKS requests and connects directly to their destinations, with no remote server required. It has no routing rules, so unmatched requests go to the first outbound in the array. JSON order has two different meanings: putting log before inbounds in the same object doesn’t change behavior, but array order often matters—especially for the default outbound and routing rules. When copying a snippet, keep the outer structure and add items to the appropriate array; don’t concatenate two complete root objects.

Root-Level Field Reference
FieldStructurePurpose
inboundsArray of objectsAccepts connections and identifies each entry point
outboundsArray of objectsDefines how destination connections are handled or discarded
routingObjectSelects an outbound and contains an array of rules
dnsObjectConfigures domain lookups initiated by the core
policyObjectSets connection timeouts and statistics options
logObjectControls log level and related output

Check Syntax First, Then Field Relationships

When saving as standard JSON, put field names and strings in straight double quotes; don’t add comments or trailing commas. Write ports as numbers, authentication methods as strings, and switches as unquoted true or false. Don’t repeat a key in the same object: some parsers use the last value, silently replacing the original rule when you think you’ve added another setting. If an error points to a line, also check the preceding line for a missing comma or an array closed too early.

Passing a syntax check only means the file can be parsed as structured data. Next, verify three kinds of relationships: that the protocol matches its settings, that every tag referenced by a rule exists, and that files referenced by the config are readable in the runtime environment. Only then investigate runtime issues such as port binding or reachability. Cores may handle unknown fields differently, and may not report them clearly. This guide covers common foundational structures across two core families; for core-specific extensions, use fields supported by the core that loads the file.

02 Accept Connections

inbounds: Listen Address, Port, and Inbound Protocol

The Listen Address Determines Who Can Reach the Inbound

For local use, set listen explicitly to 127.0.0.1 so other devices on the same network can’t reach the inbound. The application must connect to the machine running the core. If you enter this address on a phone, it points to the phone itself, not your desktop. A listener bound only to the IPv4 loopback address won’t accept connections through the IPv6 loopback address. When checking the proxy address in a client, use an explicit address first so localhost resolution doesn’t add another variable.

port is the local port the core listens on—not the server port in a subscription. The address-and-port combination is subject to operating system binding rules: if another process is using the port, the inbound may fail to start; a listener bound to all IPv4 interfaces may also overlap with one bound to a specific address. When changing the port, update the port entered in the application or system proxy settings too. If only one side changes, the client may appear to work while the application still connects to the old inbound—or even to another program that has taken over the old port.

{
  "inbounds": [
    {
      "tag": "local-socks",
      "listen": "127.0.0.1",
      "port": 10808,
      "protocol": "socks",
      "settings": {
        "auth": "noauth",
        "udp": false
      }
    }
  ]
}

The Inbound Protocol Is Checked Before Routing

This example uses a SOCKS inbound, so the application must explicitly use a SOCKS5 proxy. A browser requesting a webpage doesn’t mean the proxy handshake should use HTTP. For applications that only support HTTP proxy settings, use a separate HTTP inbound or the corresponding inbound generated by the client, and enter the port configured for it. If you send an HTTP proxy request to a SOCKS port, the port may be reachable, but the core can’t parse the destination using the expected inbound protocol—so routing never gets a chance to process it. A successful port check alone doesn’t prove a request reached the routing stage.

With auth set to noauth, no credentials are required—suitable for this test, which is restricted to the loopback address. With udp set to false, this inbound doesn’t provide SOCKS UDP forwarding. Even when enabled, the application must support SOCKS5 UDP associations, and the outbound must support that traffic too. A webpage loading only confirms that this particular request worked; it doesn’t prove that real-time communication or other UDP-dependent applications can use the same inbound. Record the affected application, proxy protocol, and transport it actually uses.

Inbound Tags, Destination Addresses, and Sniffing Are Different Things

tag names an inbound. Routing can use inboundTag to distinguish requests from different listeners. For example, name two local inbounds separately to apply a rule only to a test application’s inbound, without affecting your everyday one. An inbound tag doesn’t change automatically with the application’s proxy protocol; if you rename it, update its routing references too. If two inbounds behave differently, first check which port the application uses, then see whether the relevant rule specifies the other inbound’s tag.

A domain name isn’t always included in an inbound request. An application may pass the domain to the core, or resolve it locally and pass only an IP address. With sniffing enabled, the core can try to identify domains in supported traffic—for example, a hostname in an HTTP request or a server name in some TLS handshakes. It can’t identify every connection, and it doesn’t decrypt application traffic. Some configurations also distinguish between using the detected domain for routing and rewriting the actual destination. For easier testing, start with an application that clearly passes the domain, confirm basic routing, and only then consider enabling sniffing.

03 Make Connections

outbounds: Outbound Protocols, Tags, and the Default Route

Tags Identify Outbounds; Protocols Determine What They Do

outbounds defines which handler receives a request. Naming an outbound direct is just for readability; freedom is what actually connects directly. Similarly, a blocking outbound is often named block, while blackhole performs the blocking. A name alone doesn’t change outbound behavior. If you copy routing rules without the outbound they reference by tag, the referenced object is missing. Conversely, defining a blocking outbound won’t block anything unless a rule selects it.

{
  "outbounds": [
    {
      "tag": "direct",
      "protocol": "freedom",
      "settings": {}
    },
    {
      "tag": "block",
      "protocol": "blackhole",
      "settings": {
        "response": { "type": "none" }
      }
    }
  ]
}

In this common setup, with no separate default outbound configured, requests that match no rule go to the first item. Move the blocking outbound to the first position and every unmatched request will behave differently, even if no rules change. The default outbound and an explicit catch-all rule aren’t the same: the default applies when no rule matches, while a broad rule can prevent more specific rules below it from ever being reached. When reviewing a config, first decide which outbound should handle unknown destinations, then choose whether to rely on the first item or add a general rule at the end.

Remote Outbound Settings Have Protocol and Transport Layers

A remote outbound generally involves both protocol settings and connection settings. protocol selects the protocol used by the core; settings describes the remote address, server port, and identity information for that protocol; streamSettings describes the transport and security layers used for the connection. Both sections must match the remote server’s configuration. Copying the transport section from one node to another may leave the protocol credentials intact but break the path or handshake requirements. Compare fields by layer when troubleshooting instead of blaming every handshake failure on a subscription update.

When several fields look like they mean “address,” first check what each one is used for. A remote connection needs a dial address; a security handshake may also need a server name; some transports require a separate path or hostname. These values may be the same for some servers, but they aren’t interchangeable. Changing the dial hostname to an IP doesn’t mean the other names should change too. For details on how sharing links pass single-node settings, see Sharing Links vs. Subscription URLs. Don’t paste an entire link into a JSON address field.

Distinguish Between “Rule Matched” and “Outbound Connected”

A routing match only selects a handler; it doesn’t guarantee a connection. If a direct connection fails, check whether the local machine can resolve the destination, has a network route to it, and can reach its port. If a remote outbound fails, first distinguish between reaching the remote address and completing the outbound protocol handshake. Then check whether all destinations fail or only one. Blocking intentionally stops a request from being forwarded. The example’s none doesn’t show a human-readable block page, so an application simply reporting a connection failure is expected.

If switching to a different node still looks like a direct connection, don’t judge by whether a webpage loads. Both direct and remote connections can load the same page, and an existing long-lived connection may keep running briefly after a switch. Instead, confirm that a new request reached the intended inbound, then check logs or use a controlled comparison to see which outbound was selected. If both outbounds seem to fail, start with a minimal config containing only one direct outbound. This separates the application-to-local-inbound path from the parts that depend on a remote server.

04 Match Rules

routing: Rule Order, Destination Types, and Outbound References

Rules Are Checked in Order; the First Match Wins

routing.rules is an ordered list, not a set of candidates ranked by score. A broad rule near the top can make more specific rules below it unreachable. For example, if you first send all requests from a test inbound direct, a later rule blocking a domain on that same inbound will never be reached. To find this kind of issue, start at the top and ask “does this rule match?” at each step instead of looking only at the rule you expected to apply.

{
  "routing": {
    "domainStrategy": "AsIs",
    "rules": [
      {
        "type": "field",
        "inboundTag": ["local-socks"],
        "domain": ["full:example.org"],
        "outboundTag": "block"
      },
      {
        "type": "field",
        "inboundTag": ["local-socks"],
        "outboundTag": "direct"
      }
    ]
  }
}

The first rule requires both that the request comes from local-socks and that its destination is the exact domain example.org. Different condition fields must all match, while candidates in the same list usually work as alternatives—for example, any matching pattern in a domain list is sufficient. To match “this domain OR this destination IP range,” use two rules. Putting domain and ip in the same object doesn’t create an OR condition. This is a common reason why combining rules can reduce the number of matches.

Domain Rules Don’t Match URL Paths

Use full: for an exact domain; use domain: for that domain and its subdomains. The first doesn’t include subdomains, and the second doesn’t search the whole URL for an arbitrary substring. Enter a hostname, not a URL prefix, path, query string, or page fragment. A webpage may redirect to another domain and load static assets from a third; part of the page loading doesn’t mean every request matched the same rule. For testing, use one clearly defined hostname and check whether it’s the main document or a later resource that fails.

IP rules match destination addresses and can use a single address or a CIDR range. A port condition applies to the destination port, not the local SOCKS listening port. If an application passes an IP address, domain entries usually won’t match unless the core detects a usable domain from the traffic. Conversely, when an application passes a domain, whether routing resolves it to an address for IP rules depends on routing’s own domainStrategy. Don’t mistake routing’s failure to find a matching address for a resolution and connection failure by the outbound.

Domain Resolution Strategies and Rule Sets

Routing’s AsIs doesn’t resolve domains just to match IP rules. IPIfNonMatch tries resolving after the initial lookup finds no match, so a broad fallback rule that matches on the first pass may prevent that lookup. IPOnDemand allows routing to trigger resolution when a rule requires an IP match. Choose a strategy only if you need to match address ranges using a domain’s resolved IP. If you’re routing by hostname, there’s no need to add another query and another potential point of failure.

geosite: and geoip: depend on the resource files actually loaded and the category names they contain. Categories with the same name aren’t guaranteed to stay the same; check the resources in use to see whether a domain or range is included. A missing resource or category is a different issue from a resource loading successfully but not containing a particular address. First verify the matching path with a known domain or a small, known IP range, then switch to a category. If the same test fails, you can narrow the problem to the rule set or its update.

05 Resolve Domains

dns: Built-in Resolver, Static Mappings, and Query Sources

First Find Out Who Is Resolving the Domain

An application may resolve a domain itself and pass an IP to the inbound, or pass the domain to the core as part of a proxy request. In the latter case, the core may pass the domain to a remote server or resolve it itself during routing or direct dialing. The top-level dns settings control lookups made by the core’s resolver; they don’t automatically take over queries from every application or the operating system. If a browser uses its own DNS method, its results may differ from those of operating system lookup tools. Neither result alone proves which settings the core used.

Trace the flow for a specific connection: did the application pass a domain or an IP? Did routing trigger a lookup to match an address? Does the final outbound resolve the destination itself or pass it to a remote server? Several stages may look up the same domain, or none may do so. For example, if an application passes an IP to the core and the direct outbound only needs to dial that address, adding a static mapping for the original domain usually won’t change the result. To test a mapping, the request must retain the domain, and the selected outbound must actually use the core’s resolver.

{
  "dns": {
    "hosts": {
      "sample.test": "127.0.0.1"
    },
    "servers": ["localhost"]
  },
  "outbounds": [
    {
      "tag": "direct",
      "protocol": "freedom",
      "settings": { "domainStrategy": "UseIP" }
    }
  ]
}

Understanding hosts, servers, and an Outbound’s domainStrategy

In this example, hosts maps a test domain to a loopback address. This affects only the core using this DNS configuration. In servers, localhost means to use the local system’s resolution facilities; it doesn’t mean you need to run a DNS server on a loopback address. Entering the literal address 127.0.0.1 as a DNS server is not the same as using this special value: the former requires an actual DNS service listening at the specified address and port. A static mapping returns an address; it doesn’t perform the application protocol handshake or provide a certificate for the target domain.

freedom.settings.domainStrategy controls how the direct outbound handles domain destinations, and has a different role from routing.domainStrategy. Here, UseIP makes the direct outbound resolve the domain before dialing. Changing the routing strategy alone doesn’t tell you which address was ultimately dialed. For testing, run a known-working local HTTP service on a loopback address and access the service’s actual port from a SOCKS application that can pass a domain. If the service serves different sites based on the request hostname, also check that it accepts the test hostname.

Upstream resolvers can be configured as simple server entries; some cores also support objects that assign specific domains to particular servers. When assigning upstreams by domain, which server takes priority and whether there’s a fallback on failure are separate questions. Also distinguish between an empty answer, a timeout, and an unexpected address. Enabling several query methods at once may reveal an odd result without showing which upstream caused it. Start with one known-working resolution path, then add domain assignments and fallback restrictions one at a time to make issues easier to isolate.

Address Families, Caching, and FakeDNS

A domain may have both IPv4 and IPv6 addresses, while the current network may not reach both address families. Compare the resolution results with the actual dialed address before deciding whether to restrict queries or outbound address selection; suppressing one type of result doesn’t fix connectivity issues for that address family. Old addresses may still appear after changing a static record because the application, operating system, core, or upstream may each have its own cache. Test with a new connection and identify which cache you’ve cleared rather than just refreshing the webpage again.

FakeDNS returns a virtual address for the proxy flow to recognize. The core on the same path must map it back to the associated domain; it isn’t a general replacement for caching real addresses. If the application bypasses the core after receiving a virtual address, or the mapping has been lost, the connection may no longer be handled using the original domain. The ordinary SOCKS example doesn’t need FakeDNS. To understand how addresses are passed through a transparent proxy, see FakeDNS: How It Works and When to Use It. Get ordinary DNS resolution working first so you have a baseline for identifying where a virtual address enters the flow.

06 Manage Connections

policy: Connection Timeouts, User Levels, and Statistics

A Level Is a Policy Index, Not a Permission Ranking

policy.levels associates a set of parameters with a user level. In a JSON object, the level key is a string, such as "0"; fields that specify a user level in protocol settings are usually numbers. A level isn’t a plan name, and higher numbers don’t mean more permissions. The inbound protocol and its user-level field determine which level a connection uses. When troubleshooting, start with the default level instead of creating a new one under policy that nothing actually references, then wondering why the settings had no effect.

{
  "policy": {
    "levels": {
      "0": {
        "handshake": 8,
        "connIdle": 300,
        "uplinkOnly": 3,
        "downlinkOnly": 10
      }
    },
    "system": {
      "statsInboundUplink": true,
      "statsInboundDownlink": true
    }
  },
  "stats": {}
}

This is a snippet to merge into the root object, not a standalone config. The values illustrate what the fields mean; they’re not universal recommendations. Policy doesn’t select an outbound for routing or change an inbound’s listening scope. For problems such as an inbound rejecting access or an outbound failing to connect, first identify where the failure occurs. If the handshake hasn’t started, changing a session timeout usually won’t help. If the handshake succeeds every time but the connection drops after sitting idle, policy settings are worth testing.

What Each of the Four Timeouts Covers

handshake is measured in seconds and limits how long an inbound protocol waits for its handshake to complete. It isn’t a general-purpose timer for every network operation. It’s different from a browser’s time to first byte and from the limit for connecting to a remote server. When checking this setting, distinguish a client that connects to the port but never completes its handshake from a connection where the handshake finishes but the remote side takes too long to respond. An application’s “connection timed out” message alone doesn’t tell you whether to adjust the inbound handshake or a downstream connection setting.

connIdle measures how long a connection has had no data activity; it isn’t a fixed lifetime that starts when the connection is established. A connection that keeps sending or receiving data shouldn’t be treated as idle just because it has been open for this many seconds. uplinkOnly and downlinkOnly apply when one side has closed but the other can still transmit: they cover the periods when only the uplink or downlink remains. First check whether the application closes its sending side early or needs to keep receiving a long response, then decide whether the relevant timeout is appropriate.

A shorter idle timeout may reclaim unused connections sooner, but it can also force sessions that send data only occasionally to reconnect. A longer timeout keeps temporarily idle connections around for longer. If disconnections happen at around the configured interval, treat that as a clue—not proof—because the application, remote server, or an intermediate network device may have its own timeout. Compare three cases: ongoing transfers, completely idle connections, and connections with one side closed. Change only the setting relevant to the symptom and leave the rest unchanged to determine whether the core’s policy or another part of the path is closing the connection first.

Statistics Switches Don’t Create a Dashboard

The top-level stats in this example enables the statistics module. The two switches in policy.system enable per-inbound uplink and downlink tracking. Give each inbound you need to distinguish a stable tag; update the name in the reader if you rename it. Other switches enable per-user statistics. Whether the core can associate them with a user depends on the protocol’s user identifier, so system-level inbound counts aren’t the same as usage per application or subscription entry. If two devices use the same listener, its inbound count may include requests from both.

Statistics switches only tell the core to record the relevant metrics. Whether you can see the values depends on whether the client reads them and which running instance it reads from. Without a way to retrieve them, setting a switch to true won’t write a report to the config file. Counts from an old process also won’t automatically carry over after a restart. To verify, send a small, identifiable amount of traffic through one inbound and check for a count change in the same instance. Don’t expose a management interface to other devices just to view statistics.

07 Test the Configuration

Complete Example: Local SOCKS, Direct Connections, and Blocking One Domain

Test in a Separate Configuration

This config has no remote outbound and requires no subscription or account. It uses a local-only SOCKS inbound and a rule to block one exact domain; all other requests go to the first outbound, which connects directly. The direct outbound uses the built-in resolver for domain lookups, and the resolver gets results from the local system. This setup deliberately avoids rule sets, sniffing, and remote connections. Select the right proxy protocol in the application to focus your first test on the inbound, destination type, and outbound reference. To import a subscription as usual, follow the subscription setup guide.

Before you start, keep your existing working client config and use a separate file in a test environment that supports custom configs. Confirm that the running core can load this complete JSON file and that the example port isn’t already in use by the client. To change the port, replace it in both the example’s inbound and the test application’s proxy settings; don’t put it in the domain match. Change the proxy settings for just one application rather than routing all device traffic through the test. That way, cleanup means reverting only that application, and it’s easier to tell where requests came from.

{
  "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": {
        "domainStrategy": "UseIP"
      }
    },
    {
      "tag": "block",
      "protocol": "blackhole",
      "settings": {
        "response": { "type": "none" }
      }
    }
  ],
  "routing": {
    "domainStrategy": "AsIs",
    "rules": [
      {
        "type": "field",
        "inboundTag": ["local-socks"],
        "domain": ["full:example.org"],
        "outboundTag": "block"
      }
    ]
  },
  "dns": {
    "servers": ["localhost"]
  },
  "policy": {
    "levels": {
      "0": { "connIdle": 300 }
    }
  }
}

Verify Observable Results, Not Just Whether a Webpage Loads

First check that the core starts successfully. If parsing or listening fails, don’t keep retrying in a browser. Once it’s running, explicitly set the test application to SOCKS5, enter the local listening address and port, and choose an option that passes the domain through the proxy. Visit a test host you’ve confirmed is reachable directly from the local machine, then use a separate connection to visit example.org. The first request should go direct; the second should be blocked. Whether the first works depends on local connectivity and the destination itself, so don’t use a host that was already unreachable as your success case.

Blocking tests need a baseline too. Temporarily remove the only rule, leave rules as an empty array, reload the config, and confirm the test domain is reachable. Then restore the rule and start a new request. If the request fails with the rule and succeeds without it, the difference is likely due to that rule. If both states fail, that doesn’t confirm the block is working. If both succeed, suspect that the request isn’t using this inbound, the application resolved the domain to an IP first, or an existing connection is still using the previous config.

Run one more check in the opposite direction: use the same inbound to visit a known host other than the blocked destination, and confirm that removing and restoring the rule doesn’t affect it in the same way. This distinguishes a single rule blocking one destination from a general failure in the local proxy settings. Logs that record both the destination and inbound can also help, but log formats vary between cores and clients. Focus on new requests made now, their destination type, and the selected outbound; log text doesn’t need to match a screenshot in a particular guide.

Keep a Known-Good Baseline When Extending the Config

To add a remote outbound, keep the current direct outbound first and leave the block rule in place. Add the new outbound after it, then create a rule that directs a known test destination to the new outbound. After loading the config, test both the original and new destinations; if the original still behaves as before, you’ve avoided accidentally changing the default path. If you copy the example into your everyday client config, don’t overwrite the existing outbound array or DNS object wholesale. Merge items individually and check all references, especially for duplicate tags.

08 Troubleshoot and Maintain

Troubleshooting V2Ray Configs: Trace the Connection from Loading to Destination

Won’t Start? Check Parsing, Validation, and Binding Separately

If the core won’t start at all, save the first error. A parsing location error means checking brackets, commas, or full-width characters introduced by copying. A field type or protocol name error means checking field placement and the selected core. An address binding error means checking local interfaces and port conflicts. Each calls for a different fix. The client may show only a generic startup failure; check its core logs for the first failure. Subsequent connection errors may simply mean the inbound never started, so don’t treat them as separate issues from the first error.

If the same file loads in another environment, first confirm that you’re comparing the same config format—not a client that imports individual nodes with one that reads a complete JSON file. Rule-set paths, log directories, and available ports also depend on the runtime environment. Relative paths may not start from the directory containing the config file; seeing two files together in a file manager doesn’t prove the core can find one from the other. First verify startup with a config that references no external resources, then restore file references one at a time. This is easier than copying every path into a new directory at once.

Starts but Behaves Unexpectedly? Find the First Point Where It Deviates

Symptom and First Checks
SymptomCheck firstNext step
Application can’t reach the local proxyListening address and portConfirm the process started and the address families match
Handshake failsApplication’s proxy protocolCheck the inbound protocol and authentication method
Wrong outbound selectedDestination type and rule orderCheck inbound conditions, tags, and the default outbound
Outbound is correct but can’t connectResolution and outbound dialingDistinguish an unreachable address from a failed remote handshake
Disconnects only when idleConnection stage and durationCompare the application, policy, and remote timeouts

“Every application fails” and “only one application fails” are useful distinctions. If no requests reach the inbound, check system proxy settings or the test application’s own settings; some applications don’t use the system proxy. If only one application fails, check whether it passes the domain to the proxy, uses a different transport, or is reusing an existing connection. Don’t change the device’s proxy mode, the application’s DNS method, and the core’s routing strategy all at once to test one domain rule. Even if it starts working again, you won’t know which change helped.

If requests reach the inbound and the rules select the expected outbound, reordering routes isn’t the next step. Test the direct and remote paths separately to identify where the failure occurs: local DNS resolution, an unreachable remote address, an interrupted outbound handshake, or a failed connection to the destination service. Success with one destination doesn’t prove that others are reachable. Keep the test application and destination the same, change one thing, then make a new request. For intermittent failures, note when they occur and whether they follow a network switch or sleep; this helps separate config issues from transient network changes.

Preserve Evidence with Temporary Logs and Small Changes

{
  "log": {
    "loglevel": "info"
  }
}

For more clues, merge loglevel from the snippet into the existing log object to temporarily increase logging detail. The client may also control where logs appear and how they’re filtered; not seeing an entry in the interface doesn’t necessarily mean the core didn’t receive the request. Reproduce just one action, note the time, and check whether it appears in the expected instance’s logs. Restore the normal log level when you’re done. Before sharing diagnostic information, remove subscription URLs, identity details, and records that could identify you; don’t send the complete config.

For maintenance, keep two separate backups: a minimal example known to start successfully and the latest verified working configuration. After updating the client or switching cores, run a consistent inbound and routing test with your everyday config before enabling new features. If something regresses, use the minimal example to check that the basic structure still works, then add back the original DNS, routing, and remote outbounds section by section. Finally, note which settings are generated by the client, which depend on external resources, and which you maintain yourself. That makes it clear what to keep the next time you overwrite or migrate the config.