Free Internal Link Checker with HTTP Response Status Codes

(async () => {
    console.log("%c🔍 Scanning Internal Links...", "color: #4f46e5; font-weight: bold; font-size: 14px;");
    
    const currentHost = window.location.host;
    const currentProtocol = window.location.protocol;
    
    // 1. Gather all anchor tags on the page
    const allLinks = Array.from(document.querySelectorAll('a[href]'));
    const internalLinks = [];
    const seenUrls = new Set();

    allLinks.forEach(link => {
        try {
            // Resolve relative URLs to absolute URLs automatically
            const url = new URL(link.href, window.location.origin);
            
            // Filter: Must match current domain, must be http/https, ignore page hashes/anchors (#)
            if (url.host === currentHost && 
                (url.protocol === 'http:' || url.protocol === 'https:') && 
                !seenUrls.has(url.origin + url.pathname + url.search)) {
                
                const cleanUrl = url.origin + url.pathname + url.search;
                seenUrls.add(cleanUrl);
                
                internalLinks.push({
                    anchorText: link.textContent.trim() || '[No Anchor Text]',
                    url: cleanUrl
                });
            }
        } catch (e) {
            // Skip invalid or unparseable URLs
        }
    });

    if (internalLinks.length === 0) {
        console.log("✅ No internal links found on this page.");
        return;
    }

    console.log(`📊 Found ${internalLinks.length} unique internal URLs. Pinging URLs for status codes...`);

    // 2. Fetch status codes asynchronously
    const results = [];
    
    for (const item of internalLinks) {
        try {
            // Using standard GET or HEAD to check internal paths
            const response = await fetch(item.url, { method: 'GET' });
            
            results.push({
                "Anchor Text": item.anchorText,
                "Internal URL": item.url,
                "Status": response.status,
                "Status Text": response.statusText || (response.status === 200 ? "OK" : "")
            });
        } catch (error) {
            results.push({
                "Anchor Text": item.anchorText,
                "Internal URL": item.url,
                "Status": "FAILED / BLOCKED",
                "Status Text": "Network Error"
            });
        }
    }

    // 3. Separate clean links from broken/redirected links for easier analysis
    console.log("%c📋 All Internal Links Results:", "color: #10b981; font-weight: bold; font-size: 14px;");
    console.table(results);

    const brokenLinks = results.filter(r => r.Status === 404);
    if (brokenLinks.length > 0) {
        console.log("%c🚨 CRITICAL: Found 404 Broken Internal Links!", "color: #ef4444; font-weight: bold; font-size: 14px;");
        console.table(brokenLinks);
    } else {
        console.log("%c🎉 Clean Sweep! No 404 internal links detected on this page view.", "color: #10b981; font-weight: bold;");
    }
})();
    

async function findSourcePagesAndAnchorTypes() {

  const currentOrigin = window.location.origin;

  const currentPath = window.location.pathname;

  const currentFullUrl = currentOrigin + currentPath;

  const pageLinks = Array.from(document.querySelectorAll('a[href]'))

    .map(a => {

      try {

        const u = new URL(a.href, currentOrigin);

        return u.origin === currentOrigin ? u.origin + u.pathname : null;

      } catch { return null; }

    })

    .filter(url => url && url !== currentFullUrl);

  const pagesToScan = [...new Set(pageLinks)];

  console.log(`Scanning ${pagesToScan.length} pages on ${currentOrigin} for links pointing to "${currentPath}"...\n---`);

  const results = [];

  for (const pageUrl of pagesToScan) {

    try {

      const response = await fetch(pageUrl);

      const text = await response.text();

      const doc = new DOMParser().parseFromString(text, 'text/html');

      const matchingLinks = Array.from(doc.querySelectorAll('a[href]')).filter(a => {

        try {

          const u = new URL(a.href, currentOrigin);

          return u.origin === currentOrigin && (u.pathname === currentPath || u.pathname === currentPath + '.html');

        } catch { return false; }

      });

      matchingLinks.forEach(a => {

        let sourceType = 'Text';

        let sourceContent = a.innerText.trim().replace(/\s+/g, ' ');

        const img = a.querySelector('img');

        const svg = a.querySelector('svg');

        if (img) {

          sourceType = 'Image';

          sourceContent = img.alt ? `Alt: "${img.alt}"` : `Image Src: ${img.src.split('/').pop()} (No Alt)`;

        } else if (svg) {

          sourceType = 'SVG Icon';

          if (!sourceContent) sourceContent = '[SVG Graphic / Icon]';

        } else if (!sourceContent) {

          sourceType = 'Empty / Hidden';

          sourceContent = '[No Text Detected]';

        }

        results.push({

          'Source Page (URL)': pageUrl,

          'Source Type': sourceType,

          'Anchor Text / Source': sourceContent,

          'Exact Href Used': a.getAttribute('href')

        });

      });

    } catch (err) {

      console.warn(`Could not fetch ${pageUrl}`);

    }

  }

  console.log(`Scan Complete! Found ${results.length} incoming links:\n`);

  console.table(results);

}

findSourcePagesAndAnchorTypes();