Microformats and Microdata: What They Are, Where They Still Fit, and Where They Don't

note

2026 Update: Wondering which structured data format to choose? See Microdata vs JSON-LD vs RDFa: Which Format to Use in 2026 for a side-by-side comparison.

This older guide is best read as background on two inline markup approaches you still run into in legacy sites and CMS templates. If you’re deciding what to implement on a new project, jump to the format comparison, the dedicated HTML Microdata Tutorial, or the JSON-LD beginner guide first.

Microdata and Microformats are not interchangeable, and they also do not play the same role in search.

Microdata is one structured-data format that can be used with Schema.org. Microformats are a separate class-based convention with their own ecosystem.

tip

You do not need to add both. In most cases, you should not. Pick the one that actually matches your stack and your goal.

What is Microdata?

Simply put, Microdata is the information we add to our website’s HTML that provides search engines with a description of what type of content to expect in the DOM element. Including this information in the structure of our website helps search engines understand the content of our webpage and process it in a useful way.

For example, let’s say we have a personal blog (just like this one). When it comes to the list of articles we have written, it can quickly locate this metadata about what kind of content it is, which element contains the title, which one is the relevant image, who the author is, and any other associated information that we provide using these attributes.

Okay, so what are these tags/attributes?

We can find all the available schemas (there are tons of them) at https://schema.org/docs/schemas.html(opens in new tab). It has schemas for objects and data types that can provide the information we want the search engine to know about our content.

As a starter, let’s check out https://schema.org/CreativeWork(opens in new tab). If we scroll down the long property list, we’ll find more specific Schemas for creative works—articles, Blog Posts, Comments and Discussions, Photography, and so much more!

Let’s say we added information about the author in a blog post. We can use the Person schema, which has a list of properties defined at https://schema.org/Person(opens in new tab), which can be used to add information about the Person.

Pretty simple.

How do we use these tags?

Let’s use the Person schema we saw in the previous section as an example.

<div itemscope itemtype="https://schema.org/Person">
	<p itemprop="name">John Doe</p>
        <a itemprop="url" href="https://johndoe.com">Portfolio</a>
</div>

We can add more properties with itemprop by referring to the Person schema, and it will become part of our website’s data.

What are Microformats?

It is another way of providing semantic information about our website, but it is slightly different. While Microdata uses specialized tags/attributes in the HTML to add context to our content, Microformats uses specialized classes to tell the parser what content it looks at.

Is it a card, or is it a list, or is it an entry in a list? That kind of information. So, for a text that contains the author’s name, we could add a p-name class, and the parser would interpret it correctly as a name that belongs to a person.

What are these classes, and how do we use them?

We can find the Microformats wiki at https://microformats.org/wiki/Main_Page(opens in new tab). We take the classes that match the type of content our HTML presents, and that’s it. For example, the equivalent of the Microdata from our previous section would be:

<div class="h-card">
	<p class="p-name">John Doe</p>
        <a class="u-url" href="https://johndoe.com">Portfolio</a>
</div>

That’s it! Because they are classes, we can also use them to apply base styles for our elements if we want to. h-card can have base styles that apply to any card, and u-url can have URL styles!

important

Avoid using a processor that anonymizes the classes in the final build so that all the hard work is utilized.

Why would we want to do this?

The payoff is different for the two formats, and that difference matters.

Microdata can help parsers understand visible content more explicitly, and on the right page types it can contribute to supported Google search features when the markup matches current documentation.

Microformats are more about portable semantic conventions on the broader web. They are not a substitute for Schema.org structured data and they are not a special Google rich-results trick.

So the practical takeaway is:

• use Microdata when inline Schema.org markup is the right fit
• use Microformats when you specifically need Microformat consumers or conventions
• use JSON-LD for most new Google-focused structured-data work

We added the attributes and the classes - now what?

For Microdata, we could first validate (and view) what data is parsed by running a scan on https://validator.schema.org(opens in new tab). This will also help us catch any errors if they are present.

For Microformats, there is a list of validators/parsers in the Microformats wiki: https://microformats.org/wiki/validators(opens in new tab)

If everything is good and we’re satisfied with the information the parser reads - Congratulations! Your website renders more quality data than before.

If you’re working on structured data in 2026, I would usually go in this order:

1. What is JSON-LD?
2. Microdata vs JSON-LD vs RDFa
3. HTML Microdata Tutorial
4. JSON-LD Implementation Guide