Canonical Loop: What Causes It and How to Fix It

The short version

A canonical loop is a closed circle of canonical declarations: page A names B as canonical, and B names A right back (or a longer A → B → C → A chain). No URL in the ring points to a stable, self-terminating destination, so Google can't tell which one you actually want — it discards the entire chain and canonicalizes on its own.

How a loop forms

Canonicalization is supposed to be a one-way arrow ending at a page that points to itself. A loop happens when two or more URLs each nominate the other as the master, so the arrow never lands. The classic version is two URLs — ?ref=nav and ?ref=footer versions of the same product, each canonicalizing to the other because a rule fired on both. Longer loops show up in language folders, trailing-slash variants, or www/non-www pairs where a rewrite rule and a plugin disagree about which is primary and each "corrects" toward the other.

The tell is that every URL in the ring is internally consistent on its own — the tag is valid, the href resolves, the target returns 200. Nothing looks broken at the single-page level. The defect only exists in the relationship between the pages, which is exactly why crawl-level auditing catches it and a manual page check doesn't.

Why Google walks away from the whole ring

Google follows canonical hints, but it caps how far it will chase them and it refuses to accept a canonical that contradicts itself. When it detects that following the chain never reaches a URL that canonicalizes to itself, it treats every hint in the loop as unreliable and drops all of them. From there it's back to Google's own signals — internal links, sitemap inclusion, URL cleanliness — to pick a canonical for you. On a loop between two near-identical URLs the damage is usually mild. On a loop that pulls a thin parameter URL into contention with your real landing page, Google can consolidate signals onto the parameter version and quietly bury the page you care about.

Real failing markup, and the fix

A two-node loop between two URL variants of the same product looks like this:

<!-- Page A: https://example.com/shoes/?ref=nav -->
<link rel="canonical" href="https://example.com/shoes/?ref=footer" />

<!-- Page B: https://example.com/shoes/?ref=footer -->
<link rel="canonical" href="https://example.com/shoes/?ref=nav" />

A canonicalizes to B, B canonicalizes to A, and the arrow spins forever. The fix is to break the ring by choosing one authoritative URL — the clean, parameter-free version — and pointing every variant at it, including that clean URL pointing at itself:

<!-- The clean master, self-referencing -->
<!-- https://example.com/shoes/ -->
<link rel="canonical" href="https://example.com/shoes/" />

<!-- Both parameter variants now point at the master -->
<!-- ?ref=nav and ?ref=footer -->
<link rel="canonical" href="https://example.com/shoes/" />

One URL at the end of the chain must point to itself. That self-reference is what terminates the loop and gives Google a stable target to accept.

Loop shapes and what breaks them

How to detect it

1. Screaming Frog. This is the fastest catch. Crawl the site, then run Reports > Canonicals > Canonical Chains. Frog flags chains and loops directly, showing you the full A → B → A path so you can see where the ring closes.
2. curl the two suspects. Pull both URLs — curl -s -A 'Mozilla/5.0' URL_A | grep -i canonical and the same for URL_B — and read the hrefs side by side. If A's canonical is B and B's canonical is A, you're looking at the loop in plain text.
3. GSC URL Inspection. Inspect one URL in the ring. When User-declared canonical and Google-selected canonical disagree and the selected one is a URL you never nominated, Google has already rejected the loop and chosen for you.
4. View Rendered Source. If the raw HTML looks loop-free but a JS layer rewrites the canonical after load, check the rendered DOM — a script "correcting" the canonical on both pages can create a loop that only exists post-render.

How to fix it

1. Map the ring. List every URL in the loop and write down what each one currently canonicalizes to.
2. Choose one master — the cleanest, indexable, parameter-free URL — as the single destination for the whole group.
3. Point every variant's canonical at that master, and make the master canonicalize to itself.
4. Resolve the underlying fight. If a redirect rule and a plugin were each setting different canonicals, disable one so a single source of truth emits the tag.
5. Re-crawl and re-run the canonical-chains report to confirm the loop is gone and every chain terminates at a self-referencing URL.

FAQ

Does a canonical loop get my pages deindexed?

Not directly. Google ignores the loop and self-selects a canonical, so the pages usually stay indexed — just not necessarily the version you wanted. The real risk is signal consolidation landing on the wrong URL, which can suppress the page you actually care about ranking.

What's the difference between a canonical loop and a redirect loop?

A redirect loop returns HTTP 3xx responses that cycle and eventually error out with "too many redirects" — the browser can't load the page. A canonical loop returns clean 200s on every URL; the cycle is only in the rel="canonical" hints, so pages load fine and the problem is invisible until a crawler traces the chain. See the self-redirect loop check for the redirect flavor.

Is a two-URL loop treated differently from a longer chain?

No — any closed ring that never reaches a self-canonicalizing URL gets discarded the same way, whether it's two nodes or five. Google's cap on chain length means even a long, non-looping chain can get truncated, so the safe target is always: short chains that end in a self-reference.

Both looped URLs are near-identical duplicates. Do I still need to fix it?

Yes, because you lose control of which one Google keeps. When both are interchangeable it may not hurt rankings much, but you've handed the indexing decision to Google's defaults instead of directing it. Point both at one master and take the choice back.

How long until the loop clears after I fix it?

Google has to re-crawl every URL in the ring and re-evaluate the chain, so allow days to a few weeks depending on crawl frequency. Requesting indexing on the master URL in URL Inspection can speed up the highest-value page.

Related reading

For the underlying rules, read the canonical tag glossary entry and the Canonical Tags complete reference. Loops love parameter URLs, so pair this with URL parameter handling. If your declared canonical is fine but Google keeps overriding it, see user-declared canonical not selected.