JSON-LD vs Microdata vs RDFa: Which Structured Data Format Google Prefers in 2026

Key Takeaways

• Google's official preference is JSON-LD — it is explicitly called out as the recommended format in Google's developer documentation for all structured data.
• JSON-LD lives in a separate <script> tag — not interleaved with HTML — making it easier to write, test, and maintain without touching layout code.
• Only JSON-LD works reliably with JavaScript-rendered pages — for Next.js, React, Vue, and Angular applications, Microdata and RDFa are unreliable because they require HTML elements to be present at crawl time.
• Microdata is legacy — widely used in older WordPress themes and CMS templates from pre-2015 but rarely implemented in new projects today.
• RDFa is not a practical SEO choice in 2026 — Google processes it but it offers no advantages over JSON-LD and significant implementation complexity.

---

If you've looked at two different technical SEO guides and found conflicting advice on how to add structured data, the root cause is almost always the format question. One guide shows JSON-LD in a <script> tag. Another shows itemscope and itemprop attributes on HTML elements. A third mentions something called RDFa. All three accomplish roughly the same thing — but they are not equally supported, not equally easy to implement, and not equally reliable with modern JavaScript frameworks.

This guide explains what each format is, shows the same Article schema implemented in all three, and explains exactly why JSON-LD is the right choice for any new implementation in 2026.

---

The Three Structured Data Formats

JSON-LD

JSON-LD (JavaScript Object Notation for Linked Data) is a method of encoding structured data as a standalone JSON object inside a <script type="application/ld+json"> tag. The schema data is completely separate from the HTML content of the page — it doesn't touch any visible elements, doesn't require any changes to your HTML structure, and can be added or modified without affecting the layout.

The format was developed by the W3C and adopted by schema.org. Google began supporting it in 2013 and made it the recommended format by 2016. In 2026, it remains the only format Google actively recommends in its structured data documentation.

Microdata

Microdata is a specification from the WHATWG that encodes structured data as HTML attributes directly on visible page elements. Properties are marked using itemscope (to open a schema entity), itemtype (to specify the schema.org type), and itemprop (to mark individual properties). The schema data lives inside the HTML DOM — tangled with your layout, your component structure, and your CSS classes.

Microdata was widely adopted between 2011 and 2015 when it was the primary format supported by schema.org and Google. Most older WordPress themes and many legacy CMSes still generate Microdata. For new implementations, there is no reason to use it.

RDFa

RDFa (Resource Description Framework in Attributes) is a W3C standard that, like Microdata, uses HTML attributes to encode structured data. RDFa is more expressive than Microdata — it can represent complex linked data relationships that Microdata cannot — but that expressiveness comes with significant complexity that is rarely needed for SEO purposes.

RDFa is still used in academic publishing, government linked data systems, and some enterprise knowledge graph applications. For general web SEO in 2026, it is effectively unused in new implementations.

---

The Same Article Schema in All Three Formats

To make the format differences concrete, here is the same Article schema implemented in all three ways. The article being marked up: a blog post titled "How ChatGPT Browse Discovers and Ranks Pages" by Priya Sharma, published 25 March 2026.

JSON-LD

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How ChatGPT Browse Discovers and Ranks Pages",
  "author": {
    "@type": "Person",
    "name": "Priya Sharma",
    "url": "https://seo.yatna.ai/about/priya-sharma"
  },
  "datePublished": "2026-03-25T08:00:00",
  "dateModified": "2026-03-25T08:00:00",
  "publisher": {
    "@type": "Organization",
    "name": "seo.yatna.ai",
    "logo": {
      "@type": "ImageObject",
      "url": "https://seo.yatna.ai/logo.png"
    }
  },
  "image": "https://seo.yatna.ai/blog/images/2026/03/chatgpt-browse-seo-optimization.webp",
  "description": "ChatGPT Browse uses two separate bots — GPTBot for training and ChatGPT-User for real-time browsing. Here's how to optimise for both and get cited in live answers."
}
</script>

The JSON-LD is placed anywhere in the <head> or <body> of the page. It has zero dependencies on the surrounding HTML structure.

