JSON-LD

TL;DR — JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. is a small block of code you add to a page to spell out what the page is about — that it’s an article, a product, a recipe — in a format search engines and AI systems read easily. It sits in its own <script> tag and never changes anything visitors see. Google recommends it over the other two formats because it’s the easiest to add and keep tidy. It won’t make you rank higher, but it can make your results look richer (stars, prices, FAQs).

What JSON-LD is

When you publish a page, a human can read it and figure out “oh, this is a recipe for banana bread.” A search engine has to guess that from the words. Structured data is how you stop the guessing — you label the page in machine-readable code so engines know it’s a recipe, who the author is, what the rating is.

JSON-LD is the most popular way to write that label. The name stands for JavaScript Object Notation for Linked Data. Evidence for this claim JSON-LD is a structured-data format that can express Schema.org types and properties in a script block. Scope: Schema.org JSON-LD guidance; JSON-LD is a format, not the vocabulary itself. Confidence: high · Verified: 2026-07-14 Schema.org: JSON-LD You don’t need to know what that means to use it. In practice, JSON-LD is a chunk of code that looks like a list of labelled facts, tucked inside a <script> tag:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Bake Banana Bread",
  "author": { "@type": "Person", "name": "Patrick Stox" },
  "datePublished": "2026-06-26"
}
</script>

The key thing: that block lives separately from the words on your page. It doesn’t change a single thing your visitors see. It’s just instructions for the robots.

Why Google likes it

There are actually three ways to write structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. — JSON-LD, Microdata, and RDFa. The other two work by sprinkling extra code into your visible HTML, tangled up with your headings and paragraphs. JSON-LD keeps it all in one neat box.

That’s why Google recommends JSON-LD: it’s the easiest to add, the easiest to keep correct, and you’re far less likely to break something. Google’s words: it’s “the easiest solution for website owners to implement and maintain at scale.” All three formats are fine — JSON-LD is just the least error-prone.

What it actually does for you

Two honest things, and one myth:

• It can make your search result look richer. Recipe ratings, product prices, FAQ dropdowns, event dates — those “rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show.” come from structured data.
• It helps engines (and AI) understand your content. It connects your page to known things — your business, an author, a product.
• It does not make you rank higher. This is the myth. Adding JSON-LD is not a ranking boost. Google has said this plainly and repeatedly.

The one rule that matters

Only mark up what’s actually on the page. Don’t claim a 5-star rating in your JSON-LD if no rating is shown to visitors. Don’t describe a price that isn’t there. Structured data has to match the visible page — describing things that aren’t there is against the rules and can get your rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. pulled.

Want the precise version — the @context / @type / @id syntax, the @graph pattern, the JavaScript-injection trap that hides your markup from AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls., and how to validate it? Switch to the Advanced tab.

TL;DR — JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. (JavaScript Object Notation for Linked Data) is a W3C Recommendation from 2014 — built on JSON, but @context is what makes it linked data, not just JSON. It’s the structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. format Google recommends because it’s the easiest to implement and maintain at scale and never touches visible HTML; Microdata and RDFa are equally valid when correct. The syntax spine is @context (vocabulary — schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. for most SEO markup, though the spec allows other contexts), @type (entity), @id (a useful but optional stable URI for cross-referencing entities — the basis of @graph, itself one valid pattern among others, not a requirement). Place it in <head> or <body> — Google accepts either. GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer. renders JS so dynamically injected JSON-LD works for Google; several AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. (GPTBot, ClaudeBot included, as tested) don’t execute JS, but that’s provider- and date-specific — verify directly rather than assuming it for every AI crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index., and server-render what you can’t confirm. Structured data is not a ranking signal — it drives rich-result eligibility and entity understanding, and it must describe content visible on the page.

JSON-LD is a format, not a vocabulary

