WCAG 2.2 structure, levels and conformance

WCAG 2.2 has 86 success criteria, and a claim of Level AA conformance is a promise about 55 of them, on every page it covers and on every step of the processes those pages belong to. “We are WCAG compliant” in a footer names no version, no level and no pages, so it promises nothing anyone can check.

You will be able to find your way through the standard’s layers and the documents around it, state what Level AA demands, tell the required text from the advice that explains it, and write a conformance claimconformance claim: A statement that named web pages meet a WCAG version at a level. It is optional, but one that is made must give its date, the guidelines' title, version and address, the level, the pages covered and the technologies relied upon. that says exactly what it covers.

WCAG 2.2 is four principles, 13 guidelines and 86 success criteria

Open WCAG 2.2 at any criterion and you are three layers down. At the top are four principles: content must be perceivable, operable, understandable and robust. Each principle holds guidelines, 13 in all, such as Text Alternatives or Enough Time, which state a goal but are not tested themselves. Under the guidelines sit the success criteriasuccess criterion: A testable statement in WCAG, such as 1.1.1 Non-text Content, at Level A, AA or AAA. Conformance is judged criterion by criterion; the guidelines and principles above them are not tested themselves., the testable statements, each at one of three conformance levelsconformance level: One of WCAG's three levels, A, AA and AAA. Conforming at a level means meeting every success criterion at that level and at the levels below it, so Level AA in WCAG 2.2 means all 55 criteria at A and AA.: A, AA or AAA (WCAG 2 Overview).

The program below lists every criterion with its level, counts them by guideline and by level, and prints the ones at Level AA:

// WCAG 2.2's success criteria: number, short name and level, as the W3C Recommendation lists
// them. 4.1.1 Parsing keeps its number but is marked "obsolete and removed", so it has no level.
const criteria = `
1.1.1 A Non-text Content|1.2.1 A Audio-only and Video-only (Prerecorded)|1.2.2 A Captions (Prerecorded)
1.2.3 A Audio Description or Media Alternative (Prerecorded)|1.2.4 AA Captions (Live)
1.2.5 AA Audio Description (Prerecorded)|1.2.6 AAA Sign Language (Prerecorded)
1.2.7 AAA Extended Audio Description (Prerecorded)|1.2.8 AAA Media Alternative (Prerecorded)
1.2.9 AAA Audio-only (Live)|1.3.1 A Info and Relationships|1.3.2 A Meaningful Sequence
1.3.3 A Sensory Characteristics|1.3.4 AA Orientation|1.3.5 AA Identify Input Purpose|1.3.6 AAA Identify Purpose
1.4.1 A Use of Color|1.4.2 A Audio Control|1.4.3 AA Contrast (Minimum)|1.4.4 AA Resize Text
1.4.5 AA Images of Text|1.4.6 AAA Contrast (Enhanced)|1.4.7 AAA Low or No Background Audio
1.4.8 AAA Visual Presentation|1.4.9 AAA Images of Text (No Exception)|1.4.10 AA Reflow
1.4.11 AA Non-text Contrast|1.4.12 AA Text Spacing|1.4.13 AA Content on Hover or Focus
2.1.1 A Keyboard|2.1.2 A No Keyboard Trap|2.1.3 AAA Keyboard (No Exception)|2.1.4 A Character Key Shortcuts
2.2.1 A Timing Adjustable|2.2.2 A Pause, Stop, Hide|2.2.3 AAA No Timing|2.2.4 AAA Interruptions
2.2.5 AAA Re-authenticating|2.2.6 AAA Timeouts|2.3.1 A Three Flashes or Below Threshold|2.3.2 AAA Three Flashes
2.3.3 AAA Animation from Interactions|2.4.1 A Bypass Blocks|2.4.2 A Page Titled|2.4.3 A Focus Order
2.4.4 A Link Purpose (In Context)|2.4.5 AA Multiple Ways|2.4.6 AA Headings and Labels|2.4.7 AA Focus Visible
2.4.8 AAA Location|2.4.9 AAA Link Purpose (Link Only)|2.4.10 AAA Section Headings
2.4.11 AA Focus Not Obscured (Minimum)|2.4.12 AAA Focus Not Obscured (Enhanced)|2.4.13 AAA Focus Appearance
2.5.1 A Pointer Gestures|2.5.2 A Pointer Cancellation|2.5.3 A Label in Name|2.5.4 A Motion Actuation
2.5.5 AAA Target Size (Enhanced)|2.5.6 AAA Concurrent Input Mechanisms|2.5.7 AA Dragging Movements
2.5.8 AA Target Size (Minimum)|3.1.1 A Language of Page|3.1.2 AA Language of Parts|3.1.3 AAA Unusual Words
3.1.4 AAA Abbreviations|3.1.5 AAA Reading Level|3.1.6 AAA Pronunciation|3.2.1 A On Focus|3.2.2 A On Input
3.2.3 AA Consistent Navigation|3.2.4 AA Consistent Identification|3.2.5 AAA Change on Request
3.2.6 A Consistent Help|3.3.1 A Error Identification|3.3.2 A Labels or Instructions|3.3.3 AA Error Suggestion
3.3.4 AA Error Prevention (Legal, Financial, Data)|3.3.5 AAA Help|3.3.6 AAA Error Prevention (All)
3.3.7 A Redundant Entry|3.3.8 AA Accessible Authentication (Minimum)
3.3.9 AAA Accessible Authentication (Enhanced)|4.1.1 - Parsing (Obsolete and removed)
4.1.2 A Name, Role, Value|4.1.3 AA Status Messages`
  .split(/[|\n]/)
  .filter((line) => line.trim() !== '')
  .map((line) => {
    const [number, level, ...name] = line.trim().split(' ');
    return { number, level, name: name.join(' ') };
  });

