Skip to main content

Accessibility Testing Tools Compared (2026)

Benjamin Morton

Accessibility testing tools have a paradox. There are more options than ever, yet 95.9% of the top one million homepages still have detectable WCAG failures, up from 94.8% a year earlier (WebAIM Million, 2026). The tools exist. Developers aren't using them effectively.

This guide breaks down the six most widely used accessibility testing tools, axe-core, Lighthouse, WAVE, Pa11y, Accessibility Insights, and the DIY Playwright + axe-core approach. You'll get honest comparisons of what each tool catches, where each one falls short, and which fits your workflow. No vendor sales pitch. Just data, code examples, and practical recommendations from someone who's tested them all.

For a broader look at the full testing lifecycle, see our developer's guide to web accessibility testing.

TL;DR: Automated tools catch roughly 57% of accessibility issues by volume (Deque, 2021). axe-core is the best free engine for CI/CD. Lighthouse is fine for quick checks but misleading for compliance. WAVE excels at visual review. Pair any automated tool with structured manual testing to cover far more than automation alone.

Want to try an automated test on one page right now? Our free accessibility checker runs axe-core's WCAG 2.2 A and AA rules on any URL in a real browser, with no sign-up. (It is our own tool, built on a11yFlow.)

What Are Accessibility Testing Tools?

Accessibility testing tools scan web pages for barriers that prevent people with disabilities from using them. The WebAIM Million (2026) found an average of 56.1 errors per homepage across the top one million sites, up 10.1% from 51 in 2025.

These tools fall into five distinct categories. Understanding the differences matters because most developers grab whatever's closest and assume they're covered.

Linters and Static Analysis

Tools like eslint-plugin-jsx-a11y catch issues at write time. They flag missing alt attributes, invalid ARIA roles, and broken label associations before your code ever hits a browser. Fast feedback, but limited to what's visible in source code.

Browser Extensions

axe DevTools, WAVE, and Accessibility Insights all run as browser extensions. You click a button, the tool injects scripts into the page, and you get an overlay of issues. Great for visual review during development. Not automatable.

CLI Tools

axe-core's CLI wrapper and Pa11y both run from your terminal. They launch a headless browser, scan the URL, and output structured results. This is where CI/CD integration starts.

APIs and Scanning Services

Cloud-hosted services accept a URL and return results via API. WAVE offers a paid API, and WebAIM also licenses a version you host yourself. Several commercial platforms (Siteimprove, Level Access, and a11yFlow, which is ours) provide scan-on-demand endpoints. The tradeoff is cost versus infrastructure management.

Guided Manual Testing

Only Accessibility Insights offers structured manual testing workflows for free. Its Assessment mode walks you through a structured set of guided manual tests covering WCAG 2.2 AA criteria that automation can't reach: reading order, keyboard traps, cognitive clarity.

What Is Pushing Teams to Adopt These Tools in 2026?

Lawsuits under the Americans with Disabilities Act (ADA) hit 2,014 in the first half of 2025 alone, a 37% year-over-year increase (EcomBack, 2025). Full-year filings exceeded 5,000 (UsableNet, 2026). Legal risk is no longer theoretical. It's statistical. We break the filing data down in ADA website lawsuits.

Three regulatory shifts are converging right now. If you build for the web, all three affect you.

The European Accessibility Act Is in Force

The European Accessibility Act (EAA) took effect on June 28, 2025. Any business selling digital products or services in EU markets must meet WCAG 2.1 AA. Enforcement varies by member state, but the directive is binding. For scope, deadlines and penalties, see the European Accessibility Act developer guide.

ADA Title II Hits State and Local Government

The Department of Justice's updated ADA Title II rule requires state and local government websites serving populations over 50,000 to comply with WCAG 2.1 AA. The original April 24, 2026 deadline was later extended to April 26, 2027 (Federal Register, 2026). Government contractors and vendors are preparing now.

Lawsuits Are Getting Easier to File

Pro se ADA lawsuits, filed without an attorney, increased 40% in 2025 (Seyfarth Shaw, 2025). Many complaints now appear to be AI-drafted, lowering the barrier to litigation. E-commerce sites account for nearly 70% of all targets (UsableNet, 2026).

And here's the kicker: 22.6% of H1 2025 lawsuits targeted sites that already had overlay widgets installed (EcomBack, 2025). Overlays don't protect you.

Lollipop chart showing 2025 ADA digital accessibility lawsuit data, 69 percent targeting e-commerce, 40 percent increase in pro se filings, 37 percent year-over-year increase, and 22.6 percent targeting sites with overlay widgets

