AnyTool
Your files never leave your device. All processing happens locally in your browser.

How do I check whether my page’s canonical tag is correct — without uploading the page?

Open AnyTool’s Canonical Tag Checker, open your page and copy its HTML source (View Source / Ctrl+U), paste it in, and optionally add the page’s own URL. The tool parses the HTML in your browser with the DOMParser, extracts the existing <link rel="canonical"> (recording whether it’s in the <head> or stray in the <body>), and reads og:url and the robots meta. It then runs a full audit: is a canonical present? exactly ONE (multiple canonicals conflict and Google may ignore all of them)? in the <head> (a canonical in the <body> is ignored)? an absolute URL (a relative one is ignored)? https? self-referencing versus the page URL you entered? consistent with og:url? no trailing-slash / www / http-vs-https / letter-case mismatch, and not combined with a noindex? You get the detected canonical URL, a clear verdict (looks good / issues found / none found) and an issues list — each finding with the specific problem and how to fix it. Everything runs in your browser, so your page HTML is never uploaded. A canonical is only a HINT (Google may still pick a different canonical) and this can’t confirm the target returns 200 / is indexable, so verify the chosen canonical in Google Search Console’s URL Inspection. To CREATE a canonical, use the sibling Canonical Tag Generator.

  • Paste your page HTML → the existing rel="canonical" is extracted and audited
  • Checks: present, exactly one, in <head>, absolute, https, self-referencing, og:url match, no noindex conflict
  • Add the page’s own URL to catch trailing-slash / www / http-vs-https / case mismatches
  • 100% client-side — page HTML never uploaded; safe for staging / unreleased pages
  • Honest: a canonical is a hint (Google may override); can’t verify the target is 200/indexable — confirm in Search Console

What is

Canonical tag checking (rel=canonical audit)

Canonical tag checking is the process of auditing the rel="canonical" link a page already declares, to confirm it correctly tells search engines which URL is the preferred (canonical) version to index. A correct canonical is present, appears exactly once, sits inside the <head> (a canonical in the <body> is ignored), uses a full absolute https URL (a relative one is ignored), and — for a page that should be indexed as itself — is self-referencing (it equals the page’s own URL). Common failures are a missing canonical, multiple conflicting canonicals, a canonical in the body, a relative or http URL, a mismatch with og:url, and combining a canonical with a noindex. The canonical is only a hint — Google may still choose a different canonical from its own signals — so it should be verified in Search Console’s URL Inspection.

SEO & Web

Related terms

rel=canonicalCanonical URLSelf-referencing canonicalDuplicate contentog:urlnoindexURL InspectionCanonical Tag Generator

Frequently Asked Questions

The Checker AUDITS the canonical already in your pasted page HTML — is it present, one-only, in the head, absolute, self-referencing? The Generator CREATES a new canonical tag from a preferred URL.

They are siblings for opposite jobs. The Canonical Tag Checker is an auditor: you paste your page’s HTML source and, optionally, its URL, and it extracts the existing <link rel="canonical"> and validates it — present, exactly one, in the <head>, absolute, https, self-referencing versus the page URL, consistent with og:url, and not combined with a noindex — returning a verdict and a fix for each issue. The Canonical Tag Generator does the reverse: you give it the preferred URL and it builds the correct <link rel="canonical"> tag (and the HTTP Link-header version) for you to paste into your <head>. Use the Checker to audit a page you already have, and the Generator to create a canonical from scratch. Both run 100% in your browser.

The usual reasons: there are multiple conflicting canonicals, the canonical is in the <body> instead of the <head>, or it’s a relative URL — Google ignores all three. The checker flags each one.

A rel="canonical" link is only honoured when it appears exactly once, inside the <head>, as an absolute URL. If a page declares several canonicals they conflict and Google may ignore all of them and pick its own; a canonical placed in the <body> (often injected by a script) is ignored; and a relative href like /page is ignored because Google requires an absolute URL. The Canonical Tag Checker catches all three by parsing your pasted HTML — it counts the canonical tags, records whether each is in the head or the body, and checks that the href is a full absolute https URL — and it also flags a canonical combined with a noindex, which are contradictory signals. Even when your tag is technically valid, remember the canonical is only a hint, so confirm the canonical Google actually chose in Search Console’s URL Inspection.

