# SEO Audit & Broken Link Checker: Site Audit with 0-100 Score (`makerio/seo-audit-broken-links`) Actor

SEO checker and broken link checker in one crawl: a technical site audit with a 0-100 health score. Finds 404s, broken links and images, redirect chains, title, meta description, H1, canonical and noindex issues, sitemap and robots.txt problems and duplicates. HTML report and CSV.

- **URL**: https://apify.com/makerio/seo-audit-broken-links.md
- **Developed by:** [Makerio](https://apify.com/makerio) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 audited pages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does SEO Audit & Broken Link Checker do?

SEO Audit & Broken Link Checker crawls a website like a search engine does and tells you what is wrong with it: **broken links and images, 404 pages, redirect chains, missing or duplicate titles and meta descriptions, H1 problems, canonical and noindex mistakes, sitemap and robots.txt issues, orphan pages and AI crawler access**. You get one row per URL, an **HTML report** you can send to a client, a JSON summary and a **CSV of every broken link** with the page it is on.

- **Technical SEO audit of a whole site.** 52 checks per page and per site, sorted into errors, warnings and notices, with a health score from 0 to 100.
- **Broken link checker included.** Every internal link, external link, image, canonical and hreflang URL on the audited pages is checked, with no extra charge per link. Links to `#anchors` are checked too: the target page must have an element with that `id` or `<a name>`.
- **Soft 404 check.** One request to a page that cannot exist shows whether missing pages really return 404, and crawled pages that show the site's "not found" page with a 200 status are flagged.
- **Redirects explained.** Each redirect hop is a row, so you see chains, loops and redirects that end on an error page.
- **Sitemap and robots.txt.** Reads robots.txt and every sitemap (also sitemap indexes and .gz), and reports sitemap URLs that are broken, redirect or are noindex, pages missing from the sitemap and pages that only the sitemap knows about.
- **AI search readiness.** Shows whether robots.txt lets GPTBot, ClaudeBot, PerplexityBot, Google-Extended and other AI crawlers in, and whether the site has an llms.txt file.
- **Plain HTTP, fast and cheap.** Pages are fetched as raw HTML, the way search engines first see them. No browser, so a 200-page audit usually takes a few minutes.

### Who is it for?

- **SEO agencies and freelancers:** run a site audit for a new client, export the issues, send the HTML report.
- **Site owners and marketers:** find broken links and 404s before your visitors and Google do; schedule a weekly run.
- **Developers and QA:** check a staging site or a migration for broken links, redirect chains and noindex left on by mistake.
- **AI agents and automations:** an agent can audit a site through the Apify MCP server and read the JSON summary.

### How much does it cost?

Pay per event: **$0.004 per audited URL, $4 per 1,000 pages**. Checking the links, images and external URLs on those pages is included. Apify's usual run start of $0.00005 per GB of memory is added ($0.00005 per run with the default 1 GB).

| Site size | Cost |
|---|---|
| 50 pages | $0.20 |
| 500 pages | $2.00 |
| 5,000 pages | $20.00 |

Pages that could not be loaded at all (timeout, DNS or connection errors) are not charged. Set **Max pages per site** or a spending limit on the run to cap the cost; the crawl stops there and still writes the report. With the Apify free plan's $5 monthly credit you can audit about 1,250 pages a month for free.

For comparison, in Apify Store on 16 November 2026 most crawling SEO audit Actors charged $0.005–$0.04 per page, and broken link checkers charged about $1 per 1,000 links checked; one page often has 50–150 links.

### How to use it

1. Open the **Input** tab and enter one or more websites, e.g. `https://example.com`.
2. Set **Max pages per site** (200 by default).
3. Click **Start**. When the run finishes, open **report.html** from the Output tab, or the dataset for the per-page table.

#### Input example

```json
{
    "startUrls": ["https://example.com"],
    "maxPagesPerSite": 500,
    "checkExternalLinks": true,
    "checkImages": true,
    "excludeUrlPatterns": ["*/tag/*", "*?sort=*"]
}
```

| Field | What it does | Default |
|---|---|---|
| `startUrls` | Websites to audit, one per line | required |
| `maxPagesPerSite` | Stop after this many URLs per site | 200 |
| `checkExternalLinks` | Check links to other websites | `true` |
| `checkImages` | Check that images load | `true` |
| `useSitemap` | Also audit sitemap URLs that no page links to | `true` |
| `respectRobotsTxt` | Skip URLs that robots.txt disallows | `true` |
| `includeSubdomains` | Count blog.example.com as part of example.com | `false` |
| `maxDepth` | Clicks away from the start URL | no limit |
| `includeUrlPatterns`, `excludeUrlPatterns` | Limit the crawl with `*` wildcards or `/regex/` | — |
| `maxConcurrencyPerSite` | Parallel requests to the audited site | 4 |
| `delayMs` | Pause between requests to the site | 0 |
| `requestTimeoutSecs` | Give up on a page after this long | 20 |
| `userAgent` | Custom user agent | MakerioSEOAudit |

### What you get

#### The HTML report

`report.html` in the run's key-value store: health score, pages audited, errors, warnings, notices, broken links and average response time; then every issue with the number of pages and example URLs, the broken links with the pages they are on and the anchor text, duplicate titles and descriptions, robots.txt, sitemap and AI crawler findings, and the slowest pages.

#### One row per URL

The dataset has four views: **Overview**, **Titles and headings**, **Indexing** and **Links**. Export it as CSV, Excel or JSON. An example row from python.org (shortened):

```json
{
    "url": "https://www.python.org/about/apps/",
    "statusCode": 200,
    "responseTimeMs": 39,
    "depth": 1,
    "indexable": true,
    "indexability": "indexable",
    "title": "Applications for Python | Python.org",
    "titleLength": 36,
    "metaDescription": "The official home of the Python Programming Language",
    "metaDescriptionLength": 52,
    "h1": "Applications for Python",
    "h1Count": 7,
    "wordCount": 718,
    "canonical": null,
    "canonicalStatus": "missing",
    "lang": "en",
    "structuredData": ["WebSite", "SearchAction"],
    "internalLinks": 53,
    "externalLinks": 66,
    "brokenLinks": [
        { "url": "http://www.pygtk.org/", "statusCode": null, "error": "DNS_FAILURE", "anchor": "GTK+", "type": "external" },
        { "url": "http://wiki.python.org/moin/TkInter", "statusCode": 404, "error": null, "anchor": "Tk", "type": "external" }
    ],
    "brokenLinksCount": 4,
    "redirectingLinks": 34,
    "issues": ["broken-links", "links-to-redirects", "meta-description-too-short", "missing-canonical", "multiple-h1"],
    "errors": 1,
    "warnings": 0,
    "notices": 4
}
```

#### Summary and broken links CSV

- `OUTPUT`: JSON with the health score, issue counts and example URLs, the full broken link list, links to missing #anchors, duplicate groups, orphan pages, pages missing from the sitemap, the soft 404 check, robots.txt, sitemap, llms.txt and HTTPS/www findings for each site.
- `broken-links.csv`: one line per broken link, image or #anchor: site, page, broken URL, type, status code, error, anchor text.

### What is checked

**Errors:** 4xx and 5xx pages, pages that fail to load, broken internal and external links, missing title, broken canonical URL, redirect loops, redirects that end on an error, sitemap URLs that return errors.

**Warnings:** broken images, missing meta description, missing H1, title over 60 characters, duplicate titles and meta descriptions, several title, description or canonical tags, canonical that redirects, images without alt text, noindex pages, no mobile viewport, HTTP resources on HTTPS pages, invalid JSON-LD, redirect chains, responses slower than 1.5 s, sitemap URLs that redirect or are noindex, links to pages blocked by robots.txt, links to #anchors that do not exist on the page, missing pages that return 200 instead of 404 (soft 404), pages that look like the site's "not found" page.

**Notices:** redirects, short titles and meta descriptions, long meta descriptions, several H1, duplicate H1, missing or other-page canonical, no `lang`, fewer than 200 words, no Open Graph tags, no structured data, links to redirects, nofollow pages, HTML over 2 MB, long URLs, uppercase or underscores in URLs, orphan pages, indexable pages missing from the sitemap.

**Per site:** robots.txt and crawl delay, sitemaps and their errors, llms.txt, access for 10 AI crawlers, whether HTTP redirects to HTTPS and whether www and non-www end on one host.

Links to social networks (X, LinkedIn, Facebook, Instagram and others) that refuse automated checks are counted as *restricted*, not broken, and so are 401, 403 and 429 answers.

### Use with Apify MCP and AI agents

- **Apify MCP server.** Add `https://mcp.apify.com?tools=makerio/seo-audit-broken-links` to an MCP client such as Claude Desktop, Claude Code, Cursor or VS Code and sign in with your Apify account. Then ask, for example: *"Audit example.com, 100 pages, and list the broken links and the pages missing a meta description."*
- **API.** Start a run with `POST https://api.apify.com/v2/acts/makerio~seo-audit-broken-links/runs?token=YOUR_TOKEN` and the input JSON, then read `OUTPUT` from the run's key-value store, or use `run-sync-get-dataset-items` for small sites.

### Tips

- **Large sites:** start with 500–1,000 pages and exclude faceted URLs (`*?sort=*`, `*?filter=*`) so the page budget goes to real pages.
- **Small or slow servers:** set **Parallel requests per site** to 1–2 and add a delay.
- **Schedule it:** a weekly run with the same input shows new broken links as they appear.
- **Only one section:** use `includeUrlPatterns`, e.g. `*/blog/*`.
- **Many domains, homepage only:** paste a list of domains and set **Max pages per site** to 1. The row of each start URL has `siteChecks`: robots.txt, sitemap and its URL count, llms.txt, the AI crawlers that robots.txt blocks, and whether HTTP redirects to HTTPS. Open the **Site checks** view of the dataset.

### Limits

- Pages are read as HTML without running JavaScript. Content that a site builds only in the browser (some single-page apps) is not seen, as with most SEO crawlers in their default mode. For the same reason, an #anchor that a script adds after the page loads counts as missing; single-page-app routes such as `#/page` are not checked.
- When a server answers 429 or 503, the Actor waits as long as its `Retry-After` header says (seconds or a date, up to 10 seconds) and tries once more.
- Only public pages. The Actor does not log in, solve CAPTCHAs or get around bot protection; a site that blocks it shows 403 or 429 in the results.
- It follows robots.txt by default and identifies itself as `MakerioSEOAudit`. Audit sites you own or are allowed to audit.
- Link checks per site are capped at 40 per page in the limit (at least 2,000), so a run cannot turn into a crawl of the whole web.

### Feedback

Something looks wrong or a check is missing? Open an issue on the **Issues** tab with the URL and your input.

# Actor input Schema

## `startUrls` (type: `array`):

One website per line, e.g. https://example.com. The crawl starts here and follows links on the same site (www and non-www count as one site).

## `maxPagesPerSite` (type: `integer`):

Stop after this many URLs per site. Each audited URL is one 'page' event. Links on the audited pages are still checked.

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

Check that links to other websites work. Included in the page price.

## `checkImages` (type: `boolean`):

Check that images on the pages load. Included in the page price.

## `useSitemap` (type: `boolean`):

Also audit URLs from sitemap.xml that no page links to. Sitemaps are always read for the sitemap checks.

## `respectRobotsTxt` (type: `boolean`):

Do not request URLs that robots.txt disallows. Turn this off only for a site you own or are allowed to audit.

## `includeSubdomains` (type: `boolean`):

Treat blog.example.com and shop.example.com as part of example.com.

## `maxDepth` (type: `integer`):

How many clicks away from the start URL to crawl. Empty means no limit.

## `includeUrlPatterns` (type: `array`):

Patterns with \* as a wildcard, e.g. */blog/*. Wrap a regular expression in slashes. Empty means the whole site.

## `excludeUrlPatterns` (type: `array`):

Patterns with \* as a wildcard, e.g. */tag/* or *?sort=*. These URLs are neither crawled nor checked.

## `maxConcurrencyPerSite` (type: `integer`):

How many requests go to the audited site at the same time. Lower it for small servers. A Crawl-delay in robots.txt is respected.

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

Across all sites and link checks.

## `delayMs` (type: `integer`):

Pause between two requests to the audited site.

## `requestTimeoutSecs` (type: `integer`):

Give up on a page after this long. Link checks use at most 10 seconds.

## `userAgent` (type: `string`):

Leave empty to identify as MakerioSEOAudit. robots.txt rules are matched for MakerioSEOAudit and \*.

## Actor input object example

```json
{
  "startUrls": [
    "https://crawler-test.com/"
  ],
  "maxPagesPerSite": 50,
  "checkExternalLinks": true,
  "checkImages": true,
  "useSitemap": true,
  "respectRobotsTxt": true,
  "includeSubdomains": false,
  "maxConcurrencyPerSite": 4,
  "maxConcurrency": 10,
  "delayMs": 0,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

## `report` (type: `string`):

Health score, issues by severity, broken links with the pages they are on, duplicates, sitemap, robots.txt and AI crawler access.

## `pages` (type: `string`):

One row per crawled URL: status, title, meta description, H1, canonical, indexability, links, broken links and issues.

## `brokenLinks` (type: `string`):

Every broken link, image and #anchor: the page it is on, the broken URL, status code and anchor text.

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

Site-level results: health score, issue counts with example URLs, duplicates, orphan pages, sitemap and robots.txt findings.

# 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 = {
    "startUrls": [
        "https://crawler-test.com/"
    ],
    "maxPagesPerSite": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("makerio/seo-audit-broken-links").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 = {
    "startUrls": ["https://crawler-test.com/"],
    "maxPagesPerSite": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("makerio/seo-audit-broken-links").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 '{
  "startUrls": [
    "https://crawler-test.com/"
  ],
  "maxPagesPerSite": 50
}' |
apify call makerio/seo-audit-broken-links --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,makerio/seo-audit-broken-links"
        }
    }
}
```

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/yb6agZh2w3kYPBoED/builds/1HJDjTSPinBFJ1rqb/openapi.json
