Heading Structure Checker

Analyze heading hierarchy (H1-H6) on web pages. Check for missing H1, skipped levels, and heading order issues.

What does Heading Structure Checker do?

This actor analyzes the heading structure (H1-H6) of web pages. It extracts all headings in document order, checks for missing H1, multiple H1s, skipped heading levels, heading order jumps, empty headings, and overly long headings. Essential for SEO and accessibility.

Search engines use heading tags to understand the topical structure of a page, and screen readers depend on them for navigation. A broken heading hierarchy -- such as jumping from H1 to H4 or having multiple H1 tags -- hurts both SEO performance and accessibility compliance. This actor gives you a complete heading audit for any number of pages.

The output includes full heading counts by level (H1-H6), the maximum depth used, and a complete list of all headings in document order with their text and character length. This makes it easy to reconstruct the page outline and spot structural problems at a glance.

Use cases

• SEO specialist -- audit heading structure across an entire site to ensure search engines can parse content hierarchy correctly
• Accessibility tester -- verify that heading levels follow WCAG 2.1 guidelines so screen reader users can navigate the page
• Content editor -- review heading usage in blog posts and articles to ensure logical document outlines before publishing
• Web developer -- validate heading structure after template changes or CMS updates that may break heading order
• QA engineer -- add heading structure checks to automated testing pipelines for regression detection
• Agency team lead -- include heading validation in client-facing technical SEO audits and reports

Why use Heading Structure Checker?

• Complete heading extraction -- returns every heading (H1-H6) with its level, tag, text, and character length
• Six issue types detected -- missing H1, multiple H1s, skipped levels, empty headings, overly long headings, and heading order jumps
• Batch processing -- analyze hundreds of pages in a single run
• Structured JSON output -- heading counts, max depth, full heading list, and issues array ready for processing
• Fast and lightweight -- uses direct HTTP requests without a browser for quick results
• Pay-per-event pricing -- costs just $0.001 per page checked

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	List of web page URLs to analyze heading structure. Each page is checked independently.

Input example

{
    "urls": [
        "https://www.google.com",
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://example.com"
    ]
}

Output example

{
    "url": "https://en.wikipedia.org/wiki/Web_scraping",
    "title": "Web scraping - Wikipedia",
    "headingCounts": { "h1": 1, "h2": 12, "h3": 5, "h4": 0, "h5": 0, "h6": 0, "total": 18 },
    "hasH1": true,
    "multipleH1": false,
    "skippedLevels": [],
    "maxDepth": 3,
    "headings": [
        { "level": 1, "tag": "h1", "text": "Web scraping", "length": 12 },
        { "level": 2, "tag": "h2", "text": "Contents", "length": 8 }
    ],
    "issues": [],
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Event	Price	Description
Start	$0.035	One-time per run
URL checked	$0.001	Per page checked

Example costs:

• 10 URLs: $0.035 + (10 x $0.001) = $0.045
• 100 URLs: $0.035 + (100 x $0.001) = $0.135
• 1,000 URLs: $0.035 + (1,000 x $0.001) = $1.035

Using the Apify API

You can call Heading Structure Checker programmatically from your own applications using the Apify API. The following examples show how to start a run, wait for it to finish, and retrieve the results.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/heading-structure-checker').call({
    urls: ['https://en.wikipedia.org/wiki/Web_scraping'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('automation-lab/heading-structure-checker').call(run_input={
    'urls': ['https://en.wikipedia.org/wiki/Web_scraping'],
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Heading Structure Checker works with all major automation and integration platforms available on Apify. Connect it to Make (formerly Integromat) or Zapier to create workflows that flag pages with heading issues. Export results to Google Sheets for easy review and prioritization by your content or development team. Send Slack notifications when pages fail heading validation. Use webhooks to receive instant callbacks when a run completes, or build advanced automation pipelines with n8n. Schedule recurring runs on Apify to catch heading issues introduced by new content or template changes. All results are stored in Apify datasets and can be downloaded in JSON, CSV, or Excel format.

Tips and best practices

• Every page should have exactly one H1 -- multiple H1 tags confuse search engines about the primary topic of the page
• Never skip heading levels -- going from H2 to H4 breaks the document outline for both SEO and screen readers
• Keep headings under 70 characters -- overly long headings dilute their SEO value and are harder for users to scan
• Check after CMS or template changes -- theme updates and CMS migrations are the most common cause of broken heading structures
• Use the headings array for content audits -- the full list of headings gives you a quick outline of any page's content structure
• Pay attention to empty headings -- headings with no text content are invisible to users but confuse screen readers and waste heading hierarchy

FAQ

Why does heading structure matter for SEO? Search engines use headings to understand the topical hierarchy of a page. A clear H1 followed by logically nested H2s and H3s helps Google determine what the page is about and which sections are most important.

What is a skipped heading level? A skipped level occurs when a heading jumps more than one level, such as an H2 followed directly by an H4 with no H3 in between. This breaks the logical document outline and can confuse both search engines and assistive technologies.

Does this actor check heading content quality? The actor checks structural issues (missing, multiple, skipped, empty, too long) but does not evaluate whether heading text is well-written or includes target keywords. For keyword analysis, use the Keyword Density Analyzer actor.

Is it okay to have multiple H2 or H3 tags? Yes. Having multiple H2 and H3 tags is perfectly normal and expected. The only heading level that should appear exactly once is H1. Lower-level headings should be used as many times as needed to structure the content logically.

What is considered an overly long heading? Headings longer than 70 characters are flagged as overly long. While there is no strict SEO rule, shorter headings are easier for users to scan and more effective as search result snippets.

How many URLs can I check in one run? There is no hard limit. You can check hundreds or thousands of pages in a single run. The actor processes each URL independently and concurrently for efficient results.

Does the actor work with JavaScript-rendered pages? The actor fetches the raw HTML of each page. If headings are injected by client-side JavaScript and not present in the initial HTML response, they will not be detected. Most CMS platforms render headings in the initial HTML, so this is rarely an issue in practice.