For a page that should be indexed as itself, yes — a self-referencing canonical is best practice. Enter the page’s URL and the checker flags trailing-slash, www, http-vs-https and case mismatches.

A self-referencing canonical — where a page’s canonical equals its own URL — is the recommended best practice for any page you want indexed as itself, because it removes ambiguity for crawlers. When you enter the page’s own URL, the Canonical Tag Checker compares it to the detected canonical and reports the exact difference if they don’t match: a protocol difference (http vs https), a www vs non-www host, a trailing-slash difference, a letter-case difference in the path, or a genuinely different path. If you are intentionally canonicalising a duplicate to a master URL, a non-self-referencing canonical is expected — the tool says so — but you should confirm the target is the right URL and returns 200.

Paste the HTML source. Your browser can’t fetch most live URLs (CORS) and there’s no server proxy, so the URL box only works for CORS-enabled or same-origin pages.

Because the tool is 100% client-side with no server proxy — which is what keeps your page private — your browser can only fetch pages that explicitly allow cross-origin requests (CORS) or are on the same origin. Almost all live sites block that, so the reliable path is to open your page, use View Source (Ctrl+U), copy the HTML and paste it in. The optional “try to fetch” box is there for the rare CORS-enabled case; when it fails it tells you to paste the source instead. Note the checker reads only the HTML canonical — it can’t see an HTTP Link: response-header canonical, which could conflict — and it can’t confirm the canonical target returns 200 or is indexable, so verify the final canonical in Google Search Console’s URL Inspection.

Detailed Explanation

How It Works

What the Canonical Tag Checker Audits

The Canonical Tag Checker is the AUDITOR counterpart to the sibling Canonical Tag Generator: instead of creating a <link rel="canonical"> from a preferred URL, it validates the canonical a page ALREADY declares. The user pastes the page’s HTML source (View Source / Ctrl+U) and, optionally, the page’s own URL. A small, pure, well-typed engine (canonicalCheckEngine.ts) parses the HTML with the browser’s DOMParser and extracts every <link rel="canonical"> — recording whether each sits inside <head> (where it is honoured) or is stray in <body> (where it is ignored) — plus the <meta property="og:url"> and <meta name="robots"> so it can cross-check consistency. It then runs a full audit and returns the detected canonical URL, a clear verdict (looks good / issues found / none found) and an ordered issues list (errors → warnings → info) where every finding names the specific problem and its fix. It reuses the sibling engine canonicalEngine.ts (isAbsoluteUrl, escapeHtml) and does not modify it.

  • Audits the EXISTING canonical in pasted page HTML — distinct from the Generator, which creates one
  • Parses with the DOMParser; finds every rel="canonical" and whether it is in <head> or <body>
  • Also reads og:url and the robots meta to cross-check consistency and the noindex conflict
  • Optional page URL enables the self-referencing / trailing-slash / www / http / case checks
  • All parsing is pure client-side JavaScript — no server call, no CDN, no upload, no crawl
Methodology

The Checks It Runs and How the Verdict Is Reached

