Redirect Chain Checker: How to Find and Fix Long Redirect Chains

Redirect chains are one of the most common and most overlooked technical SEO problems. A single redirect is fine -- a browser or crawler requests URL A, gets pointed to URL B, and loads the page. But when URL A redirects to B, B redirects to C, and C redirects to D, you have a redirect chain. Every extra hop costs you page speed, crawl budget, and link equity.

The worst part is that redirect chains tend to grow silently over time. Nobody creates a four-hop redirect chain on purpose. They accumulate through site migrations, CMS changes, domain switches, and protocol upgrades. By the time you notice the performance impact, you might have hundreds of chained redirects across your site.

This guide covers what redirect chains are, why they matter, how to detect them, and exactly how to fix them.

What Is a Redirect Chain?

A redirect chain occurs when a URL redirects to another URL, which then redirects to yet another URL, and so on before reaching the final destination. The simplest redirect is a single hop:

URL A → URL B (final destination)

A redirect chain adds unnecessary intermediate steps:

URL A → URL B → URL C → URL D (final destination)

In this example, the chain is three hops long. The browser or crawler has to make four separate HTTP requests to reach the page the user actually wants to see. Each hop adds latency, and each hop gives search engines a reason to devalue the link.

Redirect Chains vs. Redirect Loops

A redirect chain eventually reaches a final destination. A redirect loop never does. In a loop, URL A redirects to B, B redirects to C, and C redirects back to A. The browser goes in circles until it gives up and shows an error.

URL A → URL B → URL C → URL A (loop -- never resolves)

Redirect loops are more severe than chains because the page never loads at all. Browsers typically give up after 20 redirects and display an ERR_TOO_MANY_REDIRECTS error. Search engines will stop crawling the URL entirely. If you have a redirect loop, fixing it is urgent -- the affected pages are completely inaccessible.

Why Redirect Chains Are Bad for SEO and Performance

A single 301 redirect is a normal, healthy part of web infrastructure. But when redirects stack into chains, three things go wrong:

1. Page Speed Degrades

Every redirect in a chain requires a full HTTP request-response cycle. On a typical connection, each hop adds 100-500ms of latency. A three-hop chain can add over a second to your page load time before the browser even starts downloading the page content. For users on mobile connections, the delay is even worse.

Google uses page speed as a ranking factor, and Core Web Vitals are directly impacted by redirect chains. The Time to First Byte (TTFB) metric specifically measures the delay before the first byte of page content arrives -- and every redirect hop inflates that number.

2. Crawl Budget Gets Wasted

Search engine crawlers have a limited crawl budget for each site -- the number of pages they will crawl in a given time period. Every redirect hop consumes part of that budget. If Googlebot hits a three-hop chain, it's used four requests just to reach one page. Multiply that across hundreds of chained URLs, and you are burning through crawl budget on redirects instead of actual content.

For small sites with a few hundred pages, crawl budget is rarely an issue. For larger sites with 10,000+ pages, wasted crawl budget means some of your pages won't get crawled as frequently, which can delay indexing of new or updated content.

3. Link Equity Dilutes

When one page links to another, it passes link equity (sometimes called "link juice"). Google has confirmed that some link equity is lost with each redirect. A single 301 redirect passes most of the equity, but each additional hop in a chain loses a small percentage. By the time you reach the end of a four-hop chain, the final page receives noticeably less link equity than it would from a direct link.

This matters most for pages that have strong backlink profiles. If your highest-authority pages are behind redirect chains, you are diluting the SEO value of every backlink pointing to them.

Common Causes of Redirect Chains

Redirect chains rarely appear all at once. They build up incrementally as changes stack on top of each other. Here are the most common causes:

Protocol and Domain Stacking

This is the single most common source of redirect chains. When a site migrates from HTTP to HTTPS and also enforces www or non-www at different times, the redirects can stack:

http://example.com → http://www.example.com → https://www.example.com → https://example.com

Each rule was added independently -- one for the www redirect, one for the HTTPS upgrade, one for dropping www later. Individually, each rule makes sense. Together, they create a three-hop chain for any link using the original http://example.com format.

Successive Site Migrations

Every time a site restructures its URLs, new redirects are added. But the old redirects are rarely updated. After two or three migrations:

/blog/2020/post-title → /articles/post-title → /content/post-title → /posts/post-title

The original URL from 2020 now goes through three hops to reach the current page. Each migration added a new redirect from the previous URL to the new one, but nobody went back to update the 2020 redirect to point directly to the final destination.

CMS and Plugin Changes

Content management systems often add redirects automatically when you change a page's slug or move it to a different category. Over time, editing a post's URL multiple times creates a chain of automatic redirects. WordPress, Shopify, and other platforms are especially prone to this because they create redirects silently in the background.

Vanity URLs and Short Links

Marketing teams often create short URLs or vanity URLs that redirect to campaign landing pages. When the landing page URL changes, the short URL gets updated to point to the new location -- but sometimes it points to the old URL, which itself redirects. Result: an unnecessary chain.

How to Detect Redirect Chains

You can't fix what you can't find. Here are the most effective ways to detect redirect chains across your site.

Method 1: Command-Line Check with curl

For checking individual URLs, curl is the fastest option. Use the -L flag to follow redirects and -I to show only headers:

curl -LI https://example.com/old-page

This shows every hop in the redirect chain, including the HTTP status code and Location header for each step. If you see more than one 301 or 302 response before the final 200, you have a chain.

Method 2: Browser Developer Tools

