To check a 301 redirect, request the old URL without letting your browser jump ahead, then read two values: the HTTP status code and the Location header. A working permanent redirect answers 301 (or 308), names the new URL in Location, and that new URL answers 200. Browser DevTools, curl and an online redirect checker all show you both.
A browser hides all of this: you land on the new page whether it got there through one clean 301, a temporary 302 or a three-hop chain. This guide covers five ways to test a redirect, from one URL to a full site crawl, then how to read the results and fix common problems.
Key takeaways
- To check a 301 redirect, request the old URL without following redirects and read two things: the status code (301 or 308 means permanent) and the Location header (where it points).
- Browser DevTools and curl show every hop, but your browser can cache permanent redirects, so use Disable cache or a fresh command-line request when you retest.
- A 200 status is not a redirect. If a page answers 200 and still sends you elsewhere, it is a meta refresh or JavaScript redirect, which Google handles differently.
- Point every old URL straight at its final destination: Google advises redirecting directly, and its crawlers follow up to 10 hops by default.
What you are looking for in a redirect test
RFC 9110, the HTTP standard, defines 301 as "the target resource has been assigned a new permanent URI" and says the server SHOULD send a Location header with the new address. Whatever method you use, a good result looks like this:
- First hop: status
301or308, withLocationpointing at the final URL. - Final hop: status
200on the page you expected. - Hop count: ideally one redirect, not a chain.
A 302 or 307 works for visitors but Google treats it as temporary. A 200 that still sends you elsewhere isn't a server-side redirect at all.
Method 1: Browser DevTools (Network tab)
This works in Chrome, Edge and Firefox with nothing to install.
- Open a new tab and open DevTools (F12 on Windows and Linux, or right-click the page and choose Inspect).
- Go to the Network tab.
- Tick Preserve log, so the redirect hop isn't cleared when the page changes. Chrome's documentation says DevTools "saves all requests until you disable Preserve log."
- Tick Disable cache. Chrome describes this as more accurately emulating "a first-time user's experience," which matters because browsers can remember permanent redirects.
- Type the old URL in the address bar and press Enter.
- Look at the first row in the list. The Status column shows the code, for example
301. - Click that row, open the Headers tab and find
Locationunder Response Headers. That's where the redirect points. - Work down the rows. Each document request is one hop, ending with the
200page.
DevTools suits a quick look at one URL, but HSTS and the browser's cache can change what you see (see "Common problems" below).
Method 2: curl on the command line (and PowerShell on Windows)
curl ships with macOS, most Linux distributions and Windows 10 (version 1803) and later, and only follows redirects when asked.
See the first hop only:
curl -I http://example.com/old-page
-I fetches headers only. Read the status line (HTTP/1.1 301 Moved Permanently) and the Location: line.
Follow the whole chain:
curl -sIL http://example.com/old-page | grep -iE "^(HTTP|location)"
-L follows each 3xx, -s hides the progress meter and grep keeps the status and Location lines. Each HTTP/ line is one hop. curl stops after 50 redirects by default, so a loop ends in an error.
Get a one-line answer for scripts:
curl -s -o /dev/null -w '%{http_code} %{redirect_url}\n' http://example.com/old-page
This prints something like 301 https://example.com/new-page and sends a GET, useful if a server answers HEAD oddly. Add -L and use %{num_redirects} %{url_effective} to see the hop count and final URL.
On Windows PowerShell: in Windows PowerShell 5.1, curl is an alias for Invoke-WebRequest, so type curl.exe to run real curl with the commands above (and -o NUL instead of -o /dev/null). To stay in PowerShell itself:
$r = Invoke-WebRequest -Uri "http://example.com/old-page" -Method Head -MaximumRedirection 0 -UseBasicParsing -ErrorAction SilentlyContinue
"$($r.StatusCode) $($r.Headers.Location)"
-MaximumRedirection 0 stops it from following the redirect, so you see the first hop, for example 301 https://example.com/new-page. We tested this in Windows PowerShell 5.1. PowerShell 7 handles unfollowed redirects differently, so if the command errors there, use curl.exe.
Method 3: An online redirect checker
Our 301 Redirect Checker takes a domain or a full URL and tests it on four starting addresses: http:// and https://, each with and without www. For every hop it shows the status code, the Location header exactly as the server sent it and the response time, and labels each hop permanent (301 or 308) or temporary (302, 303 or 307).
- Enter a domain such as
example.com, or a full old URL such asexample.com/old-page. - Run the check. Each of the four versions gets its own card with every step from start to final page.
- Read the verdict at the top. It says whether all four versions reach one canonical URL in a single permanent hop, and if not, which version fails and why: a chain, a temporary redirect, a different final URL or no answer.
- Fix your rules and rerun. Copy the result or export CSV for a ticket.
It runs from our server with no cache or HSTS memory, so it shows what a first-time visitor or crawler receives. It follows up to ten hops and flags loops, but like curl it reads headers only, so meta refresh and JavaScript redirects appear as a page answering 200. The tools are free with a free account. There's also a Bulk Redirect Checker for up to 100 URLs, and the HTTP Status Code Checker for one URL's status code and headers.
Method 4: Google Search Console URL Inspection
Search Console shows how Google itself sees the redirect.
- Open your property in Search Console and paste the old URL into the inspection bar at the top.
- Read the indexing result. A processed redirect usually shows as not indexed with the reason Page with redirect, which Google defines as "a non-canonical URL that redirects to another page." The target "might or might not be indexed."
- Inspect the new URL as well to check that the target is indexed and selected as canonical.
- Use Test live URL carefully. Google's help says the live test "first follows any redirects implemented by the page, then tests the page," and it "does not indicate that it has followed a redirect, nor will it display the final URL that was tested."
Watch for Redirect error in the Page indexing report too. Google lists the causes: a chain that was too long, a redirect loop, a redirect URL that exceeded the maximum URL length, or a bad or empty URL in the chain.
"Page with redirect" is what you want for an old URL. It only needs action when the URL shouldn't redirect.
Method 5: A crawler for bulk checks
After a migration you need to test hundreds of URLs. Google's site move guide recommends command-line tools or scripts for large numbers and crawling with a tool such as Screaming Frog.
The free version of Screaming Frog's SEO Spider crawls up to 500 URLs. To audit a redirect map with it:
- Switch to List mode and upload your old URLs.
- In the spider configuration, under Advanced, tick Always follow redirects, so it follows each one to its final destination.
- Run the crawl, then export Reports > Redirects > All Redirects for every URL, or Redirect Chains for redirects with two or more hops.
- Compare each final URL with the target in your redirect map, fix the mismatches and recrawl.
A normal crawl of the live site also finds internal links that still point at redirected URLs, which you should update.
How to read the results
Code meanings below follow RFC 9110 and MDN; the SEO effects come from Google's documentation.
| Status / type | Meaning | SEO effect (per Google) | When to use |
|---|---|---|---|
| 301 Moved Permanently | Permanent move | Strong signal the target should be canonical | Moved pages, http to https, domain changes |
| 308 Permanent Redirect | Permanent, request method kept | Treated like 301 | Permanent moves where forms or APIs send POST requests |
| 302 Found | Temporary move | Weak signal; old URL may stay indexed | Short-term swaps where the old URL comes back |
| 307 Temporary Redirect | Temporary, method kept | Treated like 302 | Temporary moves with POST requests |
| 303 See Other | Go fetch another URL with GET | Temporary | After a form submission, not for page moves |
Instant meta refresh (content="0") |
HTML tag in a page that answers 200 | Interpreted as permanent | Only when you can't set server redirects |
| Delayed meta refresh | Same, with a wait | Interpreted as temporary | Rarely a good choice |
| JavaScript redirect | Script in a page that answers 200 | Only seen if rendering works | Last resort |
| 200 OK | The page loaded; no redirect | The URL itself can be indexed | The final hop of every chain |
There is no such thing as a "200 redirect." A 200 means the server returned the page you asked for. Either your checker showed a chain ending in 200, which is correct, or a URL answers 200 but still moves visitors elsewhere, which means a meta refresh or JavaScript redirect inside the page. Open the page source and search for http-equiv="refresh" or window.location. Google advises JavaScript redirects only as a last resort, because "Google might never see it if rendering of the content failed."
For a deeper comparison of the codes, see 301 vs 302 redirects.
Redirect chains and loops
A redirect chain is when the first redirect target redirects again before a page loads: A to B to C. Google's crawlers follow up to 10 hops by default, but its site move guide advises "redirecting to the final destination directly," and, if that isn't possible, keeping chains to ideally no more than 3 and fewer than 5 hops, because longer chains add latency and some browsers handle them poorly.
A redirect loop never ends: A goes to B, and B goes back to A. RFC 9110 says a client "SHOULD detect and intervene in cyclical redirections," so browsers stop and show an error, and visitors never see the page.
To collapse a chain, point the oldest URL straight at the final URL, then update internal links, canonical tags and your sitemap. Our guide to broken links and redirect chains covers this across a whole site.
Common problems a redirect check finds
- http to https to www chains. Two separate rules, one forcing https and one forcing www, turn
http://example.cominto a two-hop chain. Combine them into one rule. See how to redirect HTTP to HTTPS and our .htaccess guide for single-hop Apache rules. - Trailing slash hops. Your redirect points at
/new-page, and the server or CMS then adds a slash with a second redirect to/new-page/. Use the exact final form, slash included, in the redirect target. - 302 left in place after a migration. It's easy to pick 302 in a plugin or hosting panel, or leave a temporary rule in place. Google treats it as a weak signal, so old URLs can linger in results. Switch to 301.
- Cached 301s in your browser. RFC 9110 says a 301 response "is heuristically cacheable," so a browser can keep reusing an old permanent redirect after you change it. Retest with DevTools' Disable cache, a private window, curl or an online checker before assuming your fix didn't work.
- Mass redirects to the home page. Google's site move guide warns that redirecting many old URLs to one irrelevant page, such as the home page, may be treated as a soft 404. Map each old URL to its closest equivalent.
Frequently asked questions
How do I check if a 301 redirect is working?
Request the old URL with curl (curl -sIL plus the URL) or a redirect checker and read the first hop. It should show 301 with a Location header naming the new URL, and the new URL should answer 200. If you see 302, a chain or a page that doesn't load, the redirect needs fixing.
How do I test a redirect URL?
For one URL, DevTools with Preserve log ticked or curl -I is quickest. To cover the http, https, www and non-www versions at once, use an online redirect checker, and for a migration list use a crawler or bulk checker.
What is a redirect chain?
A redirect chain is a series of redirects where the first destination redirects again before the final page loads, such as http to https to www. Each hop adds a round trip for visitors. Google advises redirecting old URLs to the final destination directly.
Why does my browser still go to the old redirect?
Browsers can cache permanent redirects, because the HTTP standard makes 301 responses heuristically cacheable. Clear cached files, use a private window or test with curl. If curl shows the new behavior, your change worked.
Is a 301 redirect bad for SEO?
No. Google treats 301 and 308 as a signal that the target should be canonical. Problems come from temporary redirects used for permanent moves, long chains, loops and mass redirects to an irrelevant page.
Does Google Search Console show redirects?
Yes. URL Inspection reports a redirected URL as "Page with redirect," and the Page indexing report lists redirect errors such as overlong chains or loops. The live test follows redirects silently, so use curl or a redirect checker to see each hop.
Sources
- Google Search Central: Redirects and Google Search
- Google Crawling Infrastructure: How HTTP status codes affect Google's crawlers
- Google Search Central: Site moves with URL changes
- Search Console Help: Page indexing report
- Search Console Help: URL Inspection tool
- MDN: Redirections in HTTP
- RFC 9110: HTTP Semantics, Redirection 3xx
- Chrome for Developers: Network features reference
- curl man page
- Microsoft Command Line blog: Tar and curl come to Windows
- Microsoft Learn: Invoke-WebRequest
- Screaming Frog: How to audit redirects in a site migration
- Screaming Frog: Check redirects in bulk
More guides for your industry
Free checklist (PDF)
Free marketing agencies website checklist
31 practical checks for marketing agencies: website speed and mobile, Google Business Profile and reviews, email security, booking and enquiry handling, and AI search visibility. Each one says why it matters, and many link to a free tool that checks it.
Written by the MakeItFlow team
We build the website audit these guides are based on. Every fact is checked against the primary sources listed above . How we research and check
Check your own site in 30 seconds
Run a free audit covering speed, SEO, DNS, email authentication and security headers — and get a prioritised fix list.