Internal PageRank: How Link Equity Flows Across a Website

How internal PageRank flows through a site, why some pages get starved, and how to model link equity with a crawl to send more of it to pages that earn money.

· BugViso Team

16 min read

Internal PageRank is the share of link equity each page of your site holds, calculated from your internal link graph. Every link splits its source page's score among its targets, scaled by a damping factor (classically 0.85), so shallow, well-linked pages accumulate the most. This guide shows the math, a Python model and the fixes.

Link equity is not an arbitrary metaphor. It comes from the PageRank algorithm, which Larry Page and Sergey Brin described as stationary probability distributions over directed graphs.

While external backlinks set a domain's baseline authority, your internal PageRank distribution decides how that authority is shared across your pages.

Understanding the mathematics of internal PageRank enables engineering and SEO teams to design website architectures that strategically direct crawl frequency and ranking potential toward high-converting, commercially critical pages.


The Mathematical Foundation: The Random Surfer and Damping Factor

To understand how equity moves through a website, we must examine the formal model of the Random Surfer.

The algorithm conceptualizes a web user (or crawler) who visits a webpage at random and continuously clicks outgoing hyperlinks. At each step, the surfer faces two choices:

  1. Link Following: With probability $d$, the surfer selects one of the outgoing links on the current page with equal probability and transitions to the destination page.
  2. Teleportation: With probability $(1 - d)$, the surfer ceases following links and teleports to an entirely random page chosen uniformly from all available pages in the network.

The scalar constant $d$ is known as the damping factor, conventionally set to $0.85$.

At each page the surfer makes one of two moves. With probability $d$ (0.85) they follow an outbound link, and the equity is split evenly across the page's destination URLs. With probability $1 - d$ (0.15) they jump to a random page anywhere in the graph.

The introduction of the damping factor addresses two fundamental graph phenomena that would otherwise break convergence:

  • Spider Traps: Graph cycles where two or more nodes point only to each other, causing all equity to accumulate in an inescapable feedback loop.
  • Dead Ends (Dangling Nodes): Nodes with zero outgoing links that act as "information sinks," absorbing equity and causing the total probability mass of the network to leak away.

The PageRank Formula

Mathematically, the PageRank $PR(u)$ of a given page $u$ within a graph of $N$ pages is defined recursively as:

$$PR(u) = \frac{1 - d}{N} + d \sum_{v \in B_u} \frac{PR(v)}{L(v)}$$

Where:

  • $N$ is the total count of pages in the graph.
  • $B_u$ is the set of pages that link to page $u$ (the inbound links).
  • $PR(v)$ is the PageRank of an inbound linking page $v$.
  • $L(v)$ is the total count of outbound links on page $v$.
  • $d$ is the damping factor ($0.85$).

This formulation reveals two critical mechanical truths about internal links:

  1. Equity Division: Every outbound link added to page $v$ divides the authority it transfers ($L(v)$ in the denominator). Adding 100 links to a page reduces the equity passed per link to approximately one-hundredth of the available mass.
  2. The Base Injection: The term $\frac{1 - d}{N}$ ensures that even an orphaned page with zero incoming links retains a small, non-zero baseline probability mass, representing the chance of a random teleportation.

Matrix Formulation and the Power Iteration Algorithm

On enterprise websites spanning tens of thousands of URLs, PageRank cannot be computed page-by-page. Instead, it is expressed as the stationary vector of a Markov transition matrix.

Let $A$ be the adjacency matrix of your website's internal link graph, where $A_{ij} = 1$ if page $i$ contains an internal link to page $j$, and $0$ otherwise.

We construct the row-stochastic transition probability matrix $M$:

$$M_{ij} = \begin{cases} \frac{A_{ij}}{L(i)} & \text{if } L(i) > 0 \ \frac{1}{N} & \text{if } L(i) = 0 \text{ (dangling node adjustment)} \end{cases}$$

To account for random teleportation, the Google matrix $G$ is computed as:

$$G = d M + \frac{1 - d}{N} \mathbf{E}$$

Where $\mathbf{E}$ is an $N \times N$ matrix of all ones.

The steady-state internal PageRank vector $\mathbf{p}$ satisfies the eigenvector equation:

$$\mathbf{p} = \mathbf{p} G$$

Because $G$ is a stochastic, irreducible, and aperiodic matrix, the Perron-Frobenius theorem guarantees that a unique stationary probability vector $\mathbf{p}$ exists where $\sum p_i = 1$.

  1. Initialize the vector $p^{(0)} = [1/N, 1/N, \dots, 1/N]$.
  2. Compute the next iteration: $p^{(k+1)} = p^{(k)} G$.
  3. Calculate the change: $\lVert p^{(k+1)} - p^{(k)} \rVert_1$.
  4. If it is below epsilon (for example $10^{-6}$), stop: the iteration has converged. Otherwise repeat step 2.

Typically, for standard website link topologies, the power iteration converges in 25 to 50 iterations.

Two-Way PageRank and CheiRank: Measuring Communicative Power

Modern information retrieval systems do not evaluate incoming PageRank in isolation. Research in directed network analysis reveals an inverse metric known as CheiRank.

PageRank measures the incoming popularity of a node (the probability that a random surfer lands on page $u$). CheiRank measures its outbound navigational efficiency (the probability of traversing from page $u$ to other nodes in the inverted graph).

Let $A^$ be the transposed adjacency matrix where edge directions are reversed ($A^{ij} = A{ji}$). The CheiRank vector $\mathbf{q}$ satisfies:

$$\mathbf{q} = \mathbf{q} G^*$$

Where $G^*$ is the Google matrix constructed on the inverted link topology.

In website architecture:

  • High PageRank, Low CheiRank: Authoritative content repositories, deep case studies, and primary documentation pages.
  • Low PageRank, High CheiRank: Navigational category listings, site maps, and directory indexes.
  • High PageRank, High CheiRank: Core structural hubs (such as primary category pillar pages) that both receive immense authority and efficiently distribute it across the network.

Understanding both dimensions prevents technical teams from creating "authority cul-de-sacs"—pages that accumulate high PageRank but fail to channel that equity forward into related subtopics.

PageRank vs. Kleinberg's HITS Algorithm

Another fundamental paradigm in algorithmic link analysis is Jon Kleinberg's Hyperlink-Induced Topic Search (HITS), which bifurcates graph nodes into two complementary roles:

  • Authorities: Documents that contain definitive, high-value information on a specific subject.
  • Hubs: Documents that point to multiple authoritative sources on that subject.
Evaluation DimensionGoogle PageRankKleinberg's HITS Algorithm
Graph ScopeGlobal, static web graph calculated offlineQuery-dependent neighborhood graph generated at query time
Node ClassificationSingle scalar authority score per documentDual scores: Authority weight ($x$) and Hub weight ($y$)
Algorithmic MechanicsStationary distribution of a Markov chain with damping factorMutually reinforcing vector updates ($x = A^T y$, $y = A x$)
Susceptibility to TrapsResolved via damping factor $d = 0.85$ and teleportation matrixSusceptible to topic drift and mutual reinforcement loops
Site Architecture ApplicationModeling global equity flow from homepage to deep URLsDesigning category pages (Hubs) that curate specialized articles (Authorities)

Search engines use principles from both algorithms: PageRank provides the underlying crawl frequency and baseline authority framework, while HITS principles inform how topic hubs curate and validate authoritative leaf documents.


The Mechanics of Pagination and Faceted Navigation Equity Sinks

Two of the most prevalent architectural failure modes in enterprise web applications occur in e-commerce catalogs and content archive pagination.

The Linear Pagination Chain Trap

When an archive or category lists articles across dozens of paginated pages (/blog?page=2, /blog?page=3, ... /blog?page=40), many implementations link only to the immediate next and previous pages:

$$\text{Category Page} \longleftrightarrow \text{Page 2} \longleftrightarrow \text{Page 3} \longleftrightarrow \dots \longleftrightarrow \text{Page 40}$$

In this linear chain topology, link equity degrades exponentially with each hop. By the time a crawler reaches Page 10, the transferred PageRank has attenuated by:

$$PR \propto d^{10} \approx (0.85)^{10} \approx 0.196$$

Articles linked exclusively from Page 10 receive less than one-fifth of the equity compared to articles linked on Page 1.

