Google recommends JSON-LD as the preferred format for schema markup on all page types. JSON-LD (JavaScript Object Notation for Linked Data) is a structured data format that sits inside a <script> tag in a page's HTML, entirely separate from the visible content. Google's official developer documentation explicitly states that JSON-LD is the recommended implementation wherever possible, citing its ease of maintenance and compatibility with dynamic content injection.

This page answers the most common questions about Google's recommended schema markup format, how JSON-LD compares to alternatives, where it belongs in your HTML, and what happens when you deviate from Google's guidance.

Overview: Why Google Recommends JSON-LD

Structured data tells search engines and increasingly AI systems – what your content means, not just what it says. Google supports three schema markup formats: JSON-LD, Microdata, and RDFa. Of these, JSON-LD is the only one Google actively recommends. It is simpler to implement, easier to maintain, and does not require changes to a page's visible HTML.

The distinction matters practically. Microdata and RDFa embed schema attributes directly inside HTML elements, which means a developer must touch the template to add or update structured data. JSON-LD lives in a separate <script> block, so a content team or SEO can update schema without restructuring the page's markup. For SaaS teams, agencies managing multiple client sites, and ecommerce teams with thousands of product pages, that separation is a significant operational advantage.

Beyond ease of use, JSON-LD also performs better in dynamic environments. Google's crawler can process JSON-LD injected via JavaScript, which means structured data can be added programmatically – a capability particularly relevant for single-page applications and headless CMS architectures.

Schema markup, as a broader concept, is part of how both search engines and AI systems build their understanding of what a page is about. The relationship between structured data and content meaning is worth understanding before implementation, as it shapes which schema types apply to a given page.

What Exactly Is JSON-LD, and Why Does Google Prefer It?

