Use JSON-LD for new markup, and keep any accurate Microdata or RDFa that already works. Google's structured data introduction (last updated December 10, 2025) recommends JSON-LD because it is generally easier to implement, maintain, and scale, and it lists Microdata and RDFa as supported formats too.
Bing's structured data guidance says it supports JSON-LD, Microdata, and RDFa and does not prefer one. The format alone does not decide whether a page can qualify for a Google feature. The content has to be accurate, visible on the page, and meet that feature's requirements.
Work in this order. Check what your platform already outputs, pick one format for each entity and template, migrate old markup in stages if you need to, and test the rendered page. The examples use a fictional bakery at example.com, so you can compare all three formats with identical facts.
Find the markup your page already has
Before you add anything, look at the live page. Open it in a browser, view the page source, and search for three things. A <script type="application/ld+json"> element means JSON-LD is present. The attributes itemscope, itemtype, and itemprop mean Microdata. The attributes vocab, typeof, and property mean RDFa.
Check the rendered page as well as the source file, because a theme, plugin, app, or script can add markup after the server sends the first HTML. Google's introduction describes markup that is injected dynamically, so the browser's inspector is the fair place to look. Note which templates carry markup and which entity types they describe, such as the business, a product, or an article.
If you find markup, do not assume it is wrong. Accurate Microdata or RDFa that a platform outputs correctly can stay in place. If you find nothing, you are choosing a format for new markup, and JSON-LD is the usual answer.
What the three formats change
Schema.org is the shared vocabulary. It defines types such as Bakery and properties such as telephone. JSON-LD, Microdata, and RDFa are three ways to write the same description with that vocabulary. Schema.org's getting started guide publishes its examples in all three syntaxes. For the wider definitions, see the guides on what schema markup is and on schema markup versus structured data.
JSON-LD puts the entity in a separate JSON object inside a script element. You do not add attributes to the visible HTML, so a template redesign does not break the data. The W3C JSON-LD 1.1 Recommendation (July 16, 2020) defines it as a JSON-based format for serializing linked data.
Microdata and RDFa work the other way. They add attributes directly to the visible elements, so each property is attached to the text or link it describes. Microdata uses itemscope, itemtype, and itemprop. RDFa uses vocab, typeof, property, and resource, and it offers broader linked-data capabilities than Microdata. That attachment is useful when a platform already generates it, and a cost when templates change often.
One bakery in three formats
All three examples describe the same fictional Example Bakery. The types and properties match Google's Local Business structured data feature page. Bakery is a subtype of LocalBusiness. For that Google feature, name and address are the required properties, and url, telephone, geo, openingHoursSpecification, priceRange, and servesCuisine are recommended for a food establishment. Replace every fictional value with facts that appear on your own page.
JSON-LD
Paste this into the page head or body. Change the @id, name, address, telephone, coordinates, price range, and hours. Keep the @id stable, because it is the identifier you reuse if other markup on the site refers to the same business.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Bakery",
"@id": "https://example.com/#bakery",
"name": "Example Bakery",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Example Street",
"addressLocality": "Example City",
"addressRegion": "EX",
"postalCode": "00000",
"addressCountry": "US"
},
"url": "https://example.com/",
"telephone": "+1-555-010-0000",
"servesCuisine": "Bakery",
"priceRange": "$$",
"geo": {
"@type": "GeoCoordinates",
"latitude": 40.00000,
"longitude": -75.00000
},
"openingHoursSpecification": [
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
"opens": "07:00",
"closes": "17:00"
},
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Saturday", "Sunday"],
"opens": "08:00",
"closes": "15:00"
}
]
}
</script>Microdata
The same facts as attributes on the visible elements. The heading, address, link, and phone number are the text visitors read, so edit those elements in your template and keep the attributes on them. A meta element holds a value that is not displayed, so confirm the same fact appears somewhere on the page.
<div itemscope itemtype="https://schema.org/Bakery" itemid="https://example.com/#bakery">
<h1 itemprop="name">Example Bakery</h1>
<div itemprop="address" itemscope itemtype="https://schema.org/PostalAddress">
<span itemprop="streetAddress">123 Example Street</span>,
<span itemprop="addressLocality">Example City</span>,
<span itemprop="addressRegion">EX</span>
<span itemprop="postalCode">00000</span>
<meta itemprop="addressCountry" content="US">
</div>
<a itemprop="url" href="https://example.com/">example.com</a>
<a itemprop="telephone" href="tel:+15550100000">+1-555-010-0000</a>
<meta itemprop="servesCuisine" content="Bakery">
<meta itemprop="priceRange" content="$$">
<div itemprop="geo" itemscope itemtype="https://schema.org/GeoCoordinates">
<meta itemprop="latitude" content="40.00000">
<meta itemprop="longitude" content="-75.00000">
</div>
<div itemprop="openingHoursSpecification" itemscope itemtype="https://schema.org/OpeningHoursSpecification">
<meta itemprop="dayOfWeek" content="Monday">
<meta itemprop="dayOfWeek" content="Tuesday">
<meta itemprop="dayOfWeek" content="Wednesday">
<meta itemprop="dayOfWeek" content="Thursday">
<meta itemprop="dayOfWeek" content="Friday">
<meta itemprop="opens" content="07:00">
<meta itemprop="closes" content="17:00">
</div>
<div itemprop="openingHoursSpecification" itemscope itemtype="https://schema.org/OpeningHoursSpecification">
<meta itemprop="dayOfWeek" content="Saturday">
<meta itemprop="dayOfWeek" content="Sunday">
<meta itemprop="opens" content="08:00">
<meta itemprop="closes" content="15:00">
</div>
</div>RDFa
RDFa follows the same shape with different attribute names. The vocab attribute names the vocabulary once, typeof replaces itemtype, and property replaces itemprop. The resource attribute carries the identifier that itemid and @id carry in the other two examples.
<div vocab="https://schema.org/" typeof="Bakery" resource="https://example.com/#bakery">
<h1 property="name">Example Bakery</h1>
<div property="address" typeof="PostalAddress">
<span property="streetAddress">123 Example Street</span>,
<span property="addressLocality">Example City</span>,
<span property="addressRegion">EX</span>
<span property="postalCode">00000</span>
<meta property="addressCountry" content="US">
</div>
<a property="url" href="https://example.com/">example.com</a>
<a property="telephone" href="tel:+15550100000">+1-555-010-0000</a>
<meta property="servesCuisine" content="Bakery">
<meta property="priceRange" content="$$">
<div property="geo" typeof="GeoCoordinates">
<meta property="latitude" content="40.00000">
<meta property="longitude" content="-75.00000">
</div>
<div property="openingHoursSpecification" typeof="OpeningHoursSpecification">
<meta property="dayOfWeek" content="Monday">
<meta property="dayOfWeek" content="Tuesday">
<meta property="dayOfWeek" content="Wednesday">
<meta property="dayOfWeek" content="Thursday">
<meta property="dayOfWeek" content="Friday">
<meta property="opens" content="07:00">
<meta property="closes" content="17:00">
</div>
<div property="openingHoursSpecification" typeof="OpeningHoursSpecification">
<meta property="dayOfWeek" content="Saturday">
<meta property="dayOfWeek" content="Sunday">
<meta property="opens" content="08:00">
<meta property="closes" content="15:00">
</div>
</div>Look at how much of the HTML the second and third examples change. The JSON-LD block leaves your template alone, while Microdata and RDFa depend on the element structure staying put. That difference is most of the maintenance argument.
For a ready-made version of this entity, the local business schema generator builds JSON-LD from the facts you enter. For more types and copyable code, see the JSON-LD schema examples.
Who reads which format
Google says it supports JSON-LD, Microdata, and RDFa, and it recommends JSON-LD (structured data introduction, last updated December 10, 2025). Its Rich Results Test accepts all three formats (Rich Results Test help). Which Google feature a page can qualify for depends on that feature's own documentation, not on the format.
Bing says its crawlers support Schema.org in JSON-LD, HTML Microdata, and RDFa and that they do not prefer one supported specification over another. That statement is about format. It does not say the data inside can be incomplete or inaccurate, so the same care applies whichever format you pick.
Schema.org itself is neutral. It defines the vocabulary and shows examples in all three syntaxes. A format recommendation from one search engine describes that engine, and the consistent advice across all of them is to describe real, visible content accurately. For AI search systems, see whether AI systems use schema markup.
Choose one format for each entity and template
Decide per entity and per template, not once for the whole site. A site can use JSON-LD for its articles and still leave a platform's Microdata on its product cards. The goal is that each entity on each page has one canonical description that you can keep up to date.
- JSON-LD fits new implementations, CMS templates, JavaScript applications, and large sites.
- Microdata fits a platform that already outputs it correctly, or markup that has to stay attached to visible HTML.
- RDFa fits an existing semantic HTML or linked-data system that already depends on it.
Maintenance is the practical difference. JSON-LD has low template coupling, and it is usually easy to read, copy, compare, and validate as one object. Microdata is tightly coupled to HTML elements, so a template change can quietly break coverage, and errors may be spread across nested markup. RDFa sits between the two on coupling, and its flexibility is more demanding for anyone who does not work with linked data.
Publishing two formats for the same entity is not automatically a problem. Conflicting values are, because they make the page harder to interpret. That is an implementation practice that follows from Google's general structured data guidelines (markup must describe visible, relevant content) and from the way JSON-LD identifiers work, not a separate Google penalty rule. When the same entity appears in more than one object, give it a stable @id and keep names, URLs, addresses, prices, availability, and dates identical.
Migrate inherited Microdata or RDFa in stages
Migration is optional. If the existing markup is accurate and your platform keeps it current, leaving it alone is a sound decision. Move to JSON-LD when the old markup is hard to maintain, when templates keep breaking it, or when you need to add types that the platform does not output.