const guidelines = [
  ['1.1', 'Text Alternatives'], ['1.2', 'Time-based Media'], ['1.3', 'Adaptable'], ['1.4', 'Distinguishable'],
  ['2.1', 'Keyboard Accessible'], ['2.2', 'Enough Time'], ['2.3', 'Seizures and Physical Reactions'],
  ['2.4', 'Navigable'], ['2.5', 'Input Modalities'], ['3.1', 'Readable'], ['3.2', 'Predictable'],
  ['3.3', 'Input Assistance'], ['4.1', 'Compatible'],
];
const LEVELS = ['A', 'AA', 'AAA'];
const live = criteria.filter((c) => LEVELS.includes(c.level));
const count = (list, level) => list.filter((c) => c.level === level).length;
const row = (label, cells) => label.padEnd(38) + cells.map((n) => String(n).padStart(4)).join('');

console.log(row('Guideline', ['A', 'AA', 'AAA', 'All']));
for (const [id, name] of guidelines) {
  const mine = live.filter((c) => c.number.startsWith(`${id}.`));
  console.log(row(`${id} ${name}`, [count(mine, 'A'), count(mine, 'AA'), count(mine, 'AAA'), mine.length]));
}
console.log(row('Total', [count(live, 'A'), count(live, 'AA'), count(live, 'AAA'), live.length]));
console.log('');
console.log(`4 principles, ${guidelines.length} guidelines, ${live.length} success criteria.`);
console.log(`Kept as a number only: ${criteria.filter((c) => c.level === '-').map((c) => `${c.number} ${c.name}`).join(', ')}.`);
console.log(`A Level AA claim covers ${count(live, 'A') + count(live, 'AA')} criteria: every one at A and at AA.`);

// Change the level to list another set: 'A', 'AA' or 'AAA'.
const SHOW = 'AA';
console.log('');
console.log(`The ${count(live, SHOW)} criteria at Level ${SHOW}:`);
for (const c of live.filter((x) => x.level === SHOW)) console.log(`  ${c.number.padEnd(7)}${c.name}`);

Guideline                                A  AA AAA All
1.1 Text Alternatives                    1   0   0   1
1.2 Time-based Media                     3   2   4   9
1.3 Adaptable                            3   2   1   6
1.4 Distinguishable                      2   7   4  13
2.1 Keyboard Accessible                  3   0   1   4
2.2 Enough Time                          2   0   4   6
2.3 Seizures and Physical Reactions      1   0   2   3
2.4 Navigable                            4   4   5  13
2.5 Input Modalities                     4   2   2   8
3.1 Readable                             1   1   4   6
3.2 Predictable                          3   2   1   6
3.3 Input Assistance                     3   3   3   9
4.1 Compatible                           1   1   0   2
Total                                   31  24  31  86

4 principles, 13 guidelines, 86 success criteria.
Kept as a number only: 4.1.1 Parsing (Obsolete and removed).
A Level AA claim covers 55 criteria: every one at A and at AA.

