Toolsky

Free Online Tools & Utilities for Every Task.

JSON-LD to Microdata Converter

Convert your Schema.org JSON-LD to HTML Microdata.

Microdata vs JSON-LD

Standards

JSON-LD: Modern standard, easy to maintain, lives in a script tag.

Microdata: Traditional standard, integrated directly into HTML tags.

Why Convert?

Why convert? Some legacy systems or specific CMS plugins only support Microdata.

Compatibility: Both are recognized by Google and other search engines for rich snippets.

JSON-LD to Microdata conversion moves your Schema.org structured data from a script block into the HTML of the page itself. Both formats express the same vocabulary — a business, a product, an event, their properties — but they live in different places: JSON-LD sits separately in a <script> tag, while Microdata weaves itemscope, itemtype, and itemprop attributes directly into the visible markup. This converter rewrites one as the other, so a site committed to inline markup does not have to re-author its structured data by hand.

Why Two Formats Exist for the Same Data

Schema.org launched with Microdata as its original syntax: the metadata and the content are the same HTML, so what a visitor sees is literally what the crawler reads. JSON-LD came later and quickly became the more popular recommendation because it is easier to generate from templates and databases — one block in the head, no surgery on the page body. Yet Microdata never disappeared. Some content-management themes, older SEO plugins, email templates, and in-house publishing systems are built around inline markup, and some teams prefer that metadata travel with the content it describes when fragments are copied between pages. Converting between the two is therefore a practical migration task, not a theoretical one.

The Mapping the Converter Applies

  • @type becomes itemtype: a JSON-LD object typed "LocalBusiness" becomes an element carrying itemscope and itemtype="https://schema.org/LocalBusiness".
  • Properties become itemprop: each key in the JSON-LD object is matched to the HTML element displaying that value, which gains an itemprop attribute with the property name.
  • Nested objects become nested items: an embedded object — an address inside a business, an offer inside a product — turns into its own itemscope element nested inside the parent.
  • @context and @id are left behind: Microdata has no equivalent for JSON-LD's context declaration, and identifiers are expressed differently, so the conversion focuses on the type-and-property structure itself.

How to Convert JSON-LD to Microdata Step by Step

  1. Copy the complete JSON-LD object from your existing script block — a single item such as a business, product, article, or event.
  2. Paste it into the converter's input area.
  3. Run the conversion.
  4. Examine the generated HTML: confirm the outer element carries itemscope and the correct itemtype, and that each property landed as an itemprop on a sensible element.
  5. Integrate the markup into your page, merging the attributes into the elements that actually display those values wherever your layout allows.
  6. Validate the finished page with a structured-data testing tool before publishing, since final correctness depends on how the markup meets your real page structure.

A Worked Example: One Café, Two Syntaxes

Start with this JSON-LD for a small café:

{"@context":"https://schema.org","@type":"CafeOrCoffeeShop","name":"Harbor Bean","telephone":"+1-512-555-0148","address":{"@type":"PostalAddress","streetAddress":"88 Dock Street","addressLocality":"Austin"}}

The Microdata equivalent expresses the same facts inline:

<div itemscope itemtype="https://schema.org/CafeOrCoffeeShop">
  <span itemprop="name">Harbor Bean</span>
  <span itemprop="telephone">+1-512-555-0148</span>
  <div itemprop="address" itemscope itemtype="https://schema.org/PostalAddress">
    <span itemprop="streetAddress">88 Dock Street</span>
    <span itemprop="addressLocality">Austin</span>
  </div>
</div>

Follow the correspondences: the type moved into itemtype, every property name survived as an itemprop, and the nested PostalAddress became a nested item that is simultaneously a property of its parent and an item in its own right. Nothing about the information changed — only its address on the page moved, from a script block into the markup.

When Microdata Is the Right Target

The realistic cases are migrations and constraints. A site redeveloping its templates around a Microdata-based theme needs its existing JSON-LD library converted rather than rewritten. A team embedding structured data into HTML email or syndicated fragments — contexts where a separate script block may be stripped — needs the data inline. And developers learning structured data sometimes convert a known-good JSON-LD object to Microdata simply to understand how the inline syntax works, using the generated markup as a reference. In the opposite situation, the sibling Microdata to JSON-LD converter performs the reverse migration, and the Schema Generator helps build fresh markup from scratch.

Limitations and Mistakes to Watch For

The conversion is structural, and its blind spot is your page: the converter can generate correct standalone markup, but Microdata only reaches its purpose when the itemprop attributes sit on the elements that genuinely display those values — pasting the generated block as a separate hidden lump defeats the format's intent and can look manipulative to search engines. Multi-valued properties and arrays become repeated itemprop elements, which is correct but easy to mangle when merging into a layout. Global identifiers and references (@id, itemid) do not map one-to-one, so linked-data graphs flatten somewhat in transit. Finally, test the result: a page should carry one coherent structured-data representation per item, so remove the original JSON-LD once the Microdata is live to avoid describing the same entity twice in conflicting ways. Running the source through the JSON-LD Validator before converting also ensures you are not faithfully converting broken data.

Frequently Asked Questions About Converting JSON-LD to Microdata

Do search engines accept Microdata as fully as JSON-LD?

Yes. Google and other search engines read Microdata, JSON-LD, and RDFa as equivalent carriers of Schema.org data. The format affects your templating convenience, not your eligibility for rich results.

What happens to the @context property?

It is dropped, correctly. @context tells a JSON-LD parser which vocabulary the terms come from; Microdata states the vocabulary directly in each itemtype URL, so no declaration is needed.

How are nested objects handled?

A nested object becomes a nested item: the property element also carries itemscope and its own itemtype, exactly as the café's PostalAddress did in the example above.

Can one page use both formats at once?

It can, but it should not describe the same item twice. Duplicated, diverging descriptions of one entity confuse parsers; pick one format per item and keep it consistent.

Does Microdata have to be visible on the page?

The format is designed for visible content, and that is its proper use: itemprop belongs on the elements presenting the values. Meta-tag fallbacks exist for a few special cases, but hidden bulk markup undermines the point.

What if my JSON-LD describes several items in an array?

Each top-level item converts to its own itemscope block. Convert them one at a time if your page places the items in separate locations, so each block lands beside the content it describes.

Will conversion fix errors in my structured data?

No — it translates syntax, not correctness. A wrong type or a misspelled property converts faithfully into an equally wrong Microdata version, so validate before and test after.

Same Vocabulary, New Home

Structured data is an asset you should never have to author twice. When a platform, theme, or publishing pipeline calls for Microdata, converting your existing JSON-LD preserves the types, properties, and nesting you already got right, and relocates them into the markup where the new system expects them. Convert carefully, merge thoughtfully, and validate the page you ship.