How Google actually treats your canonical tags
rel=canonical might be the most overestimated line of HTML in SEO. Teams treat it as a command. Google treats it as a suggestion, weighs it against everything else it knows, and then does whatever it thinks is right.
Google has been explicit about this for years: the canonical tag is a hint. In practice it is a strong hint, and most of the time Google follows it. But 'most of the time' is exactly why the Page indexing report has a bucket called 'Duplicate, Google chose different canonical than user'. If you have never looked at that bucket, this post is for you.
What canonicalization actually is
When Google finds multiple URLs with the same or very similar content, it clusters them, picks one representative URL for the cluster, and concentrates crawling and ranking on that one. That chosen URL is the canonical. Your tag is one input into the choice, not the choice itself.
The other inputs Google weighs against your tag:
Redirects, which are a far stronger signal than the tag.
Which URL your internal links actually point to.
Which URL appears in your XML sitemaps.
HTTPS over HTTP, and shorter, cleaner URLs over parameter soup.
Which version external links point to.
hreflang annotations, which expect self-referencing canonicals to function.
The pattern to internalize: canonicals work when all your other signals agree with them. A canonical tag fighting your internal links usually loses.
When Google ignores your canonical
In audits, the same handful of situations account for nearly every overridden canonical:
The two pages are not actually duplicates. Canonicalizing genuinely different content does not consolidate it; Google compares the pages, decides they are distinct, and discards the hint.
Conflicting signals. The tag says URL A, but the sitemap lists URL B and every internal link points at URL B. Google sides with the majority.
The canonical target is broken. Pointing at a URL that 404s, redirects, or carries noindex invalidates the hint, and Google picks its own winner.
Sitewide canonical to the homepage, usually a template bug. Google recognizes the pattern as nonsense and ignores it.
HTTP and HTTPS or www and non-www disagreements between the tag and the served URL, which turn your hint into noise.
Canonical vs noindex vs redirect
These three get confused constantly, and the confusion causes real damage. They answer different questions.
A 301 redirect says: this URL should not exist anymore, go here instead. It is the strongest consolidation signal and the right tool when users have no reason to see the duplicate. If nobody needs to load the page, redirect it. Full stop.
A canonical says: both URLs work for users, but index and credit this one. Print views, tracking parameters, session variants, syndicated copies. Users still get the page; Google consolidates the signals.
A noindex says: keep this out of the results. It does not consolidate anything. Signals pointing at a noindexed page mostly evaporate, and Google crawls long-term noindexed pages less and less over time.
And the classic anti-pattern: putting noindex and a canonical on the same page. That page is simultaneously saying 'this page equals that one' and 'drop this page from the index', two statements that contradict each other. Google has advised against combining them. Pick the one that matches your intent.
Cross-domain canonicals
The canonical tag works across domains, and it is the standard mechanism for syndication: the partner republishing your article points their copy back at your original. When the content matches closely, Google generally honors it.
Two caveats. First, it remains a hint, and if the syndicating domain is dramatically stronger than yours, Google occasionally picks the copy anyway; getting partners to noindex their copy is the safer arrangement. Second, in a world where AI Overviews and LLM crawlers are summarizing whatever version they encounter, being the recognized canonical source matters beyond the classic blue links. Set the tags up properly before syndicating, not after your own article starts losing to its copies.
Implementation bugs that keep showing up
The same defects show up in most audits, regardless of platform or company size:
Canonical to a URL that redirects. The tag points at a URL that 301s elsewhere, creating a hint chain. Point directly at the final destination.
Protocol and www mismatches. The site serves https://www, the canonical says http:// or drops the www. Usually a hardcoded template string that predates the HTTPS migration.
Staging URLs in production. A canonical pointing at staging.example.com ships to production and quietly tells Google the live site is the duplicate.
Paginated series canonicalizing to page one. Pages 2 through N are not duplicates of page 1, and this pattern tells Google to ignore everything linked from the deeper pages. Each paginated page should self-canonicalize.
Multiple canonical tags in one head, typically from two plugins fighting. Conflicting hints get ignored entirely.
A canonical that appears in the head of the raw HTML but moves or changes after JavaScript runs. If the rendered DOM disagrees with the source, you are sending Google two different hints.
An unclosed tag above the canonical that pushes it into the body during parsing, where it stops counting. This one is invisible unless you check the parsed DOM.
Auditing what Google actually chose
You declared canonicals. Google chose canonicals. The audit is about the gap between the two, and Search Console shows you both.
Open the Page indexing report and work through 'Duplicate, Google chose different canonical than user' and 'Duplicate without user-selected canonical'. These buckets are Google telling you where it disagrees with you.
Run sample URLs through URL Inspection and compare the user-declared canonical against the Google-selected canonical. A mismatch on a template usually means a mismatch across every page using it.
Crawl the site with Screaming Frog and pull the canonical reports: canonicals pointing at non-indexable URLs, canonical chains, and pages whose raw and rendered canonicals differ.
Spot-check with curl and view the raw HTML head directly. DevTools shows the rendered DOM, which hides exactly the class of bug you are hunting.
For every legitimate mismatch, fix the surrounding signals too: update internal links to the canonical version, list only canonical URLs in sitemaps, and confirm no redirect contradicts the tag.
One habit worth building: whenever a page underperforms mysteriously, inspect its Google-selected canonical before anything else. A surprising amount of 'the page dropped' turns out to be 'Google consolidated the page into a variant nobody remembered existed'.
The mindset shift
Stop thinking of the canonical tag as a control and start thinking of it as testimony. Google cross-examines it against your redirects, your internal links, your sitemaps, and the content itself. When all the witnesses agree, your canonical stands. When they contradict each other, Google believes the evidence over the declaration, which is exactly what a careful judge would do.