The 24 criteria at Level AA:
  1.2.4  Captions (Live)
  1.2.5  Audio Description (Prerecorded)
  1.3.4  Orientation
  1.3.5  Identify Input Purpose
  1.4.3  Contrast (Minimum)
  1.4.4  Resize Text
  1.4.5  Images of Text
  1.4.10 Reflow
  1.4.11 Non-text Contrast
  1.4.12 Text Spacing
  1.4.13 Content on Hover or Focus
  2.4.5  Multiple Ways
  2.4.6  Headings and Labels
  2.4.7  Focus Visible
  2.4.11 Focus Not Obscured (Minimum)
  2.5.7  Dragging Movements
  2.5.8  Target Size (Minimum)
  3.1.2  Language of Parts
  3.2.3  Consistent Navigation
  3.2.4  Consistent Identification
  3.3.3  Error Suggestion
  3.3.4  Error Prevention (Legal, Financial, Data)
  3.3.8  Accessible Authentication (Minimum)
  4.1.3  Status Messages

The totals are the numbers people quote: 31 criteria at A, 24 at AA and 31 at AAA, 86 in all. 4.1.1 Parsing keeps its number in the document, marked obsolete and removed, so the numbering has a gap instead of being renumbered. Two guidelines, 1.4 Distinguishable and 2.4 Navigable, hold 13 criteria each, nearly a third of the standard between them.

WCAG 2.2 became a W3C Recommendation in 2023, and the current edition is a corrected one from 2024. The 2023 text is also an international standard, ISO/IEC 40500:2025 (WCAG 2 Overview), and W3C keeps an errata page that marks each correction as substantive or editorial (WCAG 2.2 errata). To look a criterion up quickly, W3C’s quick reference, How to Meet WCAG, filters every criterion by level and topic.

Only the success criteria are required; the rest explains them

WCAG states which of its words bind. “The main content of WCAG 2.2 is normative”, while its introductory material, appendices, sections marked non-normative, diagrams, examples and notes are informative (WCAG 2.2, section 5.1). Around the standard, W3C publishes documents that are informative from end to end: Understanding WCAG 2.2, one page for each criterion with its intent and examples, and the Techniques for WCAG 2.2. Step through one criterion’s family to see which parts are normativenormative: Required for conformance. In WCAG 2.2 the success criteria, the conformance requirements and the glossary definitions are normative; notes, examples and companion documents are not. and which are informativeinformative: Explaining or advising, and never required for conformance. In WCAG the introduction, notes, examples and diagrams are informative, and so are all of Understanding WCAG and the Techniques.:

The pattern holds for every criterion. What a page must meet is the criterion’s text, read with WCAG’s own definitions; everything W3C writes about it helps you read it, and none of it adds a requirement:

Techniques are where teams most often misread the status. W3C’s own wording is that “Techniques are informative — that means they are not required” (Understanding Techniques). A sufficient techniquesufficient technique: A way of meeting a success criterion that W3C documents as reliable, such as H37, an alt attribute on an img element. It is informative: content may pass another way, and a technique used badly still fails. is a reliable way to meet a criterion, so content may pass with another approach, and a sufficient technique used badly still fails. A documented failuredocumented failure: A W3C technique numbered with an F, such as F30, that describes a common way content fails a success criterion. Content that matches one does not meet the criterion, unless a conforming alternate version exists. works the other way: “Content that has a failure does not meet WCAG 2.2 success criteria”, unless a conforming alternate version is provided.

Level AA means every A and AA criterion, on full pages and complete processes

A page conforms at Level AA when it satisfies every Level A and every Level AA success criterion, or when a conforming alternate version of it does (WCAG 2.2, section 5.2.1). Four more requirements say what is judged and how:

• Full pages. Conformance is judged on whole pages, and a claim may not leave any part of a page out. A chat window, an advert or a cookie banner on the page is part of the page.
• Complete processes. When a page is one step of a process, such as a checkout, every page in that process must conform at the level claimed.
• Only accessibility-supported ways of using technologies. A criterion may be met only in ways that work with users’ assistive technology and browsers.
• Non-interference. Content that the claim does not rely on must still not block the rest of the page, and four criteria apply to everything on it: 1.4.2 Audio Control, 2.1.2 No Keyboard Trap, 2.3.1 Three Flashes or Below Threshold, and 2.2.2 Pause, Stop, Hide.

The complete-processes rule decides more claims than any other, because modern sites hand steps to other providers. Follow a four-step checkout whose card page comes from a payment provider:

One failing step on a page the shop does not even host denied Level AA to all four pages, and leaving that page out of the claim did not help. The fix had to happen at the provider. That is why teams choose payment, chat and sign-in providers by their accessibility as well as their price.

Level AAA is the ceiling, and WCAG’s own note advises against making it a rule for a whole site, since some kinds of content cannot meet all of its criteria (WCAG 2.2, section 5.2.1). A team can still adopt single AAA criteria where they help its users.

A conformance claim names its date, version, level, pages and technologies

WCAG does not oblige anyone to make a claim, but a claim that is made must contain five required components (WCAG 2.2, section 5.3.1):