First, a distinction that clears up a lot of confusion: JSON-LD is the format; schema.org is the vocabulary. JSON-LD is how you write the markup; schema.org’s Article, Product, Organization types are what you say. Rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. are the feature layer on top of both. This page is about the format. (The vocabulary-for-AI angle lives in Schema Markup for AISchema markup (structured data) is machine-readable code — usually JSON-LD — that labels what your content means using the schema.org vocabulary. For AI search it's infrastructure for entity disambiguation, not a direct citation lever: controlled studies found no meaningful uplift in AI citations from adding it..)

JSON-LD is a W3C Recommendation, first published in 2014 — it predates its SEO adoption and was designed for general linked-data interoperability across the web, not specifically for search. That history is why a property like @id exists at all, and it’s the spec-level point most SEO guides skip: JSON-LD is not just JSON. It’s built on JSON syntax, but the @context declaration is what makes the data linked — identifiable and connectable across the web. Strip @context and you’ve got data a parser can’t interpret.

JSON-LD also isn’t married to schema.org. The spec lets @context reference any published vocabulary — its own examples link to non-schema.org contexts — so JSON-LD is the right answer to “what format” while schema.org is one answer, the common one for search and AI-search markup, to “what vocabulary.” A page could validly use JSON-LD with a different vocabulary; it just wouldn’t be schema.org markup anymore.

JSON-LD vs. Microdata vs. RDFa

There are three ways to express structured data, and Google supports all of them:

Google’s recommendation is explicit but narrowly scoped: “In general, Google recommends using JSON-LD for structured data if your site’s setup allows it, as it’s the easiest solution for website owners to implement and maintain at scale (in other words, less prone to user errors).”

The nuance competitors usually drop — and the one worth keeping — comes from the same Google page: “All 3 formats are equally fine for Google, as long as the markup is valid and properly implemented per the feature’s documentation.” So the recommendation is about implementation ease and error rate, not parsing speed or ranking advantage. Using Microdata is not a penalty. JSON-LD just wins in practice because it doesn’t entangle structured data with the markup a designer might edit tomorrow.

The syntax: @context, @type, @id, properties, nesting

Here’s an annotated Article block:

<script type="application/ld+json">
{
  "@context": "https://schema.org",          // the vocabulary — the common value for SEO
  "@type": "Article",                          // the entity type
  "@id": "https://example.com/post#article",   // a stable URI for this entity
  "headline": "How JSON-LD Works",            // a property (key/value)
  "datePublished": "2026-06-26",
  "author": {                                  // a nested entity
    "@type": "Person",
    "name": "Patrick Stox",
    "url": "https://patrickstox.com/"
  }
}
</script>

• @context — establishes the semantic framework (the vocabulary). For schema.org SEO markup it’s typically "https://schema.org", but that’s a convention, not a rule: @context maps terms to identifiers, and the spec lets it point to other vocabularies. It tells the parser how to interpret every property name that follows. This is the part that makes it linked data.
• @type — declares the entity: Article, Product, Organization, BreadcrumbList, etc. It maps to a schema.org type. Use the most specific applicable type — NewsArticle over Article if it fits.
• @id — a unique URI identifying the resource. It’s the mechanism that lets you reference one entity from another (see @graph below), and it’s worth setting on anything you’ll cross-reference — but it’s not universally required. The JSON-LD spec permits unidentified blank nodes, so valid JSON-LD can omit @id on entities you never need to reference elsewhere.
• Properties — ordinary JSON key/value pairs, using vocabulary terms from the @context.
• Nesting — child entities are expressed as nested JSON objects (the author object above) or arrays of objects.

The @graph pattern (the scalable approach)

Most pages need more than one entity: an Organization, a WebSite, a BreadcrumbList, and the Article or WebPage itself. The naive approach is four separate <script> blocks that repeat data. A scalable alternative is a single block with @graph — an array of entities, cross-referenced by @id. Neither the JSON-LD spec nor Google mandates @graph as the pattern — it’s syntax for expressing a graph, and other valid layouts exist (separate typed blocks, nested objects without a top-level @graph, blank nodes with no @id at all) — but on a site with several cross-referenced entities, it’s the pattern that avoids repeating the same Organization or WebSite data on every page:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#org",
      "name": "Example Co",
      "url": "https://example.com/"
    },
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "url": "https://example.com/",
      "publisher": { "@id": "https://example.com/#org" }   // reference, not a copy
    },
    {
      "@type": "WebPage",
      "@id": "https://example.com/post#webpage",
      "isPartOf": { "@id": "https://example.com/#website" },
      "breadcrumb": { "@id": "https://example.com/post#breadcrumb" }
    }
  ]
}
</script>

