Redirect Checker Guide: How to Audit URL Status Codes, Destinations, and Chains
redirect checkerURL testingHTTP headerstechnical SEOwebsite maintenance

Redirect Checker Guide: How to Audit URL Status Codes, Destinations, and Chains

RRedirect Portal Editorial Team
2026-11-16
8 min read

Learn how to check URL redirects with browser tools, curl, headers, and an audit log, then monitor chains, status codes, and destinations.

A redirect can appear to work in a browser while still returning the wrong status code, adding unnecessary hops, dropping query parameters, or creating a loop. This redirect checker guide gives you a repeatable way to test URL forwarding with browser developer tools, curl, response headers, and a simple audit spreadsheet. Use it after deployments, domain or hosting changes, and at regular technical SEO reviews.

Overview

Checking whether a URL redirects correctly means testing more than its final page. A useful audit records the original URL, every HTTP response in the journey, the final destination, the status code used, and whether the destination is relevant and accessible.

For a permanent move, the source commonly returns a permanent redirect such as 301 or 308. For a change that is genuinely temporary, a 302 or another temporary status may be appropriate. The correct choice depends on the implementation and the intended lifetime of the forwarding rule; do not treat every redirect as interchangeable. For background, see 301 vs 302 redirects.

A redirect checker should answer five questions:

  1. Does the requested URL return the expected redirect status?
  2. What is the exact value of its Location header?
  3. How many redirect hops occur before the final response?
  4. Does the final URL return a usable response rather than another error or redirect?
  5. Are the path, protocol, host, and query string handled as intended?

Testing from more than one method matters. A browser follows redirects automatically, while command-line testing exposes each response. Comparing both helps distinguish a genuine server-side issue from a browser cache, cookie, or application-specific behaviour.

What to track

1. The complete redirect path

Start with the exact source URL, including its protocol, host, path, and query string. Test common variants where relevant: HTTP and HTTPS, the www and non-www hostnames, trailing-slash variations, and old paths from a migration.

Record every hop. For example:

http://example.co.uk/old-page
  -> https://www.example.co.uk/old-page
  -> https://www.example.co.uk/new-page
  -> 200 OK

This sequence works, but it may be possible to redirect the original URL directly to the final destination. A chain is formed when one redirect points to another redirect. Long or unnecessary chains make troubleshooting harder and can add latency. Use the redirect performance testing guide when you need to examine hop count and response time in more detail.

2. Status codes and destinations

Log the status code returned by every hop, not just the final page. This reference table provides a practical starting point:

StatusTypical meaningWhat to check
301Permanent redirectConfirm the destination is the intended replacement and that the rule is not being used for a temporary test.
302Temporary redirectConfirm the move really is temporary and that the response is not an accidental default from the platform.
307Temporary redirect with method preservedCheck the request method and application behaviour, particularly for non-GET requests.
308Permanent redirect with method preservedConfirm that preserving the method is appropriate for the endpoint and implementation.
200Successful responseCheck that a source expected to redirect is not serving the old page directly.
4xx or 5xxClient or server errorIdentify whether the error occurs at the source, during a hop, or at the final destination.

The status alone does not prove that a redirect is correct. A 301 to an irrelevant page, a deleted page, or a homepage may still be a poor migration result. Compare each destination with the old URL's purpose and preserve the most relevant equivalent available.

3. Query strings and tracking parameters

Test URLs with representative query strings, not only clean paths. For example, compare:

https://example.co.uk/old-page?utm_source=newsletter&ref=summer

with the final URL returned by the server. Some rules preserve the query string automatically; others replace it, duplicate parameters, or discard it. Decide which behaviour is intended before changing the rule. Campaign parameters may be useful for analytics, but they should not be allowed to create avoidable URL variants or interfere with canonicalisation. The guide to UTM tracking without losing SEO clarity covers this planning in more detail.

4. A consistent audit log

A spreadsheet is sufficient for many recurring checks. Use columns such as:

  • Test date and environment: production, staging, or another named environment.
  • Source URL: the exact URL tested.
  • Expected status: for example, permanent or temporary.
  • Observed chain: each URL and status in order.
  • Final URL and status: the destination and its response.
  • Query-string result: preserved, transformed, removed, or not tested.
  • Canonical check: whether the final page points to the expected canonical URL.
  • Owner and action: who will investigate and what needs changing.

Cadence and checkpoints

Run a focused redirect audit after any change that could affect routing. That includes a site migration, URL structure change, CMS release, hosting move, CDN or firewall rule update, domain renewal, certificate change, or switch between HTTP and HTTPS. Test before launch in a safe environment where possible, then repeat against production immediately after release.

