Accessibility scanner false positives happen when a tool reports a WCAG failure on content that actually meets the requirement. The W3C's ACT Rules Format, the standard for writing automated accessibility test rules, defines it in one line: "When a test result incorrectly indicates non-conformance to an accessibility requirement, this is known as a false positive" (W3C ACT Rules Format 1.1). They come from a few predictable places. The scanner can't see what a sighted person sees (text over an image), it doesn't know about an exception in the criterion (a disabled button, a logo), or it ran before your JavaScript finished rendering. Good engines are built to avoid them: axe-core says it "returns zero false positives (bugs notwithstanding)" and puts uncertain results in a separate "needs review" pile (axe-core). They still happen. When you think you've found one, reproduce it, check it against the criterion's text, record the decision, and suppress only that element. Never switch off the whole rule.
What counts as a false positive in accessibility testing?
A result that says "fail" when the content passes. The ACT Rules Format also names the opposite case: "when a rule incorrectly indicates conformance, this is a false negative" (W3C ACT Rules Format 1.1). Those are the issues a scanner misses, and they are the bigger problem by far. Deque's study of more than 2,000 audits found automated testing fully covered 57% of issues by volume, against the widely held 20 to 30% estimate when you count by success criteria (Deque, 2021). So roughly 30 to 57% depending on how you count, and the rest needs a person.
Two things are often called false positives that aren't:
- A "needs review" result. axe-core's API describes
incompleteresults as "also known as 'needs review'", results that "were aborted and require further testing" (axe-core API). The tool is telling you it couldn't decide. That's an open question, not a wrong answer. - A correct flag you disagree with. "That image is decorative, so it doesn't need alt text" is a common one. WCAG 1.1.1 says decorative content must be "implemented in a way that it can be ignored by assistive technology" (WCAG 2.2). The W3C technique for that is a null
altattribute,alt=""(W3C Technique H67). Leaving the attribute off isn't the same thing, so the flag was right.
I'd go further. Before you call anything a false positive, assume it isn't one. The flags people want to dismiss tend to sit on components they're attached to.
Why do accessibility scanners flag false positives?
A scanner reads the DOM and computed styles. It doesn't look at the page the way a person does, and it doesn't know why you built something. Most false positives trace back to one of these gaps.
It can't see the real background. WCAG measures contrast "with respect to the specified background over which the text is rendered in normal usage" (Understanding 1.4.3). White text over a dark hero photo may be perfectly readable, while the element's CSS background-color is white or transparent. A tool that computes contrast from CSS alone can report 1:1 and fail it. axe-core usually avoids that by returning such cases as needs review rather than failures (axe-core). Our color contrast requirements explainer covers the thresholds in more depth.
It doesn't apply the exception. Success criterion 1.4.3 exempts text that is "part of an inactive user interface component" and text that "is part of a logo or brand name" (Understanding 1.4.3). A greyed-out <button disabled>Submit</button> at 2.8:1 is exempt from 1.4.3. If a tool can't tell the button is inactive, for example because it's a styled <div> with aria-disabled="true" that the rule doesn't account for, it will fail it.
It scanned too early. On a single-page app, the scanner may run before data loads. An icon button that gets its aria-label from a translation file a moment later looks unlabelled at scan time. The flag describes the page the scanner saw. Whether users also see that state for a moment is something you have to check.
The rule's interpretation differs from yours. WCAG is written in prose, and rule authors turn it into code. The W3C started the ACT work partly because different interpretations caused confusion; ACT "reduces confusion caused by different interpretations of accessibility guidelines" (W3C WAI, ACT overview). Even then, the format admits "it is almost inevitable that edge cases will be overlooked" in a rule, and it sets no minimum accuracy: "there are no requirements for ACT Rules to have a certain number of implementations, or to have a certain level of accuracy" (W3C ACT Rules Format 1.1).
The tool has a bug. axe-core's "zero false positives" promise carries the words "bugs notwithstanding" for a reason (axe-core). Rule engines are software. New CSS features, shadow DOM and unusual ARIA patterns all find edge cases.
The W3C's own guidance on choosing tools says it plainly: "Sometimes evaluation tools can produce false or misleading results", and tools "can not determine accessibility, they can only assist in doing so" (W3C WAI, Selecting Web Accessibility Evaluation Tools).
How do I confirm a false positive?
Treat it like any bug report you're about to close as "works as intended". You need evidence, and the evidence comes from the criterion and the page, not from the tool.
- Reproduce it. Re-run the scan on the same URL in the same state (logged in, same step of the flow). If the flag disappears after the page settles, you've found a timing issue. Note that, and then check whether real users hit the broken state.
- Read the criterion, not the rule name. Open the W3C Understanding page for the success criterion the result maps to. Read the exceptions. "Incidental" and "logotypes" in 1.4.3 are there for a reason.
- Check it the manual way. For contrast, sample the actual pixel colors behind the text and calculate the ratio with a contrast checker. For names and roles, open the accessibility tree in DevTools and see what's exposed. For alt text, listen to it with a screen reader.
- Ask a second person. If the call is close, get someone who didn't write the component to look. A false positive that two people agree on is a decision. One person's hunch is not.
A worked example: the scanner reports .hero h1 at 1.07:1, white on white. DevTools shows background-color: rgba(0,0,0,0) and a background-image on the parent <section>. You sample the photo behind the heading: the darkest relevant area gives 9:1, but the lightest patch behind the last word gives 2.6:1, below even the 3:1 allowed for large text. So this isn't a false positive after all. The tool got the number wrong and the verdict right. The fix is a scrim or a text shadow, not a suppression.
What should I do once a false positive is confirmed?
Suppress it as narrowly as you can, and leave a record.
axe-core supports both narrow and broad suppression. You can pass a context with an exclude property to skip specific elements, or set a rule's enabled option to false to turn it off entirely (axe-core API). The narrow version looks like this:
await axe.run(
{ exclude: [[".brand-wordmark"]] }, // logotype: exempt under SC 1.4.3
{ rules: { "color-contrast": { enabled: true } } }
);
Excluding .brand-wordmark from all rules is still broader than it looks, because any other issue inside that element now goes unreported. Keep the selector tight and review it when the component changes. Disabling color-contrast site-wide because of one logo hides every real contrast failure you ship afterwards, and that trade is never worth it.
Then write it down. A good record has the URL, the selector, the rule ID, the WCAG criterion, the reason (quote the exception), who decided and when. That record is useful later. If a customer, an auditor or a procurement team asks why a known flag is open, you can show the reasoning instead of a shrug. Our post on what to keep as evidence after each scan goes through the rest of that file.
Finally, if the tool is wrong, report it upstream. axe-core is open source, and a minimal reproduction helps everyone using that rule.
How does wcagc.com handle results it can't be sure of?
We run axe-core, and we keep its two kinds of output apart. Violations show up as issues with their element, selector and WCAG criterion. Results axe marks incomplete show up in a separate "Needs review" list, never as failures and never as passes, so nobody fixes a problem that may not exist or ticks off one that might. That's the opinion behind the design: a scanner that cries wolf gets ignored, and a scanner that hides its uncertainty misleads you. Neither helps.
The limit, stated plainly: our scanner can't confirm a false positive for you, and it can't find what it can't see. A clean report is not conformance. Keyboard flows, reading order and whether alt text means anything still need a person, and the WCAG checklist marks which criteria those are.
The legal frameworks ask the same question as the person testing. The EAA presumes conformity through EN 301 549, which applies WCAG to web content, and in the US, ADA cases are argued with WCAG as the reference point. All of them care whether the content works, not what a tool reported.
Frequently asked questions
What is a false positive in accessibility testing?
It is a result that reports a WCAG failure on content that actually meets the requirement. The W3C ACT Rules Format defines it as a test result that "incorrectly indicates non-conformance to an accessibility requirement" (W3C).
Does axe-core produce false positives?
Rarely, by design. Its README says it "returns zero false positives (bugs notwithstanding)" and returns uncertain cases as "incomplete" for manual review (axe-core). Bugs and edge cases still happen, so confirm before you dismiss.
Is a "needs review" result a false positive?
No. A needs-review result means the tool couldn't decide; axe-core describes these as results that "were aborted and require further testing" (axe-core API). A person has to check it either way.
Should I disable a rule that gives false positives?
No, exclude the specific element instead. Disabling a rule hides every future real failure it would catch. Narrow the suppression to one selector and record why.
Are false positives or false negatives the bigger problem?
False negatives, by a wide margin. Automated tools cover roughly 30 to 57% of issues depending on how you count (Deque), so most real barriers never produce a flag at all.
Check what your scanner sees
Run a free scan to see your violations and your "needs review" items as two separate lists, each with its element, selector and WCAG criterion. Confirm the flags you doubt against the criterion, fix the rest in your code, and then have a person test the journeys that matter with a keyboard and a screen reader.
Written by Pavel Charkasau, founder of wcagc.com. Last updated 14 November 2026.
Sources
- W3C, ACT Rules Format 1.1, W3C Recommendation 5 February 2026: https://www.w3.org/TR/act-rules-format/ — accessed 14 November 2026.
- W3C WAI, Accessibility Conformance Testing (ACT) Overview (updated 5 February 2026): https://www.w3.org/WAI/standards-guidelines/act/ — accessed 14 November 2026.
- W3C WAI, Selecting Web Accessibility Evaluation Tools: https://www.w3.org/WAI/test-evaluate/tools/selecting/ — accessed 14 November 2026.
- W3C, Web Content Accessibility Guidelines (WCAG) 2.2: https://www.w3.org/TR/WCAG22/ — accessed 14 November 2026.
- W3C WAI, Technique H67, "Using null alt text and no title attribute on img elements for images that AT should ignore": https://www.w3.org/WAI/WCAG22/Techniques/html/H67 — accessed 14 November 2026.
- W3C WAI, Understanding SC 1.4.3 Contrast (Minimum): https://www.w3.org/WAI/WCAG22/Understanding/contrast-minimum.html — accessed 14 November 2026.
- Deque Labs, axe-core README: https://github.com/dequelabs/axe-core — accessed 14 November 2026.
- Deque Labs, axe-core API documentation: https://github.com/dequelabs/axe-core/blob/develop/doc/API.md — accessed 14 November 2026.
- Deque, "Automated Testing Study Identifies 57% of Digital Accessibility Issues" (10 March 2021): https://www.deque.com/blog/automated-testing-study-identifies-57-percent-of-digital-accessibility-issues/ — accessed 14 November 2026.