How to Convert JSON-LD Schema Into Microdata

You’ve written clean JSON-LD structured data for a product page — the kind that drops into a <script type="application/ld+json"> block and gets picked up by search engines without touching your HTML. Then you hit a platform, template, or legacy CMS that either strips script tags from custom fields or specifically expects Microdata’s inline itemscope/itemprop attributes instead. Now you’re stuck rewriting the same structured data in a completely different syntax, by hand, hoping you don’t introduce a mismatched attribute along the way.

Schema.org supports both formats — JSON-LD and Microdata express the same vocabulary, just structured differently. Google and other search engines accept either. The problem is purely practical: most people write and think in JSON-LD because it’s easier to read and doesn’t require touching visible HTML, but not every system will accept it.

What converting JSON-LD to Microdata actually involves

JSON-LD keeps structured data as a separate JSON object, referencing a schema type (Product, Article, Recipe) and its properties in key-value form. Microdata instead embeds that same information as attributes directly on your visible HTML elements — itemscope itemtype="https://schema.org/Product" on a wrapping <div>, then itemprop="name" on the actual heading that displays the product name, and so on for every property.

Converting between them means mapping each JSON-LD key to the correct HTML element and attribute, in a way that produces markup search engines will parse identically to the original JSON-LD. Done manually, this is tedious and easy to get subtly wrong — a missing itemscope on a nested object, or an itemprop placed on the wrong element, breaks the structured data without throwing an obvious error.

Why people get stuck here

• Platform restrictions. Some CMS platforms, form builders, or older templates don’t allow arbitrary <script> tags in the areas where you’d need to insert JSON-LD.
• Manual mapping errors. Hand-converting even a moderately nested schema (a Product with nested Review and AggregateRating objects) means tracking a lot of attribute placement rules at once.
• Losing sync between formats. If you maintain both a JSON-LD version and a hand-written Microdata version, they drift apart the moment one gets updated and the other doesn’t.
• Uncertainty about correctness. Because malformed structured data often fails silently — no visible error, just missing rich results — it’s hard to know a manual Microdata conversion actually worked without testing it separately.

What a good JSON-LD to Microdata converter looks like

Accurate property-to-attribute mapping

Every JSON-LD key needs to become the right itemprop on a sensible HTML element, with nested objects correctly wrapped in their own itemscope.

Handles nested schema types

Real-world structured data often nests one type inside another — a Product containing an Offer, or an Article containing an Author — and the converter needs to preserve that nesting correctly in Microdata’s attribute structure.

Output you can drop straight into your HTML

The result should be ready-to-use markup, not something requiring another manual cleanup pass before it’s valid.

Common mistakes to avoid

• Placing itemprop attributes on elements that don’t actually display the corresponding visible content, which technically works but looks odd and can be flagged by strict validators.
• Forgetting to add itemscope on every nested schema type, not just the outermost one.
• Converting once and then editing the JSON-LD version afterward, letting the two versions drift out of sync.
• Not validating the converted Microdata with a structured data testing tool afterward, since a silent placement error won’t throw a visible page error.

How to do it with JSON-LD to Microdata Converter

Online Tool Store’s JSON-LD to Microdata Converter runs entirely in your browser — your structured data is converted locally.

1. Open the JSON-LD to Microdata Converter tool and paste in your existing JSON-LD script block.
2. Let it parse the schema type and properties, including any nested objects.
3. Review the generated Microdata HTML output.
4. Copy the markup into your page template, placing the itemprop attributes on the elements that actually display each piece of content.

Frequently asked questions

Do search engines treat JSON-LD and Microdata differently?

No — both are accepted formats for schema.org structured data, and search engines parse either into the same underlying data. The choice between them is a practical one about what your platform or template supports, not an SEO ranking difference.

Can I convert Microdata back to JSON-LD later?

That’s a separate conversion direction with its own mapping logic. If your platform later supports JSON-LD directly, it’s usually easier to go back to your original JSON-LD source than to re-extract it from Microdata markup.

Will the converted markup automatically match my page’s visible layout?

Not automatically — the converter maps schema properties to markup, but you still need to place the resulting itemprop attributes onto the HTML elements that actually display each piece of content on your page.

Final thought

JSON-LD and Microdata are two ways of saying the same thing to a search engine, and neither is objectively better — it comes down to what your platform will accept. Converting between them by hand is where mistakes creep in, so let a converter handle the attribute mapping and spend your own time checking the output actually lines up with your visible page content.

Try the free JSON-LD to Microdata Converter tool