Best Internal Linking Tools 2027: Top 5 Compared for SEO

The best internal linking tools for 2027 compared on price, orphan pages, click depth and link suggestions, plus a free audit script we ran on 40 real sites.

· BugViso Team

16 min read

The best internal linking tools do one of two jobs: Link Whisper and Yoast SEO Premium suggest links inside WordPress while you write, and Screaming Frog, Ahrefs Site Audit and BugViso crawl the whole site to find orphan pages, buried pages and where internal PageRank pools. Most sites need the crawl first.

We crawled 40 randomly sampled websites to the last page: 33 had orphan pages in their XML sitemap, and on the median site 54 % of pages sat 3 or more clicks from the homepage.

Below: which tool fits your CMS and budget, what each one misses, and a free script that measures orphans, click depth and internal PageRank on your own site.

Data used: 420 domains drawn at random (seed 20261003) from ranks 1,001 to 50,000 of the Tranco list 94GG2. 66 had an XML sitemap of 30 to 1,500 URLs and were crawled on 2026-11-19 with the script in this post (HTML links only, robots.txt respected, 2,000-page cap). 40 crawls finished below the cap and are analysed (21,263 pages). Orphans are sitemap URLs no crawled link reached, checked up to 200 per site, so counts are a floor. The crawl does not run JavaScript, so a page linked only by script-injected links can show as orphaned here; our JavaScript SEO tools test found such links on 35.6% of homepages. Sites are not named. Tool prices are from each vendor's own page on 2026-11-19. We make BugViso, one of the tools listed.

Internal Linking Tools at a Glance

Pick a suggestion tool when the problem is "new posts never get linked", and a crawler when the problem is "we don't know which pages are cut off".

ToolTypeWorks onFinds orphansClick depthSuggests linksPrice (2026-11-19)
Link WhisperPluginWordPress onlyYesNoYes, plus auto-linking$97/year for 1 site; free version
Yoast SEO PremiumPluginWordPressYes (orphaned content workout)NoYes, as you write$118.80/year ex VAT
Screaming Frog SEO SpiderDesktop crawlerAny siteYes, with a sitemap crawlYesNoFree to 500 URLs; £199/year
Ahrefs Site AuditCloud crawlerSites you verifyNot statedCrawl settingYes, from ranking keywordsIn Ahrefs Free: 5,000 crawl credits per project a month
BugVisoCloud site auditAny siteYes, confirmed or possibleYes, plus PageRank tiersNoFirst report free, then $1.49 a report

No tool here does both jobs well: the plugins see only post content, and the crawlers can't write links. The free script further down covers the crawl side.

Orphan pages and buried pages are the norm, not the exception: 33 of 40 fully crawled sites had sitemap URLs that no internal link reached.

