Official Manual · Configuration Reference
Shadowrocket Configuration Guide
Configuration file structure, routing rules, and match priority
For your first connection, follow the quick start guide to import an existing subscription or server details, then confirm that the connection works. Return to this page when you need to understand why a request went direct, why it matched the default policy, or how to edit a configuration file. Haven't obtained the app yet? See downloads for all platforms.
The iPhone / iPad app costs $2.99 as a one-time purchase on the App Store; check the App Store listing for system requirements. The Mac (Apple silicon and Intel), Windows, Android, and Linux versions are free, with installers available from this site under /dl/. Buying the app is a one-time purchase and does not include a network service plan. This site does not provide, sell, or recommend servers or subscriptions.
Configuration file structure and [General]
When reviewing a configuration, first check which file is active, then inspect its rules. A successful import only means the file was added to the client; it does not mean the file is handling the current connection. Check the active file in Config, then check Global Routing on Home. If the latter is not set to Config, connection results cannot tell you whether the file's regular routing rules matched. Before editing, keep a copy of the original configuration that you can switch back to, and note the active filename and mode.
Find the relevant section first, then check its settings
Section names appear in square brackets. The following lines belong to that section until the next section header. [General] contains general settings, [Rule] contains match conditions and policies, [Host] maps hostnames for resolution, and [URL Rewrite] contains actions for rewriting matching URLs. These are not four priority levels, and a request does not pass through each section in sequence. Find the section that relates to the issue: check routing for an unexpected path, host mappings for unexpected resolution, and rewrites only when the URL itself changes.
| Section | Purpose | What to record before editing |
|---|---|---|
[General] | Set general options for handling connections. | Existing exclusions and requests that still need processing. |
[Rule] | Choose a connection policy based on conditions. | The request's actual destination, expected policy, and default policy. |
[Host] | Set resolution mappings for specific hostnames. | Target hostname, original address, and test address. |
[URL Rewrite] | Match URLs and apply specified rewrite actions. | Original URL, expected destination, and redirect result. |
The line formats for these four sections are not interchangeable. Settings use an equals sign between the setting name and value; the static mapping example below uses one too. Rules use commas to separate fields, while rewrite examples use spaces between the pattern, destination URL, and action. When copying a code block, don't include explanatory text in the file. If the app can't read the file, check the section headers and field separators you just edited, especially for full-width commas or equals signs inserted by an input method and line breaks added by the editor. A visual line wrap on a webpage is not a real line break in the file; keep each rule on a single line.
General settings: keep only exclusions you understand
[General]
skip-proxy = localhost, 127.0.0.1
skip-proxy is an exclusion list in the general settings; the example lists two local destinations. It is not a DIRECT rule: the former defines which requests are excluded from proxy processing, while the latter is the policy selected after a request enters rule matching. Don't assume that an item missing from routing logs must have matched a direct rule. In particular, request capture can vary across networks and apps. Confirm that the request is within the current client's processing scope before looking for a matching rule.
Keep the other general settings in the original file. Don't copy an entire block of settings from an unknown source just to add a domain rule. If the exclusion list already contains other destinations, confirm the purpose of each one. Repeating a setting name does not merge the lists, and you shouldn't assume the values will be appended automatically. If a service is taking the wrong route, start by adding a precise rule to [Rule] and testing it. Change a general setting only after confirming that it affects the behavior in question. This makes it easier to compare the configuration before and after the change.
Changing the file, mode, and server at the same time makes results hard to compare. Change one thing per test. First confirm that the configuration loads, then check that the request reaches the new rule.
It's also important to distinguish subscription content from a local copy of the rules. An existing subscription may update server entries, or an external source may provide an entire configuration; these are different behaviors. Before editing, find out whether the app is using an imported local copy or a configuration that still updates from a remote source. If local changes disappear after a refresh, check the file's source and which file is selected before trying a different rule syntax. Save custom lines separately without credentials so you can check whether they need to be merged after the next update.
Domain rules: exact matches, suffixes, and keywords
When you know the hostname to handle, start with a domain rule. The domain field takes a hostname only—not a protocol, port, path, or query string. If you're copying a condition from a web address, extract the hostname from the full URL first. The address bar shows where the top-level page is hosted, but images, session APIs, and static assets may use other hosts. If the home page loads but some content fails, identify the specific failing requests; that alone doesn't mean the same hostname used two different policies.
Use the narrowest condition that meets your needs
| Keyword | Example condition | What it matches |
|---|---|---|
DOMAIN | api.example.com | Matches this exact hostname only. |
DOMAIN-SUFFIX | example.com | Matches the domain and its subdomains, but not hostnames with similar spelling. |
DOMAIN-KEYWORD | example | Matches requests whose hostname contains this string. |
[Rule]
DOMAIN,api.example.com,DIRECT
DOMAIN-SUFFIX,example.com,PROXY
DOMAIN-KEYWORD,example,PROXY
FINAL,DIRECT
This example lists the API hostname as an exception first, then routes other requests under the same domain through PROXY. A request to api.example.com stops at the first line and never reaches the second. A request to www.example.com matches the suffix rule; api.example.org is outside that suffix but matches the keyword rule. The keyword line demonstrates its broad reach—it isn't a recommendation to keep it in every configuration. If you only need to handle a specific, known domain, remove this broad condition. If you really need several suffixes, listing them individually is usually easier to review later.
A suffix is not a file extension or the end of a URL. For example, example.com.other.test is not a subdomain of example.com, but assets.example.com is. A keyword doesn't need to align with domain labels, so it can match unrelated hostnames containing the same string. Don't use a brand abbreviation, environment name, or common business term as a keyword unless you've checked for similar domains. If you need to cover both a site and its test domain, two exact or suffix conditions are usually easier to maintain than one broad condition.
Match the request destination, not the site's display name
For a website issue, note a reproducible action—such as opening a page, loading an image, or submitting a form—and check which hostname that action requests. For other apps, don't enter the name shown under the app icon in the domain field. If the client only sees the destination IP, a domain rule can't match the hostname. Check whether the log shows a request domain or an address, then choose the corresponding rule type. A domain resolving to a particular address doesn't mean other domains hosted at that address should use the same policy.
Paths are outside the scope of domain-rule matching. Two paths on the same host match the same domain condition, even if they serve different purposes. Adding a slash and path to the second field of DOMAIN won't make routing more precise. To change the path of an HTTP URL you manage, see URL Rewrite. To test a single endpoint, you can still send its full URL as the test request, but the matching condition should use its hostname.
Test a domain rule with at least two examples: one hostname that should match and a similarly spelled one that should not. If you've defined an exception, test that too to make sure an earlier broad rule doesn't catch it first.
When a service adds a hostname for new resources, confirm that it serves the same purpose before adding an exact condition or widening the existing suffix. Widening the suffix affects subdomains added later. It can reduce maintenance, but may also route test or admin endpoints differently. If you're unsure whether they share the same scope, list the new hostname separately. For a quick reference to rule fields and matching behavior, see Rule Types Explained.
Address rules: GEOIP, IP-CIDR, and IP-CIDR6
Address rules match a connection's destination address—not the device's own address or the visitor's location. They're useful for services accessed directly by IP address, address ranges with a confirmed purpose, or broad region-based conditions placed after domain exceptions. Address rules are straightforward for stable internal network ranges, but use caution when substituting an address for a public hostname. Public services can change addresses or share them with unrelated sites, so don't turn a single DNS lookup into a permanent rule without further checks.
Start by identifying the address family and prefix range
[Rule]
IP-CIDR,192.168.0.0/16,DIRECT
IP-CIDR6,2001:db8:1::/48,PROXY
GEOIP,CN,DIRECT
FINAL,PROXY
IP-CIDR specifies an IPv4 network. In this example, /16 fixes the first 16 bits and covers the full range from 192.168.0.0 to 192.168.255.255. If you only need to reach one device with a fixed address, use that address with /32 for a narrower match. Use /24 only when you actually need a subnet identified by its first three octets. A shorter prefix covers a wider range; the number after the slash is not the number of devices. Before adding a rule, test the boundary with one address inside the range and one in an adjacent range.
IP-CIDR6 specifies an IPv6 network. The address in this example is reserved for documentation, not a live service. Use /128 to match a single IPv6 address. Don't assume an IPv4 rule will apply the same policy to IPv6 requests. A host may resolve to both address families, and the client's actual destination can depend on the network and service status. If the same hostname behaves differently across networks, compare the address family used in each case and check whether a corresponding condition exists for only one family.
Understand the limits of region data and resolution
GEOIP,CN,DIRECT selects DIRECT when region data classifies the destination address as CN. It doesn't check the domain suffix or identify a site's language, account region, or provider. Sites using shared infrastructure may resolve to different addresses on different networks, and a database's region classification may not match your expectations. For specific sites that must always use the same route, add a domain exception first and treat the region rule as a general condition—not proof of a site's identity.
If a request starts with a hostname, the hostname alone can't determine whether an address condition matches: a usable destination address is needed, which may involve resolution. An address rule earlier in the list may cause a request that could have been routed by domain to be evaluated by address first. If a known host must always use a particular policy, place its domain rule before general rules that check addresses. Move address rules earlier only when you really want the address range to take priority, then retest with a request using a known hostname. A result from a separate browser lookup doesn't prove the client used the same address for this request.
Address matching and network reachability are separate. A destination can correctly match
DIRECT, while the current network has no route to that subnet. Changing the prefix won't create a route.
When troubleshooting an internal service, first confirm which network you're on. Two locations can use the same private subnet; away from the original network, an address may be unreachable or point to a different device. A broad direct rule for private addresses can't distinguish between those locations. If only one service needs direct access, document the specific conditions instead of expanding the rule to all private addresses. Also check existing general exclusions: if a destination bypasses rule processing, the absence of an address-rule match doesn't mean the prefix is wrong.
Keep two observations when testing address rules: the line that matched, and where the connection stopped. If a test within the address range fails, check whether it used the wrong policy or correctly went direct but couldn't reach the destination. If a proxy connection fails, check whether the selected server can access the test destination. Don't switch an entire subnet from direct to proxy based on one unreachable address. To roll back, remove the address condition you just added and retry the same destination; that helps identify whether the new rule caused the change.
Request identifiers and PROXY, DIRECT, and REJECT
Fields before the policy describe what a rule tests; the final field says what to do when it matches. USER-AGENT is a condition based on an available request identifier, while PROXY, DIRECT, and REJECT are policies. Don't confuse an identifier with a policy or put the Proxy mode shown in the interface at the start of a rule. The examples below put each policy on a separate line so you can verify both the match and the outcome.
When request-identifier matching works
[Rule]
DOMAIN,unused.example.com,REJECT
USER-AGENT,ExampleReader*,PROXY
DOMAIN,docs.example.com,DIRECT
FINAL,DIRECT
ExampleReader* in this example demonstrates prefix matching. The condition applies to the actual User-Agent value sent with a request—not the app icon name, installer name, or account. Different request libraries may use different identifiers, and an app's web view, resource loading, and background tasks may each send a different value. Identifiers can be changed or omitted, so they aren't a substitute for identity verification and can't prove that a connection came from a particular app. Test with a request you control, and record the identifier sent and the rule that matched.
Whether a rule can be used also depends on which fields the client can see for that request. A connection log showing a hostname doesn't mean the request headers are readable too. In particular, seeing a connection to an encrypted site doesn't guarantee that an identifier is available for matching. If the logs can't confirm this, don't keep shortening the keyword in an attempt to force a match. If you need to handle a particular service, prefer a precise hostname you can verify. Keep an identifier-based rule only when you need to distinguish requests that way and your test confirms the field is visible.
After choosing a policy, verify what it does—not just what the page looks like
| Policy | Purpose | Check first |
|---|---|---|
PROXY | Handle the request using the current proxy selection. | Whether the correct proxy is selected and the server can reach the destination. |
DIRECT | Access the destination service directly from the current network. | Whether resolution, routing, and the destination service work on the current network. |
REJECT | Reject the matching request. | Whether the rejected request is the intended host or request. |
PROXY is not a server address and doesn't add a subscription. After a match, the client still needs an existing, selected server that works. If the match is as expected but the page request fails, first test a known reachable, non-sensitive destination with the same selection. Then check whether that proxy can reach the failing destination. If a subscription refresh is causing trouble, return to the quick start guide to review the import and connection steps. Testing server availability and changing routing conditions are separate tasks; don't do both at once.
DIRECT doesn't mean the client has exited or the connection has been turned off. It means this request uses direct access; other requests can still follow different rules. REJECT actively blocks a request. The app may show an error, retry repeatedly, or simply omit some resources. A failed page alone doesn't prove that a reject rule matched, and missing resources don't justify removing every reject rule. Narrow the issue down to the exact request and matching rule, especially when a broad suffix may cover page content, login, and resource hosts alike.
A request can meet multiple conditions at once: for example, the document host in the example may also use the specified identifier. If identifier matching is available, it uses PROXY on the identifier rule before reaching the exact-domain direct rule below. If the document host must always connect directly, move its domain rule above the identifier rule. Retest that host after changing the order, along with a control request that should still use the proxy, to make sure the fix hasn't affected unrelated traffic.
Match order, FINAL, and Global Routing
Before checking rule order, confirm Global Routing. The same file behaves differently in different modes. To check whether a [Rule] line is active, select Config. If you're comparing connections using Proxy or Direct, the result only tells you whether the overall proxy or direct path works; it doesn't prove a rule is written correctly. When the comparison is done, switch back to the mode you need.
| Interface label | How it handles requests | Useful for checking |
|---|---|---|
| Config | Apply routing based on the current configuration. | Rule match order, exceptions, and the default policy. |
| Proxy | Use the proxy path for traffic within the processing scope. | Whether a request completes using the currently selected server. |
| Direct | Use the direct path for traffic within the processing scope. | Whether the destination is reachable directly from the current network. |
The first matching rule takes effect; the most specific rule isn't selected automatically
[Rule]
DOMAIN,health.example.com,DIRECT
DOMAIN-SUFFIX,example.com,PROXY
GEOIP,CN,DIRECT
FINAL,PROXY
Consider a new request that reaches rule matching. A request to health.example.com meets the first condition and immediately goes direct. A request to www.example.com stops at the second rule. Only other requests reach the region check; anything still unmatched then reaches FINAL. If you swap the first two lines, the suffix rule will catch the health check too. That doesn't mean the exact rule is broken—it means the exact rule never gets a chance to run. Order rules from known exceptions to regular conditions to broader ones. Change this order only when the requirements explicitly call for a broader rule to override an exception.
When two conditions with the same scope specify different policies, the last one in the file doesn't automatically win. If you find duplicate lines, check whether earlier ones came from the original configuration, then decide whether to replace the existing policy or add a narrower exception. If it's hard to see which rule is taking precedence, list the target hostname and every condition it could match, in file order. The first line with enough information to match is the one to investigate. Don't skip it and keep rewriting more precise conditions below.
The default policy determines behavior; it doesn't fix connectivity problems
FINAL contains only the rule name and policy—no domain or address field. Keep it as the last line in [Rule]; ordinary conditions after it won't work as exceptions. FINAL,DIRECT sends unlisted requests directly and suits configurations that explicitly list destinations to proxy. FINAL,PROXY proxies unlisted requests and suits configurations that use the proxy by default with direct-access exceptions. Decide how unknown destinations should be handled before choosing a default. Don't reverse the handling of every unlisted request just because one test failed.
If a request matches
FINAL, no earlier condition caught it. First confirm that the destination really needs a new rule, then check the fields, prefix, and line order. Don't change the global fallback first.
Test a rule with at least three comparisons: visit an exact exception, a destination covered only by a broader condition, and a destination covered by neither. If you also have address or identifier conditions, make sure another rule doesn't catch the third sample first. After saving and applying a change, wait before starting a new connection; refreshing the screen alone may not prevent reuse of an existing connection. Browser caches, persistent app connections, and requests from an already open page can all delay the results. An old log doesn't prove that the new rule order had no effect.
If connection behavior and logs don't agree, try a brief comparison between modes. If direct access works but the proxy doesn't, investigate the selected server first. If both work but configuration mode fails, focus on the matching rule and its policy. If both fail, check the destination and current network first. For direct-versus-proxy comparisons, use only a test destination that can be accessed over either path. A comparison table doesn't replace rule logs, but it helps prevent repeated changes in the wrong section.
[Host]: resolution mappings versus routing
[Host] sets resolution mappings for specified hostnames. It doesn't change the URL in the browser to a different domain, and it doesn't select PROXY or DIRECT. It's useful in a controlled environment when you need to keep the original hostname but use a known test address—for example, to test a service you manage. If you only want an existing site to use a different network path, change [Rule] instead of changing resolution to work around routing.
Record the name, address, and policy separately
[Host]
lab.example.com = 192.0.2.20
[Rule]
DOMAIN,lab.example.com,DIRECT
FINAL,DIRECT
The left side of a mapping line is the hostname; the right side is the address. The documentation-only address here doesn't point to a live service. A rule line specifies the expected policy for requests to that hostname; it doesn't create a mapping. Even though the same hostname appears in both parts of the example, test them as two separate questions: did the expected address receive the request, and did the request take the expected route? For a test service you manage, compare the server's request log with the client log. A page loading on its own doesn't prove the mapping worked.
Don't put a full URL on the left side of the equals sign or add a port and path on the right. Hostname resolution and the destination port are separate parameters; the port is specified by the request or selected by the protocol's default. If the service uses a test port, the request needs to specify it explicitly. Don't use a broad domain pattern for a hostname unless you need to. To test one service, use its exact hostname to avoid changing the expected resolution of other endpoints on the same domain.
Caching, resolution paths, and service identity
A static mapping can affect a resolution process that uses it, but it doesn't override every app or resolution path. If an app has cached results, connects directly to an address, resolves names itself, or handles resolution remotely, don't assume a local mapping will change all its requests. Start a new request in the app you specifically want to test and confirm the destination address in the log. Don't rely solely on a different app or system lookup tool; it may use a different resolution path.
Assigning a new address to a hostname doesn't transfer the site's identity checks to that address. The request still uses the original hostname, and a controlled test server must be able to serve that name. If you see a certificate mismatch, the wrong page, or an unexpected site response, check the server's configuration for that hostname and port. Don't ignore certificate warnings as proof that the mapping worked, and don't replace the resolution of sites you don't manage. During testing, use requests without account information to avoid sending a real session to the wrong destination.
When troubleshooting a resolution error, don't also add a GEOIP exception or change the default policy. Address conditions depend on the actual destination, so a mapping change may indirectly affect which ones match. To control for this, keep an explicit domain rule in a test copy and observe the address separately. Once the mapping is confirmed, decide whether to restore the usual address-based conditions. This lets you verify the new address without mixing proxy-versus-direct behavior into the resolution test.
Use mapping lines for tests with a clear end date. When testing is complete, remove the line from the active configuration and verify resolution has returned to normal with a new connection. If you keep a copy for future testing, label it as specific to the test environment.
If the old address is still used after you remove the mapping, first check that the current file doesn't contain another mapping for the same hostname and that you're not reusing an earlier connection. Then make a new request on the same network and compare its log instead of changing every system resolution setting. If the active file comes from a source that refreshes, check whether the mapping was added locally or came with the original file; an update could bring the latter back. Make persistent changes in the right source, and keep temporary tests in a separate copy.
[URL Rewrite]: match URLs and verify redirects
Rewriting handles request URLs the client can identify. It's useful for testing a move from an old path to a new one on a test service you manage; it solves a different problem from routing rules. DOMAIN decides which policy applies to requests for a host, but doesn't change an old path into a new one. [Host] can change the resolution address when that mapping is used, but doesn't change the path. When a request goes somewhere unexpected, first determine whether the route, resolution result, or actual request URL changed.
Start with a precise, single-request HTTP example
[URL Rewrite]
^http://example\.com/old$ http://example.com/new 302
This line contains, in order, a matching expression, a destination URL, and an action. The opening ^ and closing $ require the entire URL to match, while \. represents a literal dot in the hostname rather than any character. Only a sample whose full URL is exactly the old path matches this expression; URLs with query parameters, a trailing slash, or a different protocol aren't covered by the example. The final 302 specifies a temporary redirect. The client following the redirect sends a subsequent request to the destination URL. Check the destination and applicable rules separately to see where that next request goes.
The example URLs demonstrate the syntax; they don't mean the sites provide these paths. Test with a host you control and a read-only request that contains no personal information. If you replace example.com with your test host, keep the dots escaped in the expression on the left, but use ordinary dots in the literal destination URL on the right. If the test service uses an explicit port, account for it in the matching expression too. Don't start with a pattern that covers every page and then add rules to undo its side effects. First confirm that one path redirects as expected, then broaden the match.
Check what the rule can see, query parameters, and redirect loops
This example deliberately uses HTTP. Seeing the hostname of an HTTPS connection doesn't mean the client can read its internal path or request contents. Don't assume that changing the pattern to HTTPS is equivalent. When testing HTTP in a browser, check whether the browser upgrades the address to HTTPS before sending the request; if so, the actual request won't match this example. Start by checking the protocol and URL recorded by the test endpoint. Don't weaken normal browsing security just to make a test match.
Query parameters are part of the matching boundary. This example won't catch the old URL with parameters, nor does it append parameters to the destination automatically. If your use case requires handling parameters, specify which ones to keep and which not to forward, then test the result with values that contain no credentials. Don't use this example to infer behavior for login or submission requests: a client may change the method when following a redirect, and the service may depend on the request body. Start migration testing with a normal read; test paths that submit data separately.
The destination URL should no longer match this rule, and no other rewrite should send it back to the original URL. Make at least three requests to check: the old URL should redirect, the destination should work, and a similar path outside the condition should remain unchanged. If the browser reports too many redirects, inspect each actual destination and distinguish redirects from the configuration from those sent by the server. Don't rely only on the final address bar. A later page may hide an incorrect intermediate redirect that still affects resources or other ways of accessing the site.
For the first check, focus on the initial response: did the expected temporary redirect happen, and is the destination correct? Then check whether the follow-up request can reach it. A rewrite match and destination reachability are separate results.
After disabling a test rewrite, send a new request and compare the result again. Cached page results, existing server redirects, and an app's own URL-upgrade behavior can all persist and make it look as if the rule is still active. If you've confirmed the line isn't in the current file, check whether the client reused an earlier result or the destination service already provides the same redirect. Keep test records to the domain, path, and action; don't copy real URLs that contain identifying information.
Configuration examples, verification steps, and rollback
Here's a small change to an existing configuration: one health-check host should go direct, other services on the same domain should use the selected proxy, a confirmed internal subnet should go direct, and unlisted destinations should remain direct. The example domains demonstrate syntax only; replace them only with hosts you're allowed to test. Proxy routing requires an existing subscription or server details that you've imported, and a basic availability test with the current connection.
[Rule]
DOMAIN,health.example.com,DIRECT
DOMAIN-SUFFIX,example.com,PROXY
IP-CIDR,192.168.40.0/24,DIRECT
FINAL,DIRECT
Write down expected results, then verify each rule
Don't paste this example after an existing FINAL line, and don't create an entirely new configuration file just to use it. If the file already has a [Rule] section, merge the needed conditions there. First check whether earlier lines already cover the destinations, then choose where to insert the new rules. Replace the existing default policy only if you actually want to change how unlisted requests are handled. If the original configuration defaults to direct access, the internal-subnet line has the same effect as the current default; it makes the intent explicit and should be retested if you change the default later.
For each test, record the destination, expected matching rule, expected policy, and actual result. Use a health-check host to verify the first rule, another host on the same domain to verify the suffix, a selected internal address to verify the subnet, and a destination outside all the other conditions to verify the default. Add a conflict test too: if a request on the same domain resolves to an address in the internal subnet, the earlier domain suffix takes priority. If internal addresses must always go direct regardless of hostname, this order won't meet the requirement. First confirm that address matching is available, then change the order and repeat the first two tests.
Distinguish a correct match from a successful connection. If the page loads despite the wrong match, the test hasn't passed; the same destination may work over both proxy and direct connections. Conversely, if the right rule matches but the connection fails, don't change the rule immediately. Check which destinations are affected: if only proxy-routed destinations fail, check the selected existing server and its connectivity; if only internal destinations fail, check the network you're testing on and the actual address; if only some page requests fail, compare the hostnames used by those resources and their individual match logs.
Troubleshoot in order: inactive rules, no match, then connection failure
First check the file and mode: after saving, confirm the active configuration and Global Routing, and make sure the test request is new. If no new rule appears in the logs, check that the right file is selected and that you're not in a comparison mode. Next check the match fields: use the address when only an address is available; when a hostname is available, verify the actual hostname and rule order. Don't infer it from the page title. Only then check execution: if the right policy matched, find where direct or proxy access failed. For interface locations, see the guide to Shadowrocket interface terms.
If the issue appears only after switching networks, keep the configuration, mode, and server the same and change only the network for comparison. Note whether the resolved address, matched rule, or access result changed. A different address may match a different region or subnet condition; if the rule and policy are unchanged but the request fails, investigate the network path. If the problem occurs when obtaining or installing the app, don't edit the configuration to fix it. See the download page's installation guide or its notes on the App Store and account regions.
To roll back, switch to the saved original configuration, keep the server and test network unchanged, and retry the same request. Only if the issue no longer occurs with the original file can you reliably compare the individual configuration changes.
Rolling back doesn't mean discarding what you observed. Keep a redacted copy of the configuration diff and a few minimal reproduction steps describing the expected and actual results. If the original file behaves the same way, stop adding rules and return to the quick start guide to recheck the existing subscription, server selection, and basic connection. If only the new file reproduces the issue, add back one group of conditions at a time, then add the next group only after the first passes. This helps identify which change caused the behavior and makes it easier to review after the configuration source updates.