Open your browser's developer tools (F12), go to the Network tab, and navigate to a URL you suspect has a redirect chain. The Network tab shows every request, including redirects. Look for multiple 301/302 responses before the final 200. You can see the full chain by reading the requests from top to bottom.

Method 3: Bulk Checking with a Redirect Checker

Checking URLs one at a time is fine for troubleshooting, but it's not practical for finding all redirect chains across a site with thousands of pages. A redirect checker lets you test hundreds or thousands of URLs at once and flags any that involve chains.

To check your entire site, export all URLs from your sitemap, Google Search Console, or a site crawl. Include both current URLs and any old URLs that you know have redirects. Upload the full list to a bulk URL checker and filter the results for any URL with more than one redirect hop.

How to Fix Redirect Chains

The fix for a redirect chain is conceptually simple: make every URL point directly to the final destination, with no intermediate hops. In practice, this means updating your redirect rules so that the first URL in any chain goes straight to the last.

Step 1: Map Out the Full Chain

Before you change anything, document the complete chain for each affected URL. For example:

http://example.com/old-page → https://example.com/old-page → https://example.com/new-section/page

The final destination is https://example.com/new-section/page. Every other URL in the chain needs to redirect directly there.

Step 2: Update Redirect Rules

Go to wherever your redirects are configured -- .htaccess, Nginx config, Cloudflare Page Rules, your CMS redirect manager, or your application code. Update each intermediate redirect to point directly to the final URL.

Before (chain):

• http://example.com/old-page redirects to https://example.com/old-page
• https://example.com/old-page redirects to https://example.com/new-section/page

After (fixed):

• http://example.com/old-page redirects to https://example.com/new-section/page
• https://example.com/old-page redirects to https://example.com/new-section/page

Both old URLs now go directly to the final destination in a single hop. The chain is eliminated.

Step 3: Handle Protocol and Domain Rules Carefully

The trickiest chains to fix are those caused by layered protocol and domain rules. If your server has separate rules for HTTP-to-HTTPS and www-to-non-www, they can interact to create chains. The solution is to write a single rule that handles both in one redirect:

Instead of separate rules for http → https and www → non-www, create a single rule that redirects http://www.example.com directly to https://example.com in one hop. Most web servers and CDNs support this with proper rule ordering.

Step 4: Verify the Fix

After updating your redirects, test every URL you changed. Use curl -LI or your redirect checker to confirm that each URL now reaches the final destination in a single hop. Don't skip this step -- it's easy to introduce new chains or loops when editing redirect rules.

Step 5: Update Internal Links

Fixing redirects is only half the job. If your site's content still links to intermediate URLs in the chain, every visitor who clicks those links will still trigger a redirect. Search your codebase and CMS content for links that point to any URL that redirects, and update them to point directly to the final destination.

This is especially important after a website migration, where hardcoded internal links are one of the top sources of unnecessary redirects.

How to Prevent Redirect Chains From Building Up

Fixing existing chains is a one-time effort, but preventing new ones requires process changes. Here are the practices that keep chains from accumulating:

1. Always redirect to the final destination. When you add a new redirect, check whether the target URL itself redirects. If it does, skip the intermediate step and point directly to the final URL.
2. Audit redirects after every migration. Any time you change URL structures, go back through your existing redirects and update them to point to the new final destinations. Don't just add a new layer of redirects on top of the old ones.
3. Consolidate protocol and domain rules. Handle HTTP/HTTPS and www/non-www normalization in a single redirect rule, not separate layered rules.
4. Run periodic redirect audits. Once a quarter, export your full URL list and run it through a redirect chain checker. Catch new chains before they grow.
5. Document your redirect rules. Keep a central record of all active redirects. When multiple team members add redirects independently without visibility into what already exists, chains are inevitable.

Redirect Chains at Scale: Handling Large Sites

On a site with tens of thousands of pages and years of accumulated redirects, fixing chains manually is not realistic. Here is a practical workflow for large-scale cleanup:

1. Export all known URLs. Pull from your sitemap, Google Search Console, backlink tools, and any redirect logs or configuration files you maintain.
2. Bulk check every URL. Upload the full list to a cloud-based checker that reports the number of hops and final destination for each URL.
3. Filter for chains. Any URL with two or more redirects before the final destination is a chain that needs fixing.
4. Generate updated redirect rules. For each chain, create a rule that points the original URL directly to the final destination.
5. Deploy and re-check. Push the updated rules and run the bulk check again to verify all chains are resolved.

For sites with 75,000+ URLs, this process is only practical with cloud-based tooling that can handle the volume without tying up your local machine for hours.

Key Takeaways

Redirect chains are a silent performance and SEO drain. They build up gradually through migrations, CMS changes, and layered server rules, and they won't fix themselves. Here is what to remember:

• A redirect chain is any URL that passes through two or more redirects before reaching its final destination.
• A redirect loop is a chain that never resolves -- the URL redirects in a circle and the page never loads.
• Chains hurt SEO by wasting crawl budget, diluting link equity, and increasing page load times.
• The most common cause is layered protocol and domain redirects (HTTP to HTTPS plus www to non-www), combined with successive URL changes over time.
• The fix is straightforward: update every redirect so it points directly to the final destination in a single hop.
• Prevention requires checking for chains whenever you add new redirects, and running periodic bulk audits to catch chains before they grow.

Every redirect chain on your site is costing you speed, crawl efficiency, and link equity. The longer they exist, the more they compound. Audit your redirects today, fix the chains, and put a process in place so new ones don't accumulate.