How to Check HTTP Status Codes Across Regions When a Website Is Unreachable in Some Locations
When a website works in some regions but is unreachable in others, the key to checking HTTP status codes across regions is to request the same URL from different networks and record both whether an HTTP response was received and what that response contained. A 200 response from a working region and a 403 from an affected region call for a completely different investigation from a 200 in one region and a connection timeout in another. In the first case, prioritize access controls and identify where the response was generated. In the second, start with DNS, connectivity, and TLS rather than immediately blaming the origin service.
The first request to investigate should be the one that actually failed for the user, which is not necessarily the homepage. The browser may have loaded the homepage successfully but failed on a login redirect, a script file, or an API request. IPv4 versus IPv6, ISP egress, and cache hit status can also affect the outcome. Preserving these conditions is essential if cross-region status code comparisons are to explain why only some users cannot access the site.
The following analysis and verification methods are based on how HTTP requests work; they do not represent completed testing of any particular website. Consult the official curl manual for command options; available features depend on the version installed locally. CdnChart's website speed test can help identify CDN-related clues and individual connection timings for the target domain. Cross-region sampling should still use affected users' networks, machines you control, or monitoring services with clearly identified egress conditions. A check from a single egress point cannot replace reproducing the issue in other regions.
Identify the URL to Check from the Failed Browser Request
“The website won't open” is often just the user's summary of the symptoms. Open the Network panel in browser developer tools, enable request log preservation, and revisit the site to identify the first critical request that fails. Distinguish failures of the main document, redirect targets, static resources, and API endpoints, because they may use different domains, CDN configurations, and origins.
If the main document returns 200 but the login endpoint returns 503, repeatedly checking the homepage from multiple regions proves only that the homepage is reachable. Similarly, if the page is blank and a script returns 404 in the Network panel, investigate the resource path for that version rather than changing DNS for the entire site first.
A useful reproduction record should include the full URL and query parameters, request method, failure time and time zone, ISP and access type, and the status or error message shown in the browser. For login-related issues, also note whether the user was logged in and whether the required cookies were present. Do not copy real credentials into public support tickets or diagnostic tools.
Publicly accessible GET requests can be compared directly across regions. For POST requests, signed parameters, short-lived tokens, or order operations, use authorized test accounts and endpoints without side effects. Do not repeatedly submit production transactions just to reproduce a problem. A signature that expires between sampling times and returns 403 is not evidence of regional blocking.
A browser message such as “canceled” or “blocked by CORS policy” is also not the same as HTTP 403. Save the exact error text. Sometimes the server has responded, but the browser does not allow page scripts to read the response; sometimes the browser never established a connection. Clearly identifying the failed request and error type keeps subsequent comparisons focused on the actual problem.
Use GET to Record Both the HTTP Status Code and curl Exit Code
Do not rely only on curl -I to compare results across locations. This option sends a HEAD request, whereas actual page access usually uses GET. Some applications, gateways, and access control rules handle these methods differently. When investigating user access failures, prioritize reproducing the actual method. You can save the response body locally for inspection.
The following example is intended for a Unix-like terminal. Run it on both a working network and an affected network, using different filename prefixes to save the results. Replace the example domain with a target you are authorized to check.
Check for Proxy Use Before Running the Test
curl may inherit environment variables such as http_proxy, https_proxy, ALL_PROXY, and NO_PROXY. It may also read proxy settings from a user configuration file or a command wrapper script. Check these settings locally, along with the curl command that actually runs. Proxy addresses may contain credentials, so do not paste complete environment variables or configuration files into public support tickets.
The commands in this article assume that network policy permits direct connections. They consistently include --noproxy '*' so curl does not use an explicit proxy for these targets. This does not bypass a system VPN, transparent proxy, or network-side forwarding, so you still need to record the actual egress environment. Comparisons between working and affected egress points must use the same proxy conditions. Do not directly compare a direct connection on one side with proxied access on the other.
If your network requires a proxy, do not violate access policy to troubleshoot. Record the proxy egress separately and interpret the results as measurements of the proxy path. The remote_ip value may be the proxy address, and the proxy may resolve the target domain. These results cannot directly establish the address family or fixed-IP path from your machine to the target. Run a separate comparison through an authorized, controlled direct egress point.
curl --noproxy '*' -sS --connect-timeout 10 --max-time 30 \
-D check.headers -o check.body \
-w 'http=%{http_code}\nremote_ip=%{remote_ip}\nhttp_version=%{http_version}\nurl=%{url_effective}\ndns=%{time_namelookup}\nconnect=%{time_connect}\ntls=%{time_appconnect}\nfirst_byte=%{time_starttransfer}\ntotal=%{time_total}\n' \
'https://www.example.com/'
rc=$?
printf 'curl_exit=%s\n' "$rc"
The command deliberately omits --fail to preserve the distinction between HTTP error responses and transfer errors. Normally, curl can exit successfully when a server returns a complete 403 or 503 response. Adding --fail converts some HTTP errors into nonzero exit codes, which can make the initial records harder to interpret.
Always read http and curl_exit together. A result of http=000 does not mean the server returned a “000 status code.” It means this transfer did not obtain a usable HTTP response code. Common causes include DNS resolution failure, connection failure, TLS handshake failure, or a timeout. Check standard error output for the specific cause. Conversely, a response body can be interrupted after a 200 has been received, so “200 with a nonzero exit code” must not be recorded as a complete success.
The connection timeout and total timeout in the example are troubleshooting parameters, not acceptance criteria. Use identical settings in every region to avoid artificial differences caused by one egress point waiting 30 seconds while another waits only 5 seconds. Automatic retries are not recommended for the initial check, because a later success may obscure the first failure. If retries are necessary, retain each attempt separately.
Regional Status Codes Must Correspond to Real Network Egress Points
Switching among several DNS servers on the same machine is not equivalent to accessing a website from several regions. The HTTP connections still originate from that machine's network egress. Changing resolvers may change the DNS answers or traffic steering conditions, but it cannot simulate the actual path from a user in another region to an edge node.
Likewise, successful access from a cloud instance in an affected city does not disprove reports from local residential broadband users. Cloud instances, residential broadband, and mobile networks may use different ISP interconnections, egress address pools, or security policies. The same city label indicates only similar location metadata, not identical request conditions.
In practice, prioritize obtaining results from one affected user egress point and one working egress point at approximately the same time. You can ask authorized users to run the same commands or use machines you control whose locations and ISPs are known. Treat third-party probes as supplementary evidence, paying particular attention to their request method, timeout, redirect handling, and IPv6 support.
At each egress point, start with a small number of consecutive, low-frequency requests—for example, several samples spaced a few seconds apart—and retain every result rather than selecting a single success or failure. This sampling helps determine whether the issue is reproducible; it does not guarantee statistical reliability. If responses alternate between 200 and 403, investigate the connected IP, request time, and security logs rather than immediately switching to high-concurrency testing.
Do not arbitrarily add random query parameters during cross-region comparisons. Parameters may change cache keys, signature validation, or application behavior, causing the test in the working region to hit the cache while the test in the affected region fetches from the origin. Likewise, do not send login cookies from one network and access anonymously from another, then attribute the status difference to geography.
Distinguish “No HTTP Response” from an “HTTP Error Response”
The following distinctions directly affect the investigation sequence. The suggested checks in the table are starting points for further verification, not proof of the fault location based on a status code alone.
Observation | What can currently be confirmed | What to check first |
|---|---|---|
| No HTTP response was obtained; name resolution did not complete | The user's resolver, A and AAAA records, and the resolution error type |
| No HTTP response was obtained; the connection path may have failed | Actual connection address, address family, egress, firewalls, and routing |
| HTTPS setup did not complete successfully | Certificate chain, hostname, TLS termination node, and client environment |
301, 302, 307, or 308 | The current entry point issued a redirect | Location target, protocol, port, and subsequent hops |
403 or 429 | An HTTP processing layer rejected or limited the request | WAF events, access rules, rate-limiting criteria, and application permissions |
502, 503, or 504 | An HTTP processing layer returned a service-related or upstream-related error | The layer that generated the response, edge logs, origin fetching, and application dependencies |
200 with an abnormal page | The current response is marked as successful | Response content, critical resources, APIs, and browser execution errors |
Among common curl exit codes, 6 generally indicates that the host could not be resolved, 7 indicates a connection failure, 28 indicates a timeout, 35 concerns an SSL/TLS connection error, and 60 concerns certificate verification failure. Exit codes help narrow the investigation, but must be interpreted alongside the error text. For example, a timeout can occur during connection setup, while waiting for a response, or during a download.
If the record shows 200 but the overall transfer eventually times out, the response headers may have arrived while the body remained incomplete. Check the response size, content length, and connection closure rather than grouping this result with fully downloaded 200 responses. Success reporting should also include requests with no response, HTTP errors, and content validation failures, rather than counting only requests that received a status code.
Preserve the Full Redirect Chain When Checking 301 and 302
A 301 or 302 response from the website's entry point is not necessarily a failure. The real problem may occur at the next hop. For example, the entry point may use the main domain and then redirect to a login domain whose DNS resolution fails only in certain regions. Showing only the final status code can also hide information about the entry point and intermediate redirects.
First, inspect the Location field in check.headers without following redirects. After confirming that the target belongs to the expected service, run a check that follows redirects:
curl --noproxy '*' -sS -L --max-redirs 5 \
--connect-timeout 10 --max-time 30 \
-D redirect.headers -o redirect.body \
-w 'http=%{http_code}\nredirects=%{num_redirects}\nfinal_url=%{url_effective}\nremote_ip=%{remote_ip}\n' \
'https://www.example.com/'
rc=$?
printf 'curl_exit=%s\n' "$rc"
The redirect.headers file saves the multiple sets of response headers received during the process, allowing you to check each hop's status and Location in order. The remote_ip value here does not represent the addresses of every node in the redirect chain. If a connection fails partway through, the last received status code does not prove that the final target was reached successfully. Interpret it together with the exit code.
If working and affected regions redirect to different domains, check whether regional redirects, language selection, login state, and proxy header handling behave as intended. Do not immediately classify the difference as an attack or hijacking. Confirm the cause only when configuration, response content, and network evidence support it.
Also consider the request method. A GET redirect comparison does not represent POST redirect behavior; different redirect statuses and client handling can affect the method used afterward. For login, payment, and similar requests, check the full application workflow in a safe test environment. Do not arbitrarily change redirect behavior or forward credentials merely to obtain a final 200.
Test IPv4 and IPv6 Separately When A and AAAA Results Differ
When only some regions cannot access a site, the dividing line is often not an administrative boundary but whether local clients prefer IPv6. Dual-stack browsers may race connections or fall back between address families, and curl's default behavior may not exactly match the browser experience. Explicitly separate the tests.
Compare Both Address Families over Direct Connections
Before running the commands, confirm again that curl's proxy environment variables, configuration files, and command wrappers have not changed the test path. Both commands below disable explicit proxies with --noproxy '*'. If access must still go through a proxy, -4 or -6 may restrict only the address family used to connect to that proxy. You cannot use those results to determine whether the target site's IPv4 or IPv6 service works.
Run the following two commands against the same URL from the same controlled direct egress point at approximately the same time. Check that remote_ip belongs to the expected address family and target service. These commands do not follow redirects and are suitable for checking the current entry point first. If redirects exist, check each hop as described in the previous section.
curl --noproxy '*' -4 -sS --connect-timeout 10 --max-time 30 \
-o /dev/null \
-w 'ipv4 http=%{http_code} ip=%{remote_ip}\n' \
'https://www.example.com/'
printf 'curl_exit=%s\n' "$?"
curl --noproxy '*' -6 -sS --connect-timeout 10 --max-time 30 \
-o /dev/null \
-w 'ipv6 http=%{http_code} ip=%{remote_ip}\n' \
'https://www.example.com/'
printf 'curl_exit=%s\n' "$?"
If IPv4 consistently returns 200 while IPv6 connections repeatedly time out, prioritize the service referenced by the AAAA record, IPv6 listeners, firewalls, and network path rather than changing application caching first. This distinction materially changes the investigation sequence: both requests use the same domain and path, while failures are concentrated in one address family, pointing more strongly to differences at the connection entry point. However, first rule out the possibility that the test machine itself lacks usable IPv6 egress.
If both address families establish connections but only IPv6 returns 403, check whether IPv6 ranges have been misclassified, trusted proxy settings are missing, or the two entry points use different rules. A -6 failure caused by the absence of an AAAA record is not evidence of an IPv6 service outage. First confirm whether the site offers IPv6 access.
Use dig www.example.com A and dig www.example.com AAAA to inspect current DNS answers, recording the query time, resolver, TTL, and returned status. Start with the resolution conditions actually used at the affected egress point. If secure DNS is enabled in the browser, system commands and the browser may use different resolvers; different results do not automatically prove a DNS fault. If no HTTP response has been obtained, continue narrowing down the failed stage with DNS, connection, and TLS troubleshooting.
Compare Connection IPs to Distinguish DNS Steering from Edge Processing
If an affected region consistently fails after resolving to one address while a working region connects successfully to another, try pinning a confirmed service address from the affected egress point. This tests whether changing the connection target changes the symptoms while keeping the URL unchanged. For HTTPS, use --resolve to preserve the Host and TLS SNI associated with the URL.
Confirm That a Proxy Is Not Handling the Connection Before Pinning an Address
This test depends on curl connecting directly to the target. With an HTTP or HTTPS proxy, the proxy may resolve the target domain, so --resolve cannot establish that the connection was pinned to the specified target as intended here. Check proxy environment variables and configuration first, and use --noproxy '*' below only when policy permits direct access. If direct access is unavailable, record the proxy egress and repeat the test on an authorized machine with a direct connection. Do not interpret a proxy-returned result as evidence of differences between target nodes.
curl --noproxy '*' -sS \
--resolve 'www.example.com:443:203.0.113.10' \
--connect-timeout 10 --max-time 30 \
-D pinned.headers -o pinned.body \
-w 'http=%{http_code}\nremote_ip=%{remote_ip}\n' \
'https://www.example.com/'
rc=$?
printf 'curl_exit=%s\n' "$rc"
The address 203.0.113.10 is reserved for documentation examples. Before running the command, replace it with an authorized target that actually serves the domain. Apart from pinning the resolved address, keep the URL, method, and request headers identical to the original test. Once a connection is established, remote_ip should match the specified address. If it does not, investigate proxies, other connection-rewriting settings, or how the command is being executed before drawing conclusions about the target node. This field may also be empty if no connection has been established.
Do not substitute a direct request to an HTTPS IP address with a manually added Host header, because TLS SNI and certificate verification may differ. Do not add -k to bypass certificate errors and disguise a failure as success.
If access from the affected egress point recovers after switching to a particular address, that address or its associated network path deserves closer investigation. This does not yet establish a DNS configuration error. Anycast, load balancing, and regional ingress can cause the same IP to reach different nodes from different egress points. An address observed in a working region may also be unsuitable for long-term use in every region.
Address pinning is for short-term diagnosis, not a permanent hosts-file workaround. Next, verify whether DNS answers match the traffic steering configuration, whether the problematic address is still in service, and whether node certificates and domain bindings are consistent. Then decide whether to fix DNS or edge configuration. A CNAME, Server response header, or IP ownership label alone cannot establish the full delivery path or identify the provider that generated the response.
Correlate 403 and 429 with Rule Events Instead of Disabling the WAF
When 403 responses differ across regions, start by comparing response bodies, request identifiers, and security logs. A rejection may originate from CDN edge access controls, a WAF, the origin web service, or application permission checks. A page that resembles a vendor's error page is only a clue; confirm where it was generated through console events or logs.
Pay particular attention to geographic restrictions, IP reputation, ASN policies, request header validation, and login permissions. Shared ISP egress can place many users behind the same address, triggering per-IP rate limits and making it appear that an entire region cannot access the site. In that case, geography is only the visible pattern; the actual matching criterion may be the egress IP or a particular network type.
A 429 response usually concerns request limiting, but do not assume every platform uses identical thresholds or response headers. If the response includes Retry-After, repeat checks at low frequency according to the waiting condition it specifies. Confirm who applies the limit and whether requests are counted by IP or account. Rapid repeated probes can themselves trigger rules, turning an intermittent issue into a test-induced failure.
A safer validation method is to make narrowly scoped adjustments to a specific rule: restrict the test source, exact path, and time window; prefer the rule's monitoring or logging mode where available; and save the original configuration beforehand. If access recovers within that scope and the rule logs agree, evaluate a precise exception. If there is no improvement, revert the temporary change and continue checking application permissions or other processing layers.
Do not treat disabling the entire WAF, removing rate limits sitewide, or allowing all sources as routine fixes. Automated clients may encounter browser challenge pages, with curl returning 403 while a real browser works normally. Record that client difference. Changing only the User-Agent neither reproduces real browser behavior nor proves that access has recovered for real users.
Identify Which Layer Generated the 502, 503, or 504 Error
These status codes can help identify service or upstream errors, but they do not directly prove that the organization's origin server is down. Errors may be generated by the ingress edge, a regional upstream, an origin fetch proxy, an origin gateway, or the application. An edge cache miss also does not guarantee that the request reached the organization's origin.
Correlate edge and origin logs using the request time, time zone, path, and request identifier. If the origin access log contains the matching request and the same 503 response, at least that request entered the origin processing chain. If there is no origin record, this means only that no match was found within the logs checked. You must still rule out logging delays, sampling, checking the wrong virtual host, or a TLS failure occurring before an access log entry could be generated. For guidance on organizing relevant fields, see troubleshooting with CDN access logs, but use the log fields actually available from your provider.
Where conditions permit, use the earlier --resolve method from the same affected egress point to pin the same URL to an authorized origin address, preserving the domain and SNI for comparison. Again, confirm a direct connection and verify the actual connection address. If the origin accepts only CDN sources or requires mutual TLS or dedicated origin authentication, direct request failure is expected. In that case, this test is not evidence that the application is unavailable, and you should not broaden origin exposure to run it.
If the origin comparison succeeds while the CDN path fails, focus on edge rules, origin fetch addresses, the Host used for origin requests, TLS configuration, and links associated with particular nodes. This is still not a final conclusion. The client-to-origin path differs from the CDN-to-origin path, and caching may cause the two requests to perform different work. Ultimately, correlate successful or failed requests with their corresponding logs.
If localized Bad Gateway errors appear at the same time as a configuration deployment, roll back the relevant change for the clearly affected domain or path, then retest from the original affected egress point. Compared with restarting the entire site or moving all traffic, this approach makes causality easier to verify and helps avoid creating a second incident.
Cached Error Pages Can Prolong Regional Differences
If one location continues returning 404 or 503 after others have recovered, an error response may have been cached rather than the origin continuing to fail. Whether these statuses are cached, for how long, and whether stale content may be served depend on provider capabilities and the actual rules. Do not assume a universal default.
Compare Age, cache-control fields, and any cache diagnostic information supplied by the platform, then check console rules and edge logs. A missing response header or a header indicating a miss is not sufficient on its own to establish the request path. With tiered caching, an ingress edge miss may still be answered by an upper-tier cache.
When evidence points to a cached error, first confirm that the origin has resumed returning the correct response for the same URL. Then purge the smallest relevant set of cache keys. Account for actual cache conditions such as query parameters, hostname, language, and device variants. Purging a single apparently identical path may not cover the object users are receiving.
After the fix, check both the first request and subsequent repeated requests to confirm that the status and body remain correct after the cache is repopulated. Do not simply add random parameters and declare recovery; that may only bypass the original faulty object. Also avoid purging the entire site by default, which can send large numbers of simultaneous requests to the origin.
Confirm That the Page Actually Works After HTTP 200
A 200 status means only that the current HTTP response is marked as successful, not that the expected page was returned. A site may wrap a maintenance page, an expired-login notice, or an application error in a 200 response. It may also return a challenge page that requires browser execution. Cross-region checks should therefore inspect at least a sample of stable application indicators in the body, such as the expected page title, resource type, or an API success field.
Do not rely solely on response body hashes. Dynamic timestamps, personalized content, and random tokens can make valid responses differ. Select a small set of conditions that contain no sensitive information and indicate application success, then record HTTP success and content success separately. If an API returns 200 but its JSON indicates failure, classify it as an application-level failure rather than normal access.
If the main document works but the browser still reports errors, return to the Network panel and continue checking critical scripts, stylesheets, fonts, and APIs. For cross-origin endpoints, also inspect OPTIONS preflight requests and the CORS fields in the actual response. A 200 received by curl does not mean the browser allows the page to read it. Limit fixes to trusted origins and necessary methods. Do not indiscriminately allow origins for credentialed requests just to eliminate an error.
For issues that occur only in browsers and cannot be reproduced with curl, also check local proxies, extensions, Service Workers, and browser caches. A clean browser profile can provide a comparison, but preserve the original failing state. Do not begin by asking every user to clear their data, thereby losing request records that could identify the problem.
Verify Recovery from the Original Affected Egress Point
Recovery must be assessed against the original failed request, not by switching to a working region and stopping after seeing 200. Complete at least the following checks in order:
Request the same URL again from the original affected network, confirming that the HTTP status, curl exit code, and critical response content all match expectations.
Repeat the original browser workflow and confirm that redirect targets, critical resources, and API requests no longer fail.
Separately recheck the previously affected IPv4 or IPv6 path and both initial and repeated cache accesses. Confirm that no new issues have appeared on the working network.
Remove temporary address pinning, test allow rules, and additional diagnostic settings. Verify that normal DNS resolution, TLS verification, and security rules remain effective. If normal user access requires a proxy, also verify recovery through that proxy path.
Continue low-frequency checks during an observation window covering the original failure period. Retain failure counts and types rather than treating one successful request as sustained recovery.
When comparing timings, remember that curl's time_namelookup, time_connect, time_appconnect, and time_starttransfer are cumulative times measured from the start of the request, not independent durations for each stage. Redirects, proxies, and connection reuse also affect their interpretation. Timings can help identify where a request stalls, but the central acceptance criterion remains whether it completes fully and correctly.
The most useful outcome of investigating a regional access failure is not a map showing only red and green statuses. It is a verifiable finding: which user's network requested which address, where the request failed, which layer returned what response, and whether the original request recovered after a narrowly scoped change. Checking HTTP status codes along this evidence trail turns regional differences into actionable repair targets.
- check HTTP status codes across regions
- website unreachable in some regions
- check status codes with curl
- CDN regional access issues
- HTTP 000
- website unreachable over IPv6
- 403 and 502 troubleshooting
- curl proxy and specified-IP testing