Canonical Tag Checker

How to Use This Tool

1. 1

   Enter the page URL

   Use the exact URL you want to check. Since a canonical's whole job is to distinguish between near-identical URLs, the parameters and the trailing slash matter here.

2. 2

   Check where the canonical was found

   Head, body or Link header. A canonical in the body looks correct in the source and does nothing at all, which makes it one of the harder problems to spot by eye.

3. 3

   Read the target panel

   Status, whether it redirects, whether it allows indexing, and what its own canonical says. This is where the real failures show up.

4. 4

   Work the findings

   Failures break the consolidation outright. Warnings are things that work but are fragile or ambiguous.

What a Canonical Actually Does

A canonical tells search engines that several URLs are the same page, and which one should be treated as the real version. The ranking signals from the duplicates are consolidated into the nominated URL, and that URL is the one shown in results.

The reason it exists is that sites generate duplicate URLs constantly without anyone deciding to. Tracking parameters, session identifiers, sort orders, filters, print versions, AMP pages, HTTP and HTTPS, www and non-www, trailing slash and no trailing slash. Every one of those is a distinct URL as far as a crawler is concerned.

Without a canonical, search engines pick one themselves. They are reasonably good at it, and the choice may not be yours — which is the argument for declaring one rather than leaving it to be inferred.

The critical thing to understand is that it is a hint, not an instruction. Google weighs it against other signals — internal links, sitemaps, redirects, which version has content — and can pick a different URL. Search Console's URL Inspection tool reports both the canonical you declared and the one Google chose, and they are not always the same.

The Canonical in the Body

Google only reads canonicals inside the head. One placed in the body is ignored completely, which is a genuinely difficult problem to see, because the tag itself is perfectly well formed and appears in the page source exactly as you would expect.

It usually happens one of two ways. A script injects the canonical after the page loads and appends it to the wrong place. Or the HTML is malformed earlier in the head — an unclosed tag, a stray element that is not allowed there — and the browser implicitly closes the head, so a canonical that looks like it is in the head has actually been moved into the body during parsing.

The second case is nastier because the source looks fine. What matters is where the tag ends up after parsing, which is what this checker reports.

The fix in both cases is the same: put the canonical in the head, server-rendered, before anything that could break the parse.

What Goes Wrong at the Other End

• The target 404s. There is nothing to consolidate into, so the canonical is discarded and the page is left to be judged on its own — usually after months of its signals going nowhere.
• The target redirects. You are naming a URL that is not the real page. Point the canonical at the redirect's destination instead.
• The target carries a noindex. This is the worst combination available: the page hands its signals to a URL that has asked not to be indexed, so neither ends up in the index.
• The target's canonical points somewhere else — a chain. Search engines do not reliably follow more than one hop. Point directly at the final URL.
• The target points back at this page — a loop. Neither page nominates itself, so search engines break the tie themselves and the declaration achieves nothing.
• The target is blocked in robots.txt. The canonical cannot be verified because the crawler is never allowed to fetch the page it names.

Near Misses Are Worse Than Obvious Mistakes

A canonical pointing at a completely different page is easy to spot. The expensive ones differ from the current URL by a single character.

HTTP where the page is HTTPS. The www form where the site runs without it. A trailing slash the page does not have. A capital letter in a path, which is case sensitive and therefore a different URL entirely.

Each of these means the page is nominating a URL that either does not exist or is a redirect, and each one looks correct at a glance because the visible difference is almost nothing. This checker names the specific difference rather than reporting a generic mismatch.

The underlying fix is usually not the canonical at all. If your site answers on both www and non-www, or on both HTTP and HTTPS, that is a redirect problem — and the canonical is just where the symptom happened to surface. Our Redirect Chain Checker will show which forms actually resolve.

Canonical, Noindex or Redirect

Three tools that all remove a URL from results, and picking the wrong one is common.

• Canonical — when two URLs are genuinely the same content and you want their signals combined. The page stays accessible to visitors and its authority moves to the version you kept.
• 301 redirect — when the old URL should not exist any more. Stronger than a canonical because it is a directive rather than a hint, and it moves visitors too.
• noindex — when the page should exist for visitors but not appear in search. It throws away the page's signals rather than consolidating them, so it is the wrong choice for a duplicate.
• Nothing at all — when the pages are genuinely different. Canonicalising two distinct pages together removes one of them from search, and that is a mistake people make trying to be tidy.

Self-Referencing Canonicals

A page nominating itself is the default position for anything you want indexed in its own right, and it is worth setting explicitly even though search engines would probably reach the same conclusion.

The value is defensive. When someone reaches your page with a tracking parameter appended, the self-referencing canonical in the served HTML still names the clean URL, so the parameterised version consolidates back automatically. Without it, every campaign link is a potential duplicate.

It also documents intent. A page with no canonical might be missing one deliberately or by accident, and nobody auditing the site later can tell the difference.

The one thing to avoid is generating it from the current request URL, which some templates do. That produces a canonical naming whatever URL was requested — including the parameterised one — which defeats the entire purpose.

Where This Fits

The canonical is one of five signals that decide whether a page can be indexed, and a wrong one is only obvious when you look at it next to the others. Our Indexability Checker combines the canonical with the status code, robots.txt, the robots meta tag and the X-Robots-Tag into a single verdict.

If the canonical is fine and the page still is not ranking, the question moves elsewhere. The SEO Analyzer covers the on-page fundamentals, and the XML Sitemap Validator checks that the URLs you are submitting agree with the ones you are canonicalising to — a sitemap listing URLs that canonicalise elsewhere is a contradiction search engines have to resolve for you.

Frequently Asked Questions

Related Tools