Google Lighthouse vs WAVE 2026: Which Accessibility Tool Should You Use?
Lighthouse and WAVE are both free, both trusted by accessibility professionals, and both used daily by developers and auditors. But they were built for different jobs. This guide clarifies what each tool does well — and why most serious teams end up using both.
Quick Comparison: Lighthouse vs WAVE
Google Lighthouse
- Scope: Accessibility + Performance + SEO + Best Practices
- Accessibility engine: axe-core (Deque)
- Output: Scored report (0–100) with actionable items
- CI/CD: Excellent (Lighthouse CI for GitHub Actions etc.)
- Visual overlay: No
- Free tier: Chrome DevTools built-in, CLI
WAVE (WebAIM)
- Scope: Accessibility only
- Accessibility engine: Proprietary WebAIM rule set
- Output: Visual in-page overlay + categorized issue list
- CI/CD: Limited (paid WAVE API required)
- Visual overlay: Yes — highlights issues in-page context
- Free tier: Browser extension + wave.webaim.org
What Are Lighthouse and WAVE?
Google Lighthouse is an open-source auditing tool built directly into Chrome DevTools (Inspect → Lighthouse tab). It runs a series of automated checks across five categories — Performance, Accessibility, Best Practices, SEO, and Progressive Web App — and produces a scored report with prioritized recommendations. Lighthouse is also available as a Node CLI (npm install -g lighthouse) and through Lighthouse CI for automated pipeline integration. Its accessibility checks are powered by axe-core, the open-source engine from Deque Systems.
WAVE (Web Accessibility Evaluation Tool) is built by WebAIM at Utah State University and has been in continuous development since 2001. WAVE is purpose-built for accessibility: it has no interest in performance or SEO. Instead, it provides a deep visual audit experience through browser extensions (Chrome and Firefox) and the wave.webaim.org web service. WAVE uses its own proprietary rule set — separate from axe-core — which means it finds different violations than Lighthouse.
The key difference in philosophy: Lighthouse is a general web health tool that includes accessibility. WAVE is an accessibility-first tool that goes deep where Lighthouse stays broad.
The Accessibility Engine Difference
This is the most technically significant distinction between the two tools.
Lighthouse uses axe-core to run its accessibility audits. This means Lighthouse's accessibility results are essentially an axe-core audit wrapped in Google's report interface and scoring system. If you've already integrated axe-core into your testing pipeline or use the axe browser extension, running a Lighthouse accessibility audit will surface largely the same violations — presented differently, but from the same underlying engine.
WAVE uses WebAIM's own rule set, which was developed independently and reflects WebAIM's deep accessibility research expertise. WAVE catches some violations that axe-core (and therefore Lighthouse) misses — and vice versa. The tools have partial overlap but genuinely distinct coverage.
Practical Implication
If your team already uses axe-core or axe DevTools, running Lighthouse accessibility audits adds relatively little new information — you're running the same engine twice. WAVE, with its distinct rule set, provides genuinely complementary coverage. Teams that run both Lighthouse (for CI/CD performance + accessibility regression) and WAVE (for manual audit depth) get broader WCAG coverage than either tool alone.
Coverage: What Each Tool Finds
Where Lighthouse Excels
Lighthouse accessibility checks (via axe-core) are strong on programmatically verifiable WCAG failures:
- ARIA role and attribute validation (invalid roles, incorrect aria-labelledby references)
- Interactive element accessible names (buttons and links without descriptive text)
- Form label associations (inputs missing labels or title attributes)
- Color contrast ratio pass/fail (mathematical check against WCAG thresholds)
- Document language declaration
- Landmark region structure
- Image alt text presence (not quality)
- Performance issues that affect accessibility (time to interactive for users with cognitive disabilities)
Where WAVE Goes Deeper
WAVE's dedicated accessibility rule set surfaces additional issues and context:
- Visual heading structure display (overlaid on the actual rendered page)
- Alert-level issues (potential violations requiring human review — more liberal than axe)
- Alternative text quality indication (shows alt text value visually so reviewers can judge it)
- Link text ambiguity detection ("click here", "read more" patterns)
- Structural element visibility (renders all ARIA roles and landmarks overlaid on the page)
- Redundant or suspicious alt text flags
- Form field grouping issues not caught by axe-core
What Neither Detects Reliably
Automated tools have fundamental limits. Both Lighthouse and WAVE miss:
- Meaningful vs. decorative image distinction (can't evaluate if alt text is accurate)
- Logical reading order vs. DOM order mismatches in complex layouts
- Keyboard interaction patterns and focus management in JavaScript components
- Cognitive accessibility and plain language quality
- Audio description adequacy for video
- Touch target sizing in mobile-specific contexts
- Session timeout accessibility for users needing extended time
Lighthouse Scores vs WAVE Issue Counts
Lighthouse reports accessibility as a score from 0–100 based on the weighted impact of issues found. This scoring can be misleading: a page with a few high-impact issues may score significantly lower than a page with many low-impact issues. Conversely, a page can score 100 and still have significant WCAG violations that the automated checks simply cannot detect.
WAVE doesn't score — it categorizes. WAVE reports Errors (confirmed WCAG violations), Alerts (potential issues for human review), Features (accessibility enhancements present), Structural Elements (ARIA and structural markup found), and Contrast Errors (color contrast failures). This structure is more informative for manual auditors than a single number, though it's harder to use as a CI/CD pass/fail gate.
Don't Confuse a Lighthouse 100 Score with ADA Compliance
A Lighthouse accessibility score of 100 is meaningful — it means your site passed all automated checks the tool can evaluate. But automated tools catch only 30–40% of real WCAG 2.2 AA violations. Courts, DOJ settlements, and plaintiff attorneys look for violations that automated tools routinely miss: poor focus management, inaccessible JavaScript interactions, inadequate alt text quality. Treat a perfect Lighthouse score as a floor, not a ceiling.
CI/CD Integration: Lighthouse Has a Clear Advantage
For development teams that want automated accessibility regression testing in their deployment pipeline, Lighthouse is significantly easier to integrate than WAVE.
Lighthouse CI (@lhci/cli)
Official CLI for running Lighthouse in CI environments. Supports GitHub Actions, GitLab, CircleCI. Set budget assertions to fail builds when accessibility score drops below threshold.
Chrome DevTools Protocol
Lighthouse runs on Chrome's DevTools Protocol, making it easy to script with Puppeteer, Playwright, or any Chromium automation framework.
lighthouse npm package
Programmatic Node.js API for running Lighthouse audits. Full control over categories, throttling, and report format — ideal for custom reporting pipelines.
PageSpeed Insights API
Google's hosted Lighthouse API — run audits without managing Chromium. Rate-limited but free for reasonable use cases.
WAVE's CI/CD path requires the paid WAVE API, which adds cost and lacks the first-class framework integrations that Lighthouse CI provides. For teams that specifically need WAVE's rule set in automation — particularly accessibility-focused agencies — the WAVE API is a viable option, but most development teams will find Lighthouse CI easier to adopt.
Manual Auditing: WAVE's Visual Overlays Win
For manual accessibility audits — particularly when communicating issues to non-developer stakeholders — WAVE's visual overlay approach is dramatically more intuitive than Lighthouse's report format.
WAVE injects visual indicators directly into the rendered page: icons marking errors, alerts, features, and structural elements in context. Reviewers can toggle views to see heading structure, ARIA roles, and contrast issues overlaid on the actual page layout. This makes it easy to explain to a designer or content editor exactly what's wrong and where.
Lighthouse produces a separate panel report with descriptions and element references. This is excellent for developers, but requires more interpretation for non-technical reviewers who need to understand where on the actual page the issue appears.
When to Use Lighthouse vs WAVE
Use Lighthouse when...
- You want performance + accessibility + SEO in one automated report
- You need CI/CD integration with GitHub Actions or other pipelines
- You want to track accessibility scores over time alongside Core Web Vitals
- You're already using axe-core and want consolidated reporting
- You need a quick developer-facing audit from Chrome DevTools
Use WAVE when...
- You're conducting a dedicated accessibility-only audit
- You need to communicate issues visually to designers or content teams
- You want WAVE's broader alert set for human review
- You're checking heading structure and landmark layout in visual context
- You want complementary coverage to axe-core / Lighthouse
The Shared Limitation: Neither Tool Is Enough for ADA Compliance
Both Lighthouse and WAVE are automated testing tools, and the fundamental limitation they share is that automated testing catches only 30–40% of real WCAG 2.2 AA violations. The majority of accessibility issues — keyboard interaction patterns, focus management, reading order, meaningful alternative text, cognitive accessibility — require human evaluation.
For businesses concerned about ADA website lawsuit exposure, relying solely on Lighthouse scores or WAVE reports is insufficient. Plaintiff attorneys use their own automated tools plus manual testing to identify violations, and the violations automated tools miss are often the same ones that appear in demand letters and lawsuits.
Comprehensive accessibility compliance requires: automated testing (Lighthouse and/or WAVE and/or axe) + manual keyboard navigation testing + screen reader testing + continuous monitoring to catch regressions when your site changes. The combination of automated scanning and ongoing monitoring is what courts and accessibility standards bodies expect.
Go Beyond Lighthouse and WAVE
RatedWithAI adds continuous monitoring to your accessibility stack — catching regressions every time your site updates, not just when you remember to run a manual scan.
Sponsored
Also audit your site's full technical health
SEMrush Site Audit checks 130+ issues — missing alt text, broken links, slow pages. Free crawl up to 100 pages, no credit card required.
Frequently Asked Questions
Is Google Lighthouse better than WAVE for accessibility testing?
Neither is universally better — they have different strengths. Lighthouse excels at CI/CD integration and gives developers a combined performance + accessibility report from within Chrome DevTools. WAVE goes deeper on accessibility specifically, with a distinct rule set and visual overlays that make it easier for non-developers to understand and act on issues. Most serious accessibility programs use both: Lighthouse in the development pipeline and WAVE for manual audit passes.
Does Lighthouse use the same engine as axe?
Yes. Lighthouse's accessibility audit category is powered by axe-core, Deque Systems' open-source WCAG testing engine. This means Lighthouse accessibility results largely overlap with what you'd get from the axe browser extension or axe-core in your test suite. If you already use axe, Lighthouse adds performance and SEO auditing on top of the same accessibility detection — it doesn't significantly expand your WCAG coverage.
What does a Lighthouse accessibility score of 100 mean?
A Lighthouse score of 100 means your page passed all automated accessibility checks that Lighthouse's axe-core engine can evaluate. It does not mean your site is WCAG 2.2 AA compliant or ADA-compliant. Automated tools detect roughly 30-40% of real WCAG violations — issues requiring human judgment (reading order, alt text quality, keyboard interaction patterns) are invisible to automated scanners. Treat a 100 score as a necessary baseline, not a compliance certification.
Can WAVE and Lighthouse be used together?
Yes, and most comprehensive accessibility programs use both. Use Lighthouse in your CI/CD pipeline to catch accessibility (and performance) regressions on every deploy. Use WAVE during manual audit passes, when reviewing content, or when communicating issues to non-developer team members. Since WAVE uses a different rule set from axe-core/Lighthouse, the two tools complement each other and together catch more issues than either alone.
Is WAVE more accurate than Lighthouse?
Accuracy depends on what you're measuring. WAVE and Lighthouse (via axe-core) have different rule sets — each catches some violations the other misses. WAVE's 'alerts' category flags more potential issues for human review than axe-core's strict confirmed-only approach, which means WAVE may surface more items but some will require human judgment to determine if they're real violations. Neither tool is more accurate in an absolute sense; they have different coverage profiles and philosophies.