1. The date of the claim.
2. The guidelines’ title, version and address: Web Content Accessibility Guidelines 2.2 at https://www.w3.org/TR/WCAG22/.
3. The conformance level satisfied: A, AA or AAA.
4. A concise description of the pages the claim covers, such as a list of their addresses, including whether subdomains are included.
5. A list of the web content technologies relied upon, such as HTML, CSS, JavaScript and WAI-ARIA.

Optional components include the criteria met beyond the claimed level, the technologies used but not relied upon, and the browsers and assistive technology used for testing. The program checks three claims about the same fictional shop against the five components, and against the two requirements that a claim’s scope most often breaks:

// Checks a conformance claim against WCAG 2.2: the five required components of section 5.3.1,
// and two conformance requirements a claim's scope can break, full pages (5.2.2) and complete
// processes (5.2.3). The claims are about a fictional shop at shop.example.
const WCAG22 = 'https://www.w3.org/TR/WCAG22/';

function problems(claim) {
  const found = [];
  if (!/^\d{4}-\d{2}-\d{2}$/.test(claim.date ?? '')) found.push('no date of the claim');
  const g = claim.guidelines ?? '';
  if (!g.includes('2.2') || !g.includes(WCAG22)) found.push(`no title, version and address of the guidelines (${WCAG22})`);
  if (!['A', 'AA', 'AAA'].includes(claim.level)) found.push('no conformance level: A, AA or AAA');
  const pages = claim.scope?.pages ?? [];
  if (pages.length === 0) found.push('no list of the pages it covers');
  if (typeof claim.scope?.subdomains !== 'boolean') found.push('no word on whether subdomains are included');
  if (!(claim.technologies?.length > 0)) found.push('no list of the technologies relied upon');
  // Conformance is for full pages: no part of a page can be left out of a claim.
  for (const part of claim.scope?.excluded ?? []) found.push(`full pages: it leaves out part of a page (${part})`);
  // Every page of a process it covers must conform too.
  for (const step of claim.scope?.processes?.flatMap((p) => p.steps) ?? []) {
    if (!pages.includes(step)) found.push(`complete processes: a step it covers is missing (${step})`);
  }
  return found;
}

const claims = {
  'The footer line': { text: 'Our website is WCAG compliant.' },
  "The vendor's claim": {
    date: '2026-09-30',
    guidelines: `Web Content Accessibility Guidelines 2.2 at ${WCAG22}`,
    level: 'AA',
    scope: {
      pages: ['https://shop.example/', 'https://shop.example/cart', 'https://shop.example/address'],
      subdomains: false,
      excluded: ['the live chat window on every page'],
      processes: [{ name: 'checkout', steps: ['https://shop.example/cart', 'https://shop.example/address', 'https://pay.shop.example/card'] }],
    },
    technologies: ['HTML', 'CSS', 'JavaScript'],
  },
  'The repaired claim': {
    date: '2026-09-30',
    guidelines: `Web Content Accessibility Guidelines 2.2 at ${WCAG22}`,
    level: 'AA',
    scope: {
      pages: ['https://shop.example/', 'https://shop.example/cart', 'https://shop.example/address', 'https://pay.shop.example/card'],
      subdomains: true,
      processes: [{ name: 'checkout', steps: ['https://shop.example/cart', 'https://shop.example/address', 'https://pay.shop.example/card'] }],
    },
    technologies: ['HTML', 'CSS', 'JavaScript', 'WAI-ARIA'],
  },
};

for (const [name, claim] of Object.entries(claims)) {
  const found = problems(claim);
  console.log(`${name}: ${found.length === 0 ? 'a complete claim' : `${found.length} problems`}`);
  for (const p of found) console.log(`  - ${p}`);
}

