Canonical URL Checker

Validate canonical URL tags on web pages for SEO. Checks self-referencing, accessibility, duplicates, relative URLs, and protocol issues.

What does Canonical URL Checker do?

This actor validates canonical URL tags on web pages. It checks both HTML <link rel="canonical"> tags and HTTP Link header canonicals. It verifies that the canonical URL is accessible, self-referencing when appropriate, absolute (not relative), and consistent between HTML and HTTP headers. Each page gets a validation score and specific issues to fix.

Canonical tags tell search engines which version of a page is the "master" copy. Misconfigured canonicals can cause pages to be deindexed, split link equity, or trigger duplicate content issues. This actor catches all of those problems in a single run.

The actor supports checking pages from any publicly accessible website. You can validate your own site, audit client sites, or compare canonical implementations across competitors -- all in a single batch run. Results are returned as structured JSON with a per-page validation score from 0 to 100.

Use cases

• Technical SEO specialist -- run a bulk canonical audit across hundreds of pages to catch misconfigurations before they affect rankings
• Content team lead -- verify that blog posts and landing pages point to the correct canonical after a CMS migration
• Agency SEO manager -- include canonical validation results in monthly technical SEO reports for clients
• E-commerce manager -- ensure product pages with URL parameters (sorting, filtering, pagination) all point to the clean canonical URL
• DevOps engineer -- add canonical checks to a CI/CD pipeline after deploying URL structure changes
• Freelance SEO consultant -- deliver quick canonical audits as a value-add service for new and existing clients
• Publisher -- ensure syndicated content pages use canonical tags to point back to the original source

Why use Canonical URL Checker?

• Batch processing -- check hundreds of URLs in a single run instead of clicking through pages one by one
• Structured JSON output -- every result includes a score, issue list, and detailed fields ready for dashboards or spreadsheets
• API and integration ready -- call it from your own scripts, schedule recurring runs, or connect to Zapier and Make
• Fast and lightweight -- uses direct HTTP requests, not a browser, so it finishes quickly and costs less
• Pay-per-event pricing -- you only pay for the pages you actually check, starting at $0.001 per URL
• Detects multiple issue types -- self-referencing, accessibility, duplicates, relative URLs, HTML vs HTTP header conflicts
• Validation score per page -- each page receives a 0-100 score making it easy to prioritize which pages need attention first

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	List of web page URLs to validate canonical tags for. Each URL is checked independently.

Input example

{
    "urls": [
        "https://www.google.com",
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://example.com"
    ]
}

Output example

{
    "url": "https://en.wikipedia.org/wiki/Web_scraping",
    "title": "Web scraping - Wikipedia",
    "canonicalUrl": "https://en.wikipedia.org/wiki/Web_scraping",
    "canonicalSource": "html",
    "isSelfCanonical": true,
    "isCanonicalAccessible": true,
    "canonicalStatusCode": 200,
    "canonicalMatchesUrl": true,
    "hasMultipleCanonicals": false,
    "isRelativeUrl": false,
    "issues": [],
    "issueCount": 0,
    "score": 100,
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Event	Price	Description
Start	$0.035	One-time per run
URL checked	$0.001	Per page checked

Example costs:

• 10 URLs: $0.035 + (10 x $0.001) = $0.045
• 100 URLs: $0.035 + (100 x $0.001) = $0.135
• 1,000 URLs: $0.035 + (1,000 x $0.001) = $1.035

Using the Apify API

You can call Canonical URL Checker programmatically from your own applications using the Apify API. The following examples show how to start a run, wait for it to finish, and retrieve the results.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/canonical-url-checker').call({
    urls: ['https://en.wikipedia.org/wiki/Web_scraping'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('automation-lab/canonical-url-checker').call(run_input={
    'urls': ['https://en.wikipedia.org/wiki/Web_scraping'],
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Canonical URL Checker works with all major automation and integration platforms available on Apify. You can connect it to Make (formerly Integromat) or Zapier to trigger workflows when canonical issues are found. Send results directly to Google Sheets for easy sharing with your team, or push alerts to Slack when pages fail validation. Use webhooks to get notified as soon as a run completes, or integrate with n8n for advanced automation pipelines. You can also schedule recurring runs on Apify to monitor canonical tags on a daily or weekly basis. All results are stored in Apify datasets and can be downloaded in JSON, CSV, or Excel format.

Tips and best practices

• Start with your most important pages -- check landing pages, product pages, and top-traffic URLs first to catch high-impact issues
• Run after every migration or URL change -- canonical tags are one of the most commonly broken elements during site migrations
• Compare HTML and HTTP header canonicals -- if both are present and disagree, search engines may pick the wrong one
• Watch for relative URLs -- canonical tags must use absolute URLs; relative paths are a common CMS bug
• Schedule weekly runs -- canonical issues can appear when new pages are published or templates change
• Check paginated pages -- pages using rel="next" and rel="prev" should have canonical tags pointing to themselves, not to the first page in the series

FAQ

What is a canonical URL tag? A canonical tag (<link rel="canonical">) tells search engines which URL is the preferred version of a page. It prevents duplicate content issues when the same content is accessible at multiple URLs (e.g., with query parameters, trailing slashes, or HTTP vs HTTPS).

What score should I aim for? A score of 100 means no issues were found. Any page below 100 has at least one canonical issue that should be investigated. Focus on pages with scores below 70 first, as those typically have critical problems like inaccessible or missing canonicals.

Can I check pages behind authentication? The actor fetches pages as a regular HTTP client without login capabilities. If your pages require authentication, they will not be accessible. Consider testing on staging environments with authentication disabled.

What happens when a page has both an HTML canonical and an HTTP header canonical? The actor checks both sources. If they disagree (point to different URLs), this is flagged as an issue because search engines may not know which one to follow. Google recommends using only one method to avoid conflicts.

What happens when a canonical URL returns a redirect? The actor checks the HTTP status code of the canonical URL. If the canonical URL redirects (301 or 302), this is flagged as an issue because the canonical should point directly to the final destination URL, not to a redirect.

How many URLs can I check in one run? There is no hard limit on the number of URLs per run. You can check thousands of URLs in a single run. The actor processes URLs concurrently for faster results.