
Heading Structure Mistakes That Hurt WCAG and AI Extraction
Skipped levels, multiple H1s and fake headings get flagged in WCAG audits and blur your page for AI answers. Learn how to find and fix each one.
A broken heading hierarchy — skipped levels, multiple <h1> tags, headings picked for font size instead of structure — gets flagged under WCAG Success Criteria 1.3.1 and 2.4.6, and it makes it harder for ChatGPT, Perplexity, and Google AI Overviews to figure out what your page is actually about. Both problems come from the same root cause: headings that describe how text looks instead of what it means.
Heading structure looks cosmetic, but it's load-bearing. A page can look fine while the structure underneath is a mess, and nobody notices until a screen reader user can't find their way around it, or until someone asks why a competitor's post keeps getting quoted in AI answers and yours never does. The good news: fixing the heading structure usually solves both problems at once.
What Is Heading Hierarchy, Exactly?
Heading hierarchy is the nested outline created by <h1> through <h6> tags, where each level represents a sub-topic of the level above it. Think of it like a table of contents: the <h1> is the book title, <h2>s are chapters, and <h3>s are sections within chapters. Skip a chapter number, and the outline stops making sense to a reader, a screen reader, or a language model trying to summarize the page.
This isn't a styling decision. It's a structural one. CSS controls what a heading looks like. The tag level controls what a heading means. Mixing those up is the heading mistake that causes the most downstream damage.
What's the Difference Between a Visual Heading and a Semantic Heading?
A visual heading is text that looks big and bold. A semantic heading is text wrapped in an actual <h1>–<h6> tag, which tells the browser's accessibility tree that a new section starts there. The two aren't the same thing, and confusing them is where heading failures start.
The usual culprit is a <div> or <span> styled with a large, bold font so it looks like a heading, with no heading tag at all. It passes a visual design review every time, because it looks right. It fails an accessibility audit, because screen readers and crawlers see plain, unstructured text: no heading announced, no entry in the outline, nothing to jump to. If something reads like a section title, mark it up as one.
Why Does Heading Structure Matter for WCAG Compliance?
WCAG has no rule literally titled "heading structure." Heading problems fall under two success criteria, 1.3.1 (Info and Relationships) and 2.4.6 (Headings and Labels), with 2.4.10 (Section Headings) as a related AAA criterion. You can read all three in the WCAG quick reference.
- 1.3.1 requires that information conveyed through presentation, like a heading's size and weight, can also be determined from the code. Text that looks like a heading but is really a bolded
<div>fails it, even if the page looks perfectly fine on screen. - 2.4.6 requires that headings describe the topic or purpose of the content that follows. A vague or empty heading doesn't.
- 2.4.10, at level AAA, asks you to use section headings to organize the content in the first place.
WCAG doesn't explicitly ban skipped levels or a second <h1> in every case. But both break the logical outline that 1.3.1 exists to protect, so audits and automated scanners flag them. In practice, auditors look for three patterns:
- Multiple
<h1>tags on a single page, with no clear single heading for the main topic. - Skipped levels, where the page jumps from
<h2>to<h4>, or from<h1>to<h3>, with nothing in between. - Headings used for styling only, like picking an
<h3>because it renders at the right size, regardless of where it sits in the outline.
How Do Screen Readers Actually Use Headings?
Screen reader users rely on headings to navigate. JAWS, NVDA, and VoiceOver all let users pull up a list of every heading on the page and jump straight to the section they need, the same way a sighted user scans a page before reading it in full. In JAWS and NVDA, a single key (usually "H") skips from one heading to the next, the audio equivalent of skimming a table of contents. WebAIM's surveys of screen reader users have repeatedly found that navigating by headings is among the most common ways they find content on a page.
Now picture that headings list reading: Heading 1, Heading 1, Heading 1, Heading 4, Heading 2. It tells the user nothing useful about how the page is organized, so they fall back on reading everything in order, which defeats the point of having headings. Missing, out-of-order, or mislabeled headings aren't a minor inconvenience. They remove a core navigation tool.
What's the Correct H1, H2, H3 Order?
The rule is simple to state and surprisingly easy to break: one <h1> per page, followed by <h2>s for main sections, followed by <h3>s for subsections within those, and so on. You never skip a level going down (no jumping from <h2> straight to <h4>), though you can skip levels going back up as you move between sections.
<h1>Page Title</h1>
<h2>Major Section</h2>
<h3>Subsection</h3>
<h3>Subsection</h3>
<h2>Next Major Section</h2>
<h3>Subsection</h3>
<h4>Detail</h4>
Think of it as a ladder. You can step down one rung at a time, and you can climb back up to a higher level at any point. What you can't do is skip a rung on the way down. Here's how a correct outline compares with a broken one:
| Correct structure | Broken structure |
|---|---|
<h1> Page title | <h1> Page title |
<h2> Section one | <h3> Section one (skipped h2) |
<h3> Subsection | <h1> Section two (second h1) |
<h2> Section two | <div class="bold-text"> Subsection (not a heading at all) |
The right-hand column shows a pattern worth hunting for: a bolded <div> standing in for a real subheading. It looks identical to a real heading. Structurally, it's invisible to every tool that matters.
Why Do Multiple H1 Tags Get Flagged?
An <h1> is supposed to answer one question: what is this page about? When a page has three or four of them, that question no longer has one answer. A screen reader user who lands on the second or third <h1> partway down the page loses the sense of hierarchy. Was that a new page? A new section? A mistake? There's no way to tell from the markup alone.
Drag-and-drop builders and themes cause this when every hero section, logo, or page title defaults to an <h1>, wherever it sits on the page. HTML5 technically allows several <h1> tags inside separate <section> or <article> elements, but the fix is almost always the same: one <h1> per page, describing that page's primary content. Everything else gets demoted to <h2> or lower, based on its actual role in the outline, not its font size.
What Happens When You Skip a Heading Level?
Skipping from <h2> to <h4> feels harmless. The text still renders, and the page still looks right. But assistive technology builds its navigation model from heading level numbers, not visual appearance. When a screen reader announces "heading level 4," the user assumes there's a level 3 somewhere above it they can jump back to for context. If there isn't, the level 4 content seems to belong to nothing. Did they miss content? Is the page broken? On a long page, that friction repeats every time it happens.
Skipped levels usually come from one of two places. Either a developer picked a tag for how it looks in the default stylesheet (an <h4> happened to be the right size for a sidebar widget title), or a CMS template was built once and reused across pages with different content depths, so the levels drifted out of sync. A blog post with a deeply nested FAQ section is a classic case: someone jumps to <h5> for a sub-question without ever using an <h3> or <h4> above it.
For AI answer engines, the effect is different but just as real. Retrieval systems use heading structure to split a page into sections before deciding what to extract and cite. When the levels jump around, it's harder for the model to tell which content is a main point and which is a supporting detail.
What's the Impact of Heading Structure on AI Extractability?
AI answer engines extract content in chunks, and headings are a key signal they use to mark where one chunk ends and the next begins. When ChatGPT Search, Perplexity, or Google's AI Overviews process a page, they aren't reading it top to bottom in one pass like a person would. They segment it by structure, then judge each segment for relevance to a query.
In effect, the system is building a summary tree: main topic, major sections, supporting details. A page with one clear <h1>, logically nested <h2>s, and descriptive subheadings hands it that tree. A page where every visual heading is a styled <span>, or where three <h1> tags compete for top billing, gives it a flat pile of text with no clear topic signal. That makes it harder to pull out a confident, citable answer, and a page with clearer structure may get quoted instead, even if its writing is thinner than yours.
Heading structure is part of what the guide to AI readability calls extractability, and we think it's usually the cheapest AI-readability problem to fix. For the AI-readability version of this check, see the heading hierarchy fix guide.
What Heading Structures Work Best for AI-Readable Content?
The structure that works for screen readers is the same one that works for AI extraction:
- One
<h1>that names the page's topic. On a blog post, that's the title. On a homepage, it's usually your core value proposition. - An
<h2>for each main section, with<h3>s nested under it for subsections and no skipped rungs on the way down. - Headings that describe the section below them. A heading like "Overview" or "More info" tells neither a screen reader user nor a model what follows. A heading that names the topic does.
- A heading on every block someone might want to jump to. FAQs, product details, and pricing tiers should each get one. Decorative dividers, single-sentence callouts, and purely visual separators don't need one.
One thing we'd push back on: don't try to "fix" heading structure by stuffing keywords into every <h2> and <h3>. A heading's first job is to describe the section below it accurately. If it also contains a keyword naturally, great. If you're forcing it, you're trading clarity for a keyword.
What Heading Structure Mistakes Should You Look For?
- Multiple H1 tags. Page builders and WordPress themes can tag the logo, hero banner, and page title as
<h1>by default. Pick one. It should describe the whole page. - Skipped levels. Jumping from
<h2>to<h4>because the<h4>"looked right" in the design system. It doesn't matter how it looks. The level has to match the content's actual depth. - Headings chosen by size, not structure. A developer picks
<h3>because it renders at the size the design calls for, without checking whether it's really a subsection of the<h2>above it. When this shows up across a whole site, it's usually a CMS or template issue rather than a one-off content error. - Empty or decorative headings. Icon-only section dividers marked up as
<h2>with no visible text, sometimes just an image or an empty span inside the tag. The fix guide for empty headings shows how to repair or remove them. - Non-heading text styled to look like a heading. Bold paragraph text or a styled
<div>that looks exactly like a subheading but carries none of the meaning. Screen readers skip right past it. So do AI crawlers. - Headings used for emphasis instead of hierarchy. Wrapping a single sentence in
<h2>tags just to make it big and bold, with no section following it.
Notice a pattern? Almost every one of these comes down to treating headings as a visual tool instead of a structural one. Fix that mindset and most of the individual mistakes disappear on their own.
How Do You Audit and Fix Your Own Heading Structure?
Start with an outline of your actual markup, not your visual layout. Your browser's dev tools can show it through the accessibility tree inspector, and free extensions like the WAVE toolbar from WebAIM or HeadingsMap (for Chrome and Firefox) list every heading on a page in document order, with its level. You're looking for exactly one <h1>, no skipped levels, and headings that read sensibly when you strip out everything else on the page and list them in order.
Then read that list out loud, top to bottom, with no body text in between. Does it read like a coherent outline of your page? If a stranger read only your headings, would they understand what the page covers and how it's organized? If not, fix the headings themselves, not the body copy.
Once the outline is in front of you, the fix is mechanical:
- Pick exactly one
<h1>per page, and demote every other piece of "hero text" to<h2>. - Walk the outline top to bottom and fix any level that jumps by more than one step on the way down. An
<h2>followed by an<h4>becomes an<h2>followed by an<h3>. The guide to fixing heading order walks through this rule in detail. - Separate visual size from semantic level in your CSS. If an
<h3>needs to look smaller than usual in one section, style it with a class. Don't drop it to<h4>just to shrink the font. - Check your CMS templates, not just individual pages. If a blog template nests comments or related-posts widgets under the wrong heading level, every post built from that template inherits the same bug.
For step three, the change looks like this. The tag stays where the outline needs it, and only the look changes:
<!-- In your HTML -->
<h3 class="heading-compact">Shipping options</h3>
/* In your stylesheet */
.heading-compact { font-size: 1rem; }
Messy headings are a sign that a page wasn't built with a screen reader in mind, so check the related rules while you're in there, like form labels, link text, and landmarks. The WCAG checklist covers those rules alongside heading structure.
This is also the kind of check that's easier to automate than to eyeball. AccessKnight's scanner flags heading-order problems like skipped levels along with its other WCAG checks, and it shows in the same report whether your structure is holding back AI extraction.
Key Takeaways
- Use exactly one
<h1>per page, describing the whole page's topic. - Never skip heading levels going deeper into a page (no
<h2>to<h4>). Jumping back up between sections is fine. - Pick heading tags based on document structure, never on font size or visual weight.
- Headings are a core navigation tool for screen reader users. Treat them as a functional tool, not decoration.
- AI answer engines use heading structure to chunk and extract content, so a clean hierarchy makes each section easier to lift out and quote.
- Fixing heading structure usually resolves accessibility and AI-readability issues at the same time, with the same code change.
Next Step
Pull up the heading outline for your homepage and your top-performing blog post today, and read each one top to bottom with the body copy stripped away. If you find a second H1, a skipped level, or a bold div posing as a heading, fix that tag first. It's usually a matter of changing which tag wraps which text, not a redesign or new content. To check more pages faster, run a free AccessKnight scan and work through the heading issues it lists, using the code-level fix it gives for each one.
Frequently Asked Questions
Can a page have more than one H1?
HTML5 technically allows several H1 tags inside separate section or article elements, and WCAG doesn't explicitly ban them. But multiple H1s break the outline screen readers rely on and blur the page's main topic for AI crawlers, so audits flag them. Stick to one H1 per page.
Does skipping a heading level fail WCAG if the page looks fine?
WCAG judges the code, not the visual rendering, and it doesn't explicitly ban skipped levels. But a jump from H1 to H3 breaks the outline screen reader users navigate by, so audits and automated scanners flag it no matter how the page looks.
Does heading order affect SEO rankings?
Google hasn't confirmed heading order as a direct ranking factor. Headings do help search engines, featured snippets, and AI tools understand how a page is organized and what each section covers, which affects how well they can parse and extract your content.
What's the difference between heading structure for accessibility and for AI readability?
There isn't one, really. Screen readers need a logical outline to navigate, and AI crawlers need the same outline to chunk content correctly, so fixing the hierarchy once serves both.
Is it okay to use CSS to change how a heading looks?
Yes. Style any heading however you like, as long as the tag matches its place in the outline. CSS can't fix a skipped level, though, because screen readers and crawlers read the HTML tag, not the styling.
How do you check if your headings are in the right order?
Use a browser extension like WAVE or HeadingsMap to list every heading in order with its level, or run an automated scan that checks heading order. Read the outline top to bottom with no body text, and if it doesn't make sense on its own, fix the hierarchy.
Do empty headings cause accessibility failures?
Yes. An empty heading, or one holding only a decorative image with no text alternative, gives people navigating by headings no label at all, which is why checkers flag it under WCAG 2.4.6 (Headings and Labels). It also leaves AI crawlers guessing what that section covers.
Fix guides for this topic
Step-by-step fixes with copy-paste code for the checks this article covers.
- Heading hierarchy skips levelsWCAG 1.3.1 · Level AW3C: Understanding 1.3.1
- Page missing or has multiple h1WCAG 1.3.1 · Level AW3C: Understanding 1.3.1
- Broken heading hierarchyAI readability
- Missing landmark regionsWCAG 1.3.1 · Level AW3C: Understanding 1.3.1
Check your website's accessibility
Scan against all 33 WCAG 2.1 rules and get code-level fix suggestions — free.
Run a free scan →