Free · Fast · Privacy-first

Validate HTML Table Code

HTML tables have one of the strictest content models in the spec because every cell needs to fit into a precise grid of rows and columns, with optional thead, tbody, tfoot, and caption sections in a defined order.

⚡

Validates table element hierarchy

🔒

Checks thead, tbody, th, td structure

✨

Identifies missing scope attributes

⚡

Free and instant

Cost: Free forever
Sign-up: Not required
Processing: In your browser
Privacy: Files stay local

FreeNo signupWhite-label

Add this HTML Validator to your website

Drop the HTML Validator into any page — blog post, product docs, intranet, school portal — with a single line of HTML. Your visitors get the full tool, processed entirely in their browser. No backend, no uploads, no signup.

Files stay 100% in the visitor's browser
Responsive — adapts to any container width
Free forever, no API key needed

Embed code

<iframe
  src="https://www.fixtools.io/html/html-validator?embed=1"
  width="100%"
  height="780"
  frameborder="0"
  style="border:0;border-radius:16px;max-width:900px;"
  title="HTML Validator by FixTools"
  loading="lazy"
  allow="clipboard-write"
></iframe>

<iframe
  src="https://www.fixtools.io/html/html-validator?embed=1"
  width="100%"
  height="780"
  frameborder="0"
  style="border:0;border-radius:16px;max-width:900px;"
  title="HTML Validator by FixTools"
  loading="lazy"
  allow="clipboard-write"
></iframe>

Attribution-friendly: a small "Powered by FixTools" link appears in the embed footer.

Valid Table Child Elements: What thead, tbody, tfoot, and scope Actually Require

The HTML spec defines a strict content model for table elements. A table element permitted content is: optionally a caption element (must be first), zero or more colgroup elements, optionally a thead element, optionally a tfoot element, either one or more tbody elements or one or more tr elements (but not both), and optionally script and template elements. The order matters: caption must precede colgroup, which must precede thead. Placing a caption after the first row, or nesting tbody inside thead, are spec violations that validators catch and that distort the structural relationships screen readers rely on.

The scope attribute on th elements tells assistive technologies which cells the header applies to. Permitted values are col (the header applies to cells below it in the same column), row (the header applies to cells to the right in the same row), colgroup (the header applies to all cells in its column group), and rowgroup (the header applies to all cells in its row group). For simple tables with a single header row, scope="col" on each th is sufficient. For complex tables with headers on both rows and columns, incorrect or missing scope values cause screen readers to announce cell data without the correct header context, which makes the table effectively unusable for assistive-technology users.

The colspan and rowspan attributes on td and th elements are integer attributes whose values must be 1 or greater and must not exceed the table boundaries. The spec also prohibits overlapping cells created by colspan/rowspan combinations. Validators check that these values are valid integers and flag non-integer values, values of zero, and in some implementations values that would create structural overlaps. colspan="0" was valid in HTML4 (meaning span all remaining columns) but is not valid in HTML5: this is a common migration error in tables converted from older markup, and the validator catches every instance of it the first time the table is checked.

A fourth rule worth highlighting is the headers attribute on cells, which provides explicit associations between data cells and their header cells in complex tables. The attribute value is a space-separated list of id attribute values of the corresponding th elements. The headers attribute is required by accessibility guidelines for tables with multi-level headers, and it is the only way to disambiguate which header applies to which cell when scope alone cannot express the relationship. The validator flags incorrect id references and unrecognised ids in the headers list.

WHATWG HTML, table element MDN, HTML table element W3C, Tables for data, WAI tutorial

How to use this tool

💡

Paste your HTML table code and validate. Table-specific structural errors and accessibility requirements are clearly reported.

How It Works

Step-by-step guide to validate html table code:

1
Paste table HTML
Paste the complete table HTML including the table element, any caption, the optional thead, tbody, and tfoot sections, and every row and cell element. Validating the entire table together is important because the content model rules concern relationships between elements (cells inside rows, rows inside row groups, row groups inside the table) that fragment-level validation cannot fully verify.
2
Validate
Click Validate to run the spec check against the current HTML Living Standard. The validator walks the table the way a conforming parser would, recording each structural mistake, each invalid colspan or rowspan value, each missing scope attribute on header cells, and any other deviation from the spec within seconds of the initial click.
3
Fix table errors
Address structural and accessibility-related errors in priority order: structural problems first (missing tbody, rows outside row groups, cells outside rows), then attribute issues (scope, headers, colspan, rowspan), and finally accessibility enhancements such as adding a caption or aria-describedby. Each category builds on the previous one, so resolving the structural mistakes first makes the attribute work cleaner.
4
Re-validate
Paste the corrected table HTML back into the panel and run the check again to confirm every fix had the intended effect. The error count typically drops to zero within two or three cycles for a typical data table. Once the validator panel is clean, the table is ready for accessibility audit, integration testing, and user-facing rollout with confidence that the structure is correct.

Real-world examples

Common situations where this approach makes a real difference:

Validating a data table before accessibility review

Before submitting HTML tables to an accessibility audit, validate them to catch missing scope attributes, absent thead elements, incorrect use of td vs th for header cells, and structural mistakes such as table rows placed outside any tbody. Resolving these issues before the audit turns a long list of findings into a short list focused on the genuinely subjective accessibility decisions, which is a far better use of audit time than walking through structural errors a validator could have surfaced for free.

When to use this guide

Use this when building data tables to ensure their structure is correct for both rendering and accessibility before adding them to a page.

Pro tips

Get better results with these expert suggestions:

Table structure errors cause major accessibility failures

Incorrect table structure (missing <thead>, <tbody>, and <tfoot> elements, <th> elements without scope attributes, missing headers attribute on data cells in complex tables) is both a validation error and a serious accessibility failure. Screen readers use table structure to navigate and announce data relationships. Validate and fix table structure before launch.

Use <th scope='col'> and <th scope='row'> consistently

Every <th> element should have a scope attribute indicating whether it is a column header (scope='col') or a row header (scope='row'). The HTML validator flags missing scope attributes as warnings. Adding scope attributes takes seconds and dramatically improves how assistive technologies read and navigate your table data.

Never use tables for page layout

Using HTML tables for visual layout is not technically a validation error in HTML5, but it is a best-practices error and an accessibility failure. The HTML validator may not flag layout tables directly, but an accessibility checker will. Reserve <table> for actual tabular data that has rows and columns with meaningful relationships.

Validate table caption and summary elements

The <caption> element inside a <table> provides an accessible title for the table. Screen readers announce the caption before reading table data. An HTML table without a <caption> is not a validation error but is an accessibility gap. The aria-describedby attribute can also associate a longer description with a table for complex data sets.

Use th elements for header cells

Table header cells must use <th> not <td>. Screen readers use th elements to announce column and row headers to users.

Add scope to table headers

Complex tables should use scope="col" or scope="row" on all <th> elements. This is required for accessibility with multi-level headers.

Use caption for table descriptions

Add a <caption> element inside <table> to describe the table content. This is an accessibility requirement for data tables. HTML tables are often invalidated by issues that look minor but matter for accessibility and rendering. Missing thead, tbody, or tfoot wrappers cause screen readers to misinterpret column versus row headers. Missing scope attributes on th elements prevent assistive technology from announcing which header belongs to which cell. Missing caption elements skip a key context cue for visually impaired users browsing data-heavy pages. Our validator catches all these issues specifically for tables, flagging them by element rather than by line. This makes fixing complex multi-row tables far easier than scanning a generic error list. Beyond accessibility, valid table markup matters for screen readers, data export tools, and assistive technologies of all kinds. A spreadsheet-export script that scrapes table data from your page needs the row and column structure to be unambiguous, which only happens with valid markup. A screen reader announcing table contents to a visually impaired user relies on scope, headers, and caption attributes to navigate the data efficiently. Skipping these elements may look fine in a sighted browser but breaks the experience for anyone using assistive technology. The validator surfaces these gaps so you can fix them before launch rather than after a complaint.

FAQ

Frequently asked questions