For an established website, a monthly or quarterly review provides a practical baseline. The right interval depends on how often the site changes and how important its redirected URLs are. A smaller site with few changes may need less frequent manual review; a frequently updated platform may benefit from automated checks between formal audits.

At each checkpoint, sample or test:

  • the main HTTP-to-HTTPS and www-to-non-www rules;
  • recently changed URLs and pages removed since the previous review;
  • high-value legacy URLs, external campaign links, and QR code destinations;
  • URLs with query strings and encoded characters;
  • redirects reported by analytics, server logs, crawlers, or monitoring tools;
  • rules added by the application, web server, CDN, and hosting control panel.

Keep a baseline from a known-good test. It should include expected hop counts and final destinations, not merely a list of URLs. This makes it easier to identify a regression after a deployment.

How to run a redirect check

Browser developer tools

Open the browser's developer tools and select the Network panel. Enable recording, request the source URL, and inspect the requests in order. Look for the status code, the response headers, and the request URL at each step. The Location response header normally identifies the next destination.

Use a private browsing window or clear relevant cache and cookies when repeating a test, but do not assume this reproduces every user's experience. A cached permanent redirect can make a corrected rule appear unchanged in one browser. Compare with a command-line request and, where appropriate, a separate network or test environment.

Using curl to inspect headers

To inspect only the first response, use:

curl -I https://example.co.uk/old-page

Look for the HTTP status and the Location header. To follow redirects and show each response, use:

curl -I -L https://example.co.uk/old-page

For a more detailed trace that includes request and response headers, use:

curl -sS -D - -o /dev/null -L https://example.co.uk/old-page

These examples are intended for ordinary URL checks. Test with the same method that the application expects when reviewing forms, APIs, or other non-GET requests. Also test both the clean URL and a representative URL with a query string.

Reading results accurately

A successful check usually has an expected redirect status at the source, a direct or deliberately short path, a relevant final destination, and a successful final response. Investigate any mismatch between the expected and observed result. A redirect loop often appears as repeated URLs or a client message that the page redirected too many times. For protocol and hostname loops, follow the redirect loop troubleshooting guide.

If a rule works in one layer but fails in another, map the whole stack: browser, DNS or domain forwarding, CDN, load balancer, web server, CMS, and application. Rule order can also matter. A broad HTTP-to-HTTPS rule may run before a path-specific rule, while a CMS plugin may add a second redirect after the server has already selected a destination. Review redirect rule order and precedence before adding another exception.

How to interpret changes

Compare new results with the previous audit rather than judging a URL in isolation. The most useful changes to flag are:

  • a permanent redirect becoming temporary, or the reverse, without a documented reason;
  • an increase in hop count;
  • a final destination changing to a different protocol, hostname, path, or locale;
  • query parameters being lost, duplicated, or unexpectedly rewritten;
  • a formerly successful destination returning a client or server error;
  • a canonical URL that conflicts with the selected redirect destination;
  • a redirect accepting arbitrary external destinations, which may indicate an open redirect risk.

Do not automatically replace every redirect with a direct page response. Some redirects are intentional, including domain consolidation, secure protocol enforcement, renamed content, and temporary campaign routing. Instead, compare the observed behaviour with the documented purpose of the rule. If a redirect is no longer needed, remove it only after checking internal links, external references, bookmarks, campaign URLs, and migration requirements.

When to revisit

Schedule the next review on a monthly or quarterly cadence, and bring it forward after any deployment or infrastructure change. Revisit the audit immediately when users report an inaccessible link, analytics show an unexpected landing page, a crawler identifies new redirect errors, or a domain, certificate, DNS record, CDN, or hosting configuration changes.

Before each review, refresh the test list. Add newly redirected URLs, remove retired tests only when their purpose is documented, and include representative HTTP, HTTPS, hostname, path, and query-string variants. If your browser, crawler, command-line tool, or platform changes its reporting behaviour, update the instructions and compare a known-good URL before relying on the new output.

Finish every audit with assigned actions rather than a collection of observations. Fix loops and broken destinations first, then shorten avoidable chains, verify status-code intent, and review tracking and canonical behaviour. Record the date, change made, and follow-up result in the same spreadsheet. That small discipline turns a one-off redirect checker test into a maintainable monitoring process.

For migrations, pair this workflow with the redirect mapping template and pre-launch checklist. For domain-level forwarding, confirm that DNS, email, and HTTPS remain separate considerations by reviewing how to redirect a domain without breaking email, DNS, or HTTPS.

Related Topics

#redirect checker#URL testing#HTTP headers#technical SEO#website maintenance
R

Redirect Portal Editorial Team

Technical SEO Editors

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.