Microdata

<article
  itemscope
  itemtype="https://schema.org/Article"
>
  <h1 itemprop="headline">
    How ChatGPT Browse Discovers and Ranks Pages
  </h1>

  <div
    itemprop="author"
    itemscope
    itemtype="https://schema.org/Person"
  >
    By <a itemprop="name" href="https://seo.yatna.ai/about/priya-sharma">Priya Sharma</a>
  </div>

  <time
    itemprop="datePublished"
    datetime="2026-03-25T08:00:00"
  >
    March 25, 2026
  </time>

  <meta
    itemprop="dateModified"
    content="2026-03-25T08:00:00"
  />

  <div
    itemprop="publisher"
    itemscope
    itemtype="https://schema.org/Organization"
  >
    <meta itemprop="name" content="seo.yatna.ai" />
    <div
      itemprop="logo"
      itemscope
      itemtype="https://schema.org/ImageObject"
    >
      <meta itemprop="url" content="https://seo.yatna.ai/logo.png" />
    </div>
  </div>

  <meta
    itemprop="description"
    content="ChatGPT Browse uses two separate bots — GPTBot for training and ChatGPT-User for real-time browsing."
  />

  <!-- article body content here -->
</article>

Notice what happened: the schema is now distributed across the entire HTML structure of the article. Every property requires either an itemprop attribute on a visible element or a hidden <meta> tag. Moving any HTML element — say, wrapping the <h1> in a different component — breaks the itemprop="headline" property silently.

RDFa

<article
  vocab="https://schema.org/"
  typeof="Article"
>
  <h1 property="headline">
    How ChatGPT Browse Discovers and Ranks Pages
  </h1>

  <div
    property="author"
    typeof="Person"
  >
    By <a property="name" href="https://seo.yatna.ai/about/priya-sharma">Priya Sharma</a>
  </div>

  <time
    property="datePublished"
    datetime="2026-03-25T08:00:00"
  >
    March 25, 2026
  </time>

  <meta
    property="dateModified"
    content="2026-03-25T08:00:00"
  />

  <div property="publisher" typeof="Organization">
    <meta property="name" content="seo.yatna.ai" />
    <div property="logo" typeof="ImageObject">
      <meta property="url" content="https://seo.yatna.ai/logo.png" />
    </div>
  </div>

  <meta
    property="description"
    content="ChatGPT Browse uses two separate bots — GPTBot for training and ChatGPT-User for real-time browsing."
  />

  <!-- article body content here -->
</article>

RDFa uses property and typeof attributes instead of Microdata's itemprop and itemtype. The result is structurally similar — schema data interleaved with HTML, dependent on the DOM structure, and prone to silent breakage during refactors.

---

Why JSON-LD Is the Only Practical Choice in 2026

Separation from HTML

The most important practical advantage of JSON-LD is that it is completely independent of the page's HTML structure. Add a new section, refactor a component, move the author attribution from above the title to below it, switch from a <div> wrapper to an <article> element — none of these changes touch your JSON-LD. With Microdata or RDFa, any of these changes can silently break your schema.

For teams that iterate frequently on page design — which describes most SaaS product marketing sites — this independence is significant. Schema validation failures from Microdata breakage often go undetected for months.

Compatibility With JavaScript-Rendered Pages

This is the critical technical distinction for modern web development. Google has documented that it processes JavaScript-rendered content, but this processing is asynchronous and delayed — Googlebot renders JavaScript pages in a second crawl wave that happens after the initial HTML-only crawl. Structured data that relies on DOM elements being present may not be available during the initial crawl.

JSON-LD in a <script> tag is present in the raw HTML response from the server — it doesn't require JavaScript execution or DOM rendering. For Next.js, React, Vue, and Angular applications that serve structured data via server-side rendering or static generation, JSON-LD in a <script> tag is guaranteed to be in the HTML response. Microdata and RDFa attributes on dynamically rendered elements may or may not be present, depending on whether Googlebot's JavaScript renderer processed them before the structured data parser ran.

