Redirect checker
Up to 10 URLs, the full redirect chain with 301, 302, 307 and 308 codes
- Free
- No account required
Example: real chains recorded on 23 Sep 2026. Enter your own URLs.
| # | Code | URL → target | Time |
|---|---|---|---|
| 1 | 301 | http://cometweb.io/tools/obfuscator → https://cometweb.io/tools/obfuscator | 141 ms |
| 2 | 301 | https://cometweb.io/tools/obfuscator → /tools/code-obfuscator | 175 ms |
| 3 | 200 | https://cometweb.io/tools/code-obfuscator | 209 ms |
- Redirect chain. Every hop is another request and more waiting, so redirect straight to the final URL. Redirects in the chain:
2 - The http URL redirects to https, as it should.
| # | Code | URL → target | Time |
|---|---|---|---|
| 1 | 301 | https://google.com/ → https://www.google.com/ | 169 ms |
| 2 | 200 | https://www.google.com/ | 186 ms |
- One permanent redirect straight to the target, as it should be.
This redirect checker follows each URL you enter one hop at a time and shows the whole chain: the status code at every step, the target from the Location header, the time and the final page. It flags chains longer than one redirect, loops, temporary redirects where a permanent one is usually needed, a switch from https to http, a final page that errors and a meta refresh redirect. It does not run JavaScript, so it cannot see redirects done by a script.
When a redirect does harm
Permanent and temporary are two different signals. According to Google, a 301 or 308 says the target should become canonical. Googlebot follows 302, 303 and 307 but does not treat them as that signal. For a page move, a domain change or a switch to https, use permanent redirects.
A chain is usually what several migrations leave behind. An old URL redirects to a newer one, which redirects to the newest. Every hop is another request; Google's crawlers follow up to 10 hops by default, but visitors wait for each one. Fix the rule so the first URL points straight at the target.
Meta refresh and JavaScript are fallbacks. Google reads an instant meta refresh as a permanent redirect and a delayed one as temporary. It may never see a JavaScript redirect if rendering fails. This tool detects a meta refresh on the final page but does not run scripts.
Build redirect rules for Apache or nginx in the redirect generator, then check them here after they go live.
Check every variant of a URL
After a migration, paste one URL from each variant: http and https, with and without www, with and without a trailing slash, the old URL from the sitemap and from external links. Each should reach the target in one permanent redirect.
Google Search Central, Redirects and Google SearchHow to check a 301 and 302 redirect chain
You check a redirect chain from the URL people and crawlers actually visit to the page that answers with a 200. Four steps cover a migration as well as a routine check.
-
Collect the entry URLs
Take the old URLs from your migration map, campaign links and every version of the domain:
http://,https://, with and withoutwww. Each variant can take a different path. -
Paste them and read every hop
The tool shows the code, the Location target and the time of each hop. Look for more than one redirect, 302 codes where the change is permanent, and a final page that errors.
-
Fix the rule at the source
Change the first rule so it points straight at the final URL. If two layers do the hops, such as a CDN and the application, one of them needs to know the destination.
-
Check again and update your links
After deploying, paste the same URLs again. Then switch internal links, the sitemap and canonicals to the final URLs, so the redirect only handles outside traffic.
Example redirect chains and their fixes
The example.com URLs are placeholders. The code at each hop is the server response.
http://example.com/offer
301 → https://example.com/offer
301 → https://example.com/services
200http://example.com/offer
301 → https://example.com/services
200The rule for the old path also covers the http version, so visitors and crawlers make one request fewer.
https://example.com/pricing-2025
302 → https://example.com/pricinghttps://example.com/pricing-2025
301 → https://example.com/pricingGoogle treats 301 and 308 as a strong signal that the new URL should replace the old one, and 302 and 307 as a weak one.
server {
listen 80;
server_name example.com www.example.com;
return 301 https://example.com$request_uri;
}One rule sends every http variant straight to the final https host, without an extra hop through https://www.
Common redirect mistakes
-
Chains left by successive migrations
Each migration adds a rule at the end of the chain instead of updating the old ones. Google advises avoiding chains, because they add latency and not every browser supports long chains.
-
Every old URL sent to the home page
The visitor wanted specific content and lands on the home page with no explanation. Send each old URL to its closest equivalent, and leave URLs with no equivalent on a 404 or 410.
-
Conflicting trailing slash or www rules
One rule adds a trailing slash, another removes it, and you get a loop. The same happens when the CDN forces www and the application strips it.
-
A redirect left on 302
The default redirect helper in many frameworks returns a 302. For a permanent change, set 301 or 308 explicitly so search engines replace the old URL with the new one.
-
Removing redirects after a few weeks
Links from other sites and visitor bookmarks keep working for years. Google recommends keeping redirects for at least a year after a site move.
HTTP redirects in Google documentation and RFC 9110
| Value | What it means | Source |
|---|---|---|
| 10 | Number of redirect hops Google's crawlers follow by default. | Google Search Central, HTTP status codes |
| 301, 308 | Codes Google treats as a strong signal that the target should become canonical. 302 and 307 are a weak signal. | Google Search Central, HTTP status codes |
| 0 s | Google treats a meta refresh with no delay as a permanent redirect, and a delayed one as temporary. | Google Search Central, redirects |
| 1 year | The minimum time Google recommends keeping redirects after a site move. | Google Search Central, site moves |
| 307, 308 | These codes keep the request method. With 301 and 302, a browser may change POST to GET for historical reasons. | IETF, RFC 9110, 15.4 |
Sources checked:
Redirect codes
- 301Moved Permanently
- Permanent. A strong signal that the target replaces the old URL.
- 308Permanent Redirect
- Permanent, like 301, without changing the request method.
- 302Found
- Temporary. Google follows it but does not move canonical status.
- 307Temporary Redirect
- Temporary, like 302, without changing the request method.
Enter the URL and choose Check. The tool sends a request, reads the status code and the Location header, then repeats that for each next URL until it reaches a page that does not redirect. You get the whole chain with the code and time of each hop. You can check up to 10 URLs at once.
A 301 means moved permanently, a 302 temporarily. Google treats a 301 (and 308) as a signal that the target should be canonical; it follows a 302 (and 303, 307) but takes no such signal from it. For a permanent URL change, use 301 or 308.
It is when URL A redirects to B and B redirects to C. Every hop adds load time, and a very long chain may not be followed to the end, because Google's crawlers follow at most 10 redirects by default. The fix: every old path should point directly at the final URL.
A chain that returns to a URL it has already visited, e.g. A → B → A. After a few tries the browser shows an error and the page never loads. The usual cause is conflicting rules, for example one that adds a trailing slash and another that removes it.
No. It follows redirects from HTTP headers and detects a meta refresh on the final page, but it does not run scripts. Google warns that it may not see a JavaScript redirect if rendering fails, and recommends one only when a server-side redirect is not possible.
Often the first hop is a CDN or server switching http to https, and the second is the application moving the old path to a new one. That is a two-redirect chain. If you can, add a rule that sends the http URL straight to the final https URL.
Our server fetches the URLs, so they reach our logs. We do not keep the results. Private and local addresses are rejected at every step of the chain.
Choose 307 and 308 when you redirect a form or an API request and the method must not change. RFC 9110 allows a browser to change POST to GET on a 301 or 302, while 307 and 308 keep the method. For ordinary pages, 301 and 308 work the same in Google.
Keep redirects after a migration for as long as you can, and Google recommends at least a year. In that time, update internal links and the most important external links to the new URLs, so the redirect handles less and less traffic.
RFC 9110 sets no fixed redirect limit and only says clients should detect loops. An earlier version of the spec recommended at most five, and the RFC warns that some clients may still use such a fixed limit. One hop is the safest choice.
What else might come in handy
This test checks one thing on one page
Indexability, metadata and structure, with priorities and a client report.