Page Link Checker 🔗 — Broken Link Detector & URL Validator (Batch)

Scan any webpage for broken links, track redirect chains, and validate HTTP status codes — across internal and external links, with batch support for up to 10 pages.

---

What does it do?

Every website has links — to internal pages, external resources, documentation, images, and APIs. Over time, those links break. Pages get deleted, domains expire, and URL structures change. A single broken link on a critical page can frustrate users, damage SEO rankings, and erode trust in your content.

Page Link Checker automates the tedious process of validating every link on a webpage. Give it a URL, and it fetches the page, extracts all hyperlinks, checks each one's HTTP status, and generates a comprehensive link health report. It classifies links as internal (same domain) or external, tracks redirect chains, measures response times, and flags every broken link with its specific error.

For teams managing multiple pages, the batch mode scans up to 10 pages in a single run, producing a consolidated report across your entire content portfolio. Uses automatic retries with backoff and timeout handling; partial results are preserved even if some links fail.

---

Who is it for?

Persona	What they use it for
SEO Specialist	Auditing client sites for broken links that harm search rankings and user experience
Web Developer	Validating all links before a site deployment or migration to catch dead references
Content Manager	Ensuring all external references and citations in published articles are still reachable
QA Engineer	Automated link checking as part of the website release pipeline
Technical Writer	Verifying documentation links and cross-references before publishing
Site Reliability Engineer	Monitoring link health across the company's web properties and alerting on regressions
Digital Agency Owner	Running bulk link audits for client reports and competitive analysis

---

Why use this?

• Automated bulk link validation, not manual clicking — Checking 200+ links on a page by hand takes hours. This actor scans them all concurrently in seconds, with detailed reports on every single link.

• Internal vs external link classification — Not all links are equal. Internal link rot is a content management issue; external broken links may be out of your control but still damage user trust. The actor separates them so you know where to focus.

• Redirect chain transparency — A link that redirects three times before reaching its destination is technically reachable but adds latency. The actor captures the full redirect chain so you can update direct links and improve page load times.

• Response time per link — Links that take 5+ seconds to respond degrade user experience even if they eventually load. The actor reports response times so you can identify slow external dependencies.

• Batch scanning for portfolio-wide audits — Scan up to 10 pages in one run and get a consolidated report. Perfect for agency audits, documentation site maintenance, or pre-launch QA across an entire site.

• No external API keys required — Pure HTTP-based validation. No signups, no API tokens, no rate limits other than standard politeness. Point it at any public URL and get results.

• Enterprise-grade error handling — Automatic retries with backoff, graceful handling of timeouts, DNS failures, and SSL errors. Partial results are preserved even if some links in a batch fail.

---

Features

1. Full Link Extraction

Parses the HTML of any webpage and extracts all anchor (<a>) links. Handles relative URLs, protocol-relative URLs, and various quoting styles. Filters out non-HTTP links (javascript:, mailto:, tel:, data:, file:) and deduplicates identical URLs.

2. HTTP Status Validation

Each extracted link is checked with an HTTP HEAD request (falling back to GET if HEAD is not supported). Links returning HTTP 4xx (Client Error) or 5xx (Server Error) are flagged as broken. Response times, content types, and final URLs are captured for every link.

3. Internal vs External Classification

Links are automatically classified based on domain comparison:

• Internal links — Same domain as the scanned page
• External links — Different domain (including subdomains) Useful for prioritizing which broken links you can fix directly vs those that depend on external sites.

4. Redirect Chain Tracking

If a link redirects (HTTP 3xx), the full redirect chain is recorded: every intermediate URL from the original link to the final destination. This helps identify outdated direct links that now route through multiple hops.

5. Broken Link Report

All broken links are gathered into a dedicated report view with their status codes, error messages, anchor text, and response times. Filter and sort to find the most critical issues first.

6. Page-Level Summary

Each scanned page includes aggregate statistics:

• Total links found
• Internal vs external link counts
• Reachable vs broken link counts
• Total scan duration
• Page title and HTTP status

7. Batch Mode (Up to 10 Pages)

Submit multiple pages in a single run for portfolio-wide scanning. Each page is processed independently with its own results, then all results are pushed to the same dataset for consolidated analysis.

8. Customizable Link Limit

Control how many links to check per page (default 200, maximum 500). Useful for pages with hundreds of links where you want to spot-check rather than deep-scan.

---

Input Parameters