For any modern JavaScript framework, JSON-LD is not a preference — it is the only format that reliably delivers structured data to Googlebot.

Ease of Testing

JSON-LD can be tested by pasting the raw JSON into Google's Rich Results Test without loading the page. You can validate schema objects in isolation, before they're deployed, without needing a live URL. With Microdata or RDFa, you must inspect the rendered page to test.

JSON-LD can also be validated programmatically in CI pipelines by parsing the JSON and checking it against schema.org type definitions — enabling schema regression testing that is practically impossible with inline-HTML formats.

AI Parser Compatibility

AI systems that process web pages — including ChatGPT Browse, Perplexity, and Google's AI Overviews — parse structured data to supplement their understanding of page content. JSON-LD, as a self-contained data object, is reliably parsed by these systems. Microdata and RDFa, which require DOM traversal to reconstruct the schema graph, are less consistently processed by AI crawlers whose parsing behaviour is less documented than Googlebot's.

---

When Microdata Still Appears

Microdata is still common in specific contexts:

Legacy WordPress themes: Many premium WordPress themes pre-2018 generate Microdata via their schema implementations. If you're running an older theme, it is almost certainly producing Microdata rather than JSON-LD. The solution is to use a schema plugin (Yoast SEO, Schema Pro, Rank Math) that outputs JSON-LD and disable the theme's built-in schema generation.

Older e-commerce platforms: Shopify's default theme schemas and some Magento/WooCommerce templates still generate Microdata for product schema. Platform-specific schema guides often address this.

CMS platforms with pre-built schema: Some hosted CMSes (Squarespace, older Wix templates) generate Microdata by default. Check the source of your pages if you are on a hosted platform.

In all of these cases, the Microdata is technically processed by Google — it is not broken per se. But if you are implementing new schema or augmenting existing schema on these platforms, add it as JSON-LD in a separate script block rather than extending the inline Microdata.

---

The Bottom Line

The format decision is settled:

Criterion	JSON-LD	Microdata	RDFa
Google's official recommendation	Yes	No	No
Works with JavaScript frameworks	Yes	Unreliable	Unreliable
Independent of HTML structure	Yes	No	No
Easy to test in isolation	Yes	No	No
Still used in new implementations	Yes	Rarely	Almost never

For any new schema implementation — on any platform, in any framework, for any schema type — use JSON-LD. The only reason to work with Microdata or RDFa is when you inherit a legacy system that already uses them and a migration is not immediately feasible.

---

Validate Your Structured Data Format

After implementing or migrating to JSON-LD, validate that your schema is correctly formed and being processed:

1. View the page source and verify the <script type="application/ld+json"> tag contains valid JSON
2. Test at search.google.com/test/rich-results to confirm the schema type is detected
3. Check Google Search Console's Rich Results status report for the property to see which pages have valid schema detected

For a full structured data audit that identifies format issues, missing properties, and schema-to-content mismatches across your entire site:

Run a free schema audit at seo.yatna.ai/tools/schema-validator

---

FAQ

Does it matter if I use JSON-LD in the <head> vs the <body>?

No — Google processes JSON-LD correctly regardless of whether it is in the <head> or <body>. Convention is to place it in the <head> for cleanliness, but placement does not affect whether the schema is parsed.

Can I mix JSON-LD with Microdata on the same page?

You can, but it is not recommended. If both formats describe the same entity, there is a risk of conflicting property values. If you are migrating from Microdata to JSON-LD, disable the Microdata before deploying the JSON-LD for the same schema type.

Google says it processes Microdata — does that mean it's fine to keep using it?

Google processing Microdata means it won't be ignored — it doesn't mean it's optimal. The JavaScript rendering limitation, the maintenance fragility, and the absence of Google's active recommendation all make Microdata a suboptimal choice for new work. For existing legacy Microdata, assess whether the migration cost is justified; for new implementations, always use JSON-LD.

Is JSON-LD a Google-specific format?

No — JSON-LD is a W3C standard and is the recommended format by schema.org itself. It is also processed by Bing, Pinterest, and most other search engines and platforms that consume structured data.