# 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, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 page audits

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?

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

## How to integrate an Actor?

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

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

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

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

# README

## 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 (20 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. You are only charged for events that occur during a run.

| Event | Price | When it fires |
|---|---|---|
| Actor Start | $0.00005 | Once per run |
| Page Audit | $25 / 1,000 | For each start URL audited |
| Crawl Page Audit | $15 / 1,000 | For each crawled page audited |
| Page Discovery | $5 / 1,000 | For each link discovered during crawling |
| Screenshot Capture | $5 / 1,000 | Per page when screenshots are enabled |
| HTML Report | $20 / 1,000 | Once per run when the HTML report is generated |
| Full Axe Output | $10 / 1,000 | Per page when `storeFullResult` is enabled |

### 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: `array`):

List of URLs to start the audit from.

## `crawlDepth` (type: `integer`):

How deep to crawl links from the start URLs. 0 means only audit the start URLs.

## `maxRequestsPerCrawl` (type: `integer`):

Limit the total number of pages to audit in a single run.

## `wcagTags` (type: `array`):

Optional list of tags to include (e.g. wcag2a, wcag21aa).

## `impactThreshold` (type: `string`):

Only include violations whose impact is equal to or greater than the selected level.

## `saveScreenshots` (type: `boolean`):

If enabled, takes screenshots of elements that violate accessibility rules.

## `waitForSelector` (type: `string`):

Optional CSS selector to wait for before running the audit.

## `waitMillis` (type: `integer`):

How many milliseconds to wait after the page is loaded (or selector appears) before running the audit.

## `axeOptions` (type: `string`):

Optional JSON object passed directly to axe.run().

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

Number of parallel browser pages used during the crawl. Auto-scaling will optimize this based on available memory. Minimum allowed is 10 to ensure performance.

## `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/"
    }
  ],
  "crawlDepth": 0,
  "maxRequestsPerCrawl": 10,
  "impactThreshold": "minor",
  "saveScreenshots": false,
  "waitMillis": 0,
  "maxConcurrency": 10,
  "navigationTimeoutSecs": 20,
  "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/"
        }
    ]
};

// 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/" }] }

# 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(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": [
    {
      "url": "https://example.com/"
    }
  ]
}' |
apify call theguide/axe-accessibility-tester --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,theguide/axe-accessibility-tester"
        }
    }
}

```

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/RFF3G881f6nYgJqyt/builds/APrAtVafhXCvqVzzS/openapi.json