Microdata to JSON-LD

The Microdata to JSON-LD tool converts pasted HTML that uses Schema.org-style Microdata attributes into a JSON-LD structure you can review, copy, and adapt. It is useful when you are modernizing older templates, auditing structured data already embedded in HTML, or moving markup into a cleaner script-based format without manually retyping every property.

Paste a snippet that contains itemscope, itemtype, and itemprop attributes, then run the converter. The tool parses the submitted HTML on the Digital Domain Kit server and returns formatted JSON. It focuses on conversion, not validation: it does not prove that the schema is complete, eligible for rich results, or recommended for a particular search feature.

How to use the converter

1. Copy the section of HTML that contains your Microdata. Include the root element with itemscope whenever possible.
2. Paste it into the field labeled Enter HTML Microdata.
3. Click Convert to JSON-LD.
4. Review the formatted JSON-LD output for property names, nested items, repeated values, and missing fields.
5. Use Copy JSON-LD to copy the result into your editor, template, CMS, or structured data workflow.
6. Test the final page with the tools you normally use before publishing changes.

For best results, start with a focused snippet rather than an entire page. A product card, article block, event listing, recipe section, organization footer, or breadcrumb component is usually easier to inspect than a full document full of navigation, ads, comments, and unrelated layout markup.

What this tool reads from your HTML

The converter looks for elements marked with itemscope. It prefers root items that do not also have itemprop; if it cannot find that kind of root item, it falls back to any scoped item it can find. For each item, it reads the itemtype URL and turns Schema.org URLs such as https://schema.org/Article into a JSON-LD @type value such as Article.

Verified example

This example uses a small Article item. It includes a headline from a content attribute, a nested Person author, a publication date from datetime, an image from src, and a canonical URL from href.

Input Microdata

<article itemscope itemtype="https://schema.org/Article">
    <meta itemprop="headline" content="How to Prepare a Product Launch Checklist">
    <div itemprop="author" itemscope itemtype="https://schema.org/Person">
        <span itemprop="name">Maya Patel</span>
    </div>
    <time itemprop="datePublished" datetime="2026-03-18">March 18, 2026</time>
    <img itemprop="image" src="https://example.com/images/launch-checklist.jpg" alt="">
    <a itemprop="url" href="https://example.com/blog/product-launch-checklist">Read the guide</a>
    <span itemprop="keywords">product launch, checklist</span>
</article>

Expected JSON-LD output from this tool

{
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "How to Prepare a Product Launch Checklist",
    "author": {
        "@type": "Person",
        "name": "Maya Patel"
    },
    "datePublished": "2026-03-18",
    "image": "https://example.com/images/launch-checklist.jpg",
    "url": "https://example.com/blog/product-launch-checklist",
    "keywords": "product launch, checklist"
}

This output reflects the converter's current parsing behavior. Because the input has one root item, the result is a single JSON object and the tool adds "@context": "https://schema.org". If you paste multiple separate root items, the result may be a JSON array; review that output before placing it into a page.

Inputs, outputs, and limitations

The input is pasted HTML, not a URL fetcher and not a file upload. The converter does not crawl your site, render JavaScript, or inspect pages after templates have been assembled by a browser. It works with the markup you paste into the textarea.

The output is formatted JSON-LD based on supported Microdata attributes. That makes it a helpful starting point when migrating structured data, but it is still worth checking the result by hand. Microdata and JSON-LD can express the same vocabulary in different shapes, and real sites often contain extra wrappers, repeated fields, or theme-generated markup that deserves a careful review.

• The tool requires at least one itemscope. If none is found, it reports: No Microdata (itemscope) found in the provided HTML.
• It reads Schema.org item types, but it does not validate whether a type or property is recommended for your page.
• It does not guarantee Google rich results, enhanced listings, or search ranking changes.
• It does not know whether the converted JSON-LD matches the visible content on your live page.
• It may preserve values exactly as found, including relative URLs, tracking parameters, unusual whitespace, or old content.
• For multiple root items, check whether you need a top-level graph or separate script blocks in your own implementation.

Troubleshooting

No Microdata found

Make sure the pasted HTML includes an element with the itemscope attribute. An element with only itemprop is not enough to define a full scoped item.

The type is missing or unexpected

Check the root element's itemtype. A common pattern is itemtype="https://schema.org/Product", itemtype="https://schema.org/Article", or another Schema.org type. The converter strips the Schema.org URL prefix when it builds @type.

A value came from an attribute instead of visible text

That is expected for several elements. For example, time uses datetime, links use href, media elements use src, and elements with content use that attribute value. This often produces cleaner structured data than reading the visible label alone.

Repeated fields became an array

If the same property appears more than once, the converter groups those values into an array. This is useful for fields such as multiple images, authors, categories, or offers, but you should confirm that the final shape matches the schema pattern you intend to publish.

The JSON looks valid but may not be SEO-ready

Conversion and validation are different jobs. After copying the output, compare it with the relevant Schema.org type documentation and test the final page with structured data tools. The JSON-LD should describe content that users can actually see on the page.

Related tools

This converter pairs well with JSON formatting, HTML cleanup, and structured data workflows. Use it when you already have Microdata and want a JSON-LD draft, then move to a validator or formatter before publishing the final page.

• Use the JSON-LD to Microdata tool when you need to move in the opposite direction.
• Use the JSON Validator after editing the generated JSON-LD by hand.
• Use the JSON Beautifier when you need to reformat a compact JSON-LD script for easier review.
• Use the HTML Formatter before conversion if the source snippet is hard to read.
• Use the Canonical URL Generator when you are cleaning up SEO tags around the same page template.

Technical references

• Schema.org Microdata guide
• Schema.org JSON-LD examples
• Google introduction to structured data
• Google Rich Results Test
• Schema Markup Validator

Editorial notes

Built and maintained by Digital Domain Kit. Technical method reviewed September 14, 2026: the tool submits pasted HTML through a Livewire request, parses supported Microdata attributes with PHP DOMDocument, and returns formatted JSON for review. To report a problem with this converter, use the contact page.

This page is written for site owners, developers, SEOs, and content teams who need to inspect or migrate structured data. The tool's purpose is to convert supported Microdata markup into a JSON-LD-style representation while keeping the interactive converter as the primary page experience. Pasted HTML is submitted to the server for parsing, so avoid pasting confidential source markup unless you are comfortable processing it through this service.