Define Organization once, then point at it with { "@id": "...#org" } everywhere else instead of repeating the name, logo, and URL. This is how the major CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. schema plugins build their output, and it’s why @id exists. Bing makes the same case for JSON-LD’s nesting: it “makes defining links and relationships between data and entities… easy because it supports nested data.”

Where to place it: <head> or <body>

Google confirms both work — “You can put the JSON-LD data in the <head> or the <body> of the page.” <head> is conventional, but plenty of CMS plugins inject it near the end of <body>, and that’s fine. Bing agrees it can sit “in the header, body or foot of the page.” Don’t burn time relocating a valid block from body to head; it changes nothing. Evidence for this claim Google permits JSON-LD in either the head or body of an HTML document for supported structured-data features. Scope: Google Search JSON-LD guidance; markup must still match visible page content. Confidence: high · Verified: 2026-07-14 Google: Structured data introduction

Generating JSON-LD dynamically — and the AI crawler catch

You can build JSON-LD on the fly with JavaScript, and Google documents two ways to do it:

1. Google Tag Manager — a Custom HTML tag containing the JSON-LD, pulling values from GTM variables. (Avoid duplicating data between the page and the tag.)
2. Custom JavaScript — create the script element programmatically:

   const script = document.createElement('script');
   script.setAttribute('type', 'application/ld+json');
   script.textContent = structuredDataText;
   document.head.appendChild(script);

This works for GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer., because Google renders the page: “Google Search can understand and process structured data that’s available in the DOM when it renders the page.” So far, so good.

Here’s the catch most guides miss, stated carefully. Several AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. — including GPTBot and ClaudeBot, as commonly tested — have not executed JavaScript. If your JSON-LD only exists after a client-side script runs, a JS-skipping crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. never sees it — it’s invisible to that bot even though Googlebot reads it fine, because Google documents renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. the DOM before it looks for structured data.

Two honest caveats on that AI-crawler behavior: it’s Google’s own documentation that establishes the Googlebot side; the AI-crawler side comes from testing and reporting on individual providers, not a spec any of them publish, so it’s provider- and date-specific — a crawler’s JavaScript support can change, and I haven’t verified every provider directly. Don’t treat “AI crawlers skip JS” as a universal rule to build on; treat it as a reason to check the crawler you actually care about (or default to server renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. when you can’t check). If it isn’t in the server-rendered HTML and you haven’t confirmed the crawler executes JS, assume it can’t see it. For AI-search visibility, render JSON-LD server-side into the static HTML unless you’ve verified otherwise. (This is the JavaScript-rendering problem from a structured-data angle — see JavaScript SEOMaking sure search engines can crawl, render, and index content that depends on JavaScript..)

There’s a second caveat for ecommerce: Google warns that dynamically generated Product markup “can make Shopping crawls less frequent and less reliable,” which is a real problem for fast-changing price and availability. For products, prefer server-side rendering regardless of AI.

The policies (these have teeth now)

Google’s structured data guidelines are short and load-bearing:

• “Don’t mark up content that is not visible to readers of the page.”
• “Don’t mark up irrelevant or misleading content, such as fake reviews.”
• “Put the structured data on the page that it describes.”
• “Use the most specific applicable type and property names defined by schema.org.”
• Don’t block your structured-data pages from Googlebot via robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. or noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed..

