Best Accessibility Testing Tools for WCAG, CI and Reporting
Compare accessibility testing tools for WCAG checks, CI, manual review and reporting, with a Playwright walkthrough and the limits of automated checks.

Quick answer: the best accessibility testing tool is the one that checks the pages and flows your users actually touch, inside the workflow your team already runs. A practical shortlist:
- ACCELQ if you want accessibility validated on every page a functional test touches, with no separate scan project to build and maintain.
- Deque axe if you want the open-source engine most of the industry uses, wired into your editor, browser, command line and CI.
- Evinced if you want accessibility checks added to the UI and mobile tests you already have, including changes to the page during a flow.
- Level Access if you need scanning, scheduled monitoring, manual evaluations, PDF checks and VPATs under one roof.
- Siteimprove if a large organisation publishes constantly and needs governance, scores and remediation across the whole content estate.
Below we explain what automated tools can and cannot check, how to judge one, what each product is actually built for, and a worked Playwright example you can copy. Features come from each vendor's public documentation; this is not a hands-on benchmark, and we do not list prices because they change often.
What an accessibility testing tool can and cannot check
Accessibility testing means checking whether people who use keyboards, screen readers, magnification or voice control can complete a task. The rules most teams test against are the WCAG 2.2 success criteria, usually at level AA. WebAIM's Million-page analysis of one million homepages found the large majority have at least one detectable WCAG failure, so the demand for tooling is not hypothetical.
Three kinds of check
- Static code checks (linting). A linter reads source files and flags patterns likely to break accessibility: images without alternative text, form inputs without labels, incorrect or missing ARIA attributes, heading structure problems. Deque's own documentation is clear that a linter cannot test the runtime behaviour of your application, so it is a first line of defence, not the whole test.
- Live-page checks (rules engines). A tool such as axe-core inspects a rendered page in a browser and runs rules against it. This catches contrast failures, missing labels on rendered controls, and bad ARIA in the DOM as it actually exists.
- Assisted and manual checks. Some criteria need a human: is the alternative text actually accurate? Is the tab order sensible? Does the screen reader announce the error at the right moment? Tools can queue these as "needs review" items, but a person decides.
That third category is why no tool can hand you a certificate. The W3C's Accessibility Conformance Testing (ACT) rules exist so that automated checks mean the same thing across tools, and Siteimprove's documentation notes that when WCAG 2.2 added nine success criteria, only two could be automated reliably; the rest were left to manual testing because automating them would produce too many false positives. Treat a clean scan as "no rule violations found", never as "WCAG conformant".
How to judge an accessibility testing tool
1. What it can see
Source code only, a single rendered page, a page after interaction, a whole flow, or a crawled site? A tool that only sees the DOM at one moment will miss anything that appears after a click.
2. Standards and rulesets
Can you pick WCAG 2.0, 2.1 or 2.2, and level A, AA or AAA? Are the rules ACT-aligned? Does the vendor say plainly what it does not check?
3. Where it runs
Inside the editor, as a browser extension, as a command line step in CI, as an SDK inside your existing test suite, or as a hosted crawler? This usually decides the choice, because coverage follows where the tool runs.
4. Flow and state coverage
Can it check a logged-in checkout, a modal, a multi-step wizard? Or does it stop at public pages? Level Access, for example, documents that monitoring cannot scan single-page applications or pages behind a VPN, so you need its developer tools or extension for those.
5. False positives and "needs review" work
How does the tool separate confirmed issues from items needing human judgement? Siteimprove splits findings into issues and potential issues, where potential issues are assisted checks that a person must confirm.
6. Reporting and remediation
Findings are only useful if they reach developers. Look for Jira, Azure DevOps, GitHub or Asana integration, exportable results, trend history, and enough detail (element, rule, fix guidance) that a developer can act without re-diagnosing.
7. Governance
If your buyers or legal team ask for proof, check for VPAT or accessibility conformance statements, policy tracking, and reporting across many sites and documents rather than one site.
Five tools at a glance
Documented capabilities only. "Strong fit" describes the scenario each product's documentation is built around, not a measured score, and no prices are listed because they change frequently. The detail behind each cell is in the section for that tool below.
| Tool | Where it runs | Strongest at | Review items | Strong fit |
|---|---|---|---|---|
| ACCELQ | ACCELQ tests and their CI runs | WCAG 2.0/2.1 A and AA checks on every page a test touches | Grouped by severity in the test report | Teams already automating in ACCELQ |
| Deque axe | Editor, browser, CLI, test code, hosted monitoring | The open-source rules engine, plus linting before merge | Unsettled checks land in "incomplete" | Engineering teams wanting the standard engine |
| Evinced | Your Playwright, Cypress, Selenium or Appium tests | Issues that only appear mid-flow, by watching DOM changes | JSON or HTML report you triage | Teams with suites they don't want to rewrite |
| Level Access | Hosted platform, browser tools, its own CI | Monitoring, expert evaluations, PDF checks, VPATs | Health score for trends, not conformance | Organisations needing audit plus proof |
| Siteimprove | Hosted platform across sites, PDFs, logged-in pages | Governance across a large content estate | "Potential issues" need a reviewer | Institutions where many people publish |
ACCELQ: accessibility inside your functional tests
ACCELQ's web accessibility validation is a toggle in the Run modal under Non-Functional Testing. Turn it on and the platform validates accessibility parameters defined by WCAG 2.0 and 2.1 at levels A and AA, plus a set of best practices, on every page your functional automation touches. The check runs at the start of each action once the page has synchronised, so coverage comes from the flows you already wrote rather than from a page list you have to maintain.
The report lists violations grouped by severity and category of failure, with controls that highlight the failing HTML elements and let you move between instances of the same violation, along with remediation guidance.
Choose it when: your team already automates in ACCELQ and you want accessibility checked continuously instead of as a separate audit. This is the same "ride along with functional tests" idea we describe for API and performance checks in the CI/CD pipeline testing tutorial.
Limits: the feature is documented for the Enterprise Edition and needs a recent release, so check your edition before planning around it. Because it validates pages your tests reach, a flow nobody automated is a flow nobody checked. Automated checks also cannot judge whether alternative text is meaningful or whether a screen-reader journey makes sense; keep those passes manual.
Deque axe: the engine most teams start with
Axe DevTools for Web is Deque's product family built on axe-core, the open-source rules engine other vendors are commonly measured against. Deque says axe-core has been downloaded more than five billion times, and the browser extension has been installed hundreds of thousands of times in Chrome. The family covers the whole development path: a linter that reads source files, a browser extension, a command line tool, web APIs, Axe Watcher for adding checks to existing web test suites, and a developer hub that aggregates results across platforms.
Two parts deserve attention. First, Axe DevTools Linter performs static analysis of source code and can flag images missing alternative text, inputs without labels, incorrect or missing ARIA attributes and heading-structure problems before code is merged, including in your own design-system components. Deque is explicit that it cannot test runtime behaviour. Second, CI/CD integration is designed to run in any pipeline you already use and can block accessibility defects from reaching production. Beyond the developer tools, Deque's product list includes Axe Monitor for dynamic site-wide scanning, axe Reports for enterprise reporting, Axe Auditor for specialist manual testing, and Deque University for training.
Choose it when: you want the de facto standard, want to start free with axe-core in your own tests, and want a path from editor to CI to org-level reporting.
Limits: the free engine gives you raw results, not a programme. Dashboards, monitoring, guided manual testing and training sit in paid products, and you still need a human pass for anything a rule cannot see.
Evinced: accessibility checks inside tests you already own
Evinced's Automation SDKs add accessibility analysis to existing UI and mobile tests with a few lines of code. The web SDKs cover Cypress, Selenium (Java, JavaScript and C#), WebdriverIO, Playwright (JavaScript and Java) and TestCafe; mobile coverage includes Appium, Espresso and UIAutomator, XCUITest and WebdriverIO for mobile. Each run ends with a JSON or HTML report you can push into whatever reporting tool your team uses.
The interesting design choice is the two analysis modes. Single-run analysis scans the page at one moment in time, which is useful after you open a dropdown so the hidden part of the page is visible. Continuous mode starts an engine that keeps scanning in the background and captures every DOM change while the test runs, so a modal opened three steps into a flow is checked even though the page never reloaded. That is the gap most page-level scanners fall into in single-page applications. For manual exploration, the Web Flow Analyzer browser extension follows your clicks through a flow and compiles one deduplicated issue list for the session. For site-wide coverage, the Site Scanner crawls a site (or a list of URLs you supply) and tracks compliance over time.
Choose it when: you already have a Playwright, Cypress or Appium suite and want accessibility coverage from the flows it already exercises, without building a scan project.
Limits: you are adding a dependency to your test code, and mobile SDKs need an API key that validates against Evinced servers, so an offline environment needs arranging in advance. Coverage still equals test coverage: untested flows stay unchecked.
Level Access: scans, monitoring and human evaluation together
The Level Access platform is organised around three jobs: audit and test, build and fix, and govern and report. The audit side covers on-demand scanning, scheduled monitoring, automated flows, component testing, mobile testing, manual evaluations, design evaluations and a PDF accessibility checker. Findings can be pushed into Jira, Azure DevOps, Asana or GitHub, and the platform exposes APIs, SDKs, webhooks and its own CI tooling.
Monitoring schedules automated scans at a frequency you choose and graphs accessibility health over time, which is how you notice a regression rather than discovering it at audit time. Every scan produces an accessibility health score from 0 to 100. Two honest caveats from their own documentation: the score is based on scans only, so it is not a complete rating of accessibility and is explicitly not a measure of WCAG conformance; and monitoring cannot run on single-page applications, on apps at all, or on pages behind a VPN, so those need the browser extension or developer tools instead.
On the fix side there is automated remediation, designer tools and an accessibility widget. On the governance side, VPATs and accessibility conformance statements.
Choose it when: you need both automated scanning and expert manual evaluations, plus documented conformance proof for procurement or legal, in one vendor.
Limits: it is a full platform, so small teams buying it only to run the occasional scan are paying for capacity they will not use. Read the monitoring restrictions before you assume it covers your React application.
Siteimprove: accessibility governance for a large content estate
Siteimprove's accessibility checks are built on ACT rules aligned with WCAG, plus best-practice checks and WAI-ARIA guidance that go beyond the strictly normative requirements. WCAG 2.2 has been included in automated checking since April 2024, when target size was added and the obsolete parsing check was removed.
Findings are split into issues and potential issues. An issue is an automated check that failed. A potential issue is an assisted check that needs a human to finish the judgement, and the platform guides that review step by step. That split is the honest shape of automated accessibility work, and it is worth looking for in any tool you evaluate. A Site Target Score shows progress from 0 to 100% against the WCAG version and conformance level you pick, which gives management something to track without pretending it is a certificate.
Scope is the other reason teams pick it: coverage extends across public sites, PDFs and documents, and internal or authenticated pages, with fixes applied directly in WordPress and Drupal where content is published.
Choose it when: many non-developers publish content, you have many sites and documents, and you need one programme with scores, ownership and review queues rather than a scanner in a pipeline.
Limits: it is a monitoring and governance platform, not a developer's debugging tool, and it is not a substitute for keyboard and screen-reader testing. Siteimprove's own material also warns that overlay widgets mask issues in the browser without fixing the code underneath, so an overlay is not a compliance strategy.
Worked example: adding a11y checks to a Playwright login flow in CI
Illustrative scenario. Your team has Playwright tests for login and checkout. Nobody has ever tested accessibility beyond one manual pass months ago. You want checks that run on every pull request, fail the build only on real problems, and leave a review list for a human.
Step 1: pick the gate
Decide what blocks a merge. A common starting rule: fail on critical and serious violations only, and report the rest. Failing on every violation on day one usually gets the check deleted within a sprint.
Step 2: wire axe-core into one spec
This is the standard @axe-core/playwright shape. It scans the rendered page and asserts on the violations you care about.
import { test, expect } from "@playwright/test";
import AxeBuilder from "@axe-core/playwright";
test("login page has no serious WCAG violations", async ({ page }) => {
await page.goto("/login");
const results = await new AxeBuilder({ page })
.withTags(["wcag2a", "wcag2aa", "wcag21a", "wcag21aa", "wcag22aa"])
.analyze();
const blocking = results.violations.filter((v) =>
["critical", "serious"].includes(v.impact ?? "")
);
// Print the offending selectors so CI logs are actionable.
expect(blocking, JSON.stringify(blocking, null, 2)).toHaveLength(0);
});We have not run this exact snippet in your stack. Check the tag names against the axe-core version you install, since tags change between releases.
Step 3: cover state, not just the initial page
A login page that fails only after the error appears is the classic miss. Add a second check after the interaction:
await page.getByRole("button", { name: "Sign in" }).click();
await expect(page.getByRole("alert")).toBeVisible();
const afterError = await new AxeBuilder({ page }).analyze();
expect(afterError.violations.filter((v) => v.impact === "serious")).toHaveLength(0);The same idea is why Evinced's continuous mode and Level Access's automated flows exist: they are aimed at the DOM changes between step one and step five, which a single snapshot never sees.
Step 4: keep the review list
axe-core also returns incomplete results: checks it could not settle automatically, such as contrast on text over an image. Write them to a file and hand them to a person instead of silently dropping them.
Step 5: add the human pass
Once per release, walk the same flow with the mouse unplugged, then with a screen reader (NVDA on Windows, VoiceOver on macOS or iOS). Check tab order, focus visibility, whether errors are announced, and whether the page survives 200% zoom. Our WCAG 2.2 accessibility testing guide has the full checklist and sample test cases.
Step 6: report and trend
Push results somewhere durable. If your tests run in ACCELQ, the accessibility toggle gives you the grouped violation report for free. If they run in Playwright, publish the JSON artifact and track the count per release, so "we got worse this sprint" is a fact rather than a feeling.
Which tool should you pick?
| Your situation | Start with |
|---|---|
| Functional automation already runs in ACCELQ | ACCELQ's web accessibility validation |
| You want the industry-standard engine, free to start, in editor, browser and CI | Deque axe (axe-core, then DevTools) |
| You have Playwright, Cypress or Appium suites and want coverage without a new project | Evinced SDKs |
| You need scheduled monitoring, expert manual evaluations and VPATs | Level Access |
| Many editors publish content, PDFs and internal pages across many sites | Siteimprove |
| You are one tester learning the basics first | Read the WCAG guide and run the free axe-core browser extension |
There is no single winner, and most mature teams end up with two layers: something fast inside development, and something that monitors the live estate. A Playwright team might run axe-core in CI and buy a monitoring platform for reporting; an ACCELQ team might rely on the built-in validation and add a manual evaluation pass before major releases.
Common problems and how to fix them
- Treating a score as conformance. Level Access states plainly that its health score is scan-based and not a measure of WCAG conformance. Report scores as trends, and state what was and was not evaluated manually.
- Scanning only public pages. Login, checkout, account settings and support flows are where the money is. Add authenticated checks, or accept that your coverage stops at the front door.
- Single-page applications. Crawl-based monitoring can miss them entirely, which is why flow-based and SDK-based tools exist. Check the vendor's documented restrictions, not the marketing page.
- Overlay widgets as a fix. They change what the browser shows, not the code underneath, so the underlying failures remain. Fix the markup.
- Comparing violation counts across tools. Different rulesets, standards and page samples produce different numbers for the same site. Compare on the same ruleset and the same page list.
- No regression gate. A one-time audit decays the next time someone publishes. Run checks on every build, and keep the review list from the
incompleteresults. - Skipping the human pass. Automate what rules can see; keep keyboard-only and screen-reader passes on the release checklist.
Why this matters in interviews
"How do you test accessibility?" and "What percentage of accessibility can you automate?" are now common non-functional questions in QA and SDET interviews. A strong answer names a tool, explains where it runs, states clearly that automated checks cover only part of WCAG, and describes the manual pass that covers the rest. Mentioning the difference between a rule violation and a conformance claim is what separates a senior answer from a buzzword one.
Practise the wording, then back it with evidence: add one accessibility check to a practice project and describe the violation it found. The free QA courses include guided practice you can automate against, and the API Playground is a good place to build a small end-to-end project to talk about. For structured preparation, work through the software testing interview questions and the scenario-based interview questions.
Your next step
Do this this week, in order. First, pick one flow that matters commercially, such as login or checkout. Second, install the free axe-core browser extension and run it on that flow, then repeat with the error state visible. Third, write down every finding the tool could not settle on its own, because those are the ones a human must judge. Fourth, add one automated accessibility assertion to a single test in your suite and gate only on serious and critical issues. Fifth, put keyboard-only and screen-reader passes on your release checklist.
If you are choosing between vendors, take the same three pages and the same flow to each evaluation, and ask each one what it does not check. If your team is new to WCAG, start with the accessibility testing guide, then browse the QA resources for checklists you can hand to developers.
Stuck on a specific finding, or deciding between two tools for your stack? Describe the flow and the finding in the QA Community and get input from testers who have fixed it.
Key takeaways
- 1Automated checks are fast and repeatable, but they can only judge what a rule can see; most WCAG criteria need a human with a keyboard and a screen reader.
- 2Pick by coverage: static code linting, a live page, a multi-step flow, a whole crawled site, or a content estate including PDFs and logged-in pages.
- 3Deque axe is the engine most other tools are built on or compared against, so learning it transfers everywhere.
- 4A percentage or health score is a trend line, not a legal claim of WCAG conformance.
- 5Run checks on the flows that matter (login, checkout, search), not just the public homepage.
- 6Report findings where developers already work: Jira, Azure DevOps, GitHub, or the test report itself.
Common mistakes to avoid
- Treating a clean automated scan as proof of WCAG conformance.
- Scanning only public pages and missing login, checkout and account flows.
- Using an overlay widget instead of fixing the code underneath.
- Judging tools by violation count when rulesets and page samples differ.
- Never re-running checks after fixes, so regressions slip back in.
- Skipping keyboard-only and screen-reader passes entirely.
References
- 1ACCELQ: verify web accessibility during test execution— support.accelq.com
- 2Deque axe DevTools for Web documentation— docs.deque.com
- 3Axe DevTools Linter: what it can and cannot do— docs.deque.com
- 4Deque CI/CD integration— deque.com
- 5axe-core on GitHub— github.com
- 6Evinced developer documentation— developer.evinced.com
- 7Evinced web SDKs: single-run and continuous analysis— developer.evinced.com
- 8Evinced Web Flow Analyzer user guide— evinced.com
- 9Level Access platform and services overview— levelaccess.com
- 10Level Access: set up monitoring— client.levelaccess.com
- 11Siteimprove: guide to the accessibility checks— help.siteimprove.com
- 12Siteimprove: reviewing potential issues— help.siteimprove.com
- 13W3C: WCAG 2.2 at a glance— w3.org
- 14WebAIM Million study— webaim.org