Architectural Solution: Implement logarithmic or tiered pagination. Instead of sequential $+1/-1$ links, expose direct links to powers of two or ten (e.g., Page 1, 2, 5, 10, 20, 50). That sharply reduces the maximum graph diameter and preserves equity across deep catalog items.

Faceted Filter Combinations and Crawl Budget Exhaustion

E-commerce websites frequently allow users to filter products by color, size, price, and manufacturer. If every filter selection creates a distinct crawlable URL with full bi-directional navigation links:

$$\text{Total URLs} = \prod_{i=1}^k (N_i + 1)$$

A catalog of 500 products with 4 filter facets can generate over 100,000 distinct URL permutations. In a PageRank graph model, these infinite parameter variations act as massive equity sinks, bleeding link authority away from your primary canonical product URLs and overwhelming crawler capacity.

Engineering Fix: Point canonical tags on secondary filter-parameter permutations at the parent category, or disallow parameter combinations in robots.txt. This stops the crawler dissipating equity into non-indexable states.


Real-World Internal Architecture Topologies Compared

The structural topology of your website directly controls the transition matrix $M$, determining where equity pools and where it is starved. Below is an engineering comparison of the four most common enterprise website topologies.

TopologyEquity behavior
Strict linear pyramid (Home, Category, Subcategory, Article)Severe attenuation at depths 3-4; deep pages are starved
Siloed topic cluster (Home, Hub, Spokes A, B, C)High equity preservation within relevant topical zones
Flat, fully-meshed network (every page links to every other)Equity is homogenized; no differentiation
Cyclic faceted or pagination drain (infinite facet and sort combinations)Massive equity dissipation into infinite URL sinkholes

Topology Analysis

Architecture TypePageRank Distribution PatternCrawl EfficiencySEO Risk Profile
Deep Linear PyramidHighly skewed toward root; exponential decay per hop ($PR \propto d^k$)Poor for deep leaf nodesDeep product/article pages receive insufficient equity to rank
Topic Silo (Cluster)Balanced within clusters; high local density around thematic hubsHigh; crawlers exhaust thematic nodes cleanlyLow risk; clear topical authority signals
Flat Mega-MenuEquity flattened equally across all linked endpointsHigh initial discoveryHomogenizes equity; low-value legal pages get identical weight to core products
Faceted / Parameter MeshSevere equity dissipation into search parameter combinationsCatastrophic; crawler traps dilute crawl budgetSevere indexation bloat; duplicate content cannibalization

The "Dangling Node" and Redirect Equity Drain

In production architectures, two issues consistently degrade internal equity flow:

  1. Dangling Nodes: Pages that terminate without outgoing links (e.g., checkout completion pages, static PDF downloads, or unlinked error pages). In matrix computation, dangling nodes absorb incoming equity and redistribute it uniformly across the entire site via the $\frac{1}{N}$ correction, depriving their immediate parent sections of reciprocal equity.
  2. Redirect Chains: When internal links point to URLs that return 301 or 302 HTTP redirects, crawlers must process secondary requests. Each intermediate redirect hop incurs latency and slight computational attenuation. To trace and resolve these leaks, review our guide on redirect chain audits and link equity drains.

Modeling Internal PageRank with Python and NumPy

Engineering teams do not need to guess how equity distributes across their sites. You can model your website's exact PageRank vector using a Python script that ingests an internal crawl CSV and computes the stationary distribution via power iteration:

python
#!/usr/bin/env python3
"""
compute_internal_pagerank.py - Models Internal PageRank distribution.
Reads an edge list CSV (source_url, target_url) and computes stationary
probability vectors using NumPy and sparse matrix formulations.
"""

import sys
import pandas as pd
import numpy as np
from scipy.sparse import csr_matrix