The visible-content rule is the one to internalize. Schema that describes content not shown on the page has always been a violation; enforcement of “invisible” schema has tightened. Bing puts the warning bluntly: “even though the markup is not visible on your page, it is still read by the search engines, and putting spam data in the markup can hamper your presence.”

Common JSON-LD mistakes

• Markup that doesn’t match the visible page — the #1 policy problem (a rating in the JSON-LD that no visitor sees).
• Malformed JSON — a trailing comma, an unescaped quote, or Word smart quotes (" instead of ") that silently break the whole block. JSON-LD is strict.
• Wrong property names — inventing properties that aren’t in schema.org, or misspelling real ones, so the parser ignores them.
• A generic type where a specific one exists — Thing or Article where Recipe or NewsArticle was warranted.
• Duplicate, inconsistent Organization blocks across pages with conflicting names/logos.
• Missing required properties for the rich result you’re targeting (each feature lists its own required fields).
• JS-injected markup assumed to be visible to every crawler — Google renders it, but some AI crawlers have not, and that’s worth verifying per crawler (the catch above).

Validating JSON-LD

Four different questions get asked under “is my JSON-LD valid,” and they’re not the same question — passing one doesn’t pass the others:

• Test by URL, not pasted code, for JS-rendered pages. The Rich Results Test’s code-input mode doesn’t run your scripts or resolve relative references the way live-URL testing does — it can’t tell you what a client-side-injected block looks like after rendering.
• Bing Webmaster Tools — Markup Validator — Bing has validated JSON-LD since August 2018.
• None of these tests speak for crawlers that don’t render JavaScript (see the AI-crawler caveat above) — testing the rendered URL confirms what Google sees, not what a JS-skipping bot receives.

Does JSON-LD help SEO?

Set expectations honestly:

• Not a ranking signal. John Mueller has said structured data won’t make a site rank better. Full stop.
• Rich-result eligibility. It’s what makes you eligible for enhanced SERP features (stars, prices, FAQs, breadcrumbsBreadcrumbs are a secondary navigation trail (Home > Category > Page) that shows where a page sits in a site's hierarchy. They create internal links that pass PageRank, and when marked up with BreadcrumbList structured data they can drive the path Google shows in desktop search results.) — eligibility, not a guarantee.
• CTR, indirectly. Richer-looking results can earn more clicks, which is the real payoff for most sites.
• Entity understanding. It helps engines connect your page to known entities and the Knowledge GraphThe Knowledge Graph is Google's database of entities — people, places, organizations, and things — and the factual relationships between them. It's separate from any single website's structured data: your schema markup is one of many possible inputs to the graph, not the graph itself..
• AI searchAI search uses large language models and retrieval-augmented generation (RAG) to synthesize an answer from multiple sources rather than returning a ranked list of links. Examples include Google AI Overviews, ChatGPT Search, and Perplexity.. Fabrice Canel (Bing) confirmed in 2025 that schema markupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. helps Microsoft’s LLMs understand content — but note the controlled-study caveat from Schema Markup for AISchema markup (structured data) is machine-readable code — usually JSON-LD — that labels what your content means using the schema.org vocabulary. For AI search it's infrastructure for entity disambiguation, not a direct citation lever: controlled studies found no meaningful uplift in AI citations from adding it.: it’s infrastructure for disambiguation, not a direct citation lever.

So: implement JSON-LD for rich-result eligibility, entity clarity, and AI/LLM comprehension — not as a ranking hack.

This article sits in the structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. hub. For the AI-specific take on the schema.org vocabulary, see Schema Markup for AISchema markup (structured data) is machine-readable code — usually JSON-LD — that labels what your content means using the schema.org vocabulary. For AI search it's infrastructure for entity disambiguation, not a direct citation lever: controlled studies found no meaningful uplift in AI citations from adding it.; for the rendering mechanics behind dynamic injection, see JavaScript SEOMaking sure search engines can crawl, render, and index content that depends on JavaScript..

AI summary

A condensed take on the Advanced version:

• What it is: JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. (JavaScript Object Notation for Linked Data) is a structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. format, not a vocabulary — a <script type="application/ld+json"> block. On the SEO side it’s typically paired with the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. vocabulary, but @context can point elsewhere. A W3C Recommendation since 2014; built on JSON, but @context is what makes it linked data, not plain JSON.
• Why Google recommends it: it’s “the easiest solution… to implement and maintain at scale” and never touches visible HTML. But all three formats (JSON-LD, Microdata, RDFa) are equally valid when correct — the edge is error rate, not parsing or ranking.
• Syntax spine: @context (vocabulary — schema.org for most SEO markup, not the only valid value) · @type (entity, use the most specific) · @id (useful, optional stable URI for cross-referencing; unidentified blank nodes are also valid JSON-LD) · properties (key/value) · nesting (objects/arrays).
• @graph pattern: one block, an array of entities cross-referenced by @id — define Organization once, reference it everywhere. A scalable approach for multi-entity pages, not a spec or Google mandate; other valid graph layouts exist.
• Placement: <head> or <body> — Google accepts either; don’t relocate valid blocks.
• Dynamic injection + AI caveat: GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer. renders JS so injected JSON-LD works for Google; several AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. — GPTBot and ClaudeBot included, as tested — have not executed JS, but that’s provider- and date-specific, not a universal rule, so verify per crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. and server-render what you can’t confirm. Dynamic Product markup also risks less-frequent Shopping crawls.
• Policies: mark up only visible content; match the page; most-specific type; don’t block the page from crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index.. Enforcement of “invisible” schema has tightened.
• Common mistakes: mismatched/invisible markup, malformed JSON (smart quotes, trailing commas), wrong property names, generic types, missing required properties.
• Validation: four separate checks (JSON syntax, schema.org vocabulary, Google rich-result eligibility, live Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. parsing) that don’t substitute for each other — Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test (by URL, not pasted code), Schema.org Validator, GSC Enhancements, Bing Markup Validator.
• SEO effect: not a ranking signal. Drives rich-result eligibility, CTR, entity understanding, and LLMA large language model (LLM) is a deep-learning model trained on massive text corpora to predict the next token and generate human-like text. LLMs use the transformer architecture and power AI search features like Google's AI Overviews (Gemini) and Bing Copilot (GPT-4). comprehension (Canel, Bing, 2025).

Official documentation

Primary-source documentation from the search engines and the spec.

Google

• Intro to How Structured Data Markup Works — the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. recommendation, the “all 3 formats are equally fine” nuance, and <head>/<body> placement.
• General Structured Data Guidelines — the policies: visible content only, match the page, most-specific type, don’t block crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index..
• Generate structured data with JavaScript — the GTM and custom-JS injection approaches, plus the dynamic-Product Shopping-crawl caveat.
• Rich Results Test — validate eligibility (test by URL for JS-rendered pages).

Bing / Microsoft

• Marking Up Your Site with Structured Data — Bing recommends JSON-LD, accepts header/body/footer placement, and warns about invalid markup.
• Introducing JSON-LD Support in Bing Webmaster Tools (Aug 2018) — when Bing added JSON-LD validation.

Standards / vocabulary

• JSON-LD 1.1 — W3C Recommendation — the spec itself.
• json-ld.org — the format’s home, with the plain-language definition.
• Getting Started with Schema.org — the vocabulary JSON-LD expresses, and the visible-content rule.
• Schema.org Validator — validates against the vocabulary.

Quotes from the source

On-the-record statements from Google, Bing, and the spec. Each link jumps to the quoted passage on the source page where the page exposes the text.

Google docs — the recommendation and the nuance

• “In general, Google recommends using JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. for structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. if your site’s setup allows it, as it’s the easiest solution for website owners to implement and maintain at scale (in other words, less prone to user errors).” Jump to quote
• “All 3 formats are equally fine for Google, as long as the markup is valid and properly implemented per the feature’s documentation.” Jump to quote
• “Google Search can understand and process structured data that’s available in the DOM when it renders the page.” Jump to quote

Google docs — the policies

• “Don’t mark up content that is not visible to readers of the page.” Jump to quote
• “Use the most specific applicable type and property names defined by schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor..” Jump to quote

John Mueller, Google — JSON-LD preference and ranking

• “We currently prefer JSON-LD markup. I think most of the new structured data that kind of come out are for JSON-LD first. So that is what we prefer.” — Google Webmaster Hangout, March 2019. Coverage
• On rankings: “Structured data won’t make your site rank better.” — 2025. (Relayed via Search Engine Roundtable; confirm verbatim against the original post.) Coverage

Bing / Microsoft

• JSON-LD “makes defining links and relationships between data and entities between the data present on your pages easy because it supports nested data.” — Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility. docs. Jump to quote
• “Webmasters should be very alert as to not put invalid and incorrect information in the markup, as even though the markup is not visible on your page, it is still read by the search engines.” — Bing Webmaster ToolsThe free, first-party consoles search engines give site owners — Google Search Console and Bing Webmaster Tools — to see how their pages are crawled, indexed, and ranked, and to fix problems. The legacy name is 'webmaster tools.' docs. Jump to quote

Fabrice Canel, Microsoft Bing — schema and LLMsA large language model (LLM) is a deep-learning model trained on massive text corpora to predict the next token and generate human-like text. LLMs use the transformer architecture and power AI search features like Google's AI Overviews (Gemini) and Bing Copilot (GPT-4).

• At SMX Munich (March 2025), Canel confirmed schema markupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. helps Microsoft’s large language models understand web content. (Paraphrased across coverage; confirm verbatim against the conference recording or LinkedIn before treating any single phrasing as final.) Coverage

The spec — json-ld.org

• “JSON-LD is a lightweight Linked Data format. It is easy for humans to read and write. It is based on the already successful JSON format and provides a way to help JSON data interoperate at Web-scale.” Jump to quote

JSON-LD syntax — quick reference

The wrapper

<script type="application/ld+json">
{ ...your markup... }
</script>

The reserved keywords

Single entity

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Widget",
  "offers": { "@type": "Offer", "price": "19.99", "priceCurrency": "USD" }
}