Migrate one template at a time, so a mistake affects a small group of pages instead of the whole site.
- Inventory the Microdata or RDFa by page template and entity type.
- Compare each entity and property with the matching Google Search feature documentation.
- Build equivalent JSON-LD with the same facts, URLs, identifiers, and relationships.
- Validate the JSON-LD with the Rich Results Test and the Schema Markup Validator.
- Deploy it to a small group of representative pages.
- Inspect the live URLs and monitor Search Console after Google recrawls them.
- Remove the old format only after the replacement covers the same eligible content and the rendered page is still accurate.
Steps 3 and 7 carry the risk. In step 3, copy values from the existing attributes instead of retyping them, and reuse the same @id the old markup used, so references from other objects still point to one entity. In step 7, compare the old and new coverage property by property, because a property that existed only in the old markup disappears the moment you delete it.
If a platform already produces Microdata for a page, do not add a second hand-written JSON-LD version by reflex. Add one only after you have confirmed the two descriptions do not conflict or duplicate the same entity. For the platform-neutral setup steps, see the guide on how to add schema markup.
Check platform output before you install anything
Platforms differ in what they already generate and what you can edit, so look at the rendered page first.
Shopify themes can include Microdata for supported theme content, so view the source of a product page before you add JSON-LD from an app or snippet. Squarespace generates several structured data types automatically and says they cannot be edited or removed, so manual markup there should describe something the platform does not already cover.
Webflow lets you add schema markup manually in Page settings and in Collection pages, as its schema markup guidance (updated January 27, 2026) describes. The same page says custom-code markup can continue to work and recommends avoiding duplicate implementations. WordPress.com supports structured data through its SEO settings for some types and recommends plugins for others.
On a hand-built site, rendering JSON-LD directly is straightforward. The Next.js documentation recommends a native script tag in layout.js or page.js, and it also advises sanitizing the serialized output and validating it. For WordPress sites with their own theme or plugin output, the guide to schema markup in WordPress covers the install routes.
Test the rendered page
Each test answers a different question, and no single test answers all of them. A JSON syntax check says the code parses. Schema.org's Schema Markup Validator checks vocabulary only, so a type or property can pass there and still have no Google feature behind it. Google's Rich Results Test accepts all three formats and reports whether the markup meets the requirements of the Google features it supports.
Run the test against the live URL, not only a pasted snippet, so you test what visitors and crawlers actually receive. The Schema Nova validator is there for checking your JSON-LD before you publish it. After you publish, inspect the live URL and watch Search Console while Google recrawls the pages.