def compute_pagerank(edges_df: pd.DataFrame, damping: float = 0.85, max_iter: int = 100, tol: float = 1e-6):
    # Extract unique URLs
    unique_urls = sorted(list(set(edges_df['source']).union(set(edges_df['target']))))
    url_to_idx = {url: i for i, url in enumerate(unique_urls)}
    idx_to_url = {i: url for url, i in url_to_idx.items()}
    N = len(unique_urls)
    
    print(f"[*] Building transition matrix for {N} unique nodes...")
    
    # Map edges to indices
    sources = edges_df['source'].map(url_to_idx).values
    targets = edges_df['target'].map(url_to_idx).values
    
    # Calculate outbound degrees
    out_degree = np.bincount(sources, minlength=N)
    
    # Construct sparse transition matrix M
    # Weights are 1 / out_degree[source]
    weights = np.zeros(len(sources), dtype=np.float64)
    for i in range(len(sources)):
        src = sources[i]
        if out_degree[src] > 0:
            weights[i] = 1.0 / out_degree[src]
            
    # M[target, source] corresponds to flow from source to target
    M = csr_matrix((weights, (targets, sources)), shape=(N, N))
    
    # Identify dangling nodes (out_degree == 0)
    dangling_indices = np.where(out_degree == 0)[0]
    
    # Initialize PageRank vector uniformly
    p = np.full(N, 1.0 / N, dtype=np.float64)
    teleport = (1.0 - damping) / N
    
    print(f"[*] Commencing power iteration (damping={damping}, tol={tol})...")
    
    for iteration in range(max_iter):
        p_prev = p.copy()
        
        # Calculate dangling node mass contribution
        dangling_sum = np.sum(p_prev[dangling_indices])
        
        # Primary PageRank step: p = damping * (M * p_prev + dangling_sum / N) + (1 - damping) / N
        p = damping * (M.dot(p_prev) + dangling_sum / N) + teleport
        
        # Compute L1 error norm
        err = np.sum(np.abs(p - p_prev))
        if err < tol:
            print(f"[+] Converged in {iteration + 1} iterations (Error: {err:.2e})")
            break
    else:
        print(f"[!] Reached max iterations ({max_iter}) without absolute convergence.")
        
    # Compile results
    results = pd.DataFrame({
        'url': [idx_to_url[i] for i in range(N)],
        'pagerank': p,
        'out_links': out_degree
    }).sort_values(by='pagerank', ascending=False).reset_index(drop=True)
    
    # Normalize for intuitive display (scale top page to 100.0)
    max_pr = results['pagerank'].max()
    results['relative_score'] = (results['pagerank'] / max_pr) * 100.0
    
    return results

def main():
    if len(sys.argv) < 2:
        print("Usage: python3 compute_internal_pagerank.py <crawl_edges.csv>")
        print("CSV format required: source,target")
        sys.exit(1)
        
    csv_file = sys.argv[1]
    df = pd.read_csv(csv_file)
    
    if 'source' not in df.columns or 'target' not in df.columns:
        print("Error: CSV must contain 'source' and 'target' headers.")
        sys.exit(1)
        
    results = compute_pagerank(df)
    
    print("\nTOP 15 PAGES BY INTERNAL PAGERANK:")
    print("-" * 80)
    for idx, row in results.head(15).iterrows():
        print(f"{idx+1:02d}. [{row['relative_score']:6.2f}] (Out: {row['out_links']:3d}) {row['url']}")
    print("-" * 80)
    
    output_path = "internal_pagerank_results.csv"
    results.to_csv(output_path, index=False)
    print(f"[+] Full results exported to {output_path}")

if __name__ == "__main__":
    main()

Running the PageRank Simulation

To run this model, export your internal link edges into a simple two-column CSV:

bash
# Example CSV structure: crawl_edges.csv
# source,target
# https://example.com/,https://example.com/pricing
# https://example.com/,https://example.com/docs
# https://example.com/docs,https://example.com/docs/api

python3 scripts/compute_internal_pagerank.py crawl_edges.csv

The output gives your team exact mathematical clarity on which URLs possess outsized equity and which critical landing pages are suffering from structural starvation.


Once you have identified equity imbalances across your site, you can deploy targeted architectural interventions to reshape the graph:

  1. Contextual uplink injections. Add in-body links from high-PageRank articles to underperforming target pages.
  2. Boilerplate trimming. Remove low-value links from global footers and sidebars to reduce $L(v)$ and concentrate outbound equity.
  3. Hub breadcrumb anchoring. Make hierarchical breadcrumbs pass equity back up to category hubs.
  4. Eliminating unresolved redirects and 404s. Point links that hit 301s or 404s directly at the final canonical endpoints.