JSON-LD (JavaScript Object Notation for Linked Data) is a method of encoding structured data as a JavaScript object embedded in a `

Google prefers JSON-LD because it decouples structured data from visual markup. With Microdata or RDFa, every schema attribute must be attached to a specific HTML element – a change to the schema often means a change to the template. JSON-LD has no such dependency. It can be written, updated, or removed without touching any other part of the page. Google's Search Central documentation describes this separation as the primary reason for the recommendation. For any organization managing schema at scale – agencies running dozens of client sites, ecommerce platforms with dynamic product catalogs, SaaS companies publishing high volumes of content – JSON-LD's separation from template code is the feature that makes structured data maintainable over time.

Does Google Support Other Schema Formats?

Yes. Google supports JSON-LD, Microdata, and RDFa, and all three can be used to implement schema.org vocabulary. However, Google's recommendation is explicitly in favor of JSON-LD. Microdata involves adding itemscope, itemtype, and itemprop attributes directly to HTML elements. RDFa uses similar in-element attributes with a different syntax. Both formats remain valid and parseable by Google, but neither is recommended for new implementations. Bing and other search engines also support these three formats, with similar preferences for JSON-LD in most contexts. In practice, Microdata and RDFa are most commonly encountered on legacy sites built before JSON-LD became Google's stated preference – sites migrating from older CMS platforms occasionally inherit structured data in these formats.

Where Should JSON-LD Be Placed in a Page's HTML?

Google's documentation recommends placing JSON-LD in the <head> section of the page, though the crawler can also process JSON-LD placed in the <body>. For predictable crawling behavior, the <head> is the correct placement. The <script> block should look like this:

<head>
 <script type="application/ld+json">
 {
 "@context": "https://schema.org",
 "@type": "Article",
 "headline": "Your Article Title",
 "author": {
 "@type": "Person",
 "name": "Author Name"
 }
 }
 </script>
</head>

Multiple JSON-LD blocks can appear on a single page. Google supports more than one <script type="application/ld+json"> tag per page, which allows different schema types – for example, an Article block and a FAQPage block – to coexist without merging them into a single object. Some CMS platforms automatically inject JSON-LD into the <head> via plugin settings, which is the cleanest option for non-technical teams.

Can JSON-LD Be Injected With JavaScript Instead of Hard-Coded in HTML?

Yes. Google's crawler processes JavaScript-rendered content, and JSON-LD injected dynamically via JavaScript is treated the same as JSON-LD hard-coded in HTML. This is one of the reasons JSON-LD suits single-page applications (SPAs) and headless CMS architectures better than Microdata or RDFa. However, dynamically injected structured data depends on Googlebot successfully rendering the JavaScript before indexing. For most standard implementations, Google renders JavaScript adequately. For critical schema – product markup, FAQ schema, organization schema – hard-coding the JSON-LD in the <head> at the server level removes any rendering dependency and ensures consistent parsing. The safest approach for production sites is server-side rendering of JSON-LD, with JavaScript injection reserved for cases where it cannot be avoided.

Does Using the Wrong Schema Format Result in a Google Penalty?

Using Microdata or RDFa instead of JSON-LD does not trigger a Google penalty. Google continues to parse and process all three formats. The consequence of using a non-recommended format is not a penalty; it is an operational one. Sites using Microdata or RDFa carry a higher maintenance burden, face more risk of errors during template changes, and find it harder to scale structured data across large content inventories. Penalties related to schema markup arise from a different cause: misuse of schema to claim rich result eligibility for content that does not qualify, or adding schema that misrepresents the page's actual content. These violations – not format choice – are what Google's quality guidelines address. A breakdown of what triggers a schema-related manual action clarifies the distinction between format errors and policy violations.

Does Google's Format Recommendation Apply to All Schema Types?

Yes. Google's preference for JSON-LD applies across all schema types: FAQ, Article, Product, Organization, LocalBusiness, HowTo, BreadcrumbList, and every other type in the schema.org vocabulary. The format recommendation is not type-specific. For schema types that are more complex – such as MedicalCondition, which involves nested properties like associatedAnatomy and possibleComplication – JSON-LD is especially practical because nested objects can be written cleanly without complicating the HTML structure. Healthcare organizations implementing structured data for clinical content benefit particularly from this, as a healthcare schema markup approach typically involves multiple nested types that would become difficult to maintain in Microdata. For SaaS products and ecommerce sites, the schema types relevant to software and product pages are also best expressed in JSON-LD for the same reasons.

How Do CMS Plugins Handle JSON-LD?

Most major CMS platforms generate JSON-LD automatically through schema plugins, eliminating the need to write structured data by hand. WordPress plugins such as Yoast SEO and Rank Math inject JSON-LD into the <head> for every page, automatically populating schema types like Article, WebPage, Organization, and BreadcrumbList based on post type and site settings. Shopify generates Product schema in JSON-LD format for product pages. Wix and Squarespace include structured data generation features, though with less granular control than WordPress plugins. The limitation of most CMS-generated schema is coverage: plugins handle common types well but rarely generate schema for complex or specialized content. A medical practice site, for example, may need Physician, MedicalClinic, or MedicalCondition schema that no plugin generates automatically. For these cases, custom JSON-LD must be added manually or through a schema generator tool. The process of adding schema markup without a developer involves either manual JSON-LD editing or using a generator that outputs code ready to paste into a template.

Can Multiple JSON-LD Blocks Appear on One Page?

Yes. Google supports multiple <script type="application/ld+json"> blocks on a single page, and this is a common pattern. A blog post might include an Article block, a FAQPage block, and a BreadcrumbList block – each written as a separate JSON-LD script tag. There is no requirement to merge them. Multiple blocks are generally easier to manage than a single large nested object, particularly when different schema types are generated by different systems (a CMS plugin generating Article schema while a manually written block adds FAQPage schema). The only constraint is consistency: the properties across multiple blocks should not contradict each other. If two blocks on the same page describe the same entity with different values for the same property, Google will apply its own judgment about which value to use.

What Is the Minimum Valid JSON-LD Block?

A valid JSON-LD block requires three elements: a @context declaration pointing to https://schema.org, a @type declaration naming the schema type, and at least the required properties for that type. For an Article, Google requires headline, image, and datePublished as recommended properties (though not all are strictly required for parsing). A minimal but valid JSON-LD block looks like this:

{
 "@context": "https://schema.org",
 "@type": "WebPage",
 "name": "Page Title",
 "url": "https://example.com/page"
}

Google will parse a block this minimal, but richer markup with more properties gives the search engine more signal and increases eligibility for rich results. For types that unlock rich results – FAQPage, Product, Recipe, HowTo – the relevant required and recommended properties are documented in Google's Search Central Rich Results documentation. Missing a required property for a specific rich result type means the page is ineligible for that rich result, even if the structured data is otherwise valid. FAQ schema implementation has a specific set of required properties that must be present for the FAQ accordion to appear in search results.

Does Schema Format Affect AI Citation Eligibility?

Schema format does not directly determine whether an AI system cites a page, but the presence and quality of structured data – in any format – influences how AI systems interpret page content. JSON-LD, because it is machine-readable and separate from the visual layer, gives AI crawlers a clean, unambiguous signal about what a page represents. A page with well-formed JSON-LD declaring its type, author, topic, and key entities is easier for an AI system to classify and cite accurately than a page with no structured data at all. The connection between schema markup and AI search citations shows that structured data is one of several signals AI systems use to evaluate content. It works alongside content clarity, topical authority, and entity consistency rather than replacing them. For brands focused on appearing in AI-generated answers, structured data is a foundational signal, not a standalone solution.

Should Agencies Use JSON-LD or Another Format for Client Sites?

Agencies should use JSON-LD exclusively for all new client implementations. The operational advantages are significant at agency scale: JSON-LD can be templated, version-controlled, validated independently, and updated without touching client site templates. Microdata and RDFa require template-level access for every change, which increases both turnaround time and risk of introducing errors. Agencies managing structured data across multiple clients benefit from standardizing on JSON-LD and establishing a repeatable validation workflow – using Google's Rich Results Test and Schema Markup Validator as standard steps before deployment. The considerations for managing schema across multiple client sites address the workflow and tooling decisions that make schema maintainable at agency scale. For clients whose content spans specialized verticals – healthcare, legal, finance – JSON-LD's support for complex nested schema types is the only practical format choice.

How Do You Validate JSON-LD After Implementation?

Two tools are standard for JSON-LD validation. Google's Rich Results Test (available at search.google.com/test/rich-results) checks whether a specific URL's structured data qualifies for rich result features in Google Search. The Schema Markup Validator (validator.schema.org) checks conformance against the schema.org specification itself, independent of Google's specific requirements. Both tools should be used: the Rich Results Test confirms eligibility for specific Google features; the Schema Markup Validator catches structural errors that might not prevent rich results but indicate incorrect implementation. Common errors include missing required properties, incorrect property value types (a string where a URL is expected), and misspelled type names. The process for validating schema markup and fixing structured data errors covers the full validation workflow and common fixes. For healthcare content, validation is particularly consequential, as incorrect medical schema can misrepresent clinical information in ways that affect both accuracy and E-E-A-T signals – the validation steps for healthcare schema before publishing address the additional checks relevant to medical pages.

Does JSON-LD Work Differently for Local Businesses, Ecommerce, and SaaS?

The JSON-LD format is identical across all business types, but the schema types and properties vary significantly by context. Local businesses implementing LocalBusiness or MedicalClinic schema need to populate properties like address, openingHours, telephone, and geo coordinates. Ecommerce sites implement Product schema with offers, price, availability, and aggregateRating properties. SaaS companies typically use SoftwareApplication schema with applicationCategory, operatingSystem, and offers for pricing. The format – JSON-LD in a <script> block – is the same in all cases; what changes is which schema type applies and which properties are required for the relevant rich result feature. Local business schema implementation and ecommerce schema implementation each involve distinct type choices, but both follow the same JSON-LD format Google recommends for all pages.

Is There a Faster Way to Generate Correct JSON-LD at Scale?

Manually writing JSON-LD for every page type is error-prone and time-consuming, particularly for large sites. AI-powered schema generators address this by reading the full page content and generating accurate JSON-LD based on what the page actually contains, rather than pattern-matching on keywords. The AI-powered schema markup generator from AuthorityStack.ai takes this approach – it reads and understands page content to select the correct schema types and populate only the fields actually present on the page. This matters most for complex or specialized content: a medical page that warrants Physician schema with nested MedicalSpecialty values, or a SaaS page that needs SoftwareApplication with accurate pricing data, requires judgment about content that rules-based generators frequently get wrong. For teams generating structured data across dozens or hundreds of pages, an AI-based approach that produces accurate output the first time is significantly more efficient than editing incorrect auto-generated markup by hand. The comparison of schema generator tools covers both free and paid options, including the tradeoffs between rules-based and AI-based generation.

Quick Reference

  • Google recommends JSON-LD as the preferred schema markup format for all page types and all schema.org schema types.
  • JSON-LD belongs in a <script type="application/ld+json"> tag, ideally in the <head> section of the page.
  • Microdata and RDFa remain supported but are not recommended for new implementations; using them does not trigger a penalty but increases maintenance complexity.
  • Multiple JSON-LD blocks on a single page are fully supported and commonly used when a page warrants more than one schema type.
  • CMS plugins generate JSON-LD automatically for common schema types; custom JSON-LD is required for specialized types those plugins do not cover.
  • Validation should use both Google's Rich Results Test and the Schema Markup Validator before deployment.
  • Schema format alone does not determine AI citation eligibility, but accurate, well-formed JSON-LD strengthens the signals AI systems use to interpret and cite a page.

Generate JSON-LD Schema for any page using AuthorityStack.ai's AI-powered schema generator – paste in a URL and receive accurate, ready-to-deploy structured data in seconds.