The digital accessibility market reflects this urgency. It's valued at $1.42 billion in 2025 and projected to reach $3.24 billion by 2034, growing at an 8.6% CAGR (Straits Research, 2025).

How Do the Major Accessibility Testing Tools Compare?

axe-core dominates the open-source accessibility testing space, with tens of millions of weekly npm downloads (npm, 2026). Its default rules cover WCAG 2.0 and 2.1, and it has one opt-in rule for WCAG 2.2 (axe-core rules, 2026). It's the engine underneath most other tools, including Lighthouse and Accessibility Insights, but each wrapper makes different tradeoffs.

Having integrated all six of these tools into production workflows, I can tell you the differences that matter aren't in the rule counts. They're in false-positive rates, CI/CD ergonomics, and what happens when a scan finds 200 violations on a single page.

axe-core (Free, Open Source)

axe-core is Deque's open-source engine. Its defining feature is a zero false-positive philosophy: if axe flags something, it's a real issue. Its default rules cover WCAG 2.0 and 2.1 A/AA plus best practices. Its one WCAG 2.2 rule (target size, 2.5.8) and its AAA rules are off until you enable them, for example with the wcag22aa tag.

Strengths: Runs anywhere JavaScript runs. Integrates with Playwright, Puppeteer, Cypress, Selenium. Deque maintains official packages for a CLI, Playwright, Puppeteer, WebdriverIO and WebdriverJS (axe-core-npm). The JSON output is clean and structured.