Passing a test does not guarantee a rich result. Google's general guidelines say valid markup does not promise any particular search appearance, and Google may not show a feature even when everything validates. For how far structured data goes in search generally, read whether schema markup helps SEO. For choosing the entity type itself, see the guide to the types of schema markup.
Questions people ask
Does Google support Microdata and RDFa, or only JSON-LD?
Google says it supports JSON-LD, Microdata, and RDFa, and it recommends JSON-LD. Existing Microdata or RDFa can remain when it is accurate and working. Check the specific feature page for the properties that feature requires.
Can JSON-LD and Microdata describe the same page?
Yes, but conflicting values make the page harder to interpret, and one canonical description is easier to maintain. If you keep both, use the same facts and the same @id for the same entity, and confirm the two do not duplicate it. If a platform already outputs Microdata, test its output before you add a manual copy.
Is JSON-LD visible to visitors?
The script element is not displayed on the page. The facts in it still have to match content that visitors can see, because Google's guidelines require structured data to describe visible, relevant content.
Why is my markup valid but not showing as a rich result?
Valid markup is a precondition for a feature, not a promise of one. Google decides whether to show a search appearance, and some features no longer exist. Google stopped showing FAQ rich results in May 2026, and FAQPage remains a valid schema.org type. Google's August 2023 announcement retired HowTo rich results. Check the feature gallery for what Google currently supports.
What should a Shopify or Squarespace owner check before adding manual markup?
Look at the rendered page source to see what the theme or platform already outputs. Then add only the types that are missing, and give any entity that is already marked up a single description instead of a second one.