Nesting — a child entity is a nested object (or an array of objects):

"author": { "@type": "Person", "name": "Patrick Stox" }

The @graph pattern — define once, reference by @id:

{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "Organization", "@id": "https://ex.com/#org", "name": "Ex Co" },
    { "@type": "WebSite", "publisher": { "@id": "https://ex.com/#org" } }
  ]
}

Common properties by type

• Article / BlogPosting: headline, author, datePublished, image, publisher
• Product: name, image, brand, offers (→ price, priceCurrency, availability)
• Organization: name, url, logo, sameAs (social/Wikidata URIs)
• BreadcrumbList: itemListElement → ListItem (position, name, item)
• FAQPage: mainEntity → Question → acceptedAnswer → Answer

Rules of thumb

• @context is "https://schema.org" for most SEO markup — that’s a convention, not a spec requirement. Use straight quotes, never smart quotes.
• No trailing commas — JSON is strict.
• Use the most specific @type available.
• Mark up only what’s visible on the page.
• Place in <head> or <body> — both valid.
• @id and @graph help you cross-reference and organize entities but aren’t required — blank nodes and other layouts are valid too.
• For crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. you haven’t verified execute JavaScript (several AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls., GPTBot and ClaudeBot included, have not in testing), render server-side.
• Validate as separate layers: Rich Results Test (by URL) for Google eligibility + Schema.org Validator for vocabulary — one passing doesn’t mean the other does.

