Redirect Chains and Loops: Find and Fix Them

Redirects are a normal, healthy part of running a website. You move a page, you redirect the old URL to the new one, and visitors and search engines follow along. The trouble starts when those redirects stack up. Redirect chains — where one URL points to another, which points to another, before finally landing on a real page — are one of the most common and most overlooked technical SEO problems. This guide explains what redirect chains and loops are, why they hurt, and exactly how to find and flatten them.

What is a redirect chain?

A redirect chain is a sequence of two or more redirects between the URL a user or crawler requested and the final destination it actually loads. Instead of a clean single hop, the browser has to make several round trips before it sees real content.

A typical chain looks like this:

A  →  B  →  C  →  D

Here, A redirects to B, B redirects to C, and C finally redirects to D, the page that returns a 200 OK. Every arrow is a separate request and response.

The ideal version is a single hop:

A  →  D

One request, one redirect, done.

What is a redirect loop?

A redirect loop is a chain that never reaches a destination because it points back on itself:

A  →  B  →  A  →  B  →  ...

The browser follows the redirects until it hits its limit and then gives up, usually showing an error like "too many redirects." A loop is always a bug — the page is effectively unreachable. Loops commonly appear when two conflicting rules fight each other, for example one rule forcing a trailing slash and another stripping it.

Why redirect chains hurt

Chains rarely break a page outright, which is why they linger for years. But they cost you in several ways.

• Added latency and TTFB. Each hop is a full DNS, connection, and server round trip. On mobile networks, three or four extra hops add real, perceptible delay to time-to-first-byte and overall load.
• Wasted crawl budget. Search engines spend resources resolving each hop instead of fetching real pages. On large sites this matters — every redirect a bot follows is a fetch it did not spend on new or updated content. (More on this in crawl budget explained.)
• Potential link-equity dilution. Google's own guidance on 301 redirects confirms they pass ranking signals to the destination, but relying on long chains is risky. The cleaner and shorter the path, the more confident you can be that signals consolidate on the right URL.
• Risk of the crawler giving up. Googlebot follows a limited number of hops per chain in a single crawl. If a chain is too long, it may stop following and try again later — or not pass through the equity you expected — delaying or weakening how the final URL is indexed.

301 vs 302 vs 307: which to use

Choosing the wrong status code is a common cause of weak or messy redirects. Here is what each one means and when to reach for it.

The rule of thumb: if a change is permanent and you want the new URL to rank, use a 301. If the original page is coming back, use a 302 or 307 so search engines do not swap it out permanently.

Common causes of redirect chains

Chains almost always grow from small, well-intentioned rules layering on top of each other over time.

• HTTP→HTTPS plus non-www→www stacked. A request to http://example.com redirects to https://example.com, which then redirects to https://www.example.com. Two hops where one would do.
• Old migrations layering up. Each site redesign or platform move adds another rule. A URL retired three migrations ago can pass through three separate redirects before landing.
• Trailing-slash inconsistencies. One rule adds a trailing slash, another removes it, and a third forces lowercase. Stacked together they create extra hops — or, when they conflict, a loop.
• CMS and plugin redirects fighting server rules. Your server config and your CMS may both try to manage the same redirect, producing two hops instead of one.

How to find redirect chains

You cannot fix what you cannot see, and browsers hide chains by design. The reliable way to find them is to crawl your site with a tool that records the full response path for every URL.

A desktop crawler maps every URL, follows each redirect, and reports the complete hop sequence with the status code at each step. Crawl Cove's redirect checker does exactly this: it traces the full redirect path for every URL on your site, flags every chain with its hop count, and tells you the final destination — so you can see at a glance which URLs take three hops when they should take one. A URL trapped in a redirect loop can't hide either: the crawler gives up after ten redirects and raises a critical error on that URL, so a loop surfaces in the same audit.

Because Crawl Cove runs locally on your Windows machine and keeps the audit private, you can re-crawl as often as you like while you clean redirects up, and compare versioned audits to confirm a chain is actually gone. For every chain it finds, it explains the fix in plain English rather than leaving you to interpret a wall of status codes.

When you review the results, sort by hop count first. Anything with three or more hops is a priority, and any loop should be fixed immediately because those pages are unreachable.

How to flatten a redirect chain

Flattening means pointing the first URL straight at the final destination, removing every intermediate hop.

Take this chain:

Before:  /old-page  →  /new-page  →  /new-page/  →  https://www.example.com/final

That is three hops. To flatten it, update the rule for /old-page so it goes directly to the end:

After:   /old-page  →  https://www.example.com/final

One hop. The key points when flattening:

1. Always redirect to the final 200 URL, never to another redirect. Confirm the destination returns a 200 OK, not a 3xx.
2. Update the source, not the middle. Editing an intermediate rule still leaves a chain; you want the entry point pointing at the end.
3. Preserve the right status code. If the move is permanent, the single remaining hop should be a 301.
4. Re-crawl to confirm. After editing, crawl again and check the hop count dropped to one.

Best practices to prevent new chains

• Maintain a single source of truth for redirects so server config and CMS rules do not overlap.
• Always point new redirects at the live, final URL — never at a URL you know is itself redirected.
• Standardize your canonical form (HTTPS, www-or-not, trailing-slash, lowercase) and enforce it in one consolidated rule rather than several stacked ones.
• Audit redirects on a schedule and especially before and after any migration, when chains multiply fastest.
• Clean up legacy rules as you migrate, instead of leaving every old rule in place forever.

Wrap-up

Redirect chains are quiet performance and SEO drains: they slow pages, waste crawl budget, and put your link equity at unnecessary risk, while loops make pages unreachable altogether. The fix is straightforward once you can see the full path — flatten every chain to a single hop pointing at the final 200 URL, use a 301 for permanent moves, and keep your redirect rules consolidated so new chains do not form. Crawl your site regularly, sort by hop count, and treat any loop as urgent. A few minutes of cleanup keeps both visitors and search engines moving straight to the page that matters.