How is this different from the Broken Link Checker?

Broken Link Checker fetches every link to see whether it actually resolves (200 OK, 404, redirect, etc), which is a liveness check. This tool doesn't fetch anything; it catalogs the internal link structure itself, counts links, shows anchor text, and flags structural patterns like duplicates and href formatting issues, which is useful even for links you already know are live.

Why does it need the page's own URL, not just the HTML?

Determining whether a link is "internal" requires knowing what origin counts as internal, and resolving a relative href (like href="/about" or href="contact") into an absolute URL requires a base to resolve it against. Both of those need the page's own URL, which is why this tool asks for it explicitly even when you paste HTML rather than fetch it live.

What's the problem with a relative href that has no leading slash?

A href without a leading slash, like href="about" instead of href="/about", resolves relative to the current page's directory, not the site root. That works fine on a page at https://example.com/about but breaks if the exact same markup (a shared header or footer component, for example) is rendered on a page one directory deeper, like https://example.com/blog/post, where it now points to https://example.com/blog/about instead.

Why flag duplicate internal links instead of just deduplicating them?

A page linking to the same internal URL multiple times (in a nav, then again in body content, then again in a footer) is common and often intentional, so this tool surfaces duplicates as information rather than silently hiding them. Whether repeated links to the same page are a problem worth fixing depends on context this tool can't see, like whether the repeated anchor text is diluting a more specific internal-linking strategy.

Internal Link Checker - Audit a Page's Internal Link Structure

Overview

Introduction

Internal links are how both users and search engine crawlers move around a site, and how link authority flows from well-linked pages to newer or less-discoverable ones. A page's internal linking rarely gets audited directly, since it's easy to eyeball a page and assume the links look fine without actually counting or categorizing them.

This tool does that cataloging for you: paste or fetch a page's HTML and its URL, and get every internal link enumerated with its anchor text, plus two structural checks that are easy to miss by eye, duplicate links and hrefs likely to break when markup is reused elsewhere on the site.

What Is Internal Link Checker?

A link-structure auditor that parses <a href> elements out of HTML with the browser's own DOMParser, resolves each href against the page's own URL, and classifies it as internal (same origin) or external.

For internal links specifically, it reports the total count, each link's anchor text, which hrefs repeat more than once on the page, and which relative hrefs are missing a leading slash - a pattern that resolves correctly on the page it was written for but silently breaks if the same markup is reused at a different URL depth.

How Internal Link Checker Works

HTML is parsed with DOMParser to collect every <a href> element and its text content. mailto:, tel:, javascript:, and bare-fragment (#) links are skipped, since they aren't page-to-page navigation links.

Each remaining href is resolved to an absolute URL against the page's own URL. A link is internal when its resolved origin matches the page's origin; internal links are then checked for exact-href duplicates and for relative hrefs written without a leading slash.

When To Use Internal Link Checker

Reviewing a new or redesigned page's internal linking before publishing, to confirm it links to the pages it's meant to and doesn't accidentally repeat the same link excessively.

Auditing a template or reusable component (header, footer, sidebar) across pages at different URL depths, where a leading-slash mistake is most likely to actually break something.

Building an internal-linking strategy for SEO, where knowing exactly which pages a given page links to (and how often) is the starting point.

Often used alongside Broken Link Checker, External Link Checker and Anchor Text Analyzer.

Features

Advantages

Runs entirely client-side against pasted or fetched HTML, so no crawler or backend is needed to catalog a page's internal links.
Flags a real, easy-to-miss bug pattern (leading-slash-less relative hrefs) that only breaks under specific reuse conditions, so it's rarely caught by just reading the markup.
Distinguishes internal from external links using the actual resolved origin, not a guess based on the href's format, so protocol-relative and absolute same-origin links are still classified correctly.

Limitations

This is a static-HTML snapshot, not a JS-rendered-DOM crawl; links injected client-side by JavaScript after the initial HTML loads (common in single-page apps) won't appear unless the pasted or fetched HTML already includes them.
It only reports internal links; use External Link Checker for the cross-origin side of a page's outbound linking.
It doesn't verify that flagged links actually resolve; a relative href without a leading slash is flagged as a risk pattern, not confirmed as broken, since confirming that requires fetching it (see Broken Link Checker).

Examples

A leading-slash-less relative link

Input

Page URL: https://example.com/blog/post
<a href="about">About</a>

Output

Resolved: https://example.com/blog/about - flagged: relative href without leading slash

Written as href="about" instead of href="/about", this resolves relative to /blog/ instead of the site root, landing on the wrong page.

Best Practices & Notes

Best Practices

Fetch the page directly rather than pasting HTML when possible, so the tool has an accurate URL to resolve relative links against without you having to type it in separately.
Prefer root-relative ("/about") or absolute ("https://example.com/about") hrefs over directory-relative ones ("about", "../about") in shared components, since those are the pattern most likely to break silently when reused.
Review duplicate internal links with intent, not by default removing them; a repeated link to a key conversion page (like a pricing page) linked from multiple places on a long page is often deliberate.

Developer Notes

Internal/external classification compares resolved URL.origin values (scheme + host + port), not just hostname, so http:// and https:// versions of the same host are correctly treated as different origins, matching how a browser itself scopes CORS and same-origin behavior.

Internal Link Checker Use Cases

Counting and reviewing all internal links on a page before publishing to confirm the intended pages are linked
Auditing a shared header/footer/nav component for relative-href bugs before it ships across every page depth on a site
Mapping which pages a given page links to as an input for a broader internal-linking or site-architecture review

Common Mistakes

Writing a directory-relative href in a component meant to be reused across pages at different URL depths, which only breaks on some of those pages and can go unnoticed for a long time.
Assuming a link is internal just because it looks like a relative path, when in some markup relative hrefs can still resolve to an entirely different origin if a <base> tag changes the resolution base (rare, but worth checking on pages using one).

Tips

If a page shows more duplicate internal links than expected, check whether the same call-to-action or nav item is being rendered twice in the markup by mistake, not just linked twice on purpose.

Internal Link Checker