JSON-LD vs Microdata vs RDFa: Which Structured Data Format AI Shopping Agents Parse Best in 2026

JSON-LD is the structured data format that AI shopping agents parse most efficiently because it delivers a complete, self-contained product entity in a single JSON block requiring one parsing pass, while Microdata and RDFa force agents to traverse scattered DOM elements and reconstruct entity relationships from attribute annotations embedded across the page.

Google has recommended JSON-LD as its preferred structured data format since 2014, and as of August 2026, 54.8% of all websites use JSON-LD according to w3techs. But the SEO rationale you already know is only half the story. The other half is how AI shopping agents like ChatGPT, Perplexity, and Google AI Mode actually ingest and parse your product data, and why the format you choose directly affects whether your products get recommended.

This article breaks down the three structured data formats, compares them from an AI agent parsing perspective, and gives you a concrete implementation path.

The Three Structured Data Formats Explained

Schema.org supports three serialization formats for structured data: JSON-LD, Microdata, and RDFa. All three can describe the same product information. The difference is how that information is encoded in your HTML.

JSON-LD (JavaScript Object Notation for Linked Data)

JSON-LD is a serialized JSON format embedded in a <script type="application/ld+json"> tag, usually placed in the <head> or before the closing </body> tag. The structured data exists as a separate data layer, independent of the visual HTML.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wireless Noise-Cancelling Headphones",
  "image": "https://store.com/images/headphones.jpg",
  "description": "Premium over-ear headphones with active noise cancellation.",
  "sku": "WH-1000",
  "brand": { "@type": "Brand", "name": "AudioPro" },
  "offers": {
    "@type": "Offer",
    "url": "https://store.com/headphones",
    "price": "299.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "312"
  }
}
</script>

Everything the AI agent needs sits in one block. No DOM traversal required.

Microdata

Microdata embeds structured data directly in HTML elements using itemscope, itemtype, and itemprop attributes. The data is interleaved with the visual markup.

<div itemscope itemtype="https://schema.org/Product">
  <img itemprop="image" src="https://store.com/images/headphones.jpg" />
  <span itemprop="name">Wireless Noise-Cancelling Headphones</span>
  <span itemprop="sku">WH-1000</span>
  <div itemprop="offers" itemscope itemtype="https://schema.org/Offer">
    <link itemprop="availability" href="https://schema.org/InStock" />
    <span itemprop="price">299.00</span>
    <meta itemprop="priceCurrency" content="USD" />
  </div>
</div>

To extract the full product entity, a parser must walk every HTML element, check for itemprop attributes, track nesting through itemscope boundaries, and reconstruct the entity graph from scattered fragments.

RDFa

RDFa (Resource Description Framework in Attributes) works similarly to Microdata but uses a different attribute vocabulary (vocab, typeof, property, resource). It is even more verbose and requires the same DOM-traversal approach.

<div vocab="https://schema.org/" typeof="Product">
  <img property="image" src="https://store.com/images/headphones.jpg" />
  <span property="name">Wireless Noise-Cancelling Headphones</span>
  <div property="offers" typeof="Offer">
    <span property="price">299.00</span>
    <meta property="priceCurrency" content="USD" />
  </div>
</div>

RDFa adoption is minimal in ecommerce. According to w3techs, RDFa is used by roughly 18% of websites, compared to JSON-LD’s 54.8%. Most RDFa usage is on non-ecommerce sites.

Why AI Shopping Agents Prefer JSON-LD

Google’s official documentation states: “We recommend using a format that’s easiest for you to implement and maintain (in most cases, that’s JSON-LD).” But Google is not the only consumer of your structured data anymore. AI shopping agents from OpenAI, Perplexity, Anthropic, and Google’s own AI Mode all parse product pages differently than traditional crawlers.

Here is why JSON-LD gives you an advantage with AI agents specifically.

1. Single-Pass Parsing vs DOM Traversal

JSON-LD is a complete JSON object. An AI agent can extract the <script> block, run a single JSON parse, and immediately access the full product entity with all nested properties. The computational cost is minimal.

Microdata and RDFa require the agent to render the full DOM, traverse every element, check attributes, track scope boundaries, and reconstruct the entity. For a complex product page with 200+ HTML elements, this is significantly more processing overhead.

