Accessibility testing tools can find missing labels, weak color contrast, invalid landmarks, and other problems early—but no automated scanner can prove that an interface is accessible. This guide compares axe, Lighthouse, WAVE, and Pa11y, then turns their findings into a repeatable WCAG testing workflow with severity triage, keyboard checks, component coverage, and CI examples.
Overview
The right tool depends on where you are in the development process. Browser extensions are useful for investigating a page during development. Command-line tools and CI integrations are better for repeatable checks on known URLs. Component-level tests help catch regressions before a feature is assembled into a full page. Manual testing remains necessary for interaction, focus order, error recovery, screen-reader announcements, and other behaviors that static analysis cannot reliably judge.
| Tool | Automated rule coverage | Browser extension | CI support | False positives | Reporting | Component testing | WCAG mappings |
|---|---|---|---|---|---|---|---|
| axe | Focused automated checks powered by axe-core | Yes, through browser tooling | Yes, through test runners, command-line integrations, and CI workflows | Usually actionable, but every result needs context | Detailed rule, node, and remediation information | Strong fit when run inside component or browser tests | Rules commonly include related WCAG criteria; verify the version and rule documentation in use |
| Lighthouse | Accessibility audits included alongside performance and other page checks | Available through browser developer tooling and related workflows | Yes, including Lighthouse CI workflows | Results can reflect page state, viewport, and audit limitations | Page-level report with audit explanations | Better suited to rendered pages than isolated components | Audits can reference WCAG-related requirements, but passing Lighthouse is not equivalent to conformance |
| WAVE | Visual feedback for detected errors, alerts, features, and structural information | Yes | Possible through available integrations or hosted workflows; confirm the current setup before standardizing it | Visual annotations require human interpretation | Highly visual, useful for inspecting page structure and context | Useful for rendered component examples and pages | Findings may relate to WCAG criteria; check the current documentation and interpret results manually |
| Pa11y | Automated accessibility testing for supplied pages, using configurable runners | Not primarily an extension-first tool | Strong command-line and Pa11y CI use case | Thresholds and rules can be configured, but context still matters | Command-line output and CI-oriented reports | Works well against component preview routes or story URLs | Supports standards and rules configured for the selected runner; verify the active standard and version |
For many teams, a practical combination is axe or Pa11y for repeatable automated checks, Lighthouse for page-level audits and performance context, and WAVE for visual investigation. This is not a ranking. It is a division of labor. Tool names, browser extension behavior, supported integrations, rule sets, and WCAG references can change, so confirm the current documentation before committing a workflow to a long-lived project.
What automated testing can and cannot establish
Automated checks are good at finding patterns such as missing accessible names, certain contrast issues, duplicate identifiers, invalid relationships, and some landmark or form problems. They are not a complete accessibility audit. A test may not understand whether a label is meaningful, whether a custom widget behaves like its expected pattern, or whether a keyboard user can recover from an error. Treat a passed scan as evidence that known automated checks passed—not as proof that the page meets every WCAG success criterion.
Checklist by scenario
When building a component
- Give the component a keyboard-operable interaction model before styling it.
- Render its useful states: empty, loading, error, disabled, expanded, selected, and validation states where applicable.
- Run axe-core or an equivalent check against each meaningful state.
- Test with keyboard-only input, including visible focus, tab order, Escape behavior, and activation with the expected key.
- Check the accessible name, role, value, state, and description of interactive elements.
- Keep the component test close to the component source so a regression is identified before page-level testing.
When reviewing a page or feature
- Run Lighthouse and one focused scanner such as axe or WAVE against the authenticated and unauthenticated states that users can reach.
- Inspect the DOM around every reported node instead of accepting the suggested fix without context.
- Navigate the complete feature with a keyboard and record the order in which focus moves.
- Test zoom or text resizing according to the project’s accessibility requirements and check for clipped or inaccessible content.
- Verify headings, landmarks, link purpose, form instructions, error messages, and status updates.
- Repeat the checks at narrow and wide layouts, with realistic content and the same data states used in production.
When adding a CI gate
- Choose a stable route, fixture, or component preview rather than scanning a page that depends on unpredictable third-party content.
- Pin tool versions where your package-management policy allows it, and record the selected standard or ruleset.
- Start by reporting failures without blocking every merge; remove noise and fix baseline issues first.
- Block new critical issues or regressions once the output is trusted.
- Store reports as build artifacts so a developer can inspect the affected node and page state.
A simple Lighthouse CI configuration might look like this:
module.exports = {
ci: {
collect: {
url: ['http://localhost:3000/', 'http://localhost:3000/account'],
numberOfRuns: 1
},
assert: {
assertions: {
'categories:accessibility': ['warn', {minScore: 0.9}]
}
}
}
};The exact configuration syntax and available assertions depend on the installed Lighthouse CI version. For Pa11y CI, a project may define URLs and a threshold in a configuration file, then run the project’s Pa11y CI command in the build. A generic command pattern is:
npx pa11y-ci --config .pa11yci.jsonFor browser-based tests, an axe integration can scan the rendered page after the application has reached a known state:
await page.goto('/checkout');
await page.getByRole('button', {name: 'Continue'}).click();
const results = await new AxeBuilder({page}).analyze();
expect(results.violations).toEqual([]);Use these examples as workflow patterns, not copy-and-paste guarantees. Confirm imports, package names, commands, and configuration options against the versions installed in your repository.
What to double-check
Severity triage template
Automated tools often use different impact labels and scoring approaches. Normalize findings into a project-owned triage record:
- Issue: concise description and the affected route, component, or state.
- User impact: what a keyboard, screen-reader, zoom, low-vision, or cognitive-access user may be unable to do.
- Evidence: tool name, version, rule identifier, selector or node, screenshot, and reproduction steps.
- Priority: blocking task, high-risk defect, normal defect, or advisory improvement.
- Owner and fix: responsible team, proposed change, and test that prevents recurrence.
- Verification: automated result plus the manual check used to confirm the behavior.
Prioritize issues that prevent a core task, trap focus, hide essential information, or affect a shared component. Do not use a scanner’s label as the only basis for priority; business context and user impact matter.
Keyboard-testing checklist
- Can every interactive control receive focus?
- Is the focus indicator visible against the surrounding colors?
- Does focus move in a logical order that matches the task?
- Can menus, dialogs, tabs, comboboxes, and custom controls be operated without a pointer?
- When a dialog opens, does focus move to an appropriate control and return sensibly when it closes?
- Can the user escape an overlay or other temporary mode?
- Are disabled, selected, expanded, and current states understandable?
- After validation fails, can the user find the message and reach the field that needs correction?
WCAG mapping checks
Record the WCAG version and success-criterion references shown by the tool, but avoid treating mappings as legal or conformance determinations. A single success criterion may require several manual tests, and one automated result may relate to only part of a requirement. Store the tool version, ruleset, browser, viewport, page state, and test date with the report. This makes later comparisons meaningful when a rule changes or a team updates its dependencies.
Common mistakes
- Scanning only the home page: authenticated flows, forms, dialogs, checkout steps, and error states often contain the important interactions.
- Fixing the selector instead of the experience: changing markup to silence a rule can create a technically quiet but confusing interface.
- Ignoring dynamic state: a page may pass before a menu opens, an alert appears, or content updates asynchronously.
- Using one tool as a verdict: different tools expose different evidence, and none replaces manual testing.
- Blocking every existing warning immediately: noisy gates encourage teams to disable them. Establish a baseline, improve signal, then tighten the threshold.
- Failing to test shared components: a small change to a dialog, form field, or navigation component can affect many routes.
- Leaving findings without ownership: an accessibility report is useful only when each accepted issue has a decision, owner, and verification plan.
When to revisit
Run this workflow for every new feature, redesign, navigation change, form change, component-library release, and accessibility regression investigation. Revisit the tool comparison before seasonal planning cycles, after browser or test-runner changes, and whenever your CI environment changes. Also review it when a tool releases a new major version, changes its browser extension behavior, updates its rule set, or alters its WCAG references.
For a practical next step, choose one representative journey and create a small accessibility test matrix: page states, automated tool, keyboard checks, expected result, and owner. Run it locally, review every finding with the DOM and user task in view, then add only the stable checks to CI. Link those checks to the same browser test workflow your team already uses; the comparison of frontend testing tools can help when selecting that layer. Recheck the matrix after each release or workflow change, and update the documented tool versions and WCAG mappings instead of assuming yesterday’s report still describes today’s application.