# Broken Link Monitor For Website Owners (`shahabuddin38/broken-link-monitor-for-website-owners`) Actor

I build web automation and website auditing tools for website owners, agencies, and marketers.

- **URL**: https://apify.com/shahabuddin38/broken-link-monitor-for-website-owners.md
- **Developed by:** [Shahab Uddin](https://apify.com/shahabuddin38) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Monitor for Website Owners

Find broken links, redirects, and website errors instantly.
Scan any website and detect SEO issues that hurt rankings, user experience, and conversions.

🔍 What is this tool?

Broken Link Monitor for Website Owners is a powerful website crawler & SEO audit tool that scans your website and detects:

❌ Broken links (4xx / 5xx errors)
🔁 Redirects (301 / 302 / 307 / 308)
⚠️ Page errors and crawl issues
🔗 Internal and external links
📊 Website link health overview

Perfect for website owners, SEO experts, agencies, developers, and bloggers.

💡 Why use this tool?

Broken links and redirects can:

Hurt your Google rankings (SEO)
Reduce user trust and experience
Cause lost traffic and revenue
Affect site crawlability and indexing

👉 This tool helps you fix those issues fast.

⚡ Key Features
🌐 Multi-page website crawler
🔍 Internal + external link checker
⚙️ Technical SEO audit ready
🔐 Smart SSL handling (auto retry)
⚡ Fast scanning with safe defaults
📁 Export results (JSON / CSV)
🧠 Intelligent crawl stopping logic
🛠️ Works even on sites with SSL issues
🎯 Best For
Website owners fixing broken links
SEO professionals doing technical audits
Agencies managing client websites
Developers maintaining site health
Bloggers & ecommerce store owners
🧾 Input

Provide the following:

{
  "startUrl": "https://example.com/",
  "maxPages": 25,
  "checkExternalLinks": false,
  "ignoreSslErrors": false
}
Input Options
Field	Description
startUrl	Website URL to scan
maxPages	Max pages to crawl (recommended: 10–50)
checkExternalLinks	Check external links or not
ignoreSslErrors	Ignore SSL errors if site has issues
📊 Output

Each result includes:

sourcePage → Page where link was found
linkUrl → Detected link
finalUrl → Final URL after redirects
statusCode → HTTP status
isInternal → Internal or external
result → broken / redirect / error
Summary Example
{
  "startUrl": "https://example.com/",
  "crawledPages": 12,
  "foundLinks": 145,
  "brokenLinks": 5,
  "redirects": 9,
  "externalLinks": 60,
  "internalLinks": 85
}
⚙️ How it works
Starts from your homepage
Crawls internal links (same domain)
Extracts all valid URLs
Checks status of each link
Reports broken links, redirects, and errors
Stops based on maxPages or crawl limits
🧠 Smart Crawling System
Only crawls internal pages
Avoids duplicate URLs
Handles relative & absolute links
Ignores invalid links (mailto, tel, javascript)
Continues even if some pages fail
Automatically retries SSL errors when needed
🚨 Important Notes
If a site has JavaScript-only navigation, some links may not be detected
Increase maxPages for deeper scans
Use ignoreSslErrors = true only if SSL issues occur
💰 Why this tool is different

Unlike basic link checkers, this tool:

✔️ Performs a real multi-page crawl
✔️ Detects technical SEO issues
✔️ Handles SSL failures automatically
✔️ Designed for real-world websites
✔️ Built for speed + accuracy
🧪 Example Use Cases
SEO audit before website launch
Fix broken links after migration
Monitor site health regularly
Improve Google indexing
Find hidden crawl errors
🔥 SEO Keywords (Optimized)

Broken link checker, website audit tool, SEO audit tool, website crawler, link checker tool, technical SEO tool, find broken links, website health checker, crawl website, SEO scanner

---
### Apify Integration

This actor is designed to run on the [Apify platform](https://apify.com/). It uses Apify's input schema and dataset features for configuration and result storage.

#### How to use on Apify

1. **Deploy the actor**
   - Push this repository to your Apify account or create a new actor and upload the code.
2. **Configure input**
   - The actor uses the following input schema (see `input_schema.json`):
     - `startUrl` (string, required): The first page to crawl (e.g., https://example.com/)
     - `maxPages` (integer, default: 25): Maximum number of internal pages to crawl
     - `checkExternalLinks` (boolean, default: false): Whether to check external links
     - `ignoreSslErrors` (boolean, default: false): Ignore SSL certificate errors
3. **Run the actor**
   - The actor will crawl the website, check links, and store results in the Apify dataset.
4. **View results**
   - Results are available in the Apify run dataset as JSON or CSV. Each record contains:
     - `sourcePage`, `linkUrl`, `finalUrl`, `statusCode`, `isInternal`, `result`

#### Example input (Apify UI or API)
```json
{
  "startUrl": "https://example.com/",
  "maxPages": 25,
  "checkExternalLinks": false,
  "ignoreSslErrors": false
}
````

#### Example output (dataset record)

```json
{
  "sourcePage": "https://example.com/",
  "linkUrl": "https://www.example.com/",
  "finalUrl": "https://www.example.com/",
  "statusCode": 200,
  "isInternal": false,
  "result": "ok"
}
```

***

# Actor input Schema

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

The first page to crawl (e.g., https://example.com/)

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

Maximum number of same-domain internal pages to crawl

## `checkExternalLinks` (type: `boolean`):

Whether to check discovered links pointing to external websites

## `ignoreSslErrors` (type: `boolean`):

Ignore SSL certificate verification errors when crawling pages and checking links

## Actor input object example

```json
{
  "startUrl": "https://example.com/",
  "maxPages": 25,
  "checkExternalLinks": false,
  "ignoreSslErrors": false
}
```

# 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 = {
    "startUrl": "https://example.com/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahabuddin38/broken-link-monitor-for-website-owners").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 = { "startUrl": "https://example.com/" }

# Run the Actor and wait for it to finish
run = client.actor("shahabuddin38/broken-link-monitor-for-website-owners").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrl": "https://example.com/"
}' |
apify call shahabuddin38/broken-link-monitor-for-website-owners --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shahabuddin38/broken-link-monitor-for-website-owners",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Broken Link Monitor For Website Owners",
        "description": "I build web automation and website auditing tools for website owners, agencies, and marketers.",
        "version": "0.9",
        "x-build-id": "3HaI9ImIVcDBMbURu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahabuddin38~broken-link-monitor-for-website-owners/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahabuddin38-broken-link-monitor-for-website-owners",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/shahabuddin38~broken-link-monitor-for-website-owners/runs": {
            "post": {
                "operationId": "runs-sync-shahabuddin38-broken-link-monitor-for-website-owners",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/shahabuddin38~broken-link-monitor-for-website-owners/run-sync": {
            "post": {
                "operationId": "run-sync-shahabuddin38-broken-link-monitor-for-website-owners",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "The first page to crawl (e.g., https://example.com/)"
                    },
                    "maxPages": {
                        "title": "Max Pages to Crawl",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of same-domain internal pages to crawl",
                        "default": 25
                    },
                    "checkExternalLinks": {
                        "title": "Check External Links",
                        "type": "boolean",
                        "description": "Whether to check discovered links pointing to external websites",
                        "default": false
                    },
                    "ignoreSslErrors": {
                        "title": "Ignore SSL Errors",
                        "type": "boolean",
                        "description": "Ignore SSL certificate verification errors when crawling pages and checking links",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```