Broken Links Are Broken Revenue (and Broken Trust)

The link that was fine on launch day

Links are the one part of a website that decays without anyone touching it. You ship a page with forty working links. Over the next two years, six of the destinations move, three of the companies fold, two products get renamed, and your own team restructures the URL scheme twice. Nobody edited that page, and yet a quarter of its links now lead nowhere. That is link rot, and it is relentless because it is driven by the entire rest of the web changing around you, not by anything you did. Your content is a snapshot of a web that no longer exists.

The scale is documented and worse than intuition suggests. Per the Pew Research Center study on disappearing online content, 38% of webpages that existed in 2013 were no longer accessible a decade later. The same study found 23% of news webpages and 21% of government webpages contain at least one broken link, and a striking 54% of Wikipedia articles link to at least one reference page that no longer exists. If the most carefully maintained reference site on Earth is half-rotted, your marketing site is not exempt, and per industry surveys summarized by broken-link statistics for 2025, over 42% of websites currently have broken links.

The revenue path, made concrete

"Broken links are bad" is easy to nod at and easy to deprioritize. The specifics are harder to ignore, and the survey data is stark.

The broken link in the conversion path

A dead link in a checkout flow, a pricing page, a "Buy now" button, or an email campaign is a direct, immediate loss. Per Conductor's overview of broken links and UX and corroborating surveys, a majority of online shoppers abandon a site after encountering a broken link, and roughly 70% abandon a purchase if they hit a broken checkout link. The user who clicked was ready to act and hit a wall. They do not file a bug; they leave, and often they do not come back. This is the most expensive broken link and the one most likely to be discovered by a customer rather than a test.

The 404 that throws away a backlink

Someone with a high-authority site linked to your page. You restructured your URLs and that page now 404s. The backlink, a ranking asset you could not buy, now points at a dead end, and the authority it carried evaporates. Per Semrush's analysis of broken-link SEO impact, this is a pure, recoverable loss: a single 301 from the dead URL to a live one reclaims the equity, but only if you know the backlink exists. Most teams never audit their inbound links against their own 404s, so this loss runs indefinitely.

The crawl-budget tax

Every internal link to a 404 is a request Googlebot spends discovering nothing. On a large site, a thousand broken internal links is a thousand crawls wasted on dead ends instead of your real content, slowing how fast new and updated pages get indexed and earning traffic.

The trust tax

Broken links erode credibility measurably. Surveys cited across the SEO literature find that a large majority of visitors say broken links reduce their trust in a site, and 404s drive a noticeable jump in bounce rate. Search engines read a site littered with dead links as poorly maintained, a soft quality signal that compounds across the domain and is hard to attribute when rankings slip.

Why you find out from a customer

The reason broken links persist is a detection gap. They are invisible in normal development: the link worked when you wrote it, the destination broke later, and nothing in your codebase changed to flag it. Analytics will not tell you either, a 404 often does not fire a clean event, and even when it does, nobody is watching the 404 report daily. So the discovery channel becomes a customer emailing "your link is broken" or, far more often, silently leaving and never mentioning it.

The only systematic way to find broken links is to crawl your site, follow every link (internal and external), and record the HTTP status of each destination. Done by hand for one page it is trivial; done across a site of thousands of pages with thousands of outbound links, it is a job for a crawler.

# The raw mechanic: crawl, follow every link, record status + source page
const seen = new Set();
const broken = [];

async function crawl(url, foundOn) {
  if (seen.has(url)) return;
  seen.add(url);
  let res;
  try { res = await fetch(url, {method: 'HEAD', redirect: 'follow'}); }
  catch (e) { broken.push({url, foundOn, status: 'NETWORK_ERROR'}); return; }

  if (res.status >= 400) {
    broken.push({url, foundOn, status: res.status});   // 404,410,5xx...
    return;
  }
  // Same-origin: parse and recurse into its links
  if (new URL(url).origin === SITE_ORIGIN) {
    for (const link of await extractLinks(url)) await crawl(link, url);
  }
}
// Output: every dead destination AND the page it was linked from.

The critical column in that output is foundOn, the page the broken link lives on. A list of dead URLs is useless without knowing where each one is referenced, because that is what you actually have to fix. A good crawler also handles HEAD-hostile servers (some return 405 to HEAD and need a GET), respects rate limits so you do not hammer external hosts, and re-checks transient 5xx errors before flagging them, so the report is signal rather than noise.

Fix by category

The remediation depends on the link type. For an internal 404 caused by a moved page, add a 301 redirect from the old URL to the new one and update the source link to point directly at the new URL (so you do not create a redirect chain). For a dead inbound backlink, 301 the old URL to the most relevant live page to reclaim the equity, and prioritize these because they recover authority you cannot otherwise buy. For a broken external link, update it to the destination's new home, swap it for an equivalent source, or remove it if no replacement exists. For a page that is genuinely gone with no replacement, return a real 410 Gone so crawlers stop wasting budget revisiting it.

Make the 404 page itself work harder, too, a useful 404 with search, navigation, and links to popular pages recovers some of the users who would otherwise bounce, turning a dead end into a redirect of attention. But a good 404 page is damage control, not a fix; the goal is for users not to reach it in the first place. And critically, your custom 404 page must still return a 404 status code, not a 200, a "helpful" 404 page served with a 200 status becomes a soft 404 that wastes crawl budget all over again.

Catch them continuously, gate the critical ones

Link rot is continuous, so detection has to be continuous. A one-time cleanup is stale within weeks as the rest of the web keeps moving. Schedule a full crawl on a regular cadence, and add a deploy-time check that the links in your highest-stakes flows, checkout, pricing, primary navigation, top landing pages, all return 200 before the build ships.

# CI gate: critical-path links must be alive before deploy
const CRITICAL = [
  '/checkout', '/pricing', '/cart', '/signup',
  ...await topLandingPages(20),     // your highest-traffic pages
];
const dead = [];
for (const path of CRITICAL) {
  for (const link of await extractLinks(SITE + path)) {
    const res = await fetch(link, {method: 'GET', redirect: 'follow'});
    if (res.status >= 400) dead.push({page: path, link, status: res.status});
  }
}
if (dead.length) { console.error('Dead links in critical paths:', dead); process.exit(1); }

The split matters: gate the critical paths hard in CI (a broken checkout link should fail the build), and report the long tail from a scheduled crawl ranked by traffic, so the chores get worked down without blocking releases. That way the emergency-class breakage never ships and the chore-class breakage never accumulates.

The bottom line

Broken links are broken revenue and broken trust, leaking quietly because the web rots around your unchanged pages, 38% of decade-old pages gone, a quarter of news pages broken, half of Wikipedia's references dead, 42% of sites affected today. Each internal 404 wastes crawl budget and strands link equity, each dead inbound backlink throws away authority you cannot buy, and each broken link in a conversion path is a customer who left without telling you, and most do not tell you. The fixes are simple and cheap; the hard part is finding the links before a customer does, ranked by where the money and the authority actually are. Crawl continuously, gate your critical paths in CI, fix by category, and stop learning about your dead links from your users.