# Website SEO, Accessibility & AI Readiness Auditor (`feeng/website-seo-ai-readiness-auditor`) Actor

🔎 Crawl websites and turn technical SEO, accessibility, security, performance, broken-link, structured-data, robots.txt, llms.txt, and AI crawler signals into prioritized 0–100 audit scores and client-ready reports.

- **URL**: https://apify.com/feeng/website-seo-ai-readiness-auditor.md
- **Developed by:** [Daniel S.](https://apify.com/feeng) (community)
- **Categories:** SEO tools, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 audited website 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/platform/actors/running/actors-in-store#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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Website SEO, Accessibility & AI Readiness Auditor

Audit public websites for technical SEO, accessibility signals, security headers, broken links, lightweight performance risks, structured data, `robots.txt`, `sitemap.xml`, `llms.txt`, and major AI crawler directives. Get deterministic 0–100 scores, concrete evidence, prioritized fixes, structured dataset views, and a client-ready HTML report. 🔎

This Actor is built for SEO agencies, web developers, accessibility specialists, content teams, and website owners who need more than a raw crawl. It converts page-level signals into an actionable audit without a paid API and without calling another Actor.

### Quick Start 🚀

1. Add one or more website URLs or domains.
2. Keep **Maximum pages per site** at `10` for the first run.
3. Leave every audit module enabled.
4. Click **Save & Start**.
5. Open **Audit overview** for the prioritized page list or **Client-ready HTML report** for the visual summary.

Bare domains are accepted, so `example.com` becomes `https://example.com/`. The Actor follows same-site HTML links, prioritizes sitemap URLs, respects `robots.txt` by default, and stops at the configured per-site page limit.

### What It Audits

| Area | Checks |
| --- | --- |
| Technical SEO | HTTP status, indexability, robots directives, canonical tags, page title, meta description, H1 structure, structured data, internal/external links |
| Crawl discovery | `robots.txt`, declared and default sitemaps, sitemap indexes, same-site link discovery |
| Broken links | Unique internal and external destinations with status/error evidence mapped back to affected pages |
| Accessibility signals | HTML language, image alt attributes, programmatic form labels, accessible link/button names, main landmarks |
| AI readiness | `llms.txt`, JSON-LD context, semantic main content, and access rules for GPTBot, ChatGPT-User, OAI-SearchBot, ClaudeBot, Claude-SearchBot, Google-Extended, PerplexityBot, CCBot, and Bytespider |
| Security | HTTPS, HSTS, Content Security Policy, nosniff, Referrer-Policy, Permissions-Policy, and frame embedding protection |
| Performance hints | Initial HTML response time, transfer size, script pressure, render-blocking script hints, stylesheets, iframes, DOM size, and image lazy-loading coverage |
| Conversion structure | Forms, phone/email links, and common call-to-action labels |
| Mobile signals | Responsive viewport declaration, responsive image markup, and legacy layout-table hints |

### Why Use This Website Audit Actor? ✨

- **Evidence instead of vague grades:** every deduction has an issue code, severity, observed value, and concrete remediation action.
- **Agency-ready deliverables:** send the HTML report to a client or import flat CSV rows into a spreadsheet.
- **AI search visibility checks:** review machine-readable context and crawler policy alongside conventional SEO.
- **Predictable cost:** one visible dataset result per audited URL; no hidden API or third-party Actor charge.
- **Automation friendly:** purpose-built dataset views and JSON output work with the Apify API, webhooks, Make, Zapier, and AI agents.
- **Low infrastructure overhead:** the Actor performs direct HTTP analysis without launching a browser.

### URL-Level Output

Every audited page creates one dataset row with:

- `pageScore` and `siteScore` from 0 to 100
- category scores for SEO, accessibility, AI readiness, security, and performance hints
- critical, warning, informational, and total issue counts
- indexability and robots evidence
- title, description, H1, canonical, and structured data details
- checked and broken link evidence
- image, form, CTA, mobile, and accessibility signals
- security header and performance evidence
- `llms.txt` and AI crawler access status
- complete `issues`, `evidence`, and `recommendations` objects

See [`examples/output.json`](examples/output.json) for a representative row.

### Structured Dataset Views 📊

The default dataset has seven views:

- **Audit overview:** page/site scores, issue counts, indexability, broken links, and first actions.
- **SEO & indexability:** metadata, canonicals, robots, structured data, and link signals.
- **Accessibility signals:** fast HTML triage before manual WCAG testing.
- **AI readiness:** `llms.txt`, schema context, semantic structure, and AI crawler directives.
- **Security & performance:** headers, HTTPS, mobile, timing, transfer, script, and DOM hints.
- **Evidence & recommendations:** complete issue and remediation objects.
- **All URL-level data:** the full structured contract for APIs and integrations.

### Key-Value Store Reports

Each run stores:

- `REPORT.html`: client-ready visual report
- `REPORT.json`: run totals, site summaries, page rows, and request diagnostics
- `SUMMARY.json`: compact run and site summary
- `OUTPUT.json`: URL-level result export
- `OUTPUT.csv`: spreadsheet-ready flat export
- `ERRORS.json`: transparent request and sitemap diagnostics

### Example Input

```json
{
  "startUrls": [
    { "url": "https://example.com" },
    { "url": "https://www.apify.com" }
  ],
  "maxPagesPerSite": 10,
  "includeLinkChecks": true,
  "includeAiReadiness": true,
  "includeAccessibility": true,
  "includePerformanceHints": true,
  "respectRobotsTxt": true,
  "maxLinkChecksPerSite": 100,
  "maxSitesConcurrency": 2,
  "linkCheckConcurrency": 8,
  "requestTimeoutSecs": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Input Reference ⚙️

- `startUrls`: 1–20 public URLs or domains. The request-list UI accepts one URL per row.
- `maxPagesPerSite`: 1–200 same-site HTML pages per website.
- `includeLinkChecks`: check unique internal and external link destinations.
- `includeAiReadiness`: inspect `llms.txt`, AI crawler policy, structured context, and semantic content.
- `includeAccessibility`: run deterministic accessibility markup checks.
- `includePerformanceHints`: collect lightweight response and document complexity signals.
- `respectRobotsTxt`: avoid following disallowed discovered URLs. The submitted start URL is still fetched once.
- `maxLinkChecksPerSite`: 0–1,000 unique link checks per website.
- `maxSitesConcurrency`: audit 1–8 input websites in parallel.
- `linkCheckConcurrency`: perform 1–20 link status checks in parallel per website.
- `requestTimeoutSecs`: 5–90 seconds per request.
- `proxyConfiguration`: optional Apify Proxy settings.

### How Scoring Works

The score is deterministic and explainable:

- SEO: 40% of the default score
- Accessibility: 20%
- AI readiness: 15%
- Security: 15%
- Performance hints: 10%

Disabled optional modules are removed from the weighted calculation rather than treated as perfect. Each finding has an explicit deduction; category scores cannot fall below zero. Page grades are:

| Score | Grade |
| ---: | --- |
| 90–100 | Excellent |
| 75–89 | Good |
| 60–74 | Needs work |
| 40–59 | Poor |
| 0–39 | Critical |

The site score is the average of the audited page scores. It describes only the sampled URLs and is not a search-ranking guarantee.

### Recommended Audit Sizes

| Use case | Pages per site | Link checks |
| --- | ---: | ---: |
| Fast sales qualification | 3–5 | 25 |
| Standard agency audit | 10–25 | 100 |
| Content-heavy website | 50–100 | 250 |
| Large technical crawl sample | 200 | 500–1,000 |

Start small. Sitemap and same-site discovery make the first 10–25 pages useful for prioritization, but a capped sample cannot prove that every website URL is healthy.

### Run Locally

Requirements: Node.js 22 or newer.

```bash
npm install
export APIFY_LOCAL_STORAGE_DIR=./storage
printf '%s\n' '{"startUrls":[{"url":"https://example.com"}],"maxPagesPerSite":2}' > storage/key_value_stores/default/INPUT.json
npm start
```

Run the network-free unit tests:

```bash
npm test
```

Run a real public-web smoke test:

```bash
npm run smoke -- https://example.com
```

The smoke script uses the same HTTP client, sitemap discovery, page auditor, scorer, site aggregation, and HTML renderer as the Actor.

### Run on Apify

```bash
npx --yes apify-cli login
npx --yes apify-cli push
```

Then open the Actor in Apify Console, paste the example input, and verify the dataset views plus `REPORT.html`. See [`APIFY_PUBLISHING_CHECKLIST.md`](APIFY_PUBLISHING_CHECKLIST.md) for the exact publication process.

### Scheduling and Agency Workflows

- Run monthly technical health checks and send a webhook when critical issue counts increase.
- Audit prospect websites in small batches and prioritize outreach by `siteScore`.
- Export `OUTPUT.csv` into an agency audit workbook.
- Send `REPORT.html` to an account manager for review before a client meeting.
- Compare stored `REPORT.json` snapshots in your own automation to identify regressions.

This version is a point-in-time auditor, not a stateful change monitor. Historical comparisons can be built with scheduled runs and retained datasets.

### Important Limitations

- The Actor analyzes server-returned HTML and does not render client-side JavaScript. JavaScript-only metadata or links may not appear.
- Performance results are lightweight technical hints, not Lighthouse, CrUX, Core Web Vitals, or laboratory browser measurements.
- Accessibility checks are deterministic markup triage, not a WCAG conformance statement. Manual keyboard, screen-reader, contrast, and interaction testing remains necessary.
- Security header checks are not a penetration test or vulnerability assessment.
- `llms.txt` and AI crawler behavior are evolving. A discovered file or allowed crawler does not guarantee inclusion in an AI answer.
- Robots and noindex directives may be intentional. Confirm business and legal policy before changing them.
- External sites can block, throttle, redirect, or vary responses by region. Use Apify Proxy only when needed.

### Responsible Use

Audit only public websites you are permitted to access. Respect target terms, robots policies, reasonable request rates, privacy obligations, and applicable law. Verify findings before changing a production website or contacting a prospect.

### Pricing

Recommended Store pricing is **$0.010 per URL-level result** plus Apify's standard low synthetic Actor start event. A standard 10-page website audit therefore costs about **$0.10**, before any optional platform-usage pass-through. See [`PRICING.md`](PRICING.md) for margin assumptions and setup details.

# Actor input Schema

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

Public websites to audit. Enter a homepage, an internal page, or a bare domain; missing https:// is added automatically. Each site is crawled independently and only same-site HTML pages are followed.

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

Maximum same-site HTML pages audited for each input website. Sitemap URLs are prioritized, then internal links are followed until this limit is reached.

## `includeLinkChecks` (type: `boolean`):

Check unique internal and external links referenced by crawled pages. Broken-link evidence is added back to every affected URL.

## `includeAiReadiness` (type: `boolean`):

Inspect llms.txt, structured data, semantic content signals, and robots.txt access for GPTBot, OAI-SearchBot, ClaudeBot, Google-Extended, PerplexityBot, CCBot, and other major AI crawlers.

## `includeAccessibility` (type: `boolean`):

Run deterministic HTML checks for document language, image alt attributes, form labels, accessible link/button names, landmarks, and heading structure. This is not a substitute for manual WCAG testing.

## `includePerformanceHints` (type: `boolean`):

Report response time, HTML transfer size, script and stylesheet pressure, render-blocking scripts, iframe count, and image lazy-loading opportunities. This is a lightweight technical audit, not a Lighthouse field-data score.

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

Do not follow discovered URLs disallowed for this auditor's user agent. The submitted start URL is still fetched once so its public audit can be returned.

## `maxLinkChecksPerSite` (type: `integer`):

Safety limit across unique internal and external links found on one site. Increase carefully because link checks can dominate run time.

## `maxSitesConcurrency` (type: `integer`):

Number of input websites audited in parallel. Pages within one site are fetched sequentially to reduce load on the target.

## `linkCheckConcurrency` (type: `integer`):

Maximum link status requests performed in parallel per website.

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

Maximum time for one website request before recording a transparent timeout error.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Direct requests are cheapest and work for many public websites; use a proxy when targets block cloud traffic or require a regional IP.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "maxPagesPerSite": 10,
  "includeLinkChecks": true,
  "includeAiReadiness": true,
  "includeAccessibility": true,
  "includePerformanceHints": true,
  "respectRobotsTxt": true,
  "maxLinkChecksPerSite": 100,
  "maxSitesConcurrency": 2,
  "linkCheckConcurrency": 8,
  "requestTimeoutSecs": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `auditOverview` (type: `string`):

Scores, issue counts, indexability, broken links, and first actions for every audited URL.

## `seoAudit` (type: `string`):

On-page SEO, indexability, canonical, structured data, and link evidence.

## `accessibilityAudit` (type: `string`):

Deterministic HTML accessibility triage data.

## `aiReadinessAudit` (type: `string`):

llms.txt, semantic context, structured data, and AI crawler directives.

## `technicalAudit` (type: `string`):

Security headers, HTTPS, mobile, response, and page-weight hints.

## `issuesAndRecommendations` (type: `string`):

Complete issue objects and prioritized remediation actions.

## `allData` (type: `string`):

Full structured rows for integrations and custom analysis.

## `htmlReport` (type: `string`):

Visual run summary with site scores, priority findings, and audited URL table.

## `jsonReport` (type: `string`):

Run summary, site summaries, URL-level rows, and diagnostics in one JSON file.

## `summaryJson` (type: `string`):

Compact totals and per-site summaries without full page rows.

## `csvExport` (type: `string`):

Flat URL-level export for spreadsheets and CRMs.

## `jsonExport` (type: `string`):

Complete URL-level dataset export.

## `errors` (type: `string`):

Transparent robots.txt, sitemap, llms.txt, and page request failures.

# 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": [
        {
            "url": "https://example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("feeng/website-seo-ai-readiness-auditor").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": [{ "url": "https://example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("feeng/website-seo-ai-readiness-auditor").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 '{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ]
}' |
apify call feeng/website-seo-ai-readiness-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=feeng/website-seo-ai-readiness-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website SEO, Accessibility & AI Readiness Auditor",
        "description": "🔎 Crawl websites and turn technical SEO, accessibility, security, performance, broken-link, structured-data, robots.txt, llms.txt, and AI crawler signals into prioritized 0–100 audit scores and client-ready reports.",
        "version": "0.1",
        "x-build-id": "odySFF12mtQV5kGyv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/feeng~website-seo-ai-readiness-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-feeng-website-seo-ai-readiness-auditor",
                "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/feeng~website-seo-ai-readiness-auditor/runs": {
            "post": {
                "operationId": "runs-sync-feeng-website-seo-ai-readiness-auditor",
                "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/feeng~website-seo-ai-readiness-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-feeng-website-seo-ai-readiness-auditor",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🌐 Website URL(s) or domains",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Public websites to audit. Enter a homepage, an internal page, or a bare domain; missing https:// is added automatically. Each site is crawled independently and only same-site HTML pages are followed.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "Website URL",
                                    "type": "string",
                                    "description": "Public HTTP or HTTPS website URL.",
                                    "minLength": 1
                                }
                            }
                        },
                        "default": [
                            {
                                "url": "https://example.com"
                            }
                        ]
                    },
                    "maxPagesPerSite": {
                        "title": "📄 Maximum pages per site",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum same-site HTML pages audited for each input website. Sitemap URLs are prioritized, then internal links are followed until this limit is reached.",
                        "default": 10
                    },
                    "includeLinkChecks": {
                        "title": "🔗 Check broken links",
                        "type": "boolean",
                        "description": "Check unique internal and external links referenced by crawled pages. Broken-link evidence is added back to every affected URL.",
                        "default": true
                    },
                    "includeAiReadiness": {
                        "title": "🤖 Audit AI discoverability",
                        "type": "boolean",
                        "description": "Inspect llms.txt, structured data, semantic content signals, and robots.txt access for GPTBot, OAI-SearchBot, ClaudeBot, Google-Extended, PerplexityBot, CCBot, and other major AI crawlers.",
                        "default": true
                    },
                    "includeAccessibility": {
                        "title": "♿ Audit accessibility signals",
                        "type": "boolean",
                        "description": "Run deterministic HTML checks for document language, image alt attributes, form labels, accessible link/button names, landmarks, and heading structure. This is not a substitute for manual WCAG testing.",
                        "default": true
                    },
                    "includePerformanceHints": {
                        "title": "⚡ Audit performance hints",
                        "type": "boolean",
                        "description": "Report response time, HTML transfer size, script and stylesheet pressure, render-blocking scripts, iframe count, and image lazy-loading opportunities. This is a lightweight technical audit, not a Lighthouse field-data score.",
                        "default": true
                    },
                    "respectRobotsTxt": {
                        "title": "Respect robots.txt while crawling",
                        "type": "boolean",
                        "description": "Do not follow discovered URLs disallowed for this auditor's user agent. The submitted start URL is still fetched once so its public audit can be returned.",
                        "default": true
                    },
                    "maxLinkChecksPerSite": {
                        "title": "Maximum links checked per site",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety limit across unique internal and external links found on one site. Increase carefully because link checks can dominate run time.",
                        "default": 100
                    },
                    "maxSitesConcurrency": {
                        "title": "Concurrent websites",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Number of input websites audited in parallel. Pages within one site are fetched sequentially to reduce load on the target.",
                        "default": 2
                    },
                    "linkCheckConcurrency": {
                        "title": "Concurrent link checks",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum link status requests performed in parallel per website.",
                        "default": 8
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 5,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Maximum time for one website request before recording a transparent timeout error.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct requests are cheapest and work for many public websites; use a proxy when targets block cloud traffic or require a regional IP.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