Field	Type	Required	Default	Description
url	string	Yes*	—	Single webpage URL to scan for links. Either this or batchData[] must be provided.
batchMode	boolean	No	false	Enable batch processing to scan multiple pages in one run
batchData	array	No*	—	Array of objects with url fields for batch scanning (max 10 items)
maxLinks	integer	No	200	Maximum number of links to validate per page (1–500). Links beyond this limit are noted in the log but not checked.

*Either url (single mode) or batchMode: true with batchData[] (batch mode) must be provided.

---

Example Input

Single Page Scan

{
  "url": "https://example.com",
  "maxLinks": 100
}

Batch Scan (Multiple Pages)

{
  "batchMode": true,
  "batchData": [
    { "url": "https://example.com" },
    { "url": "https://example.org" },
    { "url": "https://example.edu" }
  ],
  "maxLinks": 200
}

---

Output Format

Each scanned page produces one dataset item with the full scan results.

Output Structure

Field	Type	Description
url	string	The webpage URL that was scanned
page_title	string	HTML <title> tag content
page_status_code	integer	HTTP status code of the scanned page
page_content_type	string	Content-Type header of the scanned page
total_links_found	integer	Total number of links extracted from the page
internal_links	integer	Links pointing to the same domain
external_links	integer	Links pointing to external domains
broken_links	integer	Links returning HTTP 4xx/5xx or connection errors
reachable_links	integer	Links returning HTTP 2xx/3xx successfully
scan_duration_ms	number	Total scan time in milliseconds
links	array	Detailed results for each checked link (see below)
error	string	Error message if the page could not be scanned
success	boolean	Whether the page scan completed

Link Object Fields

Field	Type	Description
url	string	The link URL that was checked
status_code	integer	HTTP status code (e.g., 200, 301, 404, 500)
error	string	Error description if the check failed
response_time_ms	number	Time to get a response in milliseconds
content_type	string	Content-Type of the linked resource
anchor_text	string	Visible text of the link (max 100 chars)
is_internal	boolean	Whether this link points to the same domain
is_broken	boolean	Whether this link returned an error (4xx/5xx/timeout)
redirect_chain	array	List of URLs in the redirect chain (empty if direct)

Example Output (Single Page)

{
  "url": "https://example.com",
  "page_title": "Example Domain",
  "page_status_code": 200,
  "page_content_type": "text/html",
  "total_links_found": 42,
  "internal_links": 15,
  "external_links": 27,
  "broken_links": 3,
  "reachable_links": 39,
  "links": [
    {
      "url": "https://example.com/about",
      "status_code": 200,
      "error": null,
      "response_time_ms": 234.5,
      "content_type": "text/html",
      "anchor_text": "About Us",
      "is_internal": true,
      "is_broken": false,
      "redirect_chain": []
    },
    {
      "url": "https://example.org/old-page",
      "status_code": 301,
      "error": null,
      "response_time_ms": 156.2,
      "content_type": "text/html",
      "anchor_text": "External Resource",
      "is_internal": false,
      "is_broken": false,
      "redirect_chain": [
        "https://example.org/old-page",
        "https://example.org/new-page"
      ]
    },
    {
      "url": "https://example.com/broken-link",
      "status_code": 404,
      "error": null,
      "response_time_ms": 89.1,
      "content_type": "text/html",
      "anchor_text": "Dead Page",
      "is_internal": true,
      "is_broken": true,
      "redirect_chain": []
    },
    {
      "url": "https://example.com/resource",
      "status_code": null,
      "error": "Request failed: ConnectError",
      "response_time_ms": 15200.0,
      "content_type": "",
      "anchor_text": "Expired Resource",
      "is_internal": false,
      "is_broken": true,
      "redirect_chain": []
    }
  ],
  "scan_duration_ms": 12450.3,
  "error": null,
  "success": true
}

---

Use Cases

• Pre-deployment link audit — Before launching a new site or major update, scan every page for broken links. Fix dead references before users find them.

• Monthly SEO maintenance — Run a batch scan of your entire sitemap monthly to identify new broken links. Google penalizes sites with excessive 404s.

• Documentation quality assurance — Technical documentation sites often have hundreds of cross-references and external links. Automate link checking as part of your CI/CD pipeline.

• Client reporting for agencies — Include link health metrics in monthly client reports. Show the number of broken links found and fixed, demonstrating proactive site management.

• Competitor link analysis — Scan competitor websites to find their broken external links. Identify opportunities for broken link building (suggesting your content as a replacement).