1. The Global Menu Pruning Strategy

Many modern sites include complete "mega-menus" containing hundreds of links on every single page. If your homepage contains 250 links, each link passes only:

$$\frac{PR(\text{Home})}{250} \times 0.85$$

Remove low-priority operational links (e.g., "Terms of Service", "Privacy Policy", "Press Releases") from the header and place them in a compact footer, or noindex them. You reduce the denominator $L(v)$, which amplifies the equity passed to your commercial category pages.

A single in-body link embedded within an article that has accumulated dozens of external backlinks transfers substantial internal PageRank. Regularly review your top 10% highest-backlink URLs and ensure they feature contextual links pointing to newly launched, high-priority pages.

For automated methods of identifying broken and decaying links across legacy posts, consult our guide on broken link checkers for large sites.

If your web application renders navigation via JavaScript dynamic clicks rather than standard HTML href anchors, crawlers may never build the correct edge graph during initial pass parsing. Review our technical guide on JavaScript links and crawl discovery to ensure that your single-page applications emit standard crawlable DOM structures.

Internal PageRank is the theory behind Phase 5 of the step-by-step on-page SEO checklist. To see how deep pages sit in practice, read click depth and SEO, and compare with where links really live in do footer links help SEO.


Frequently Asked Questions

What is internal PageRank?

Internal PageRank is the share of link equity each page of a website holds, calculated only from the site's own internal link graph. Each page splits its score among the pages it links to, scaled by a damping factor, so pages that are well linked and close to the homepage collect the most. It shows which pages your structure favours and which it starves.

What is the damping factor in PageRank?

The damping factor is the probability that the "random surfer" keeps following links instead of jumping to a random page, classically set to 0.85. The remaining 0.15 covers random jumps anywhere in the graph. It stops equity getting trapped in link loops or lost at pages with no outgoing links, and it means equity shrinks a little with every hop.

Yes, each extra link on a page reduces the equity passed through every other link on it. PageRank divides a page's outgoing equity by its number of outbound links, so a page with 100 links passes roughly one-hundredth of its share through each. Trimming low-value boilerplate links concentrates equity on the links that matter.

Linear pagination that links only to the next and previous page drains equity from deep archive pages. Each hop multiplies equity by the damping factor, so an article linked only from page 10 gets about 0.85 to the power of 10, roughly one-fifth of what a page 1 article gets. Linking to pages such as 1, 2, 5, 10, 20 and 50 shortens those chains.

How can I calculate internal PageRank for my own site?

Export your internal links from a crawl as a two-column CSV of source and target URLs, then run a power-iteration PageRank calculation over it, such as the Python and NumPy script in this guide. The result ranks every URL by modelled equity. Compare that list with your money pages to see which important pages are underlinked.


Modeling internal link equity starts with an accurate graph, and on JavaScript-heavy sites that means crawling the rendered DOM.

A BugViso scan runs this model for you on the pages it crawls (up to 300 per scan): it computes an internal PageRank for each page and shows it as an equity score and tier (high, medium, low or depleted) in the link graph, alongside the inputs:

  1. Extracts the Full Directed Graph: Crawls your site while executing client-side scripts, recording every internal a[href] edge across both static and dynamic DOM states.
  2. Finds Hubs and Orphans: Reports the most-linked pages and the orphan pages no internal link reaches.
  3. Identifies Equity Bottlenecks and Dangling Nodes: Highlights terminal pages, broken 404 targets, and excessive redirect chains that interrupt link equity distribution.
  4. Tracks Click Depth and Distance: Measures the exact shortest-path click distance from your homepage to every document, so you can see which critical pages sit more than three clicks from the root.

For an end-to-end framework on auditing technical infrastructure and crawl health, explore our guide on how to audit a website for SEO the right way.

You can see every rule BugViso applies in its technical SEO audit tool.


Treat internal linking as a graph governed by PageRank mechanics, not guesswork. Technical teams can then remove equity bottlenecks and channel crawl authority toward their most valuable pages.

To get the link graph, click depth and orphan list for your own site, sign in and run a BugViso scan.

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.