Tools for validating JSON-LD

• Schema.org Validator — the broader vocabulary check. A block can pass here and still fail Google’s feature-specific rules.
• Google Rich Results Test — test the deployed URL when renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. matters, especially for client-side-injected markup. This test covers Google’s supported rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show., not every schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. type.

JSON-LD mistakes to avoid

Marking up facts visitors cannot see. A rating, price, author, or other claim in JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. must agree with the visible page. Hidden or misleading structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. can cost the page its rich-result eligibility. Do instead: generate markup from the same source of truth as the visible content.

Treating valid JSON as valid schema. A parser can accept perfectly formed JSON whose property names do not exist in schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor.. Do instead: run both a JSON-LD vocabulary check and the target feature’s Google requirements.

Using smart quotes or trailing commas. JSON is strict; typographic quotes and a comma after the final property can invalidate the entire block. Do instead: serialize the data rather than assembling JSON strings by hand.

Choosing a generic type when a specific one exists. Thing or broad Article markup throws away useful meaning when the page is clearly a Recipe, Product, or NewsArticle. Do instead: use the most specific applicable schema.org type.

Duplicating entities with conflicting details. Multiple Organization blocks with different names, logos, or URLs make the graph ambiguous. Do instead: give the entity one stable @id, define it once, and reference that identifier elsewhere.

Assuming schema.org validity guarantees a Google rich result. Google supports a subset of types and adds required properties and content policies of its own. Do instead: validate vocabulary first, then test eligibility for the specific Google feature.

Injecting JSON-LD in JavaScript and assuming every crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. sees it. Google can render client-side markup, but JS-skipping AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. may never receive it. Do instead: server-render JSON-LD when those consumers matter, and test the live URL rather than only pasted code.

Prove a JSON-LD deployment took effect

Test 1 — The live page contains valid, page-matching JSON-LD

• Test to run — Fetch the deployed URL with the Schema Markup Validator and compare the detected entities and values with the visible page.
• Expected result — The JSON parses, all properties belong to schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., @id references resolve within the graph where intended, and claims such as names, prices, ratings, and dates match what users see.
• Failure interpretation — Parser errors point to malformed JSON; vocabulary warnings point to misspelled or unsupported properties; mismatched values point to separate content and schema data sources drifting apart.
• Monitoring window — Immediate after deployment and cache clearance.
• Rollback trigger — Remove or revert the new block if it publishes false visible-content claims, breaks a previously valid graph, or cannot be parsed.

Test 2 — The target search feature recognizes the rendered markup

• Test to run — Run the deployed URL through Google’s Rich Results Test, then use the Rich-Result Eligibility Checker to inspect missing required and recommended fields by type.
• Expected result — Google detects the intended supported type without critical errors; any client-side-generated block appears in the rendered HTML.
• Failure interpretation — A Schema.org Validator pass paired with a Google failure usually means the type is not a supported Google feature, a Google-required field is missing, a content policy is unmet, or the renderer never received the block.
• Monitoring window — Immediate in both tests; Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. changes wait for a recrawlCrawl frequency is how often a search engine comes back to re-fetch a page it already knows about. Popular pages that change often get refreshed many times a day; stable pages can go weeks or months between crawls — and you influence it indirectly, not by setting a dial..
• Rollback trigger — Roll back client-side injection if it makes previously visible structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. disappear from the rendered result, or remove unsupported feature claims from the launch until the required content is present.

Test yourself: JSON-LD

Five quick questions on the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. format. Pick an answer for each, then check.

Resources worth your time

My related writing

• Schema Markup: The Easy Way to Get Rich Results — the Ahrefs guide to structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., schema typesSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., and rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. (the feature layer on top of JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.).
• The Beginner’s Guide to Technical SEO — where structured data fits in the broader technical picture.
• JavaScript SEO Issues & Best Practices — the renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. side: why JS-injected markup behaves differently for crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. that don’t run JavaScript.
• Meet the New Web Crawlers — my Cloudflare Radar analysis of AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. (GPTBot, ClaudeBot and friends) — the bots that skip your JS-injected schema.

