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.
Kazi Khalid Hasan Tamim · 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.txtrespected, 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".
| Tool | Type | Works on | Finds orphans | Click depth | Suggests links | Price (2026-11-19) |
|---|---|---|---|---|---|---|
| Link Whisper | Plugin | WordPress only | Yes | No | Yes, plus auto-linking | $97/year for 1 site; free version |
| Yoast SEO Premium | Plugin | WordPress | Yes (orphaned content workout) | No | Yes, as you write | $118.80/year ex VAT |
| Screaming Frog SEO Spider | Desktop crawler | Any site | Yes, with a sitemap crawl | Yes | No | Free to 500 URLs; £199/year |
| Ahrefs Site Audit | Cloud crawler | Sites you verify | Not stated | Crawl setting | Yes, from ranking keywords | In Ahrefs Free: 5,000 crawl credits per project a month |
| BugViso | Cloud site audit | Any site | Yes, confirmed or possible | Yes, plus PageRank tiers | No | First 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.
What 40 Full Crawls Show About Internal Links
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 affected | Median site |
|---|---|---|
| Orphan pages (in the sitemap, no HTML link reaches them) | 33 of 40 | 14 % of sitemap URLs |
| Pages 3+ clicks from the homepage | 35 of 40 | 54 % of pages |
| Pages 4+ clicks from the homepage | 30 of 40 | 15 % of pages |
| Pages with only 1 internal link pointing in (10 %+ of a site's pages) | 24 of 40 | 17 % of pages |
| Top 10 % of pages hold half or more of internal PageRank | 23 of 40 | 65 % 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: best for WordPress auto-linking
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: best for keyword-based link opportunities
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.
- "Our new posts never get linked." Suggestions while writing: Link Whisper or Yoast SEO Premium.
- "Which pages are cut off or buried?" A crawler that compares links with the sitemap: Screaming Frog, BugViso or the script below.
- "Which pages get the most internal link value?" An internal PageRank model: Screaming Frog's Link Score or BugViso's equity tiers.
- "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.
Run It Yourself: A Free Internal Link Audit Script
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.
#!/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("&", "&") 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:
$ 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-pagesabove 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.
How BugViso Maps Internal Link Equity Automatically
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.
- 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.
- Links must be real links. Google can generally only follow
<a>elements with anhref(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.
How to check internal links on a website?
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.
Audit the Structure Before You Add Links
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
Kazi Khalid Hasan Tamim · 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.
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 where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.