Canonical Tag Checker

Paste a page HTML into this canonical tag checker and it lists every canonical tag in the code, shown exactly as written, then tests each one for count, placement, and form. Add the current page URL and it also checks self reference, trailing slash and www consistency, and flags a canonical that points at a different domain.

The four things this canonical tag checker cannot do

Read these before you trust any result, because they set the limits of what a paste can prove.

• It cannot see a canonical delivered in the HTTP Link header. Headers never appear in page source, so a tag that looks missing here may still exist at header level.
• It cannot load the canonical target to check its status or any redirects in front of it.
• It cannot read the target own canonical or noindex, so chains and loops stay invisible from a single paste.
• It cannot report the canonical Google actually selected for the page. Only Search Console shows that.

Everything else about the tag itself can be judged from the code, and that is what this tool does. A missing result here is reported as no tag found in the pasted code, never as proof that the live page has no canonical.

How do you check a canonical tag here?

• Open the page, view its source, and copy the head section or the full page.
• Paste the code into the box above. Every canonical found is listed with its raw value, untouched.
• Read the checks under the list. Each one is marked pass, check, or fix, with the reason written out.
• Add the current page URL if you want the comparison checks. The URL is only compared against the tag. It is never fetched.
• Compare the canonical with the og:url in the same paste, which this tool does for you, and review any hreflang alternates listed at the end.

The run happens in your browser and nothing is uploaded, so staging pages and templates still under review are safe to paste.

What makes a canonical tag pass its checks?

Start with presence and count. A page should carry one canonical, and exactly one. Two canonicals with different targets are worse than none, because crawlers may ignore both rather than pick a side. Next comes placement. The tag belongs inside the head of the page. A canonical printed in the body is ignored by search engines, a classic side effect of a template bug or a misplaced plugin hook.

Form matters too. An absolute URL, starting with the full protocol and domain, leaves nothing to interpretation, while a relative path asks the crawler to work out the rest. The protocol check looks for https rather than http, since pointing a secure page at its insecure twin invites a redirect hop you never planned. When you add the page URL, the checker also tests whether the canonical points back at the page itself, whether the trailing slash habit matches between the two, and whether one uses www while the other drops it. Small mismatches like those are how duplicate versions of a page survive for years.

Why test a canonical from a paste at all?

Because the moments when canonicals break are the moments before a page goes live. A new template ships with the test domain still in the tag. A staging build gets copied to production with its own address baked in. A plugin update starts printing a second canonical next to the theme one. A URL based fetcher cannot reach any of those pages, since they sit behind logins or do not exist in public yet.

A paste reaches all of them. You copy the source from your CMS preview or your staging build, and the same checks run that you would want on the live page. Catching a cross-domain canonical in review costs a minute. Catching it after Google has spent a month crediting the wrong domain costs far more.