Lighthouse Audits

The Lighthouse Audits resource provides a comprehensive catalog of all Lighthouse accessibility audits, including their WCAG criterion mappings, conformance levels, and POUR principle classifications.

URI Patterns

lighthouse://audits

static

Complete catalog of all 40+ Lighthouse accessibility audits

lighthouse://audits/{auditId}

template

Specific audit detail by ID

Show Parameters

auditId

string

required

Lighthouse audit identifier (e.g., color-contrast, image-alt, aria-valid-attr)

lighthouse://audits/level/{level}

template

Filter audits by WCAG conformance level

Show Parameters

level

enum

required

WCAG conformance level: A, AA, or AAA

lighthouse://audits/principle/{principle}

template

Filter audits by POUR principle

Show Parameters

principle

enum

required

One of: perceivable, operable, understandable, robust

POUR Principles

Lighthouse audits map to the four WCAG principles:

Principle	URI	Examples
Perceivable	`lighthouse://audits/principle/perceivable`	color-contrast, image-alt, video-caption
Operable	`lighthouse://audits/principle/operable`	bypass, link-name, tabindex
Understandable	`lighthouse://audits/principle/understandable`	document-title, html-has-lang, label
Robust	`lighthouse://audits/principle/robust`	aria-* audits, duplicate-id-*

Response Schema

Single Audit