• Content migration validation — After migrating a site to a new domain or CMS, scan all pages to ensure no internal links still point to the old URLs or have broken in the process.

---

FAQ

What types of links does this actor check? It checks all anchor <a href="..."> links on the page. This includes internal links (same domain), external links (different domains), and various URL formats. Links using javascript:, mailto:, tel:, data:, and file: protocols are skipped as they cannot be validated via HTTP.

How does it handle relative URLs? Relative URLs are resolved against the scanned page's final URL (after any redirects). So <a href="/about"> on https://example.com/blog/page becomes https://example.com/about.

What counts as a "broken" link? Any link that returns HTTP 4xx (Client Error), HTTP 5xx (Server Error), or cannot be reached due to DNS failure, connection timeout, SSL errors, or network issues. HTTP 3xx redirects are NOT counted as broken.

How many links can it check per page? Default is 200 links per page, configurable up to 500. This limit prevents excessive run times on pages with thousands of links. Links beyond the limit are noted in the log but not checked individually.

How many pages can I scan in batch mode? Up to 10 pages per run. Each page is processed concurrently for maximum throughput.

Does it follow redirects on the scanned page itself? Yes. When fetching the initial page, the actor follows up to 20 redirects to reach the final page content. This handles common setups where http:// redirects to https:// or www to non-www.

Why does the link count differ from browser DevTools? Browsers execute JavaScript which can dynamically add links to the DOM after page load. This actor works with the raw HTML, which is faster and more predictable but may miss JS-injected links. It also deduplicates identical URLs, which browsers often display separately.

Can I scan pages that require authentication? Only public pages. The actor does not handle cookies, session tokens, or login forms. For private/internal sites, run the actor within your network or use Apify Proxy.

How long does a typical scan take? A page with 200 links typically completes in 10–60 seconds, depending on server response times. Slow or unresponsive links are given generous timeouts but can extend the run. Batch scans scale linearly — 5 pages × 100 links each ≈ 30 seconds to 3 minutes.

Does this actor store the checked pages' content? No. Only the link metadata (URL, status, timing) is stored in the result dataset. The actual page HTML is not retained.

Can I use this in CI/CD? Yes. Run the actor via the Apify API and check for broken_links > 0 in the output to fail a build. Example: curl -s "https://api.apify.com/v2/acts/perryay~page-link-checker/runs?token=$TOKEN" | jq '.data[].broken_links | add'.

What happens if the scanned page itself is down? The actor reports an error for that URL and does not attempt link checking. Other pages in a batch run are unaffected.

---

Usage & Billing

This actor uses a pay-per-event pricing model. You are charged only for successful operations:

Event Name	Price (USD)	Trigger
apify-actor-start	$0.005	Every run (once per run)
page-scan	$0.010	Each page successfully scanned
link-check	$0.002	Per successfully validated link (up to 200/page)
batch-report	$0.005	One-time charge when using batch mode

Example cost:

• Single page with 150 links: $0.005 + $0.010 + (150 × $0.002) = $0.315
• Batch of 5 pages with 100 links each: $0.005 + $0.005 + (5 × $0.010) + (500 × $0.002) = $1.06

Only successfully checked links are charged. Links that failed due to network errors or timeouts are not billed.

---

MCP Integration

This actor can be used as a tool inside any MCP-compatible AI client (Claude Desktop, Cursor, VS Code with Copilot) via the Apify MCP server.

Quick Start

1. Ensure your MCP client is configured to use the Apify MCP server:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

On first connection, your browser will open to sign in to Apify and authorize access.

2. Ask your AI assistant to scan a page for broken links. Example prompts:

"Use the Page Link Checker to scan https://example.com and report any broken links."

"Scan these three pages for broken links: example.com, example.org, and example.edu. Show me only the broken ones."

Bearer Token Alternative

For headless environments (CI/CD, VS Code without browser-based OAuth), configure with a personal API token:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}

Note: The OAuth flow is recommended for security. API tokens should be treated as secrets and never committed to version control.

---

Related Tools

• URL Health ❤️‍🩹 — URL & SSL Health Checker — Check individual URL status, SSL validity, and response times
• Link Quality Analyzer 🔗 — Deep analysis of link attributes and quality scoring
• Bulk HTTP Header Checker — Check HTTP headers across multiple URLs simultaneously
• Website Technology Stack Detector — Identify the tech stack powering any website