Why do most of my results say "Unknown (CORS/network)"?

Because your browser is doing the checking directly, and browsers block reading the response status of a cross-origin request unless the target server explicitly allows it via CORS headers - most ordinary websites don't send those headers for arbitrary requests. This is expected behavior, not a bug, and it's the same restriction every client-side tool like this one runs into; a server-side link checker doesn't have this limitation because it isn't running inside a browser's security sandbox.

So when is this tool actually useful?

Mainly for checking a site's own internal links, since same-origin requests aren't subject to CORS restrictions at all and will reliably return a real status. It's also useful for links to CORS-friendly targets like API documentation sites or CDNs that do send permissive headers. For a full audit of external links across a large site, a server-side crawler is the more reliable tool.

Why only 50 links, and only 5 at a time?

A page can easily contain hundreds of links, and firing that many concurrent fetch requests from a browser tab can make the page unresponsive or trip a target site's own rate limiting. Capping at the first 50 links found, 5 requests in flight at a time, keeps the check fast and the browser responsive while still covering the links most pages actually need checked.

Why does the tool try HEAD first and then GET?

A HEAD request asks a server for just the response status and headers without downloading the full page body, which is faster and lighter for a simple status check. Some servers don't implement HEAD correctly and return a 405 Method Not Allowed even though the resource exists, so this tool automatically retries with a full GET request in that case rather than reporting a false error.

Broken Link Checker - Find Dead Links in a Page's HTML

Overview

Introduction

Dead links quietly erode a page's usability and, over time, its search rankings, but manually clicking through every link on a page to check it is tedious and easy to give up on halfway through.

This tool automates the tedious part: paste or fetch a page's HTML, and it pulls out every unique link and checks each one's HTTP status directly from your browser, so you get a categorized list instead of a wall of anchor tags to click one by one.

What Is Broken Link Checker?

A link extraction and status checker that parses <a href> elements out of HTML and fetches each unique, absolute http(s) link to report its status: OK (2xx), Redirect (3xx), a client or server error (4xx/5xx), or Unknown when the browser can't read the response due to CORS.

It runs entirely client-side, with no backend crawler behind it, which is why cross-origin results are honestly labeled "Unknown" rather than guessed at or reported as broken when they might not be.

How Broken Link Checker Works

HTML is parsed with the browser's own DOMParser to collect every <a href> element, resolving relative links against the page's URL when it was fetched directly (relative links in pasted-only HTML with no known source URL are skipped, since there's no base to resolve them against).

Unique links are checked 5 at a time, up to the first 50 found on the page, using a HEAD request first (falling back to GET if the server doesn't support HEAD). Each result is categorized by status code range, with anything that fails outright due to CORS or a network error reported as Unknown rather than assumed broken.

When To Use Broken Link Checker

Spot-checking a page's internal navigation and content links after a site restructuring, redesign, or CMS migration that might have broken relative paths.

Quickly verifying a handful of external links in a blog post or documentation page before publishing, especially links to CORS-friendly targets like API docs or CDN-hosted assets.

Often used alongside XML Sitemap Validator and Meta Tag Checker.

Features

Advantages

Runs entirely in the browser with no server-side crawler, so there's nothing to install or configure to get a quick check.
Categorizes results honestly by what the browser can actually observe, distinguishing a confirmed error from a CORS-blocked unknown instead of conflating the two.
Caps concurrency and total link count automatically, so checking a link-heavy page doesn't freeze the tab or trigger a target site's rate limiting.

Limitations

Most links to other domains will report as Unknown due to browser CORS restrictions, which is a fundamental limitation of any client-side checker, not something this tool can work around.
Only the first 50 unique links found are checked; a page with more links than that needs to be checked in sections, or with a server-side crawler for full coverage.

Examples

A page with one working and one broken internal link

Input

<a href="/about">About</a>
<a href="/old-page-removed">Old page</a>

Output

https://example.com/about - OK - HTTP 200
https://example.com/old-page-removed - Client error - HTTP 404 Not Found

Both are same-origin links (fetched from example.com), so CORS doesn't block reading their real status codes.

An external link on a site with strict CORS

Input

<a href="https://example.org/resource">External resource</a>

Output

https://example.org/resource - Unknown (CORS/network) - Blocked by CORS or a network error

The browser can't read the response status for this cross-origin request because example.org doesn't send permissive CORS headers - this doesn't mean the link is actually broken.

Best Practices & Notes

Best Practices

Fetch the page directly (rather than pasting HTML) whenever possible, since that gives the tool a base URL to correctly resolve relative links against.
Treat an "Unknown" result as inconclusive, not as evidence of a broken link; manually click through a sample of them if you need certainty on external links.
Re-check a page after fixing reported errors, since a single broken link is sometimes a symptom of a wider pattern (like a renamed URL slug) affecting other links too.

Developer Notes

Concurrency is capped at 5 simultaneous requests via a simple worker-pool pattern over a shared cursor index, and the total checked is capped at 50 links; both limits exist to keep the browser tab responsive on link-heavy pages, not because of any external rate limit.

Broken Link Checker Use Cases

Checking a page's internal links for 404s after a site restructuring or URL slug change
Verifying outbound links in a blog post or documentation page before publishing
Spot-checking a small site's navigation for dead links without setting up a dedicated crawler

Common Mistakes

Assuming every "Unknown" result is a broken link, when it usually just means the target blocked the browser's cross-origin status check, not that the link is actually dead.
Pasting HTML without fetching the source page first, then being confused why relative links (like href="/about") aren't checked; there's no base URL to resolve them against in that case.

Tips

For a thorough audit of external links across a whole site, use this tool for internal links and a dedicated server-side link-checking service for external ones.
If a same-origin link unexpectedly shows Unknown, check whether the page itself sends restrictive CORS headers on its own resources; that's rarer but does happen with some CDN or asset-serving setups.

Broken Link Checker