axe DevTools vs Google Lighthouse: Accessibility Testing Compared
Both tools use axe-core under the hood, but they serve different purposes. Here's when to use each one — and why you might want both.
axe DevTools and Google Lighthouse are the two most popular free accessibility testing tools. Since Lighthouse actually uses axe-core as its accessibility engine, the question isn't really "which is better" — it's "which fits your workflow." This guide breaks down the real differences.
Both tools share a fundamental limitation
Automated accessibility testing catches approximately 30-40% of WCAG issues. Neither axe nor Lighthouse can evaluate image alt text quality, logical reading order, or keyboard interaction patterns. Manual testing remains essential regardless of which tool you choose.
The Key Difference
Lighthouse runs a subset of axe-core rules alongside performance, SEO, and best practices audits. axe DevTools runs the full axe-core rule set and focuses exclusively on accessibility.
Dedicated accessibility tool. Runs ~96 rules from the full axe-core engine. Focused entirely on finding and explaining WCAG issues.
Multi-purpose audit tool. Runs 57 accessibility audits as part of a broader audit covering performance, SEO, best practices, and accessibility.
Feature Comparison
| Feature | axe DevTools | Lighthouse |
|---|---|---|
| Accessibility rules | ~96 rules (full axe-core) | 57 audits (axe-core subset) |
| Zero false positives | Yes (guaranteed) | Yes (inherited from axe-core) |
| Browser extension | Yes (Chrome, Firefox, Edge) | Built into Chrome DevTools |
| CLI available | Yes (axe-core npm) | Yes (lighthouse npm) |
| CI/CD integration | Yes (axe-core, @axe-core/playwright) | Yes (Lighthouse CI) |
| Performance testing | No | Yes (core feature) |
| SEO auditing | No | Yes (core feature) |
| Issue explanations | Detailed with fix suggestions | Basic descriptions |
| Element highlighting | Yes (pinpoints exact elements) | Limited |
| Guided manual testing | Pro version only | No |
| Price | Free (Pro: paid plans available) | Free |
Detailed Reviews
axe DevTools
Browser Extension / npm Package
Strengths
- Full axe-core rule set (~96 rules) catches more issues than Lighthouse
- Zero false positives guarantee — every issue reported is a real problem
- Detailed fix suggestions with code examples for each violation
- Element highlighting pinpoints exactly where issues occur in the DOM
Limitations
- -Only tests the current visible page state (no site-wide crawling)
- -Guided manual testing requires the paid Pro version
- -No performance or SEO auditing — accessibility only
Developers who need thorough, accurate accessibility testing during development
Google Lighthouse
Chrome Built-in / CLI / npm
Strengths
- Built into Chrome — no installation needed, always available
- Tests accessibility alongside performance, SEO, and best practices in one audit
- Lighthouse CI makes it easy to add accessibility checks to deployment pipelines
- Powered by axe-core, so results are reliable (within its rule subset)
Limitations
- -Runs only 57 of ~96 axe-core rules — misses issues axe would catch
- -Accessibility score (0-100) can be misleading — a perfect score doesn't mean full compliance
- -Less detailed explanations and no element highlighting for accessibility issues
Quick audits and CI/CD pipelines where you want accessibility checks alongside performance
Head-to-Head: Common Scenarios
Quick page check
LighthouseBuilt into Chrome, no setup needed. Open DevTools, run audit, get results in seconds alongside performance data.
Deep accessibility audit
axe DevToolsFull rule set catches more issues. Detailed element highlighting and fix suggestions make debugging faster.
CI/CD pipeline
Tie — depends on needsLighthouse CI is simpler to set up and covers performance too. axe-core via Playwright or Jest provides more thorough accessibility-specific testing.
Team reporting
axe DevToolsBetter issue explanations and fix guidance make it easier to hand off issues to developers. Lighthouse's numeric score can oversimplify.
Non-technical users
LighthouseThe simple 0-100 score and built-in availability make it more approachable for designers and product managers.
Our Recommendation
Use axe DevTools when...
- Accessibility is your primary concern, not just one of many audits
- You need the most thorough automated scanning possible
- Your team needs clear fix guidance to resolve issues
- You're debugging specific accessibility problems
Use Lighthouse when...
- You want a quick, all-in-one audit (performance + accessibility + SEO)
- You're adding basic accessibility checks to an existing CI/CD pipeline
- You need a simple score to track progress over time
- You're introducing accessibility testing to a team for the first time
Use both when...
- You want comprehensive coverage — Lighthouse for broad checks, axe for depth
- Your CI/CD runs Lighthouse for gating and axe for detailed regression testing
- Different team members prefer different workflows
- You're building a mature accessibility testing strategy
Beyond Automated Testing
Whether you choose axe, Lighthouse, or both, automated tools are only part of the picture. Industry research consistently shows that automated scanning catches approximately 30-40% of WCAG issues. The remaining 60-70% require manual testing.
Manual tests no automated tool can replace:
Keyboard navigation
Can every interactive element be reached and operated with just a keyboard?
Screen reader testing
Does the content make sense when read aloud by NVDA, VoiceOver, or JAWS?
Alt text quality
Are image descriptions meaningful, not just present?
Content structure
Is the heading hierarchy logical? Does the reading order make sense?
Error handling
Are form errors clearly communicated to all users, including those using assistive technology?
Frequently Asked Questions
Does Lighthouse use axe-core?
Yes. Google Lighthouse uses axe-core as its underlying accessibility engine, running approximately 50 axe rules. The standalone axe DevTools extension runs the full rule set of ~96 rules and offers additional features like element highlighting and detailed fix suggestions.
Which tool catches more accessibility issues?
axe DevTools catches more issues because it runs the full axe-core rule set (~96 rules) while Lighthouse only runs a subset (57 audits). For comprehensive automated scanning, axe DevTools is the more thorough option.
Can I use both axe and Lighthouse together?
Yes, and many teams do. Lighthouse is convenient for quick checks since it's built into Chrome, while axe provides deeper analysis. In CI/CD, you might use Lighthouse CI for broad performance and accessibility gating and axe-core for detailed accessibility regression testing.
Are axe and Lighthouse sufficient for WCAG compliance?
No. Both are automated tools that catch approximately 30-40% of WCAG issues. Full compliance requires manual testing including keyboard navigation, screen reader testing, and human judgment on content quality.
What about the Lighthouse accessibility score?
The Lighthouse accessibility score (0-100) only reflects the 57 audits it checks. A score of 100 means you passed those specific automated checks — it does not mean your site is fully accessible. Many critical issues (like keyboard traps, meaningful alt text, and logical reading order) aren't included in the score.
Related Resources
Continue building your accessibility testing knowledge.
All Testing Tools Compared
Full comparison of axe, WAVE, Lighthouse, Pa11y, Siteimprove, and inclly.
Automated vs Manual Testing
What each approach catches and how to build an effective testing strategy.
Manual Testing Guide
5 essential tests every developer should know, from keyboard to screen reader.
WCAG 2.2 AA Checklist
All 50 Level A and AA success criteria with testing indicators.
Go Beyond axe and Lighthouse
inclly combines axe-core scanning with framework-specific code fixes, audit trails for compliance, and clear flags for issues that need manual review. See what automated tools miss.
Start Free Scan