Tools
humans.txt generator
humans.txt generator: build a humans.txt file with TEAM, THANKS and SITE sections from the humanstxt.org template. Free, runs in your browser.
Canonical chain and loop checker
Canonical chain and loop checker: paste url -> canonical pairs, follow every hop and catch loops and multi-hop chains. Free, runs in your browser.
Runs entirely in your browser. Nothing you enter is uploaded, logged or stored.
This tool resolves the pairs you paste; it cannot fetch pages across origins to read their rel="canonical" tag itself, so collect each hop by hand first (view source, or your crawler's canonical export).
Key takeaways
- Google recommends adding a self-referential rel=canonical link to the canonical page itself, so a settled chain should end there.
- A canonical loop, where a URL eventually points back to one already visited, never settles on a page that references itself.
- Every intermediate hop in a chain is a page that points onward instead of carrying the self-reference Google recommends.
- Google treats a declared canonical as a hint, not a rule, so a messy chain leaves the final choice to Google.
- The tool resolves only the pairs you paste; it cannot fetch pages across origins, so each hop has to be collected first.
What it takes
- A pasted list of canonical pairs, one per line as "url -> canonical"
- The URL to start resolving from
How to use it
- 1Collect each hop by handA client-side tool cannot fetch another origin's HTML, so open each page's source or a crawler export and note its rel=canonical target as one "url -> canonical" line.
- 2Paste the pairs and pick a starting URLThe start dropdown lists every URL that appears on the left side of a pair; choosing one walks the chain from there.
- 3Read the hop listEach numbered row is one canonical hop, in the order the resolver followed them, ending at a self-reference, a URL outside the pasted set, or a repeat.
- 4Fix a loop firstA loop means two or more URLs point at each other in a cycle with no URL ever carrying a self-referencing canonical, so no crawler settles on a winner among them.
- 5Flatten a multi-hop chainOnce the true final URL is known, point every duplicate's canonical straight at it instead of at the next hop, matching Google's own self-referencing recommendation.
Google’s documentation recommends adding a self-referential rel="canonical" to the canonical
page itself, and it treats every declared canonical as a hint rather than a rule. A chain breaks
the first idea: page A points to B, B points to C, and only C references itself. A loop breaks it
completely: A points to B, B to C, and C back to A, so no page in the set ever says “index me”.
Neither shows up when you check canonical tags one page at a time.
What this canonical chain checker does
It reads each pasted line as url -> canonical, parses both sides with the browser’s URL
parser, and builds a lookup from every left-hand URL to its target. Lines without exactly one
arrow, or with a URL that does not parse, are reported by line number. Then it walks from the
start URL you choose, one hop at a time, and stops at the first of:
- A self-reference. The current URL’s canonical points to itself. The chain has settled.
- A URL outside the pasted set. The target has no line of its own, so the walk cannot go on.
- A repeat. The target was already visited in this walk. That is a loop.
The walk is capped at 25 hops so a malformed paste cannot freeze the tab. Google publishes no chain-length limit for canonicals, because chains are not a pattern its documentation recommends.
How to read the results
The hop list numbers each URL from 0, the start, in the order followed. Below it, a verdict with a Pass, Warning or Problem badge:
| Result | Badge |
|---|---|
| Self-referencing, no chain (0 hops) | Pass |
| 1 hop to a self-referencing canonical | Pass |
| 2 or more hops to a self-referencing canonical | Warning |
| 1 hop, ends outside the pasted set | Pass |
| 2 or more hops, ends outside the pasted set | Warning |
| Loop detected | Problem |
A one-hop result that ends outside the set only means the final URL was not pasted. Add a line for it, ideally showing it pointing to itself, and the chain can be confirmed.
Worked example
The tool loads with four pairs built around the tracked dress URL Google uses as its example:
https://example.com/dresses/cocktail?gclid=1 -> https://example.com/dresses/cocktail
https://example.com/dresses/cocktail -> https://example.com/dresses/party
https://example.com/dresses/party -> https://example.com/dresses/formal
https://example.com/dresses/formal -> https://example.com/dresses/cocktailStarting from the tracked URL, the hop list reads 0 the ?gclid=1 URL, 1 cocktail, 2 party, 3
formal, and 4 cocktail again, marked “(back to hop above, a loop)”. The verdict is Loop detected,
with a Problem badge. The tracked URL did its job, but the clean URL it pointed to never settles.
Change the last line to https://example.com/dresses/formal -> https://example.com/dresses/formal
and the verdict becomes “3 hops to a self-referencing canonical”, a Warning. The fix is to point
the tracked URL, cocktail and party straight at formal.
Common mistakes it catches
- Loops from two edits that each looked fine. One person points B at C during a merge, another later points C at A. Both changes pass review alone.
- Chains left by a migration. Old canonicals point at URLs that now declare a newer canonical of their own.
- A canonical to a URL that is itself a duplicate. Google’s documentation also warns against specifying different canonical URLs for the same page through different techniques, which a chain can hide.
- Slash and case variants. Because URLs are compared exactly after parsing, a chain that
depends on
/pageversus/page/shows up as ending outside the set.
Related tools and reading
Sources
- 1.What is canonicalization - Google Search CentralPrimary
- 2.Consolidate duplicate URLs - Google Search Central
Frequently asked questions
What is a canonical chain?
A chain is when page A's rel=canonical points to page B, and page B's own canonical points on to page C instead of to itself. Each duplicate should point straight at the final URL, and that final URL should carry a self-referencing canonical.
Why can't this tool fetch the pages and follow the chain itself?
A browser page cannot read another origin's HTML through a plain fetch call without that origin explicitly allowing it with CORS headers, which most sites do not set for arbitrary pages. Pasting the pairs sidesteps that limit entirely.
Is a two-hop canonical chain always wrong?
It is not against any explicit rule, since Google's documentation does not name a maximum chain length. It is still unnecessary indirection once the final URL is known, and it hides a loop until someone walks the whole chain.
What counts as a loop here?
The resolver stops and flags a loop the moment a hop points at a URL already visited earlier in the same walk, including two URLs that simply point at each other.
Why does a URL with and without a trailing slash count as different?
Each URL is normalized by the browser's URL parser, which adds a slash to a bare domain but otherwise keeps paths as typed. So /page and /page/ are two different URLs here, just as they can be two different URLs to a crawler.
Related reading
Tools
Image lazy loading and width/height checker
Image lazy loading checker: paste HTML to test every img tag for width and height, lazy loading on the likely LCP image. Free, runs in your browser.
Tools
Noindex, canonical and sitemap conflict checker
Noindex, canonical and sitemap conflict checker: see where one page's three signals contradict Google's own guidance. Free, runs in your browser.
Tools
Open Graph tag checker for required og properties
Open Graph tag checker: tests pasted og meta tags for the four required properties, relative URLs, duplicates and og:type. Free, runs in your browser.