Canonical URL: When to Set a Canonical Address and Which Mistakes Cost Traffic

A canonical tag, <link rel="canonical"> in a page's code, tells Google which of several similar addresses is the main one and should rank. You need it whenever the same content opens at different URLs: filters and sorting in an online store, http and https, www and non-www, UTM parameters, print versions. Canonical mistakes are invisible from the outside, the site keeps working as before, while traffic quietly leaks across duplicates or disappears together with the main page you accidentally "handed over" to another one. Below we cover when the tag is needed, how to check it and the eight mistakes we find most often in audits.

What rel="canonical" is and why Google needs it

Google does not like duplicate pages. When it finds five addresses with the same text, it has to pick one for the results and treat the rest as copies. It makes that choice itself, by its own signals, and not always the way you would like. The canonical tag gives it a hint: "of these five, this one is the original". It sits in the <head> and looks like this:

<link rel="canonical" href="https://example.com/catalog/chairs/">

Two things matter here. First, it is a hint, not a command. Google can ignore it if it decides you made a mistake, for example by pointing the canonical at a page with different content. Second, a canonical does not hide the page from visitors and does not redirect them. A person can open any of the addresses and see the content; the only thing that changes is which address appears in search and where Google consolidates the signals, including links pointing at the duplicates. The official description of the mechanism is in Google's documentation on consolidating duplicate URLs.

Canonical, 301 or noindex: which one to choose

Three tools solve a similar problem ("hide the extra stuff") but behave differently. Mixing them up is the most expensive mistake of all.

• A page with rel="canonical" stays visible to users; every URL opens.
• After a 301 the old URL opens the new one straight away, for people and bots.
• A noindex page opens but drops out of the results.

A simple rule: if people need the page but Google does not, and it has an "older sibling" with the same content, that is a canonical. If nobody needs the page, that is a 301. If people need the page but it has no equivalent and has no business in search, that is noindex.

When you need a canonical: seven typical situations

1. Filters and parameters in an online store. The address /chairs/?color=black&sort=price shows the same category as /chairs/. Without a canonical, Google sees hundreds of variants of one page. The exception: filters you deliberately turn into separate landing pages with their own copy and search demand ("black office chairs"); those need a canonical pointing at themselves.
2. Pagination. Pages like /blog/?page=2 are not duplicates of the first page, they hold a different list. A canonical from page two to page one hides every article that sits deeper from Google. Each pagination page should point to itself.
3. http and https, www and non-www. The four versions of a domain should collapse into one via 301 redirects, and a canonical on every page is the safety net in case a redirect fails somewhere.
4. UTM tags and ad parameters. ?utm_source=facebook, ?gclid=..., ?fbclid=...: a tagged address should carry a canonical to the clean address. This is the most common reason dozens of "advertising" copies of the home page end up in the index.
5. Print versions and mobile duplicates. /article/print/ or m.example.com point to the full version.
6. One product in several categories. If a chair opens both as /office/chair-x/ and as /sale/chair-x/, pick the main path and put it in the canonical on both.
7. Cross-domain. The same text on two of your sites, or an article a partner republished: the copy gets a canonical to the original. Google supports this across domains, but with the same condition: the pages have to be genuinely identical.

How to check which canonical Google actually sees

What is written in the code and what Google chose are two different things. Search Console has the URL Inspection tool: paste an address into the bar at the top, and in the Indexing block you will see two fields: "User-declared canonical" and "Google-selected canonical". If they match, all is well. If not, Google disagreed with something and you need to find out what: most often the pages are not identical, or the "canonical" target redirects, or it is blocked from indexing.

For a bulk check, any crawler such as Screaming Frog will do: it shows the canonical of every page and flags the ones that do not point to themselves. A quick manual check is to open the page source (Ctrl+U) and search for rel="canonical". If there are two tags, that is already a mistake. One more place a canonical can hide is the HTTP Link: header, visible in the developer tools on the Network tab or through an online header checker.

Eight canonical mistakes that cost traffic

In our audit experience, the canonical setup is broken in one way or another on roughly every third site that comes to us. Here is what we run into most often.

1. Canonical pointing to a noindex page. You tell Google "this is the main version" while that page carries a ban on indexing. The signals contradict each other and both pages end up dropping out of search.
2. Chains and loops. Page A points to B, B points to C, or A points to B and B points back to A. Google follows only one hop and eventually picks something of its own. A canonical should always lead to the final page, which points to itself.
3. Relative addresses. href="/catalog/chairs/" instead of the full https://example.com/catalog/chairs/ technically works, but any error in the base path turns it into something like https://example.com/catalog/catalog/chairs/. Absolute URLs only.
4. Every page canonicalized to the home page. A template classic where the address was hard-coded once in the header. The result: only the home page stays in search, and categories and products are treated as its copies. We have seen stores lose almost all of their search traffic this way within a couple of months.
5. Different canonicals in the HTML and the HTTP header. The CMS sets one, a caching plugin or CDN adds another. Google gets two hints and ignores both. Keep a single source.
6. Canonical pointing to a page that redirects or returns 404. After a URL structure change the old canonical stays in the templates, and every page points to an address that no longer exists.
7. Canonical between language versions. A Ukrainian page with a canonical to the Russian version (or the other way round) removes one of the languages from search. Language versions are linked through hreflang, and each has its own canonical.
8. Pagination canonicalized to page one. Described above: products from page two onwards stop existing for Google if there are no other paths to them.

A separate word on a hidden mistake: a canonical that changes depending on the parameter. The page /chairs/?page=3 has the canonical /chairs/?page=3, while /chairs/?page=3&sort=price suddenly gets /chairs/. The logic of "strip only some parameters" has to be spelled out explicitly, otherwise the programmer does whatever is simplest. All of this is a standard part of a detailed SEO audit, and that is where it should be caught, not after the rankings drop.

How to implement canonicals on popular platforms

• WordPress: the page editor has a "Canonical URL" field for manual values; check tag pages and author archives.
• OpenCart: filters need custom work or an SEO module.
• Shopify: a product in a collection, /collections/x/products/y, already points to /products/y.
• Magento / Adobe Commerce: enable "Use Canonical Link Meta Tag" for products and categories.
• Laravel, Next.js and others: generate the tag without query parameters except allowed ones (such as page), cover with tests.

On any platform, run a crawler after implementation and check three groups: filter pages, pagination and UTM-tagged addresses. That is where something is most often off. At Query we usually do this as part of technical optimization together with redirects, robots.txt and the sitemap, because these things only work as a set.

Where to start

• Open the source of the home page, any category and any product: is there a canonical, is it absolute, does it point to itself.
• Add ?utm_source=test to a category address and check whether the canonical stayed clean.
• In Search Console, in the Page indexing report, look at the group "Duplicate, Google chose different canonical than user": that is the list of places where Google disagreed with you.
• Check the second pagination page: its canonical should point to itself.
• If the site runs on a custom CMS, ask the developer to show where the address in the tag comes from, and put the parameter rules in writing.