auditCanonical(html, pageUrl?) applies the real-world rules that decide whether Google honours a canonical. PRESENT: a page with no canonical is a warning (Google will pick one from its own signals; add a self-referencing canonical). EXACTLY ONE: multiple rel="canonical" links are an error because conflicting canonicals are contradictory and Google may ignore all of them and choose its own. IN <head>: a canonical found in the <body> (often script-injected) is an error because it is ignored — only a head canonical counts. ABSOLUTE: a relative or empty href is an error because Google ignores relative canonicals; the tool suggests the absolute form. HTTPS: an http canonical is a warning. SELF-REFERENCING: when the page URL is supplied, the canonical is compared to it after a neutral normalization that folds only the case-insensitive scheme + host and drops the fragment — so a match confirms a self-referencing canonical, and a mismatch is reported with the exact difference (protocol, www vs non-www, trailing slash, path letter-case, or a genuinely different path), noting that an intentional duplicate→master canonical is legitimate. OG:URL CONSISTENCY: an og:url that differs from the canonical is a warning. NOINDEX CONFLICT: a canonical combined with a robots noindex is a warning because the two directives contradict each other. Findings are sorted errors → warnings → info → pass, and the verdict is “none found” when there is no canonical, “issues” when any error or warning fires, and “good” otherwise.

  • Present? exactly one? in <head>? absolute? https? self-referencing? og:url match? not noindexed?
  • Multiple canonicals or a body canonical are ERRORS (Google ignores them); http is a warning
  • Self-ref compare folds only scheme+host case and drops the fragment, so www / slash / case diffs surface
  • Reports the exact mismatch type: protocol, www vs non-www, trailing slash, path case, or different path
  • Verdict: none found / issues found / looks good, from errors → warnings → info → pass ordering
Limitations

Paste Source (CORS), a Canonical Is a Hint, Confirm in Search Console

The tool is explicit about three honest limits. First, paste the page SOURCE: because it is 100% client-side with NO server proxy (which is what keeps your page private), your browser can only fetch CORS-enabled or same-origin pages — almost all live sites block cross-origin requests, so the reliable path is View Source (Ctrl+U) → copy → paste; the optional “try to fetch” box is only for the rare CORS-enabled case and, on failure, tells you to paste instead. Second, a canonical is a HINT, not a directive: even a technically perfect canonical can be overridden because Google weighs a cluster of signals — internal links, sitemaps, redirects, HTTPS preference and URL cleanliness — and may pick a different canonical, so the tool advises confirming the canonical Google actually chose in Google Search Console’s URL Inspection. Third, it checks only the HTML canonical you paste: it CANNOT confirm the canonical target returns HTTP 200, isn’t a redirect and is actually indexable (that needs a live crawl), and it cannot see an HTTP Link: response-header canonical, which could conflict with the HTML one. To CREATE a canonical tag rather than audit one, the sibling Canonical Tag Generator is the right tool.

  • Paste your page source — browser can’t fetch most live URLs (CORS); no server proxy keeps it private
  • A canonical is a HINT: Google may pick a different canonical from links, sitemaps, redirects and HTTPS
  • Can’t verify the target returns 200 / is indexable — confirm in Search Console’s URL Inspection
  • Reads only the HTML canonical, not an HTTP Link: header canonical (which could conflict)
  • To create a canonical instead of auditing one, use the sibling Canonical Tag Generator
Canonical tag checking: in-browser (AnyTool) vs online canonical checkers
CapabilityAnyToolTypical online checkers
ProcessingRuns entirely in your browser (DOMParser)Sends your page / URL to a server
Your pageHTML never uploaded, works offlinePage or URL crawled server-side
Staging / unreleased pagesSafe — nothing leaves the deviceExposed to a third-party service
InputPaste your page HTML source (+ optional page URL)Often a URL the tool crawls
ChecksPresent, one-only, in <head>, absolute, https, self-ref, og:url, noindexVaries
Self-referencing checkCompares canonical vs the page URL you supplyOften only if it crawls the URL
Verdict + fixesClear verdict + a specific fix per issueVaries
HonestySays a canonical is a hint; confirm in Search ConsoleOften implies it is authoritative
Cost / signupFree, no signupOften gated or ad-heavy

AnyTool audits a page’s existing canonical locally from pasted HTML and uploads nothing, which is safe for staging or unreleased pages. It extracts and validates the HTML canonical but cannot confirm the target returns 200 / is indexable and cannot see an HTTP header canonical — and a canonical is only a hint Google may override, so confirm the chosen canonical in Google Search Console’s URL Inspection. To create a canonical, use the sibling Canonical Tag Generator. Comparison as of July 2026.