A redirect sends a browser or crawler from one URL to another. A redirect chain is what you get when the destination redirects again, and maybe again after that:

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

Three hops to reach a page that one redirect could have reached. Nobody set that up on purpose. Chains build up when rules are added years apart by people who don’t know about each other’s: an HTTPS rule, then a www rule, then a trailing-slash rule, then a URL change after a redesign.

Why redirect chains matter

  • They slow every visit down. Each hop is a full request and response before the browser can even start loading the page. On a mobile connection, three hops can add a second before anything appears.
  • They spend crawl budget. A search engine fetches every intermediate URL. On a large site, that is time not spent discovering and refreshing your real pages.
  • Long chains get abandoned. Google’s documentation says Googlebot follows up to 10 redirect hops; past that it gives up and reports a redirect error. Browsers stop at a similar limit.
  • Loops never resolve. A chain that leads back to itself (A → B → A) shows visitors an error page and leaves crawlers with nothing to index.

Google has said that 301 and 302 redirects don’t lose PageRank, so a short chain is mostly a speed and crawling problem rather than a ranking penalty. It is still worth fixing: it is usually a one-line server change, and it fixes every URL the rule touches at once.

How to find redirect chains

You need to follow every redirect on the site and count the hops, which means a crawl. Check three places:

  1. Your homepage over plain HTTP. Request http://yourdomain.com and http://www.yourdomain.com and follow each to the end. These are the URLs old links and people typing your address hit first, and they are where stacked HTTPS and www rules show up.
  2. Every crawled page. Any internal link that takes two or more hops to resolve is a chain.
  3. Your internal links. A link that points at a redirecting URL isn’t a chain by itself, but it is one hop you don’t need, and it is often the first hop of a chain.

For a single URL, curl shows every hop:

curl -sIL http://example.com/shoes | grep -iE '^(HTTP|location)'

How to fix a redirect chain

1. Send every old URL straight to the final one

The fix is to make each redirect point at the final destination, not at the next step. For the classic HTTPS plus www chain, do both in one rule. In nginx, with https://example.com as the canonical host:

server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://example.com$request_uri;
}

server {
    listen 443 ssl;
    server_name www.example.com;
    # ssl_certificate ... (www needs a certificate too)
    return 301 https://example.com$request_uri;
}

In Apache, in .htaccess:

RewriteEngine On
RewriteCond %{HTTPS} off [OR]
RewriteCond %{HTTP_HOST} ^www\. [NC]
RewriteRule ^ https://example.com%{REQUEST_URI} [L,R=301]

Whichever host you choose, every combination of http/https and www/non-www should now reach it in a single hop.

2. Repoint old redirect rules

After a migration, the old site’s redirects often point at URLs that have since moved again. Update each rule’s target to the page’s current URL. Your CMS or redirect plugin usually lists them with their targets, which makes this a search-and-replace job.

3. Update the links themselves

Change internal links, navigation and your XML sitemap to use final URLs, including the trailing slash if your site uses one. Then visitors and crawlers skip the redirect entirely, and if the rules change again later, nothing depends on them.

4. Fix redirects that end in errors

A redirect whose target now returns a 404 or 500 is a broken promise: search engines and visitors follow it and land on an error. Point it at the closest live page, or remove it and let the old URL return 404 or 410 if there is no replacement.

SEO Audit Hub reports each of these separately so the fix is obvious: redirect chain for the homepage probe over HTTP, page redirect chain for any crawled page that takes two or more hops or loops, internal link to redirect against the page whose link needs editing, and redirect to error for rules whose target is broken.