Finding (40 sites crawled to the last page)Sites affectedMedian site
Orphan pages (in the sitemap, no HTML link reaches them)33 of 4014 % of sitemap URLs
Pages 3+ clicks from the homepage35 of 4054 % of pages
Pages 4+ clicks from the homepage30 of 4015 % of pages
Pages with only 1 internal link pointing in (10 %+ of a site's pages)24 of 4017 % of pages
Top 10 % of pages hold half or more of internal PageRank23 of 4065 % held by the top 10 %

For tool choice, this means three things. Orphans only show up when a crawl is compared with the sitemap, which post-content plugins can't do. On 8 of the 66 sites we crawled, plain HTML led to fewer than 10 pages although their sitemaps listed 30 to 1,256 URLs; those sites need a crawler that renders JavaScript (see the JavaScript SEO tools comparison). And internal PageRank pools in navigation pages (the homepage alone held a median of 3 %), so a tool that models it shows which pages to link from.

The 5 Best Internal Linking Tools, One by One

Link Whisper is a WordPress plugin that suggests internal links in the post editor, reports orphan pages and, on paid plans, inserts links automatically for keywords you choose. Its pricing page lists Starter at $97 a year for 1 WordPress site and Agency at $497 a year for 50 sites. The free version on WordPress.org includes editor suggestions and an orphan report; auto-linking is premium.

The catch: it only runs on WordPress, and keyword auto-linking repeats one anchor on every match. Read the guide to internal link anchor text before you switch on keyword rules.

Yoast SEO Premium: best if you already run Yoast

Yoast SEO Premium suggests relevant pages to link to as you write, and its orphaned content workout lists posts nothing links to. Yoast lists Premium at $118.80 a year (ex VAT), with redirects and AI-drafted meta descriptions in the same licence.

It is the cheapest upgrade if Yoast is already installed, but it is not a crawler: links your theme adds in menus, footers or widgets sit outside its view.

Screaming Frog SEO Spider: best desktop crawler for deep audits

Screaming Frog SEO Spider crawls any site from your computer and reports internal links, link counts, crawl depth, anchor text and an internal Link Score per URL. Crawl the XML sitemap with the site and it lists orphan pages. The free version stops at 500 URLs per crawl, and a £199 yearly licence removes the limit and adds crawl configuration, saved crawls and JavaScript rendering.

It is also the most hands-on: nothing tells you which link to add where.

Ahrefs Site Audit includes internal linking suggestions that name the page to link from, the page to link to, the ranking keyword and the context it appears in. Site Audit is included with Ahrefs Free for sites you verify, at 5,000 crawl credits per verified project a month, and it can render JavaScript.

Suggestions start from keywords your pages already rank for, so a new page gets few. Its Site Audit page doesn't mention an orphan report or say which features the free plan includes.

BugViso: best for internal PageRank and orphans inside a full audit

BugViso builds an internal link graph from every crawled page and reports orphan pages, click depth, inbound and outbound link counts, and an internal PageRank equity score with a tier (high, medium, low or depleted) for every page.

The crawl runs in a real browser, so links that JavaScript adds are found, which matters on the 8 of 66 sites in our sample where a plain HTML crawl reached fewer than 10 pages. And BugViso calls an orphan confirmed only when the crawl reached every page it knew about; otherwise it says "possible". Where others go further: BugViso doesn't suggest or insert links, doesn't analyse anchor text, and a single report crawls up to 200 pages (monthly plans 75 to 300).

How to Choose an Internal Linking Tool

Choose by where the gap is, not by feature count. Four questions settle it.

  1. "Our new posts never get linked." Suggestions while writing: Link Whisper or Yoast SEO Premium.
  2. "Which pages are cut off or buried?" A crawler that compares links with the sitemap: Screaming Frog, BugViso or the script below.
  3. "Which pages get the most internal link value?" An internal PageRank model: Screaming Frog's Link Score or BugViso's equity tiers.
  4. "We publish hundreds of pages from templates." Links built into the template, not a plugin. The guide to programmatic internal linking shows how to generate related links at build time.

If the basics are new, the internal linking best practices guide covers where links belong and how many to add.

This script crawls your site's HTML links from the homepage, reads the XML sitemap and prints orphan pages, click depth, pages with a single inbound link and how concentrated internal PageRank is. It is the tool behind the data above: Python standard library only, robots.txt respected (per RFC 9309), 0.2 s between requests.

python
#!/usr/bin/env python3
"""Audit a site's internal links: orphan pages, click depth, weak pages and internal PageRank.

Crawls the HTML links from the homepage (no JavaScript), reads the XML sitemap,
then reports what an internal linking tool should tell you.

Usage: python3 internal_link_audit.py https://example.com [--max-pages 1000]
"""
import gzip
import re
import sys
import time
import urllib.request
import urllib.robotparser
from collections import Counter, deque
from html.parser import HTMLParser
from urllib.parse import urljoin, urlparse

UA = "Mozilla/5.0 (compatible; internal-link-audit/1.0)"
SKIP = re.compile(r"\.(jpe?g|png|gif|webp|avif|svg|ico|pdf|zip|mp4|mp3|css|js|xml|json|txt|docx?|xlsx?)$", re.I)


def key(url):
    """Compare URLs without scheme, www, fragment or trailing slash."""
    p = urlparse(url)
    host = (p.hostname or "").removeprefix("www.")
    path = p.path.rstrip("/") or "/"
    return host + path + ("?" + p.query if p.query else "")


def fetch(url, timeout=20):
    req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept-Encoding": "gzip"})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        body = r.read(5_000_000)
        if r.headers.get("Content-Encoding") == "gzip" or body[:2] == b"\x1f\x8b":
            body = gzip.decompress(body)
        return r.geturl(), r.headers.get("Content-Type", ""), body.decode("utf-8", "replace")


class Links(HTMLParser):
    def __init__(self, base):
        super().__init__()
        self.base, self.hrefs = base, []

    def handle_starttag(self, tag, attrs):
        a = dict(attrs)
        if tag == "base" and a.get("href"):
            self.base = urljoin(self.base, a["href"])
        elif tag == "a" and a.get("href"):
            self.hrefs.append(urljoin(self.base, a["href"].strip()))


def sitemap_urls(root, robots_txt, limit=20000):
    queue = re.findall(r"(?im)^\s*sitemap:\s*(\S+)", robots_txt) or [urljoin(root, "/sitemap.xml")]
    seen, urls = set(), []
    while queue and len(seen) < 50 and len(urls) < limit:
        sm = queue.pop(0)
        if sm in seen:
            continue
        seen.add(sm)
        try:
            xml = fetch(sm)[2]
        except Exception:
            continue
        locs = [x.strip() for x in re.findall(r"<loc>\s*(?:<!\[CDATA\[)?(.*?)(?:\]\]>)?\s*</loc>", xml, re.S)]
        if "<sitemapindex" in xml:
            queue += locs
        else:
            urls += [u.replace("&amp;", "&") for u in locs]
    return urls[:limit]


def pagerank(nodes, edges, alpha=0.85, rounds=40):
    n = len(nodes)
    pr = {k: 1 / n for k in nodes}
    for _ in range(rounds):
        dangling = sum(pr[k] for k in nodes if not edges[k])
        nxt = {k: (1 - alpha) / n + alpha * dangling / n for k in nodes}
        for src in nodes:
            for dst in edges[src]:
                nxt[dst] += alpha * pr[src] / len(edges[src])
        pr = nxt
    return pr


def audit(start, max_pages=1000, delay=0.2):
    root = f"{urlparse(start).scheme}://{urlparse(start).netloc}/"
    try:
        robots_txt = fetch(urljoin(root, "/robots.txt"))[2]
    except Exception:
        robots_txt = ""
    rp = urllib.robotparser.RobotFileParser()
    rp.parse(robots_txt.splitlines())

    final_url, _, _ = fetch(start)  # follow the homepage redirect (http -> https, www)
    host = (urlparse(final_url).hostname or "").removeprefix("www.")
    same = lambda u: (urlparse(u).hostname or "").removeprefix("www.") == host

    depth, edges, alias = {key(final_url): 0}, {}, {}
    queue, queued = deque([final_url]), {key(final_url)}
    truncated = False
    while queue:
        if len(edges) >= max_pages:
            truncated = True
            break
        url = queue.popleft()
        k = key(url)
        if not rp.can_fetch(UA, url):
            continue
        try:
            got, ctype, html = fetch(url)
        except Exception:
            continue
        time.sleep(delay)
        if "html" not in ctype or not same(got):
            continue
        g = key(got)
        if g != k:  # redirected: count links to k as links to g
            alias[k] = g
            if g in edges:
                continue
            depth.setdefault(g, depth[k])
        p = Links(got)
        p.feed(html)
        out = set()
        for h in p.hrefs:
            if not h.startswith("http") or not same(h) or SKIP.search(urlparse(h).path):
                continue
            hk = key(h.split("#")[0])
            out.add(hk)
            if hk not in queued:
                queued.add(hk)
                depth[hk] = depth[g] + 1
                queue.append(h.split("#")[0])
        edges[g] = out

    pages = set(edges)
    for src in pages:  # resolve redirects, drop links to pages we never fetched as HTML
        edges[src] = {alias.get(d, d) for d in edges[src]} & pages - {src}
    inbound = Counter(d for src in pages for d in edges[src])
    pr = pagerank(sorted(pages), edges) if pages else {}

    sm = sitemap_urls(root, robots_txt)
    reached = pages | set(alias)
    orphans = []
    for u in sm if not truncated else []:  # an unfinished crawl can't confirm orphans
        if not same(u) or key(u) in reached:
            continue
        try:  # a sitemap URL that redirects to a crawled page is not an orphan
            got = fetch(u)[0]
            if key(got) in reached:
                continue
        except Exception:
            continue  # dead sitemap URL: a sitemap problem, not an orphan
        orphans.append(u)
        if len(orphans) >= 200:
            break

    ranked = sorted(pr.values(), reverse=True)
    top = max(1, len(ranked) // 10)
    home = key(final_url)
    buckets = Counter(min(depth[p], 5) for p in pages)
    return {
        "site": final_url,
        "pages_crawled": len(pages),
        "crawl_complete": not truncated,
        "sitemap_urls": len(sm),
        "orphans_in_sitemap": len(orphans) if not truncated else None,
        "orphan_examples": orphans[:10],
        "depth": {("5+" if d == 5 else str(d)): buckets[d] for d in sorted(buckets)},
        "max_depth": max((depth[p] for p in pages), default=0),
        "one_inbound_link": sum(1 for p in pages if p != home and inbound[p] == 1),
        "pagerank_top10pct_share": round(sum(ranked[:top]), 3) if ranked else 0,
        "pagerank_home_share": round(pr.get(home, 0), 3),
    }


def _selftest():
    assert key("https://www.a.com/x/#top") == key("http://a.com/x") == "a.com/x"
    nodes = ["a", "b", "c"]
    pr = pagerank(nodes, {"a": {"b", "c"}, "b": {"a"}, "c": {"a"}})
    assert abs(sum(pr.values()) - 1) < 1e-9 and pr["a"] > pr["b"] == pr["c"]


if __name__ == "__main__":
    _selftest()
    if len(sys.argv) < 2:
        sys.exit(__doc__)
    cap = int(sys.argv[sys.argv.index("--max-pages") + 1]) if "--max-pages" in sys.argv else 1000
    r = audit(sys.argv[1], cap)
    print(f"Site: {r['site']}  pages crawled: {r['pages_crawled']}"
          f"{'' if r['crawl_complete'] else ' (stopped at --max-pages, orphans unconfirmed)'}")
    print(f"Click depth: {r['depth']}  (deepest: {r['max_depth']})")
    print(f"Pages with 1 internal link pointing in: {r['one_inbound_link']}")
    print(f"Sitemap URLs: {r['sitemap_urls']}  orphans (in sitemap, no link reaches them): "
          f"{'not checked' if r['orphans_in_sitemap'] is None else r['orphans_in_sitemap']}")
    for u in r["orphan_examples"]:
        print("  ORPHAN", u)
    print(f"Internal PageRank held by the top 10 % of pages: {r['pagerank_top10pct_share']:.0%}"
          f"  (homepage alone: {r['pagerank_home_share']:.0%})")

Here is the real output for bugviso.com, run on 2026-11-19:

text
$ python3 internal_link_audit.py https://bugviso.com
Site: https://bugviso.com  pages crawled: 324
Click depth: {'0': 1, '1': 25, '2': 298}  (deepest: 2)
Pages with 1 internal link pointing in: 1
Sitemap URLs: 315  orphans (in sitemap, no link reaches them): 1
  ORPHAN https://bugviso.com/blog/ieltsbiz-review
Internal PageRank held by the top 10 % of pages: 79%  (homepage alone: 4%)

The one orphan is deliberate: an unlisted review, kept out of the blog index but left in the sitemap. An orphan is a question, not automatically an error: decide whether to link it, merge it or drop it from the sitemap.

The 79 % means the pages in the global menu and footer hold most internal PageRank. If a page that earns money sits outside that top 10 %, link to it from one inside it.

💡 Rule of thumb: set --max-pages above your sitemap's URL count. A crawl that stops early can't confirm orphans, because an uncrawled page could be the one linking to them.

BugViso's link graph engine runs the same three checks as the script (orphans, click depth and internal PageRank), but on links rendered in a real browser. Each page gets an inbound count, an outbound count, a click depth and an equity tier, and the report flags pages 3 or more clicks deep and pages carrying more than 150 internal links.

A plain HTML crawl misses links that JavaScript adds; BugViso's Playwright crawl sees them. And because the graph sits inside the technical SEO audit, a deep, orphaned page that also fails Core Web Vitals shows up as one problem, not three exports.

2 Limits Every Internal Linking Tool Shares

Every internal linking tool measures a model of your site, not Google's view of it.

  1. Orphans need a sitemap. A page in neither your links nor your sitemap is invisible to every tool here, and Google's sitemaps overview says a sitemap helps discovery without guaranteeing a crawl.
  2. Links must be real links. Google can generally only follow <a> elements with an href (Google's link guidelines), and it wants anchor text that is "descriptive, reasonably concise, and relevant". One phrase auto-linked everywhere rarely is.

Frequently Asked Questions

What is the best internal linking tool?

The best internal linking tool depends on the job. For WordPress sites that need links added while writing, Link Whisper or Yoast SEO Premium fit best. To find orphan pages, buried pages and internal PageRank on any site, use a crawler: Screaming Frog, Ahrefs Site Audit, or BugViso inside a full site audit.

Is there a free internal linking tool?

Yes. Link Whisper has a free WordPress version with editor suggestions and an orphan report. Screaming Frog SEO Spider is free up to 500 URLs per crawl, and Ahrefs includes Site Audit in Ahrefs Free for verified sites. The Python script in this post is free and works on any site.

How to find orphan pages on a website?

To find orphan pages on a website, crawl it from the homepage by following links, then compare the pages you reached with the URLs in your XML sitemap. Any sitemap URL that no link reaches is an orphan. In our crawl of 40 sites, 33 had at least one. Only trust the list once the crawl has finished.

To check internal links on a website, run a crawler that records every <a href> link between your own pages: Screaming Frog, Ahrefs Site Audit, BugViso or the free script above. Check four numbers per page: inbound links, outbound links, click depth and the target's status code. Start with pages that have one inbound link or none.

How do I check the click depth of pages?

Check the click depth of pages with a crawler that starts at the homepage and counts the shortest chain of links to every page; Screaming Frog, BugViso and the script above all report it. Keep important pages within 3 clicks. In the median site we crawled, 54 % of pages were 3 or more clicks deep.

Can AI do internal linking?

Yes, partly. Link Whisper sells "AI powered internal links" that it suggests while you write and can insert for keywords you set, and Yoast SEO Premium suggests related pages in the editor. A person should still approve each link: automatic linking repeats the same anchor, can link from irrelevant paragraphs and can't see orphans that only a full crawl finds.

Find the orphans and buried pages first, then use a suggestion tool to fix them. Links added to a structure you haven't measured mostly strengthen pages that already have plenty. Run the script, or let a BugViso site audit map the link graph, depth and PageRank tiers, and spend your linking effort on the pages the map shows are cut off.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.