Yes. Using thead and tbody is required for semantic HTML tables and is an accessibility expectation. It also gives browsers and screen readers the context they need to handle large tables correctly, particularly when only the body is scrollable while the header stays fixed. Even though the spec permits omitting these elements in some cases, doing so removes structural information that assistive technologies rely on, which is why the explicit form is treated as the conformance norm for data tables.

Use <th> with a scope attribute for headers, add a <caption> element to describe the table, group rows with thead and tbody (and tfoot when applicable), and ensure the reading order of cells makes sense when linearised. Screen readers navigate tables cell by cell using these attributes, and a missing scope or absent thead can make a numerically simple table almost unusable for assistive-technology users. For complex tables add headers attributes on cells and consider an aria-describedby description.

The spec requires: caption (optional, first), colgroup (optional), thead (optional), tfoot (optional), tbody or tr elements. Note that tfoot can appear before or after tbody in the source and browsers will still render it at the bottom of the table. The strict ordering before tbody existed historically to let browsers render the footer before downloading the entire body for slow connections, and the rule has been preserved for backwards compatibility with that early use case.

No. colspan="0" was valid in HTML4 as a way to span all remaining columns, but it is not permitted in HTML5 (the Living Standard). Use the exact number of columns to span instead. This is a common migration error in tables converted from older markup because the colspan="0" pattern was popular in early websites and tends to survive several rounds of edits before anyone notices it has stopped being valid. The validator catches every instance the first time the table is checked.

Use th for header cells: cells that label a column or row. Use td for data cells: cells that contain data values. The distinction is semantic, not visual: both can be styled to look identical, but screen readers announce th elements differently and rely on them to provide header context for the data cells beneath. Treating th as a styling choice rather than a semantic one breaks the assistive-technology experience even when the visual output is unchanged.

A caption provides a text description of the table that search engines can read and associate with the data inside. For data tables containing structured information, a clear caption helps search engines understand the table purpose and index its content correctly, which improves the chances of the table appearing in rich result formats. The caption is also helpful for users who skim a long page because it gives the table a recognisable title independent of any surrounding heading structure.

The spec permits table elements inside td and th cells. However, nested tables are discouraged for data tables because they break the linear reading order for screen readers and produce a confusing announcement experience for assistive-technology users. Nested tables were a common HTML4 layout technique that survived into modern code because they happened to work visually, but they should not be used in new HTML and existing instances are good candidates for refactoring to CSS layout.

The scope attribute on th elements identifies which cells the header applies to. Valid values are: col (same column), row (same row), colgroup (the column group), and rowgroup (the row group). Using any other value is a validation error. Picking the right scope for each header cell is essentially a one-time effort because the structure of a table rarely changes after it is built, and the resulting accessibility improvement for screen reader users is substantial relative to the effort. Table validation focuses on accessibility-critical attributes like scope, headers, and caption that screen readers depend on to convey relationships between cells. Complex tables with merged cells need explicit headers attributes to remain accessible. Many WCAG audit findings trace back to table accessibility issues that a generic HTML check ignores. Beyond accessibility, table validation also catches structural errors that affect rendering. For data-heavy applications, table validation also catches accessibility issues with sortable headers, sticky headers, and virtualized scrolling. Modern table validators also check for responsive table patterns. Tables that work well at desktop widths often fail on mobile, requiring techniques like horizontal scrolling, stacked layouts, or card-based alternatives. For internationalized content, table validation also checks for proper bidirectional text handling. Tables containing mixed left-to-right and right-to-left content need specific dir attribute placement to render correctly. A validator that flags these issues prevents subtle layout bugs in localized versions of your site that might otherwise be missed during English-only testing cycles.

Three patterns cause most accessibility regressions in tables. First, using td elements when th elements are required for column or row headers, which strips semantic meaning that screen readers depend on. Second, omitting the scope attribute on th elements, leaving screen readers to guess whether each header applies to its column or row. Third, using empty cells or merged cells without explicit headers attributes, breaking the association between data cells and their describing headers.

Validate the initial HTML structure separately from the dynamic data injection. The initial markup should pass validation with empty or placeholder rows. After data loads, use JavaScript to validate the populated table state using your test framework. For data analytics dashboards, table validators also flag pagination accessibility issues commonly seen in admin interfaces.