Canonical Tag Checker, Spot Mismatched URLs
Check whether a page's canonical tag correctly matches its own URL or points elsewhere.
Filled automatically when fetching a URL — required when pasting HTML directly, since the HTML alone doesn't say what URL it's served at.
- Paste HTML or fetch a URL to check its canonical tag.
How it works
- 1
Fetch a URL or paste HTML
Enter a live URL and click Fetch, or paste a page's HTML directly.
- 2
Confirm the Page URL field
This fills automatically when fetching. When pasting HTML, enter the page's actual URL yourself.
- 3
Review the report
Check protocol, domain, path, and query parameters individually, along with an overall self-referencing verdict.
- 4
Confirm any flagged differences are intentional
A non-matching canonical isn't automatically wrong, verify it reflects an intentional pattern like pagination or consolidation.
About the Canonical Tag Checker, Spot Mismatched URLs
A canonical tag is a quiet instruction to search engines about which version of a page is the real one, and when it's wrong, the mistake rarely shows up as an obvious error, pages just stop ranking, or an entire site's canonicals silently all point back to the homepage. This tool checks a page's canonical tag against its actual URL, using real comparison logic rather than a plain string match, so genuine mistakes get flagged clearly while intentional, legitimate uses of a non-self-referencing canonical don't.
Why a naive comparison gives false alarms
A page's live URL almost never matches its canonical byte for byte, tracking parameters like utm_source get added by ad platforms and email tools, a trailing slash may or may not be present, and none of that is actually a problem, it's often exactly what a correct canonical is supposed to strip away. This tool ignores known tracking parameters when comparing URLs, and treats a canonical that correctly excludes them as a pass rather than a mismatch, which is the opposite of what a simple string comparison would report.
The specific bug worth watching for: canonical to the homepage
One particular misconfiguration is common enough to call out by name, a CMS template bug that causes every page on a site to output a canonical pointing at the homepage instead of itself. Because it's the same tag on every page, it's easy to miss during a spot check of just one or two pages, and the effect is severe, it can tell search engines that an entire site's worth of content is duplicate of the homepage. This tool checks for that pattern specifically, a canonical resolving to the root path while the actual page isn't the homepage, and flags it distinctly from an ordinary path mismatch.
When pointing elsewhere is actually correct
A non-self-referencing canonical isn't automatically a mistake, a paginated series correctly pointing every page at page one, syndicated content pointing back at its original source, or several URL variants of the same product consolidating onto one preferred version are all legitimate, intentional uses of the exact same mechanism that breaks a site when it's misconfigured. This tool reports those cases as something to confirm rather than a hard failure, showing exactly what differs so the intent can be verified, rather than assuming every mismatch is automatically wrong.
Why the page's own URL has to be entered separately
A page's HTML never states its own URL anywhere inside itself, that information only exists in how the page was requested, which is why this tool needs a separate Page URL field to compare against. Fetching a live URL fills this in automatically from the actual address that was requested, but pasting HTML directly means providing that URL manually, since there's no other way to know what address a chunk of pasted markup is meant to represent.
Runs entirely in your browser
Comparison happens locally against whatever HTML and URL you provide, nothing is uploaded. Fetching a URL does route through this site to retrieve that page's content, but everything else, including the actual comparison logic, runs entirely on your device. Since a site's canonical tags and its XML sitemap should generally agree with each other, our XML Sitemap Validator is worth checking too, both part of the same Technical SEO collection this tool belongs to.
Frequently asked questions
Is it always wrong for a canonical to point somewhere other than the page itself?
No, pagination series, syndicated content, and consolidating duplicate URL variants are all legitimate uses of a non-self-referencing canonical. This tool flags differences for you to confirm rather than treating all of them as errors.
Why doesn't a tracking parameter on my URL show up as a mismatch?
Common tracking parameters like utm_source are ignored when comparing, since a canonical correctly excluding them is standard practice, not a problem to flag.
What's the canonical-to-homepage issue this checks for specifically?
A CMS misconfiguration where every page's canonical points at the homepage instead of itself, which can tell search engines an entire site's content is duplicate. This is flagged distinctly from an ordinary path mismatch since it's a much more serious pattern.
Why do I need to enter the page's URL separately?
A page's HTML doesn't contain its own URL anywhere, that only exists in how the page was requested. Fetching a live URL fills this in automatically; pasting HTML requires entering it manually.
What happens if a page has more than one canonical tag?
It's flagged as a real problem. Google has stated that behavior becomes unpredictable when more than one canonical tag is present on a page.
Does a www versus non-www mismatch get treated differently from other domain differences?
Yes, a difference that's only the www prefix is called out specifically, since it's almost always accidental, separate from a canonical pointing to a genuinely different domain, which can be an intentional pattern.
Does a trailing slash difference count as an error?
It's noted but not treated as a failure, since search engines generally handle a trailing slash difference as effectively equivalent.
Is my page's HTML or URL sent to a server?
Fetching a URL routes through this site to retrieve that page's content, but the actual comparison and validation logic all run locally in your browser.