Weaknesses: No guided manual testing. No visual overlay (that's axe DevTools, the browser extension). You need to build your own reporting layer.

Lighthouse Accessibility Audits

Lighthouse ships built into Chrome DevTools and runs a set of weighted accessibility audits. Sounds comprehensive, but there's a catch. It uses a subset of axe-core's rules, and its scoring system can be misleading.

Manuel Matuzovic demonstrated that a deliberately inaccessible site could achieve a perfect Lighthouse accessibility score of 100 (Matuzovic, 2019). The scoring weights range from 3 to 10 based on perceived user impact, but many critical issues simply aren't tested. A high Lighthouse score means "no flagged violations," not "accessible."

Strengths: Zero setup, already in your browser. lighthouse-ci works in GitHub Actions. Good for quick sanity checks.

Weaknesses: Runs only part of axe-core: mostly its WCAG 2.0 A/AA rules, a few 2.1 rules, and axe's one 2.2 rule, target size (Lighthouse source). The score creates false confidence. Not suitable as your only testing tool.

WAVE

WAVE takes a different approach: visual, in-page feedback. It renders icons and indicators directly onto your page, showing exactly where issues occur. The browser extensions run entirely in your browser, so no page data is sent to WebAIM (WAVE extensions).

Strengths: Designers and non-developers love it. The visual feedback makes issues tangible. The contrast checker is excellent. A paid API and a self-hosted engine cover batch and CI use.

Weaknesses: No official CLI. Automation costs money: the hosted API charges $0.025 to $0.04 per credit (one credit per basic page check) after 100 free credits (WAVE API), and the self-hosted Stand-alone API and Testing Engine, which WebAIM says can run in continuous integration, starts at $4,000 a year. WebAIM says WAVE checks many WCAG 2.2 issues, but its documented checks map to criteria that already existed in WCAG 2.0 and 2.1 (WAVE documentation). Its alerts flag things a person must review, so expect some triage.

Pa11y

Pa11y is a Node.js CLI tool. It uses HTML_CodeSniffer by default but can run axe-core as an alternative runner, or both in one run. Either way, its standard settings stop at WCAG 2.1: HTML_CodeSniffer checks against WCAG 2.1, and Pa11y's axe runner asks axe only for its WCAG 2.0 and 2.1 rules plus best practices, so axe's 2.2 rule does not run (Pa11y axe runner, HTML_CodeSniffer). Pa11y CI adds pipeline support with threshold configuration (Pa11y CI).

In Craig Abbott's benchmark at the UK's Department for Work and Pensions, Pa11y found 20% of known issues versus axe-core's 27% (Craig Abbott/DWP, 2021). Combining both tools raised detection to 35%.

Strengths: Simple CLI interface. Pa11y CI is great for threshold-based gating. Configuration is a short JSON or JavaScript file.

Weaknesses: Lower detection rate than axe-core. HTML_CodeSniffer produces more false positives. No WCAG 2.2 checks in its standard settings. Smaller community.

Accessibility Insights

Microsoft's Accessibility Insights is the only free tool offering structured guided manual testing. FastPass runs automated checks plus tab-stop visualization in under five minutes. Assessment mode walks you through a structured set of guided manual tests aligned to WCAG 2.2 AA.

Strengths: The guided Assessment mode is genuinely unique. FastPass is the fastest way to check keyboard navigation. Powered by axe-core's engine.

Weaknesses: Browser extension only, for Chrome and Edge: no CLI, no API, and no public CI/CD option (Microsoft's Azure DevOps extension is for its internal teams only, per its GitHub repo). Can't automate it.

DIY: Playwright + axe-core

Roll your own by combining Playwright's browser automation with @axe-core/playwright. You get full control over authentication, multi-page crawling, and custom reporting. This is what most mature engineering teams end up building.

Strengths: Total flexibility. Runs in any CI/CD system. You control the browser context, viewport, auth state, and page interactions before scanning.

Weaknesses: You own the infrastructure. Browser dependencies in CI are finicky. You'll spend days building what a managed service handles out of the box.

a11yFlow (Managed API)

Full disclosure: a11yFlow is our product, so weigh this section accordingly. It exists to solve the DIY problem above. You want axe-core scanning in your pipeline without maintaining Playwright, browser binaries, and a reporting layer yourself.

a11yFlow wraps real Chromium and axe-core behind a REST API. You POST a URL, poll for the result, and get structured JSON back: severity-ranked violations, WCAG 2.2 guideline mappings, remediation guidance, and a 0-100 score. There's a CLI and an MCP server for editor and agent workflows, plus a CI/CD gate that fails a build on violations.

Strengths: No browser infrastructure to manage. Same axe-core engine and coverage as rolling your own, but with result storage, scoring, and a single API call. Free tier (25 scans/month, no card) to evaluate it.

Weaknesses: It scans rendered URLs, so it doesn't replace in-editor linting or guided manual testing. Like every automated tool here, it catches roughly 57% of issues by volume. You still need manual review for the rest. Paid tiers start at £19/month once you exceed the free allowance; we go deeper on free versus paid tools and a budget-first setup for startups separately.

Feature Comparison Table

Feature

axe-core (free)

axe DevTools (paid tiers)

Lighthouse

WAVE

Pa11y

Accessibility Insights

a11yFlow (ours)

Price

Free, open source (MPL 2.0)

Pro extension: paid, per user. CI/CD and API bundle: by quote

Free, open source (Apache 2.0)

Free site and extensions. API $0.025 to $0.04 per credit, 100 free. Self-hosted from $4,000/yr

Free, open source (LGPL 3.0)

Free, open source (MIT)

Free 25 scans/mo, paid from £19/mo

Browser extension

Via the free axe DevTools extension

Yes

Built into Chrome DevTools

Yes (Chrome, Firefox, Edge)

No

Yes (Chrome, Edge)

No

CLI

Yes (@axe-core/cli)

Yes (axe DevTools CLI)

Yes

No official CLI

Yes

No

Yes

CI/CD

Official CLI, Playwright and Puppeteer packages

Bundle only

Lighthouse CI

Paid API or licensed stand-alone engine

Pa11y CI

No public option

Yes (CLI --fail-on gate)

API

JavaScript library

Bundle only

Node module

Yes, paid

Node.js API

No

REST API

WCAG 2.2

One rule (target size), off by default

Yes, as a selectable ruleset (default is 2.1 AA)

Runs axe's 2.2 target-size rule

WebAIM says yes; documented checks map to 2.0 and 2.1 criteria

No (2.1 at most)

Assessment covers 2.2 AA

Yes (axe's 2.2 AA rules on by default)

Guided manual testing

No

Yes (Pro: Intelligent Guided Tests)

No

No

No

Yes (Assessment)

No

Engine

axe-core

axe-core plus AI checks

Subset of axe-core

WebAIM's WAVE engine

HTML_CodeSniffer (default) or axe-core

axe-core

axe-core

False positives

Zero policy

Zero policy

Via axe

Alerts need manual review

Warnings need triage

Via axe

Via axe

Best for

Developers, CI/CD

Teams, enterprise

Quick audits

Visual review

CLI scripting

Manual + automated

Managed CI/API scanning

Checked October 2026. Sources: axe-core rules, axe-core npm packages, axe DevTools plans, axe DevTools Extension FAQ, axe DevTools 4.5 release notes, axe DevTools CLI, Lighthouse, Lighthouse axe settings, Lighthouse CI, WAVE API pricing, WAVE Stand-alone API and Testing Engine, WAVE help, WAVE documentation, Pa11y, Pa11y axe runner, Pa11y CI, Accessibility Insights Assessment, Accessibility Insights for Web. a11yFlow figures come from our pricing page.

Where Every Tool on This List Hits the Same Ceiling

Before comparing the tools, it is worth knowing what none of them can do. They all run the same class of static checks, so they share a ceiling: automated scanning detects roughly 57% of accessibility issues by volume (Deque, 2021).

That ceiling is the same whichever tool you pick, so it is not a basis for choosing between them. No scanner here will tell you whether alt text is meaningful rather than merely present, whether focus order makes sense, or whether a timeout is survivable. Those need a person at the keyboard. We cover the size of that gap, and why the headline figure is disputed, in automated vs manual accessibility testing.

What automation is genuinely good at is the high-volume, binary failures, and that is where these tools differ.

What Automation Catches Well

The WebAIM Million (2026) identified the top six error types responsible for 96% of all detected failures:

  1. Low contrast text, 83.9% of homepages
  2. Missing alt text, 53.1% of homepages
  3. Missing form labels, 51% of homepages
  4. Empty links, 46.3% of homepages
  5. Empty buttons, 30.6% of homepages
  6. Missing document language, 13.5% of homepages

These are exactly the kinds of issues automated tools excel at finding. They're structural, pattern-based, and binary, the attribute is either there or it isn't.

Top 6 WCAG Errors on Homepages (2026) Percentage of the top one million homepages with each error type Low contrast text 83.9% Missing alt text 53.1% Missing form labels 51% Empty links 46.3% Empty buttons 30.6% Missing language 13.5% These six error types account for 96% of all detected errors. Source: WebAIM Million, 2026

The ARIA Trap

Here's a stat that surprises people: homepages using ARIA averaged 59.1 errors, against 42 on homepages without it (WebAIM Million, 2026). WebAIM notes that those pages also tend to be more complex, so ARIA isn't the only cause. But ARIA is unforgiving: misuse creates worse barriers than having no ARIA at all. Automated tools catch some ARIA misuse, but not the subtle semantic errors that confuse screen readers.

Donut chart showing accessibility issue detection rates, automated tools catch 57 percent, manual testing adds 28 percent, and specialized assistive technology testing covers the remaining 15 percent, for a combined 85 percent detection rate

Citation capsule: Automated accessibility tools detect approximately 57% of issues by volume, according to Deque's study of 2,000+ audits covering 13,000 pages. The top six error types account for 96% of all failures detected across one million homepages (WebAIM Million, 2026), with low contrast text appearing on 83.9% of sites.

Which Tool Should You Choose?

The right tool depends on your team size, compliance requirements, and where accessibility testing fits in your workflow. Combining automated and manual testing covers far more than either alone, but you don't need every tool to get there.

Here's a decision framework based on five common scenarios.

Solo Developer or Side Project

Use: the free axe DevTools browser extension (built on axe-core) + Lighthouse quick checks.

You don't need CI/CD gating yet. Install the axe DevTools extension, run it on key pages during development, and fix what it finds. Use Lighthouse for a score sanity check, but don't treat a 100 score as proof of accessibility. It isn't.

Startup (2-15 Engineers)

Use: Playwright + @axe-core/playwright in CI/CD, plus WAVE for visual review during design.

Write accessibility tests alongside your integration tests. Gate pull requests on zero critical violations. Have designers use WAVE to catch contrast and structure issues before code review.

Enterprise or Regulated Industry

Use: axe DevTools Pro (paid, per user) + Accessibility Insights Assessment for manual testing.

You need guided manual workflows, audit trails, and Jira integration. axe DevTools Pro adds Intelligent Guided Tests and AI-enhanced automation, and connects to Jira. CI/CD integration and organization-wide reporting need Deque's Axe DevTools for Web bundle, which is priced by quote (Deque). Pair it with Accessibility Insights' guided Assessment mode for manual coverage.

CI/CD-First Team

Use: axe-core via Playwright or Pa11y CI for threshold gating.

Configure violation thresholds in your pipeline. Fail the build on any critical or serious violation. Track violation counts over time to measure progress. More on this setup in the next section. If you'd rather not maintain browser binaries and a reporting layer in CI, a managed API like a11yFlow (our product, disclosure noted) gives you the same axe-core gate through a single call.

Compliance-Focused (Legal Deadline Approaching)

Use: Multiple tools in parallel + manual audit.

Run axe-core and Pa11y together, Craig Abbott's research shows this raises detection from 27% to 35%. Add manual testing with Accessibility Insights. Consider a professional audit for the remaining gaps.

Can You Run These Tools in CI?

axe-core, Lighthouse and Pa11y are free, open source and run headless, which is the practical reason to care about them: the tool that catches a violation on your laptop is worth far less than the one that blocks the pull request. All three have CI-ready runners. WAVE reaches CI only through WebAIM's paid API or its licensed stand-alone engine, which is the biggest strike against it for engineering teams on a budget.

The setup we use pairs Playwright with @axe-core/playwright in a GitHub Actions workflow, gating pull requests on zero critical and serious violations while tracking moderate and minor counts as metrics rather than blockers. The full working configuration, including caching, matrix runs, and how to handle pre-existing accessibility debt without blocking every PR, is in how to set up accessibility testing in GitHub Actions.

Citation capsule: axe-core, Lighthouse and Pa11y are free, open-source accessibility testing tools that run headless in a CI pipeline. WAVE's free website and extensions are manual; it reaches CI only through WebAIM's paid API ($0.025 to $0.04 per credit) or its licensed stand-alone engine (from $4,000 a year), according to WebAIM.

Frequently Asked Questions

Which accessibility testing tool is best for beginners?

The axe DevTools browser extension is the best starting point. It uses Deque's open-source engine, runs with a single click, and explains every violation in plain language. No setup, no configuration, no command line required.

Can automated tools make my site fully WCAG compliant?

No. Automated scanners cover just over half of known accessibility barriers (Deque, 2021). Keyboard traps, reading order, and cognitive clarity still require human judgment. Use Accessibility Insights' Assessment mode for structured manual coverage.

Is Lighthouse good enough for accessibility testing?

Lighthouse is fine for quick checks but misleading for compliance. It runs only a subset of axe-core's rules and uses weighted scoring. A deliberately inaccessible demo site achieved a perfect 100 score (Matuzovic, 2019). Don't treat Lighthouse as your compliance benchmark.

How many accessibility rules does axe-core have?

axe-core 4.14 lists 94 rules, not counting experimental and deprecated ones. Its WCAG 2.0 and 2.1 A/AA rules and best-practice checks run by default; its one WCAG 2.2 rule (target size) and three AAA rules are opt-in. The count changes between releases; the current rules are documented in the axe-core rule-descriptions reference (Deque, 2026). Its zero false-positive policy means every flagged issue is a genuine violation.

Do I need both axe-core and Pa11y?

Running both tools together raises detection from 27% (axe-core alone) to 35% of known issue types (Craig Abbott/DWP, 2021). If you're under compliance pressure, the overlap is worth the extra CI time. For most teams, axe-core alone covers the critical ground.

Are accessibility overlay widgets a valid testing alternative?

No. Overlays don't fix underlying code. 22.6% of ADA lawsuits in H1 2025 targeted sites with overlay widgets installed (EcomBack, 2025). Courts have not accepted overlays as evidence of compliance. Use proper testing tools, not cosmetic patches.

What's the cost of ignoring accessibility testing?

More than 5,000 ADA digital accessibility lawsuits were filed in 2025 (UsableNet, 2026). E-commerce sites represent nearly 70% of targets. Beyond litigation, inaccessible sites exclude roughly 16% of the global population. The cost of testing is negligible compared to the cost of a lawsuit.

How often should I run accessibility tests?

Run automated scans on every pull request and after every deployment. Regressions creep in with every feature, a new button without a label, a modal that traps keyboard focus. CI/CD integration catches these before users encounter them.

Key Takeaways

Accessibility testing in 2026 isn't optional. With EAA enforcement active, ADA Title II deadlines approaching, and lawsuit volumes hitting record highs, the question isn't whether to test, it's which tools to use and how to integrate them.

Here's what matters:

  • axe-core is the foundation. Its zero false-positive policy and broad WCAG coverage make it the industry standard engine. Start here.
  • Don't trust Lighthouse scores for compliance. Use Lighthouse for quick sanity checks, not as proof of accessibility. A perfect score does not mean an accessible site.
  • Automation covers roughly half the problem. That's significant, but you still need manual testing for keyboard navigation, reading order, and cognitive clarity.
  • CI/CD integration is non-negotiable. Gate your pull requests on accessibility violations. Catching issues in a pipeline costs a fraction of fixing them after deployment.
  • Combine automated and manual testing. axe-core plus structured manual review with Accessibility Insights closes the majority of coverage gaps.

Pick a tool. Add it to your pipeline this week. Every scan you run catches barriers that real people face every day.

If you want axe-core scanning in CI without owning the browser infrastructure, you can try a11yFlow's API free (25 scans a month, no card). It's the managed option we built for the DIY scenario above.

For the full testing lifecycle, see our complete developer's guide to accessibility testing.