# Broken Link Checker Pro (`bin_ai_tools/broken-link-checker-pro`) Actor

Check websites for broken links, redirects, timeouts, and HTTP errors. Export clean results for SEO audits and website maintenance.

- **URL**: https://apify.com/bin\_ai\_tools/broken-link-checker-pro.md
- **Developed by:** [Bin Bin](https://apify.com/bin_ai_tools) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00001 / result

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Broken Link Checker Pro

Find broken links across an entire website with a lightweight, HTTP-only scan. Broken Link Checker Pro is designed for SEO agencies, website owners, and maintenance teams that need clear link-status results without the cost of running a browser.

### Why use Broken Link Checker Pro?

- **Site-wide broken link checking** — enter one website URL and scan up to 100 same-domain pages by default.
- **No false broken alerts for 403/429** — access-blocked and rate-limited links are reported as `blocked`, not broken.
- **Weekly monitoring** — enable `monitorMode` and run the Actor from an Apify Schedule to compare each scan with the previous baseline.
- **Actionable changes** — see `NEW_BROKEN`, `STILL_BROKEN`, and `RESOLVED` on recurring scans.
- **No browser, low cost** — direct HTTP requests keep runtime and platform usage low.
- **Built for SEO and maintenance workflows** — export one Dataset row per checked link for audits, client reports, and repair backlogs.

### Quick start

1. Enter the website URL you want to check.
2. Keep the default settings for a standard scan, or enable **Weekly monitoring mode** for a scheduled recurring check.
3. Click **Start**, then open **Checked links** for individual results or **Scan summary** for totals.

### What it checks

- Same-domain pages are crawled breadth-first, up to 100 pages by default.
- Links are normalized and deduplicated globally. The Dataset keeps the first page where each link was found as `sourcePage`.
- External links are checked for status only. The Actor never continues crawling an external domain.
- HTTP results are classified as `ok` (2xx), `redirected` (3xx), `broken` (404/410 and other 4xx except blocked responses), `server-error` (5xx), or `blocked` (403/429).
- Redirects are followed, the redirect status is retained, and the resulting destination is recorded in `finalUrl`.
- Timeouts, DNS failures, connection failures, and other request failures are recorded with an `errorType`.
- Transient failures are retried automatically up to two times.
- `403` and `429` are reported as `blocked` and never set `isBroken` to `true`.

### Input

| Field | Default | Description |
| --- | ---: | --- |
| `startUrl` | — | Required HTTP or HTTPS URL to audit. |
| `maxPages` | `100` | Maximum same-domain HTML pages to crawl; capped at 100. |
| `maxConcurrency` | `3` | Conservative number of simultaneous HTTP requests; allowed range is 1–5. |
| `timeoutSecs` | `20` | Per-request timeout in seconds; allowed range is 5–60. |
| `monitorMode` | `false` | Turn on for weekly or other scheduled scans. The first run marks current broken links as `NEW_BROKEN` and saves a baseline; later runs report changes. |

The form is intentionally small so a marketing, SEO, or website-operations user can run an audit without configuring a browser, proxy, session, or crawl rule set.

### Dataset output

Each Dataset row contains exactly these fields:

- `sourcePage` — page where the unique link was first found.
- `url` — normalized link checked by the Actor.
- `finalUrl` — URL after redirects, when a response was received.
- `statusCode` — HTTP status code, or empty when no response was received.
- `isBroken` — `true` for broken, server-error, or unreachable links. Blocked links are always `false`.
- `errorType` — technical detail such as `http_4xx`, `http_5xx`, `timeout`, `dns`, `connection`, `request`, `blocked`, or empty.
- `responseTimeMs` — elapsed request time including automatic retries.
- `status` — user-facing classification: `ok`, `redirected`, `broken`, `server-error`, `unreachable`, or `blocked`.
- `changeStatus` — in later monitor runs, `NEW_BROKEN`, `STILL_BROKEN`, or `RESOLVED` when applicable.

The Dataset is useful for SEO audit exports, redirect cleanup, pre-launch QA, recurring website maintenance, and prioritizing fixes by broken-link type.

### Monitoring mode and scheduled runs

Set `monitorMode` to `true` when this Actor is used from an Apify Schedule. The first run marks current broken links as `NEW_BROKEN` and stores the broken URL set as a baseline. Later runs compare the same site's normalized URLs and add `changeStatus` where a link is newly broken, still broken, or resolved.

The baseline is stored in a named Apify Key-Value Store and is separated by a hash of `startUrl`, so different scheduled sites do not overwrite one another. Each run also writes a `RUN_SUMMARY` record to its default Key-Value Store with `totalLinks`, `ok`, `redirected`, `blocked`, `broken`, `newBroken`, and `resolved` counts.

### Scope and limitations

This V1.1 uses direct HTTP requests to keep runs affordable and predictable. It does not execute JavaScript, render browser-only navigation, log in to protected areas, submit forms, or crawl external domains. Links in JavaScript-generated menus and client-side applications may therefore be missed. Respect the target website's robots, rate, and access policies before running an audit.

# Actor input Schema

## `startUrl` (type: `string`):

Required. Enter the public HTTP or HTTPS address where the website scan should begin, for example https://example.com/.

## `maxPages` (type: `integer`):

How many same-domain HTML pages to scan. The default and maximum are 100 pages.

## `maxConcurrency` (type: `integer`):

How many HTTP requests may run at the same time. Keep the default 3 for a conservative scan; lower values are gentler on the website.

## `timeoutSecs` (type: `integer`):

How long to wait for each link before reporting a timeout. The default 20 seconds is suitable for most websites.

## `monitorMode` (type: `boolean`):

Turn on when using an Apify Schedule. The first run marks current broken links as NEW\_BROKEN and saves the baseline; later runs report NEW\_BROKEN, STILL\_BROKEN, and RESOLVED links.

## Actor input object example

```json
{
  "startUrl": "https://example.com/",
  "maxPages": 100,
  "maxConcurrency": 3,
  "timeoutSecs": 20,
  "monitorMode": false
}
```

# Actor output Schema

## `results` (type: `string`):

One Dataset row for every unique HTTP(S) link found, including its source page, final URL, status, and monitoring change when available.

## `summary` (type: `string`):

Quick totals for checked, healthy, redirected, blocked, broken, newly broken, and resolved links.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bin_ai_tools/broken-link-checker-pro").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("bin_ai_tools/broken-link-checker-pro").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call bin_ai_tools/broken-link-checker-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bin_ai_tools/broken-link-checker-pro"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JyRmoW9Uur8JBU7Se/builds/pichOqVg5G8V2TuPF/openapi.json