When requesting a specific audit (e.g., lighthouse://audits/color-contrast):

auditId

string

required

Lighthouse audit identifier (e.g., "color-contrast")

title

string

required

Human-readable audit title (e.g., "Contraste de color")

description

string

required

Explanation of what the audit checks

wcagCriterion

string

required

Related WCAG criterion ID (e.g., "1.4.3")

wcagLevel

string

required

WCAG conformance level: "A", "AA", or "AAA"

wcagPrinciple

string

required

POUR principle: "perceivable", "operable", "understandable", or "robust"

Multiple Audits

When requesting filtered lists (e.g., lighthouse://audits/level/AA), the response is an array of audit objects with the same schema.

Examples

Get a Specific Audit

const result = await client.readResource({ 
  uri: 'lighthouse://audits/image-alt' 
});

const audit = JSON.parse(result.contents[0].text);

Response:

{
  "auditId": "image-alt",
  "title": "Texto alternativo en imágenes",
  "description": "Los elementos <img> deben tener un atributo alt con texto descriptivo.",
  "wcagCriterion": "1.1.1",
  "wcagLevel": "A",
  "wcagPrinciple": "perceivable"
}

Get the Full Audit Catalog

const result = await client.readResource({ 
  uri: 'lighthouse://audits' 
});

const allAudits = JSON.parse(result.contents[0].text);
console.log(`Total Lighthouse audits: ${allAudits.length}`);

Returns: Array of 40+ audit objects covering all Lighthouse accessibility checks.

Get All Level A Audits

const result = await client.readResource({ 
  uri: 'lighthouse://audits/level/A' 
});

const levelA = JSON.parse(result.contents[0].text);
console.log(`Level A audits: ${levelA.length}`);
levelA.forEach(audit => {
  console.log(`- ${audit.auditId}: ${audit.title}`);
});

Returns: All audits that map to WCAG Level A criteria (fundamental requirements).

Get All Perceivable Audits

const result = await client.readResource({ 
  uri: 'lighthouse://audits/principle/perceivable' 
});

const perceivable = JSON.parse(result.contents[0].text);
console.log('Perceivable audits:');
perceivable.forEach(audit => {
  console.log(`- ${audit.auditId} → WCAG ${audit.wcagCriterion}`);
});

Returns: Audits checking for text alternatives, adaptable content, and distinguishable elements.

Quick Reference Tables

Perceivable Audits

Audit ID	Title	WCAG	Level
`color-contrast`	Contraste de color	1.4.3	AA
`image-alt`	Texto alternativo en imágenes	1.1.1	A
`input-image-alt`	Texto alternativo en input de imagen	1.1.1	A
`area-alt`	Texto alternativo en áreas	1.1.1	A
`object-alt`	Texto alternativo en objetos	1.1.1	A
`video-caption`	Subtítulos en video	1.2.2	A
`video-description`	Audiodescripción en video	1.2.5	AA
`meta-viewport`	Meta viewport	1.4.4	AA

Operable Audits

Audit ID	Title	WCAG	Level
`bypass`	Saltar bloques de contenido	2.4.1	A
`link-name`	Nombre accesible de enlaces	2.4.4	A
`button-name`	Nombre accesible de botones	4.1.2	A
`heading-order`	Orden de encabezados	2.4.6	AA
`tabindex`	Uso de tabindex	2.4.3	A
`accesskeys`	Teclas de acceso únicas	2.4.1	A
`meta-refresh`	Meta refresh	2.2.1	A
`tap-targets`	Tamaño de áreas táctiles	2.5.5	AAA

Understandable Audits

Audit ID	Title	WCAG	Level
`document-title`	Título del documento	2.4.2	A
`html-has-lang`	Atributo lang en HTML	3.1.1	A
`html-lang-valid`	Valor válido de lang	3.1.1	A
`valid-lang`	Atributos lang válidos	3.1.2	AA
`label`	Etiquetas de formularios	3.3.2	A
`form-field-multiple-labels`	Múltiples etiquetas en campo	3.3.2	A

Robust Audits (ARIA & Parsing)

Audit ID	Title	WCAG	Level
`aria-allowed-attr`	Atributos ARIA permitidos	4.1.2	A
`aria-required-attr`	Atributos ARIA requeridos	4.1.2	A
`aria-required-children`	Hijos ARIA requeridos	4.1.2	A
`aria-required-parent`	Padre ARIA requerido	4.1.2	A
`aria-roles`	Roles ARIA válidos	4.1.2	A
`aria-valid-attr`	Atributos ARIA válidos	4.1.2	A
`aria-valid-attr-value`	Valores ARIA válidos	4.1.2	A
`aria-hidden-body`	ARIA hidden en body	4.1.2	A
`aria-hidden-focus`	Foco en elementos ARIA hidden	4.1.2	A
`duplicate-id-active`	IDs duplicados en elementos activos	4.1.1	A
`duplicate-id-aria`	IDs duplicados en referencias ARIA	4.1.1	A

Common Use Cases

Understand What Lighthouse Checks

const result = await client.readResource({ 
  uri: 'lighthouse://audits/color-contrast' 
});

const audit = JSON.parse(result.contents[0].text);

console.log('Lighthouse color-contrast audit:');
console.log(`- Checks: ${audit.description}`);
console.log(`- Maps to WCAG: ${audit.wcagCriterion}`);
console.log(`- Level: ${audit.wcagLevel}`);

Output:

Lighthouse color-contrast audit:
- Checks: Los colores de fondo y primer plano no tienen una relación de contraste suficiente.
- Maps to WCAG: 1.4.3
- Level: AA

Map Lighthouse Results to WCAG

After running Lighthouse analysis, look up the WCAG criteria:

// 1. Run Lighthouse
const lighthouseResult = await analyzeWithLighthouse('https://example.com');

// 2. For each failing audit, get the mapping
for (const auditId of lighthouseResult.failingAudits) {
  const auditResult = await client.readResource({ 
    uri: `lighthouse://audits/${auditId}` 
  });
  const audit = JSON.parse(auditResult.contents[0].text);
  
  // 3. Look up the full WCAG criterion
  const criterionResult = await client.readResource({ 
    uri: `wcag://criteria/${audit.wcagCriterion}` 
  });
  const criterion = JSON.parse(criterionResult.contents[0].text);
  
  console.log(`${audit.title} → ${criterion.title}`);
  console.log(`Affected users: ${criterion.affectedUsers.join(', ')}`);
}

Build Audit Coverage Report

See which WCAG levels Lighthouse covers:

const result = await client.readResource({ 
  uri: 'lighthouse://audits' 
});

const audits = JSON.parse(result.contents[0].text);

const byLevel = {
  A: audits.filter(a => a.wcagLevel === 'A').length,
  AA: audits.filter(a => a.wcagLevel === 'AA').length,
  AAA: audits.filter(a => a.wcagLevel === 'AAA').length
};

console.log('Lighthouse WCAG coverage:');
console.log(`- Level A: ${byLevel.A} audits`);
console.log(`- Level AA: ${byLevel.AA} audits`);
console.log(`- Level AAA: ${byLevel.AAA} audits`);

Filter by Principle for Focused Audits

const result = await client.readResource({ 
  uri: 'lighthouse://audits/principle/robust' 
});

const robustAudits = JSON.parse(result.contents[0].text);

console.log('Robust principle audits (ARIA, parsing):');
robustAudits.forEach(audit => {
  console.log(`- ${audit.auditId}`);
});

Output: All ARIA-related and HTML parsing audits.

Lighthouse vs WCAG Resources

Use both resources together for complete context:

Resource	Purpose	Example Query
`lighthouse://audits`	What does Lighthouse check?	”Does Lighthouse have an alt text audit?”
`wcag://criteria`	What does WCAG require?	”What’s the full requirement for 1.1.1?”

Workflow: Lighthouse → WCAG → Remediation

Run Lighthouse analysis

Use analyze-with-lighthouse to get accessibility score and failing audits

const result = await analyzeWithLighthouse('https://example.com');
console.log(`Score: ${result.score}/100`);
console.log(`Failed audits: ${result.failingAudits.length}`);

Look up audit details

For each failing audit, get the Lighthouse audit information

const audit = await client.readResource({ 
  uri: `lighthouse://audits/${auditId}` 
});
const auditData = JSON.parse(audit.contents[0].text);

Get WCAG criterion

Use the wcagCriterion field to look up full WCAG requirements

const criterion = await client.readResource({ 
  uri: `wcag://criteria/${auditData.wcagCriterion}` 
});
const wcagData = JSON.parse(criterion.contents[0].text);

Apply remediation

Use suggestedActions from the WCAG criterion to fix the issue

console.log('How to fix:');
wcagData.suggestedActions.forEach(action => {
  console.log(`- ${action}`);
});

Integration with Tools

The analyze-with-lighthouse tool returns failing audit IDs that you can look up:

// 1. Run Lighthouse
const analysis = await analyzeWithLighthouse('https://example.com');

// 2. analysis.failingAudits contains audit IDs like:
// ["color-contrast", "image-alt", "link-name"]

// 3. Look up each audit for details
for (const auditId of analysis.failingAudits) {
  const result = await client.readResource({ 
    uri: `lighthouse://audits/${auditId}` 
  });
  const audit = JSON.parse(result.contents[0].text);
  console.log(`${audit.title} (WCAG ${audit.wcagCriterion})`);
}

Coverage Notes

Lighthouse checks approximately 40+ accessibility audits, but this is only a subset of all WCAG 2.1 criteria. Automated tools can only detect about 30-40% of accessibility issues. Manual testing is required for comprehensive WCAG conformance.

What Lighthouse Cannot Check

Lighthouse audits focus on automated-detectable issues. It cannot verify:

Quality of alt text (only checks if it exists)
Logical heading structure (only checks sequential order)
Meaningful link text (only checks if text exists)
Keyboard navigation flow (only checks focusable elements)
Screen reader experience (requires manual testing)
Cognitive accessibility (reading level, consistency)

For complete WCAG coverage, combine Lighthouse with:

Manual keyboard testing
Screen reader testing
Expert review of content quality

Error Responses

Invalid audit IDs return an error object:

{
  "error": "Auditoría Lighthouse 'invalid-audit' no encontrada"
}

Invalid level or principle values return similar error messages.

WCAG Criteria

Look up full WCAG requirements for each audit

Lighthouse Tool

Run Lighthouse analysis to get failing audits

Contrast Thresholds

Specific thresholds for the color-contrast audit

Lighthouse Prompt

Guided workflow for score-focused audits

Standards Reference

This resource is based on:

Lighthouse v10+ accessibility audit definitions
axe-core rule mappings (Lighthouse uses axe-core internally)
WCAG 2.1 criterion mappings

For official Lighthouse audit documentation, see: Lighthouse Accessibility Audits

Overview

Reference Data

URI Patterns

POUR Principles

Response Schema

Single Audit

Multiple Audits

Examples

Get a Specific Audit

Get the Full Audit Catalog

Get All Level A Audits

Get All Perceivable Audits

Quick Reference Tables

Perceivable Audits

Operable Audits

Understandable Audits

Robust Audits (ARIA & Parsing)

Common Use Cases

Understand What Lighthouse Checks

Map Lighthouse Results to WCAG

Build Audit Coverage Report

Filter by Principle for Focused Audits

Lighthouse vs WCAG Resources

Workflow: Lighthouse → WCAG → Remediation

Integration with Tools

Coverage Notes

What Lighthouse Cannot Check

Error Responses

WCAG Criteria

Lighthouse Tool

Contrast Thresholds

Lighthouse Prompt

Standards Reference

Build docs developers (and LLMs) love

Overview

Reference Data

​URI Patterns

​POUR Principles

​Response Schema

​Single Audit

​Multiple Audits

​Examples

​Get a Specific Audit

​Get the Full Audit Catalog

​Get All Level A Audits

​Get All Perceivable Audits

​Quick Reference Tables

​Perceivable Audits

​Operable Audits

​Understandable Audits

​Robust Audits (ARIA & Parsing)

​Common Use Cases

​Understand What Lighthouse Checks

​Map Lighthouse Results to WCAG

​Build Audit Coverage Report

​Filter by Principle for Focused Audits

​Lighthouse vs WCAG Resources

​Workflow: Lighthouse → WCAG → Remediation

​Integration with Tools

​Coverage Notes

​What Lighthouse Cannot Check

​Error Responses

​Related Resources

WCAG Criteria

Lighthouse Tool

Contrast Thresholds

Lighthouse Prompt

​Standards Reference

Build docs developers (and LLMs) love

URI Patterns

POUR Principles

Response Schema

Single Audit

Multiple Audits

Examples

Get a Specific Audit

Get the Full Audit Catalog

Get All Level A Audits

Get All Perceivable Audits

Quick Reference Tables

Perceivable Audits

Operable Audits

Understandable Audits

Robust Audits (ARIA & Parsing)

Common Use Cases

Understand What Lighthouse Checks

Map Lighthouse Results to WCAG

Build Audit Coverage Report

Filter by Principle for Focused Audits

Lighthouse vs WCAG Resources

Workflow: Lighthouse → WCAG → Remediation

Integration with Tools

Coverage Notes

What Lighthouse Cannot Check

Error Responses

Related Resources

Standards Reference