What Is Microdata?

Written byFlavio Amiel Founder, Roborank

Updated July 15, 2026

Microdata is a structured data format, defined in the WHATWG HTML standard, that adds machine-readable meaning to a page using HTML attributes — chiefly itemscope, itemprop, and itemtype. Unlike JSON-LD, it annotates the visible HTML elements themselves, tying each schema.org property to the markup that renders it on screen.

Key Takeaways

Microdata is part of the WHATWG HTML Living Standard and works through three core attributes: itemscope, itemprop, and itemtype.
itemscope creates an item, itemtype names its vocabulary (usually a schema.org URL), and itemprop labels each property — itemtype has no meaning without itemscope.
Google accepts Microdata as a valid structured data format but recommends JSON-LD instead, because Microdata is embedded in the HTML and breaks more easily.
Because Microdata attributes wrap the visible content, the markup and the rendered page can never silently disagree — but layout changes can strip properties without warning.

How Microdata Works

Microdata is defined in the WHATWG HTML Living Standard as a native HTML feature, not a separate technology bolted on. Its model is a set of items — groups of name-value pairs — expressed through global HTML attributes that you place on existing elements. Three attributes carry the load:

itemscope — a boolean attribute that, when added to an element, creates a new item: a container for a group of properties. It marks the boundary of one described entity.
itemtype — the URL of the vocabulary that defines the item’s properties, almost always a schema.org type such as https://schema.org/Product. Per the spec, itemtype has no meaning without itemscope on the same element — there is no item for it to type.
itemprop — placed on a descendant element to label it as one property of the item. The property’s value is usually the element’s text content, so <span itemprop="price">29.99</span> both displays and describes the price.

The defining trait is that Microdata annotates the visible HTML. Each property sits on the very element that renders it, so the markup and the on-screen content are, by construction, the same text. That’s Microdata’s one structural advantage over JSON-LD: the data can’t silently contradict the page, because it is the page.

Example of Microdata

The WHATWG specification’s own illustrations show the pattern search engines rely on. Take a concert listing marked up as a schema.org MusicEvent. The outer element gets itemscope and itemtype="https://schema.org/MusicEvent", establishing the item. Inside it, the element showing the event name carries itemprop="name", the start time carries itemprop="startDate", and the venue carries itemprop="location". A crawler walks the item’s descendants, collects each itemprop, and reconstructs a structured MusicEvent — event name, date, and venue — from markup that a human reader sees as an ordinary page.

This is a genuinely documented mechanism rather than folklore: the attributes, their relationships, and the parsing model are all specified in the WHATWG HTML standard, and Google’s Rich Results Test will parse valid Microdata exactly as it parses JSON-LD. The lesson it teaches is why the same coupling that guarantees markup matches the page also makes Microdata brittle. Because itemprop lives on the specific element that shows the value, moving that element, replacing it in a redesign, or letting a page builder re-render the HTML can strip the property without any error — the page still looks fine, but the structured data is now incomplete. On a hand-built static page that rarely matters; on a template-driven CMS it’s a standing liability, which is the practical reason the industry migrated to JSON-LD.

The thing people get wrong

I rarely recommend writing new Microdata, but I do run into it constantly on older sites and I’m careful not to rip it out carelessly. The trap is that Microdata is fused to the HTML: an itemprop sits on the exact <span> that shows the price, so a well-meaning template refactor or a switch to a new page builder can quietly detach half your properties and nobody sees the rich result disappear until traffic drops. If you inherit a page marked up in Microdata and it’s working, the safest move is usually to migrate it to a JSON-LD block, validate both against the Rich Results Test, and only then remove the inline attributes. Microdata isn’t wrong — it’s just fragile in a way that modern, template-driven sites punish.

Frequently Asked Questions

What is Microdata in SEO?

Microdata is a structured data format that adds schema.org meaning to a page through HTML attributes like itemscope, itemprop, and itemtype, placed on the visible elements. Search engines read these attributes to understand the page’s entities. It predates JSON-LD, which Google now recommends instead.

What are itemscope, itemprop, and itemtype?

They are the three core Microdata attributes. itemscope marks an element as a structured data item, itemtype gives the URL of the vocabulary defining its properties (usually a schema.org type), and itemprop labels a descendant element as one property of that item. itemtype requires itemscope to have meaning.

Is Microdata still valid for Google?

Yes. Google accepts Microdata as one of three valid structured data formats, alongside JSON-LD and RDFa, and treats all three as equally fine when correctly implemented. Google recommends JSON-LD, but existing valid Microdata continues to work for rich result eligibility.

Should I use Microdata or JSON-LD?

For new markup, JSON-LD in almost every case. It lives in a separate script block that is easier to maintain and doesn’t break when a page’s layout changes. Microdata’s advantage — being tied to visible HTML — is now outweighed by its fragility on template-driven sites.

The Bottom Line

Microdata is the older, inline way of adding structured data: schema.org meaning attached directly to a page’s HTML through itemscope, itemprop, and itemtype. It’s still perfectly valid to Google and you’ll find it across the web, but its tight coupling to the visible markup makes it fragile on modern sites. New work belongs in JSON-LD; inherited Microdata is worth migrating rather than trusting indefinitely.

Sources

HTML's microdata features (WHATWG HTML Living Standard) — WHATWG
Introduction to structured data markup in Google Search — Google Search Central

Rank & Cash — the weekly SEO breakdown

One practical teardown a week on ranking in search and getting cited by AI. No fluff.