Link Checker

Every broken link on your site is a small tax: on your visitors’ patience, on your search rankings, and on your own credibility. A dead link in a blog post from 2021 quietly rots there until someone notices, usually a visitor who bounces before you ever find out. Link Checker exists to make finding those dead ends fast enough that you’ll actually do it: paste a URL, and every link on that page gets checked live, in parallel, with results streaming in as they resolve rather than making you stare at a spinner for a minute.

The real cost of a broken link

Search engines treat broken links as a quality signal, and not a good one. Every 404 a crawler hits on your site burns a little of your crawl budget (the finite attention Google gives your domain on each visit) on a dead end instead of a page that matters. Internal links that 404 also break the flow of “link equity,” the ranking value that flows through your site’s internal linking structure; a broken link to your best landing page means that page gets a little less credit than it should. Outbound links are just as important: linking out to a resource that’s since disappeared makes an otherwise well-researched page look stale and unmaintained, both to readers and to anyone evaluating your site’s trustworthiness (E-E-A-T, in Google’s language). None of this is catastrophic on its own (one dead link won’t tank a page) but broken links accumulate. A site that’s been publishing for a few years without ever auditing its links usually has more of them than its owner expects.

How the parallel checker actually works

Checking a page’s links quickly is harder than it sounds. A page can carry anywhere from a handful of links to several hundred, and checking them one at a time (waiting for each request to time out or respond before starting the next) would take minutes for a link-heavy page and give you zero feedback while you wait. So Link Checker splits the job in two. First, it fetches your page once and extracts every link: it resolves relative URLs to absolute ones, classifies each as internal or external, captures the anchor text so you know where each link lives in your content, and dedupes repeats (a link to your homepage in the header and the footer counts once, with an occurrence count). Anything that isn’t actually checkable (mailto:, tel:, javascript:, bare # anchors) gets filtered into a separate skipped list with an honest reason, rather than silently vanishing from the count.

Then the checking itself happens in small, parallel batches: ten links per request, two requests running at once, so twenty links are being verified simultaneously at any moment. Each link gets a lightweight HEAD request first (we don’t need the page body, just the status code), with a strict timeout so one slow server can’t stall the whole scan; if a site refuses HEAD requests outright (some do, returning 403 or 405), we retry that one link as a minimal GET. The live counter and segmented progress bar fill in as each batch resolves: green for OK, amber for redirected, red for broken, so you can watch the picture assemble in real time instead of waiting for a single verdict at the end. A “Stop” button lets you bail out early on a huge page without losing the results you’ve already got.

One deliberate design choice: some sites detect automated link checkers and block them with unusual status codes: LinkedIn is the classic example, returning 999 to bots instead of a normal response, and Cloudflare-protected sites sometimes return a challenge page as a 403. A naive checker reports these as broken links, which is exactly wrong: the link works fine for an actual visitor, it’s the checker that got turned away. Link Checker recognises these patterns and labels them “blocked” with an honest explanation, never lumping them in with genuinely dead links. False positives are the fastest way to make people stop trusting a link checker’s output, so we’d rather under-claim than over-claim.

Fixing what you find

Once the scan finishes, the “Broken links” shortlist is the one to act on first: it’s every link that returned a real error (404, 410, 500 and friends), with a copy button so you can drop the whole list into a spreadsheet or a ticket. For each one, you generally have three options: redirect it if the destination moved (a 301 to the new location preserves most of the link’s value and fixes the user experience instantly), remove or replace it if the content is genuinely gone and nothing replaces it (better to drop a dead reference than leave a dead end), or fix the source if the link was simply typed wrong to begin with, surprisingly common, especially for internal links. Redirected links that show a long chain (multiple hops before landing) are worth a second look even though they’re not broken: each hop adds latency and a small amount of link-equity loss, and our Redirect Tracer will show you the exact hop-by-hop path if you want to collapse a chain down to a single direct redirect. Broken internal links are worth double-checking against your 404 page, too: if you’re seeing a cluster of them, it’s often a sign a URL structure changed somewhere without updating the links that point at it.

This tool intentionally scopes to a single page, checked thoroughly, rather than promising a full-site crawl: that keeps it fast, keeps it free, and keeps it honest about what it’s actually doing. For the pages that matter most (your homepage, top landing pages, your most-linked blog posts), running this on demand whenever you publish or update content is a fast, cheap habit that catches rot long before it piles up.

For AI agents

This tool exposes a plain-text endpoint designed for language models and agents:

GET https://nitrosites.com/tools/link-checker/scan.php?action=extract&url=<target>&format=agent

It returns a token-cheap digest of the page’s link inventory: every checkable link with its type (internal/external) and anchor text, plus the skipped list with reasons. Note that this covers the extract step only: the live liveness checks (status codes, redirects, broken/blocked verdicts) are interactive-only in v1 and require the batch-checking UI on this page, there’s no single-request digest for them yet, since checking is itself a multi-request, client-orchestrated process. Soft rate limits apply; extraction results are cached briefly. No key or login required.

Frequently asked questions

Why do broken links matter for SEO?

They waste crawl budget, leak link equity into dead ends and signal neglect to both users and search engines. Fixing them is one of the cheapest quality wins in SEO.

Does this check my whole website?

It checks one page deeply: every link on it, live. For whole-site audits you'd schedule a crawler; for the pages that matter (home, key landing pages, popular posts), a fast on-demand check like this is what you actually reach for.

Why does a link show as "blocked" instead of broken?

Some sites (LinkedIn is famous for it) refuse automated checkers with special status codes even though the link works in a browser. We label those honestly instead of calling them broken: false alarms are the worst thing a link checker can do.

What's wrong with target="_blank" without noopener?

The opened page gets a window.opener reference back to yours (a phishing vector called tabnabbing) and it can hurt performance. Add rel="noopener" (modern browsers now imply it, but explicit is safer for older ones).

How many links can it check?

Up to 200 per page, checked in parallel batches of twenty. Anything beyond that is listed as skipped so the count always adds up.