Redirect Chains: How They Affect SEO and Speed

Redirects are an integral part of website management. They are needed when migrating to a new domain, changing URL structure, or switching from HTTP to SSL/TLS проверку. However, improper use of redirects creates redirect chains that slow down loading and harm SEO rankings. Let's examine this problem in detail.

Types of HTTP Redirects

301 — Permanent Redirect

A 301 code tells browsers and search engines that the page has been permanently moved. Search engines pass link equity (link juice) to the new URL and eventually replace the old URL with the new one in their index.

When to use 301:

• Site migration to a new domain
• Permanent URL structure changes
• Canonicalization (www to non-www, HTTP to HTTPS)
• Merging duplicate pages

302 — Found (Temporary Redirect)

A 302 code indicates a temporary redirect. Search engines keep the original URL in the index and do not pass link equity to the new address.

When to use 302:

• A/B testing of pages
• Temporary redirect to a maintenance page
• Geo-based user redirection
• Redirect during an incomplete migration

307 and 308 — Strict Redirects

307 (Temporary) and 308 (Permanent) are stricter versions of 302 and 301 respectively. They guarantee that the HTTP request method (POST, PUT) is preserved during the redirect. For regular GET requests, the behavior is identical to 302 and 301.

What Is a Redirect Chain

A redirect chain occurs when one URL redirects to another, which in turn redirects to a third, and so on. A simple example:

http://example.com → 301 → https://example.com → 301 → https://www.example.com → 301 → https://www.example.com/new-page/

In this case, the browser makes three sequential requests instead of one. Each redirect adds a delay of 100–500 ms (DNS Lookup, TCP connection, TLS handshake, response wait).

How Redirect Chains Affect SEO

Link Equity Loss

Google has stated that 301 redirects pass full link equity. However, in practice, each step in a chain can weaken the transfer. With a chain of 3–4 redirects, the loss can be significant.

Slower Indexing

Googlebot has a limited crawl budget for each site. Redirect chains waste this budget — the bot spends requests following chains instead of indexing useful pages.

Problems Discovering the Final URL

Google follows a maximum of 10 redirects in a chain. If the chain is longer, Googlebot will stop following the redirects and the page will not be indexed.

Mixing 301 and 302

If a 302 redirect appears in the chain, the search engine may conclude that the redirect is temporary and not pass link equity to subsequent links. This is a common mistake, especially when configuring through a hosting panel.

Impact on Loading Speed

Each redirect in a chain requires a full request-response cycle:

1. DNS resolution (if the domain changes) — 20–120 ms
2. TCP connection — 10–100 ms
3. TLS handshake (for HTTPS) — 30–150 ms
4. Sending request and receiving response — 10–200 ms

In total, each step adds 70 to 570 ms. A chain of three redirects can add over a second to load time — critical for mobile users and the LCP metric.

How to Find Redirect Chains

Manual Check

Use the enterno.io HTTP header checker tool. It shows the HTTP response code and the Location header if there is a redirect. Check each URL in the chain sequentially.

Tools for Bulk Checking

• Bulk URL check on enterno.io — check up to 20 URLs simultaneously
• Screaming Frog SEO Spider — a crawler that finds all redirects on a site
• Google Search Console — the Coverage report shows pages with redirects
• Ahrefs / SEMrush — site audits detect chains

Checking via curl

curl -sIL https://example.com 2>&1 | grep -E "^HTTP/|^location:"

The -L flag tells curl to follow redirects, and -I shows only headers.

How to Eliminate Redirect Chains

1. Direct Redirect to the Final URL

Instead of a chain A → B → C → D, set up direct redirects: A → D, B → D, C → D. Each intermediate URL should redirect directly to the final address.

2. Update Internal Links

Find all internal links pointing to URLs with redirects and replace them with the final URLs. This eliminates redirects for users coming from your own site.

3. Canonicalization via Server Configuration

Set up a single canonicalization rule instead of multiple sequential ones. For nginx:

# One rule instead of a chain: http → https + www → non-www
server {
    listen 80;
    listen 443 ssl;
    server_name www.example.com example.com;

    # Single redirect to the final URL
    if ($scheme = "http") {
        return 301 https://example.com$request_uri;
    }
    if ($host = "www.example.com") {
        return 301 https://example.com$request_uri;
    }
}

4. Audit .htaccess (Apache)

Multiple RewriteRule directives added at different times often create unintended chains. It is recommended to:

• Consolidate redirect rules
• Use the [L] (Last) flag to stop processing after a match
• Add new rules at the beginning of the file, not the end
• Test every change by checking headers

5. Update External Links

Where possible, update links in social media, directories, email campaigns, and other external resources to point to current URLs.

Common Causes of Chains

• HTTP to HTTPS migration + www canonicalization — two sequential redirects
• CMS or site structure change — old rules are not updated
• Trailing slash — /page → /page/ adds an extra step
• Domain change — old domain → new domain, but the new domain also has redirects
• URL shorteners — bit.ly → intermediate page → final URL

Redirect Loops

Even more dangerous than chains are loops (redirect loops), where URL A redirects to B, and B redirects back to A. Browsers detect the loop and display an ERR_TOO_MANY_REDIRECTS error.

Common causes of loops:

• Conflict between server rules and CMS rules
• CDN or proxy adding its own redirects
• CMS plugins conflicting with each other
• Incorrect SSL configuration on CDN (flexible mode + redirect to HTTPS on origin)

Redirect Checklist

1. Use 301 for permanent and 302 for temporary redirects
2. Maximum chain length — 1 redirect (ideally 0)
3. Regularly check your site for chains and loops
4. Update internal links when URLs change
5. Consolidate canonicalization rules into a single redirect
6. Test redirects after every configuration change
7. Monitor crawl budget in Google Search Console