The footer line: 6 problems
  - no date of the claim
  - no title, version and address of the guidelines (https://www.w3.org/TR/WCAG22/)
  - no conformance level: A, AA or AAA
  - no list of the pages it covers
  - no word on whether subdomains are included
  - no list of the technologies relied upon
The vendor's claim: 2 problems
  - full pages: it leaves out part of a page (the live chat window on every page)
  - complete processes: a step it covers is missing (https://pay.shop.example/card)
The repaired claim: a complete claim

The footer line fails all six checks: it has no date, no version or address, no level, no pages, nothing about subdomains and no technologies. The vendor’s claim has every component but leaves out the chat window that sits on every page, and the provider’s card page that the checkout depends on. The repaired claim lists the card page, says that subdomains are included, and names WAI-ARIA among the technologies relied upon, because its widgets depend on it.

Two more rules complete the picture. When a page holds content its author cannot control, such as user comments, WCAG allows a statement of partial conformance: the page does not conform, but it would at a named level if the listed parts from uncontrolled sources were taken away. It is a statement of non-conformance, not a conformance claim (Understanding Conformance). And because content that conforms to WCAG 2.2 also conforms to 2.1 and 2.0, as WCAG 2.2 itself states, a 2.2 claim satisfies a policy that names one of the older versions, except that such a policy may still expect 4.1.1 Parsing to be tested and reported (WCAG 2.2).

Practise: work out the level a page reaches

The exercise turns the conformance rules into code: from a page’s results, the highest level it reaches, and from a process’s pages, the level the whole process can claim. Its sample tests use the checkout of this lesson:

const LEVELS = ['A', 'AA', 'AAA'];

/** The highest level one page reaches: 'AAA', 'AA', 'A' or 'none'. */
export function pageLevel(results) {
  const failures = results.filter((r) => r.outcome === 'fail');
  if (failures.length === 0) return 'AAA';
  // Work out the highest level that no failure blocks.
  return 'none';
}

/** The level a whole process can claim: the lowest level among its pages. */
export function processLevel(pages) {
  return 'none';
}

import { test, assert } from 'mysmartcopilot:test';
import { pageLevel, processLevel } from './level.mjs';

const pass = (sc, level) => ({ sc, level, outcome: 'pass' });
const fail = (sc, level) => ({ sc, level, outcome: 'fail' });
const absent = (sc, level) => ({ sc, level, outcome: 'not-present' });

// The lesson's checkout: three pages pass, the provider's card page fails 3.3.8 at Level AA.
const basket = [pass('1.1.1', 'A'), pass('2.4.11', 'AA'), absent('1.2.2', 'A'), fail('2.4.12', 'AAA')];
const address = [pass('1.3.1', 'A'), pass('3.3.8', 'AA'), pass('3.3.7', 'A')];
const card = [pass('1.1.1', 'A'), fail('3.3.8', 'AA'), pass('4.1.2', 'A')];
const thanks = [pass('1.3.1', 'A'), pass('4.1.3', 'AA'), absent('2.2.1', 'A')];

test('a page with no failure reaches AAA, and content that is not present counts as satisfied', () => {
  assert.equal(pageLevel(address), 'AAA');
  assert.equal(pageLevel(thanks), 'AAA');
});

test('a Level AAA failure leaves the page at AA', () => {
  assert.equal(pageLevel(basket), 'AA');
});

test('a Level AA failure leaves the page at A', () => {
  assert.equal(pageLevel(card), 'A');
});

test('a Level A failure leaves the page at none, whatever else passes', () => {
  assert.equal(pageLevel([pass('1.4.3', 'AA'), fail('1.1.1', 'A'), fail('1.4.3', 'AA')]), 'none');
});

test('one failing step sets the level of the whole process', () => {
  assert.equal(processLevel([basket, address, card, thanks]), 'A');
  assert.equal(processLevel([basket, address, thanks]), 'AA');
  assert.equal(processLevel([address, thanks]), 'AAA');
});

test('a process with a page at none claims none, and an empty process claims none', () => {
  assert.equal(processLevel([address, [fail('2.1.1', 'A')]]), 'none');
  assert.equal(processLevel([]), 'none');
});

Then check the four ideas of this lesson, from the layers of the standard to the claim:

Interview questions

Fresher · What do the levels A, AA and AAA mean in WCAG, and which one do laws usually ask for?

They are WCAG’s three conformance levels. Level A holds the 31 most basic criteria, Level AA adds 24 more, and Level AAA adds the last 31. Conforming at a level means meeting every criterion at that level and at every level below it, so a Level AA page meets all 55 criteria at A and AA. Laws and procurement standards usually ask for Level AA, of WCAG 2.0, 2.1 or 2.2 depending on the rule. W3C advises against demanding Level AAA across a whole site, as some kinds of content cannot meet all of its criteria, though a team may adopt single AAA criteria where they help its users.

Two harder questions of this module start from this lesson:

Key takeaways

• WCAG 2.2 has four principles, 13 guidelines and 86 testable success criteria: 31 at Level A, 24 at AA and 31 at AAA; 4.1.1 Parsing is obsolete and removed.
• Only the success criteria, the conformance requirements and the glossary definitions are normative; notes, Understanding pages and techniques explain them and require nothing.
• Level AA means every Level A and AA criterion is met, on full pages and on every page of a process; one failing step denies the level to the whole process.
• A conformance claim is optional, but one that is made gives its date, the guidelines’ version and address, the level, the pages it covers and the technologies relied upon.