# Axe Accessibility Tester (`theguide/axe-accessibility-tester`) Actor

Run automated WCAG audits with axe-core on any set of webpages and export structured reports.

- **URL**: https://apify.com/theguide/axe-accessibility-tester.md
- **Developed by:** [TheGuide](https://apify.com/theguide) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Stats:** 13 total users, 0 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Axe Accessibility Tester

Check any group of webpages for WCAG compliance in minutes. Enter the pages you care about, run the scan, and share a clear report that highlights the most critical issues first.

### What you get
- **Instant overview** – A dashboard for each page showing how many serious, moderate, and minor issues were detected.
- **Shareable HTML report** – Every run creates a polished report link that anyone on your team can open without technical tools.
- **Plain-language guidance** – Each issue explains what is wrong, why it matters, and what to ask your developers to fix.
- **Pay only for audited pages** – Pricing is per page, so you control the cost of every scan.

### Who benefits most
- Marketing and content teams shipping new landing pages or campaigns.
- Agencies delivering quick accessibility checks to clients.
- Compliance or legal teams that must document WCAG / ADA status.
- Product managers who need a prioritized list of fixes for engineering.

### How to run a scan
1. Paste the URLs you want to audit. You can add a short label to keep track of each page.
2. (Optional) Choose the WCAG tags or specific rules you want to focus on.
3. Start the actor. It loads every page, runs the latest axe-core engine, and records the results.
4. Open the dataset tab for this run and click the HTML report link to review or share the findings.

### Input fields explained
- **Pages to scan (`startUrls`)** – Paste one or more page addresses. Each entry can include an optional `label` so you recognize the page in the results table.
- **WCAG tags (`wcagTags`)** – Keep this empty to catch all issues, or write tags such as `wcag2aa` if you only need that level.
- **Custom rule filters (`runOnly`)** – Advanced option to limit the audit to named axe rules or tags. Most users can leave it blank.
- **Minimum impact (`impactThreshold`)** – Pick the lowest severity you want in the report. For high-level reviews choose `serious`; for full detail choose `minor`.
- **Extra axe settings (`axeOptions`)** – Add JSON options only if you need to tweak axe-core behaviour.
- **Include raw axe data (`storeFullResult`)** – Set to `true` if you want the unfiltered axe payload for technical follow-up. Otherwise the report only keeps the filtered issues.
- **Navigation timeout (`navigationTimeoutSecs`)** – How long the scan waits for a page to finish loading (45 seconds by default).
- **Proxy configuration (`proxyConfiguration`)** – Use Apify proxies when a site blocks repeated requests or requires a specific location.

All other technical defaults (concurrency, retries, etc.) are preconfigured so you can run the actor without adjustments.

### Output
- **Dataset table** – One row per page with the label, URL, issue counts by severity, and a direct link to the HTML report.
- **Violations view** – A second table listing every individual issue with its description, impact, documentation link, and affected element.
- **HTML report (`OUTPUT`)** – A branded, reader-friendly report you can download or share as a link.
- **Optional raw data** – If you enable `storeFullResult`, the dataset includes the entire axe-core response for advanced analysis.

### Pricing
- Billing uses Apify’s pay-per-event model.
- Each audited page triggers the `page-audit` event.
- You are only charged for pages that complete a scan during the run.

### Tips for best results
- Start with your most visited or legally sensitive pages (homepage, signup flows, forms).
- Run the actor after every content or product release to prevent regressions.
- Share the HTML report with designers and engineers to coordinate fixes.
- Re-run the scan after fixes to confirm that issues are resolved.

### Need help?
Use the contact form on the actor’s Apify page if you need enterprise volumes, scheduled monitoring, or custom branding in the report.

# Actor input Schema

## `startUrls` (type: `string`):

JSON array of request sources (e.g. [{ "url": "https://example.com" }]).
## `wcagTags` (type: `string`):

Optional comma or newline separated list, or JSON array, of tags to include (e.g. wcag2a, wcag21aa).
## `runOnly` (type: `string`):

Optional JSON object passed to axe runOnly (e.g. { "type": "tag", "values": ["wcag2aa"] }).
## `impactThreshold` (type: `string`):

Only include violations whose impact is equal to or greater than the selected level.
## `axeOptions` (type: `string`):

Optional JSON object passed directly to axe.run().
## `maxConcurrency` (type: `integer`):

Number of parallel browser pages used during the crawl.
## `maxRequestsPerCrawl` (type: `integer`):

Limit the total number of pages to audit in a single run.
## `navigationTimeoutSecs` (type: `integer`):

How long to wait for each page to load before running axe.
## `storeFullResult` (type: `boolean`):

When enabled, the dataset will contain the complete axe results (violations, passes, incomplete, inapplicable). Otherwise, it stores a condensed violation summary.
## `proxyConfiguration` (type: `object`):

Configure proxies to use for the crawl. Using Apify Proxy is recommended for production runs.

## Actor input object example

```json
{
  "startUrls": "[{\"url\": \"https://example.com\", \"label\": \"Example\"}]",
  "maxConcurrency": 2,
  "navigationTimeoutSecs": 45,
  "storeFullResult": 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 = {
    "startUrls": "[{\"url\": \"https://example.com\", \"label\": \"Example\"}]"
};

// Run the Actor and wait for it to finish
const run = await client.actor("theguide/axe-accessibility-tester").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\", \"label\": \"Example\"}]" }

# Run the Actor and wait for it to finish
run = client.actor("theguide/axe-accessibility-tester").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\\", \\"label\\": \\"Example\\"}]"
}' |
apify call theguide/axe-accessibility-tester --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=theguide/axe-accessibility-tester",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Axe Accessibility Tester",
        "description": "Run automated WCAG audits with axe-core on any set of webpages and export structured reports.",
        "version": "0.0",
        "x-build-id": "N5d9B2G5I3F1C8OTX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/theguide~axe-accessibility-tester/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-theguide-axe-accessibility-tester",
                "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/theguide~axe-accessibility-tester/runs": {
            "post": {
                "operationId": "runs-sync-theguide-axe-accessibility-tester",
                "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/theguide~axe-accessibility-tester/run-sync": {
            "post": {
                "operationId": "run-sync-theguide-axe-accessibility-tester",
                "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": "Pages to audit",
                        "type": "string",
                        "description": "JSON array of request sources (e.g. [{ \"url\": \"https://example.com\" }])."
                    },
                    "wcagTags": {
                        "title": "WCAG tags",
                        "type": "string",
                        "description": "Optional comma or newline separated list, or JSON array, of tags to include (e.g. wcag2a, wcag21aa)."
                    },
                    "runOnly": {
                        "title": "Run only",
                        "type": "string",
                        "description": "Optional JSON object passed to axe runOnly (e.g. { \"type\": \"tag\", \"values\": [\"wcag2aa\"] })."
                    },
                    "impactThreshold": {
                        "title": "Impact threshold",
                        "enum": [
                            "minor",
                            "moderate",
                            "serious",
                            "critical"
                        ],
                        "type": "string",
                        "description": "Only include violations whose impact is equal to or greater than the selected level."
                    },
                    "axeOptions": {
                        "title": "Custom axe options",
                        "type": "string",
                        "description": "Optional JSON object passed directly to axe.run()."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of parallel browser pages used during the crawl.",
                        "default": 2
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max pages per run",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Limit the total number of pages to audit in a single run."
                    },
                    "navigationTimeoutSecs": {
                        "title": "Navigation timeout (seconds)",
                        "minimum": 5,
                        "maximum": 180,
                        "type": "integer",
                        "description": "How long to wait for each page to load before running axe.",
                        "default": 45
                    },
                    "storeFullResult": {
                        "title": "Store full axe output",
                        "type": "boolean",
                        "description": "When enabled, the dataset will contain the complete axe results (violations, passes, incomplete, inapplicable). Otherwise, it stores a condensed violation summary.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Configure proxies to use for the crawl. Using Apify Proxy is recommended for production runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
