usdigitalmarketingindex.com SEO
How do multi-hop redirects affect search crawler efficiency?
Updated November 15, 2026
Each extra hop is an extra request a crawler must make before it reaches content, and past a limit the crawler stops following. Google’s documentation gives the limit: “By default, Google’s crawlers follow up to 10 redirect hops” (how HTTP status codes affect Google’s crawlers). A chain shorter than that still resolves, so a two-hop redirect does not, in itself, lose a page its place in search. The cost is in requests spent, in time added for visitors, and in fragility: every hop is a point that can break, loop, or be changed by someone who does not know the chain exists. The fix is to make every redirect point straight to the final URL.
How redirect chains form
Chains are built one reasonable decision at a time.
- A page moves from A to B. Later B moves to C. The first redirect is never updated.
- A site changes from HTTP to HTTPS, then from non-www to www, then adds a trailing slash, each handled by its own rule.
- A migration maps old URLs to new ones that are themselves redirected by an older rule.
- A vanity or campaign URL points to a page that has since moved.
Stacked protocol and host rules alone can add three hops to every legacy URL before any content-level redirect is applied.
A hop is not always a server response. Some are made by a script after the page loads, and whether those can stand in for server-side redirects is examined in the guide to whether JavaScript redirects are suitable replacements for permanent server-side redirects.
Measuring hop depth
Trace a URL without following redirects automatically, so each response is visible. A conceptual trace, with example addresses:
$ curl -sI http://example.com/old-page
HTTP/1.1 301 Moved Permanently
Location: https://example.com/old-page
$ curl -sI https://example.com/old-page
HTTP/1.1 301 Moved Permanently
Location: https://www.example.com/old-page
$ curl -sI https://www.example.com/old-page
HTTP/1.1 301 Moved Permanently
Location: https://www.example.com/new-page/
$ curl -sI https://www.example.com/new-page/
HTTP/1.1 200 OK
That is three hops before a 200. To see a whole chain in one command, let the tool follow redirects and print each response:
$ curl -sIL http://example.com/old-page
For a whole site, run a crawler over the list of legacy URLs and internal link targets and export hop counts. Check two sources of URLs: the ones your own pages link to, and the old URLs that other sites link to.
One detail from Google’s documentation affects testing. It notes that “Google Inspection Tools doesn’t follow redirects”. Inspecting a redirecting URL in Search Console tells you about that URL, not about the end of its chain. Inspect the final URL separately.
Mapping final targets
Build a table with every redirecting URL and where it ends.
| Source URL | Current chain | Hops | Final URL | Final status |
|---|---|---|---|---|
| http://example.com/old-page | HTTP to HTTPS, to www, to new path | 3 | https://www.example.com/new-page/ | 200 |
| https://www.example.com/summer-sale | To /sale/, to /offers/ | 2 | https://www.example.com/offers/ | 200 |
| https://www.example.com/blog/post-12 | To /articles/post-12, to /articles/ | 2 | https://www.example.com/articles/ | 200, wrong target |
| https://www.example.com/promo | To /promo-2022/ | 1 | https://www.example.com/promo-2022/ | 404 |
The table exposes more than hop counts. The third row ends at a listing page instead of the article, and the fourth ends at an error. Flattening a chain is also the moment to check that the destination is the right one and that it works.
The same table serves a second repair. Internal links that still point at a redirecting address can be rewritten to the final URL, for the reasons given in the guide to why internal links should point to the final URL rather than to a redirecting address.
Testing direct redirects
Rewrite the rules so each source goes to its final URL in one step.
- For every row, set the redirect target to the final URL from the table.
- Combine protocol, host, and slash normalization into a single rule that produces the canonical form at once.
- Update internal links to point at final URLs directly. A link on your own site should never need a redirect.
- Update the sitemap to list final URLs only.
- Re-run the trace on every source URL.
Validation checks:
| Check | Pass condition |
|---|---|
| Each legacy URL | One redirect response, then 200 |
| Redirect type | Permanent, for moves that are permanent |
| Final URL | Returns 200 and is the intended content |
| Internal links | None point at a redirecting URL |
| Protocol and host variants | Each resolves to the canonical form in one hop |
| No loops | No URL appears twice in its own chain |
Keep the scale of the problem in proportion. Google’s crawl budget documentation lists long redirect chains among things that affect crawling negatively, in guidance written for very large sites. On a small site, a few two-hop chains are an untidiness worth fixing when convenient. On a site with millions of URLs, a rule that adds two hops to every address multiplies requests across the whole inventory.
Avoid one overstatement: that every intermediate redirect destroys the value of links. Google’s documentation describes redirects as a strong signal that the target should become canonical, and sets the following limit at ten hops. The reasons to flatten are efficiency, speed, and reliability.
A chain that never ends is a different fault, a loop, which stops crawlers and visitors alike. Detecting those before a launch is covered in the guide to detecting redirect loops before a redesigned website launches.
The rule: one source, one hop, one working destination.
Add your comment to this answer