When AI agents operate under token budgets, latency constraints, or rate limits, the format that requires less processing per page wins. JSON-LD reduces the extraction cost to a single deserialization operation.

2. Data Completeness in One Block

JSON-LD allows you to define a complete product entity including nested offers, ratings, brand, reviews, and shipping details in a single structured block. Nothing is fragmented.

With Microdata, the same information is spread across dozens of HTML elements. If any element is dynamically loaded (via JavaScript after page render), an AI agent that does not execute JavaScript will miss that data entirely. JSON-LD in the initial HTML payload ensures the data is present at first parse.

3. No Coupling to Visual Markup

Microdata and RDFa couple your structured data to your visual HTML. If you redesign your product page template, move elements around, or change CSS frameworks, your structured data can break silently. A <span itemprop="price"> that gets wrapped in a new div or renamed during a redesign can silently remove your price from structured data extraction.

JSON-LD sits in its own block, decoupled from visual markup. You can redesign your entire product page without touching the structured data. This separation is not just about maintenance convenience. It means your structured data is more resilient, more consistent, and more likely to remain intact as your templates evolve.

4. Multi-Entity Support Without Page Restructuring

A product page often needs to describe multiple entities: the Product, an Offer, an AggregateRating, a BreadcrumbList, and possibly an Organization. With JSON-LD, you can output multiple entity blocks or a single @graph structure without changing your HTML layout:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Product",
      "name": "Wireless Noise-Cancelling Headphones",
      "sku": "WH-1000",
      "offers": { "@type": "Offer", "price": "299.00", "priceCurrency": "USD" }
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://store.com/" },
        { "@type": "ListItem", "position": 2, "name": "Headphones", "item": "https://store.com/headphones" }
      ]
    }
  ]
}
</script>

With Microdata, each entity must be physically positioned in the HTML where it makes visual sense. Breadcrumbs go in the breadcrumb nav, product data goes in the product section, and reviews go in the reviews widget. If your page does not have a natural HTML element for an entity, you are forced to add hidden elements, which Google may flag as policy violations.

Adoption Data: Where Ecommerce Stands

Format	Web Adoption (w3techs, Aug 2026)	Google Recommendation	AI Agent Parsing Efficiency
JSON-LD	54.8% of all websites	Recommended	Single-pass JSON parse
Microdata	~28% of all websites	Supported	DOM traversal required
RDFa	~18% of all websites	Supported	DOM traversal required

Despite JSON-LD being the recommended format for over a decade, a significant percentage of ecommerce stores still use Microdata, often inherited from legacy Shopify themes, old WooCommerce templates, or third-party plugins that have not been updated.

Google’s own case studies demonstrate the impact of structured data regardless of format. Rotten Tomatoes saw a 25% higher click-through rate after adding structured data to 100,000 pages. The Food Network saw a 35% increase in visits after converting 80% of their pages. Nestlé measured 82% higher CTR on pages with rich results. Rakuten found users spent 1.5x more time on structured data pages.

But these results were measured for Google Search rich results. The AI agent era introduces a new consumer of your structured data, and the parsing efficiency gap between JSON-LD and other formats matters more now than it did for traditional crawlers.

The AI Agent Parsing Problem

Traditional Google crawlers have no parsing constraints. Googlebot renders pages fully, executes JavaScript, and has effectively unlimited processing budget per page. Whether your structured data is JSON-LD or Microdata, Google can extract it.

AI shopping agents operate differently:

They may not execute JavaScript at all, or may only partially render pages
They work under token budgets that limit how much HTML they can process
They may parse pages in batch, where processing efficiency directly affects how many products get indexed
They often use simplified HTML parsers rather than full browser engines

A study cited in our AI citation benchmarks analysis found that structured data presence and format quality are among the top factors determining which products AI agents recommend. Stores with clean, complete JSON-LD consistently outperform those with fragmented or missing structured data.

For a deeper look at what AI agents read beyond schema, see our analysis of HTML elements that determine product discoverability.

Migration Guide: Moving from Microdata or RDFa to JSON-LD

If your store currently uses Microdata or RDFa, migrating to JSON-LD is the single highest-impact change you can make for AI agent discoverability. Here is how to do it.

Step 1: Audit Your Current Structured Data

Before migrating, map what you currently have. Use the Schema Validators guide to run a full audit. Identify:

Which pages have structured data and which do not
Which format is used (JSON-LD, Microdata, RDFa, or mixed)
Which schema.org types and properties are implemented
Where errors or warnings exist

Step 2: Build Your JSON-LD Templates

For each page type (product, category, homepage, blog post), create a JSON-LD template that covers all required and recommended properties. For product pages, at minimum:

Property	Required	Why It Matters for AI Agents
name	Yes	Primary product identifier in recommendations
image	Yes	Visual reference in AI shopping results
description	Yes	Context for product comparison
sku or gtin	Yes	Unique product identification
brand	Yes	Brand entity for filtering and trust
offers.price	Yes	Price comparison data
offers.priceCurrency	Yes	Internationalization
offers.availability	Yes	In-stock verification
aggregateRating	Recommended	Trust signal for AI ranking
shippingDetails	Recommended	Fulfillment comparison

Step 3: Implement Server-Side JSON-LD Generation

Generate JSON-LD server-side so it appears in the initial HTML response. Do not inject JSON-LD via client-side JavaScript. AI agents that do not execute JavaScript will never see it.

For Shopify stores, use a JSON-LD template in your theme.liquid files. For WooCommerce, use PHP to generate JSON-LD in your template files or use a plugin that outputs server-rendered JSON-LD. For custom platforms, generate JSON-LD in your backend templating layer.

Step 4: Validate Before Deploying

Run every page type through Google’s Rich Results Test and the Schema.org Validator. Check that:

All required properties are present
No nested entity errors exist
The JSON-LD is valid JSON (no trailing commas, no unescaped quotes)
The @context is correct (https://schema.org)
URLs in the JSON-LD match canonical URLs

Set up a CI/CD validation pipeline using the approach described in our structured data validation pipeline guide so regressions are caught before deployment.

Step 5: Remove Old Microdata/RDFa Gradually

Once JSON-LD is live and validated, remove the old Microdata or RDFa attributes from your HTML templates. Do this gradually to avoid breaking anything:

Deploy JSON-LD alongside existing Microdata
Monitor Google Search Console for structured data errors
Confirm rich results are still generating
Remove Microdata attributes (itemscope, itemtype, itemprop) from HTML
Remove RDFa attributes (vocab, typeof, property) if applicable
Validate again after removal

Common Mistakes That Break JSON-LD for AI Agents

Even stores that use JSON-LD often make errors that reduce AI agent parseability.

Mixed Formats on the Same Page

Some Shopify themes output JSON-LD for Product but use Microdata for BreadcrumbList. This forces AI agents to use two different parsing strategies on the same page. Standardize on JSON-LD for all entities.

JavaScript-Injected JSON-LD

If your JSON-LD is injected by a React, Vue, or Next.js client-side script, AI agents that do not execute JavaScript will not see it. Use server-side rendering (SSR) or static site generation (SSG) to ensure JSON-LD is in the initial HTML.

Incomplete Nested Entities

A Product with an Offer that is missing priceCurrency creates an incomplete entity. AI agents may discard the entire offer block if critical fields are missing. Use the schema stack framework to ensure every nested entity is complete.

Duplicate Conflicting Data

Some ecommerce platforms output multiple JSON-LD blocks for the same product (one from the theme, one from a plugin, one from Google Tag Manager). If these conflict (different prices, different availability), AI agents may discard both. Audit your page source for multiple JSON-LD blocks and consolidate.

Using `http://` Instead of `https://` in @context

Schema.org documents note that the @context URL works with both http:// and https://, but consistency matters. Some AI parsers normalize URLs and may treat http://schema.org and https://schema.org as different contexts. Use https://schema.org everywhere.

Platform-Specific JSON-LD Status

Platform	Default Format	JSON-LD Ready	Migration Effort
Shopify (current themes)	JSON-LD	Already supported	None required
Shopify (legacy themes)	Microdata	Needs theme update	Medium
WooCommerce	Varies by plugin	Needs PHP templates	Medium
BigCommerce	JSON-LD	Already supported	None required
Magento/Adobe Commerce	Mixed	Needs custom work	High
Wix	JSON-LD	Already supported	None required
Custom (headless)	Developer choice	Build from scratch	High

For platform-specific implementation details, see our platform structured data implementation guide.

The Business Case for JSON-LD Migration

If you need internal buy-in for a JSON-LD migration, here are the numbers that matter:

54.8% of all websites already use JSON-LD (w3techs, August 2026). Your competitors likely already have it.
Google officially recommends JSON-LD over other formats for all structured data implementations.
Rotten Tomatoes measured 25% higher CTR after implementing structured data across 100,000 pages (Google case study).
Nestlé measured 82% higher CTR on pages with rich results enabled by structured data (Google case study).
The Food Network saw 35% more visits after converting 80% of pages to include structured data (Google case study).
AI shopping agent traffic is growing and structured data format directly affects whether your products are parseable by these agents.

The cost of migration is typically a few hours of development work per platform. The cost of not migrating is invisible but compounding: every AI agent recommendation your store misses because of parseability issues is a sale that went to a competitor.

FAQ

Does Google penalize Microdata or RDFa?

No. Google states that all three formats are equally valid for search features. The recommendation for JSON-LD is about implementation simplicity and maintenance, not ranking advantage. However, JSON-LD is easier to get right, which means fewer errors, which means better structured data coverage, which can indirectly improve search performance.

Can I use JSON-LD and Microdata together?

Technically yes, but it is not recommended. Having both formats on the same page increases the risk of conflicting data and forces parsers (including AI agents) to reconcile two sources. Pick one format and use it consistently across all page types.

Do AI agents like ChatGPT and Perplexity actually read structured data?

Yes. AI shopping agents use structured data as a primary signal for understanding product entities, prices, availability, and attributes. Pages with complete, valid structured data are significantly more likely to appear in AI shopping recommendations than pages without it. The format matters because AI agents have different parsing constraints than traditional search crawlers.

How long does a JSON-LD migration take?

For a Shopify store on a current theme, JSON-LD is likely already in place and no migration is needed. For WooCommerce, a developer can implement JSON-LD templates in 4-8 hours depending on theme complexity. For custom or headless platforms, budget 1-2 days including testing.

Should I include JSON-LD for pages that are not product pages?

Yes. Implement JSON-LD on every page type: Organization on the homepage, BreadcrumbList on all pages, Article on blog posts, CollectionPage on category pages, and Product on product pages. AI agents build entity graphs across your entire site, and missing structured data on non-product pages weakens the overall graph.

Sources

Google Search Central, “Introduction to structured data markup in Google Search” - developers.google.com/search/docs/appearance/structured-data/intro-structured-data
w3techs, “Usage Statistics of JSON-LD for Websites, August 2026” - w3techs.com/technologies/details/da-jsonld
Schema.org, “Data Model” - schema.org/docs/datamodel.html (founded by Google, Microsoft, Yahoo, and Yandex; based on RDF Schema)
Google Search Central case studies: Rotten Tomatoes (+25% CTR), Food Network (+35% visits), Nestlé (+82% CTR), Rakuten (1.5x time on page) - cited in Google structured data introduction
Schema.org Developers documentation - schema.org/docs/developers.html

Check your store agent discoverability score free at shopti.ai.

The Three Structured Data Formats Explained#

JSON-LD (JavaScript Object Notation for Linked Data)#

Microdata#

RDFa#

Why AI Shopping Agents Prefer JSON-LD#

1. Single-Pass Parsing vs DOM Traversal#

2. Data Completeness in One Block#

3. No Coupling to Visual Markup#

4. Multi-Entity Support Without Page Restructuring#

Adoption Data: Where Ecommerce Stands#

The AI Agent Parsing Problem#

Migration Guide: Moving from Microdata or RDFa to JSON-LD#

Step 1: Audit Your Current Structured Data#

Step 2: Build Your JSON-LD Templates#

Step 3: Implement Server-Side JSON-LD Generation#

Step 4: Validate Before Deploying#

Step 5: Remove Old Microdata/RDFa Gradually#

Common Mistakes That Break JSON-LD for AI Agents#

Mixed Formats on the Same Page#

JavaScript-Injected JSON-LD#

Incomplete Nested Entities#

Duplicate Conflicting Data#

Using http:// Instead of https:// in @context#

Platform-Specific JSON-LD Status#

The Business Case for JSON-LD Migration#

FAQ#

Does Google penalize Microdata or RDFa?#

Can I use JSON-LD and Microdata together?#

Do AI agents like ChatGPT and Perplexity actually read structured data?#

How long does a JSON-LD migration take?#

Should I include JSON-LD for pages that are not product pages?#

Sources#