Official

• Google’s Intro to How Structured Data Markup Works — the JSON-LD recommendation and the “all 3 formats” nuance, straight from the source.
• Google’s Generate structured data with JavaScript — the dynamic-injection methods and the Product caveat.
• JSON-LD 1.1 — W3C Recommendation and json-ld.org — the format itself.

From around the industry

• Google On Which Structured Data It Prefers — Search Engine Journal — the write-up of Mueller’s “we currently prefer JSON-LD” comment.
• Microsoft Bing Copilot uses schema for its LLMs — Search Engine Land — Fabrice Canel’s SMX Munich 2025 confirmation that schema helps Bing’s LLMsA large language model (LLM) is a deep-learning model trained on massive text corpora to predict the next token and generate human-like text. LLMs use the transformer architecture and power AI search features like Google's AI Overviews (Gemini) and Bing Copilot (GPT-4)..
• What Is JSON-LD Structured Data & Why Do You Need It? — Ignite Visibility — a solid beginner-level walkthrough.
• A Beginner’s Guide to JSON-LD Schema for SEOs — SALT.agency — practical syntax-and-implementation guide aimed at SEOs.

JSON-LD

JSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.

Related: Structured Data, Schema Markup for AI, JavaScript SEO

JSON-LD

JSON-LD (JavaScript Object Notation for Linked Data) is a lightweight format for encoding structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. inside a <script type="application/ld+json"> tag on a web page. It uses the schema.org vocabulary to describe entities — articles, products, organizations, events, and more — in a way search engines and AI systems can parse without ambiguity. It’s a W3C Recommendation (first published 2014), built on plain JSON but adding a semantic layer (@context, @type, @id) that turns ordinary data into linked data.

Unlike Microdata and RDFa, which embed markup attributes directly into your visible HTML elements, JSON-LD lives in a separate script block and never touches the page’s visible markup. That separation is the core reason Google recommends it: “In general, Google recommends using JSON-LD for structured data if your site’s setup allows it, as it’s the easiest solution for website owners to implement and maintain at scale.” All three formats are equally valid to Google when correctly implemented — the recommendation is about ease and a lower error rate, not a parsing or ranking advantage.

JSON-LD is the format; schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. is one vocabulary it can carry — @context can point elsewhere, but schema.org is the common choice for search and AI-search markup.

Three things worth keeping straight:

• @context and @type are the spine. @context (typically "https://schema.org" for SEO markup, though the spec allows other values) tells the parser which vocabulary you’re using; @type declares the entity (e.g. Article, Product, Organization). @id gives an entity a stable URI so it can be referenced — useful, but not required (unidentified blank nodes are valid JSON-LD) — and it’s the basis of the @graph pattern that connects multiple entities in one block. @graph itself is a scalable option for multi-entity pages, not a spec or Google requirement.
• Structured data isn’t a ranking signal. It governs rich-result eligibility and helps engines understand entities; it doesn’t lift positions. The markup must also describe content that’s actually visible on the page.
• Dynamically injected JSON-LD has an AI-crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. catch. GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer. renders JavaScript, so JS-injected JSON-LD works for Google. Several AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. — including GPTBot and ClaudeBot, as commonly tested — have not executed JavaScript, but that’s provider- and date-specific rather than a guaranteed rule; verify the crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. you care about and render server-side for AI visibilityLLM visibility (or AI visibility) is the aggregate measure of how often and how prominently a brand or page shows up in AI-generated answers — across AI Overviews, ChatGPT, Perplexity, Copilot, and Gemini. It's the AI-search analog of organic visibility, but it's driven by different signals. when you can’t confirm otherwise.

Related: Structured Data, Schema Markup for AI, JavaScript SEO

Changelog