Home/Schema Guide

The Complete Schema.org Structured Data Guide

Everything you need to implement JSON-LD schema markup on any website — from WordPress and Shopify to custom HTML. Boost your rich results eligibility and improve how Google understands your content.

JSON-LDWordPressShopifyWixRich ResultsLocal SEO

What is schema.org structured data?

Schema.org is a collaborative vocabulary created by Google, Bing, Yahoo, and Yandex to give search engines a standardised way to understand webpage content. When you add structured data markup to your pages, you are essentially speaking search engines' native language — telling them not just that a page exists, but exactly what type of content it contains.

For example, a recipe page without schema looks like a wall of text to a search engine. With schema markup, Google knows it contains a cooking time of 30 minutes, 4 servings, a 4.8-star rating from 200 reviews, and a list of ingredients. That data can then appear directly in search results as a rich snippet.

Key insight

Schema markup does not live inside your visible page content. It is embedded in your HTML as metadata — typically as a JSON-LD script block — and is only read by search engine crawlers and other machines.

Why schema markup matters for SEO in 2026

Structured data has become one of the most reliable ways to differentiate your search listings. While it is not a direct ranking signal, its impact on visibility is significant and well-documented.

Rich results

FAQs, star ratings, breadcrumbs, and product details appear directly in SERPs, dramatically increasing real estate and CTR.

Knowledge Panels

Organization and Person schema helps Google generate Knowledge Panels for your brand — a powerful trust and authority signal.

AI and SGE visibility

Google's AI Overviews and Search Generative Experience pull heavily from structured data to attribute answers and sources.

Voice search

Schema markup improves the likelihood of your content being used in voice search answers, particularly HowTo and FAQ types.

E-E-A-T signals

Author and Person schema supports Google's Experience, Expertise, Authoritativeness, and Trustworthiness evaluation framework.

Local pack visibility

LocalBusiness schema with accurate geo-coordinates and opening hours supports local pack and map pack appearances.

JSON-LD: Google's recommended format

There are three ways to implement schema markup — JSON-LD, Microdata, and RDFa. Google officially recommends JSON-LD for all new implementations, and for good reason: it is clean, portable, and does not require you to modify your existing HTML structure.

A JSON-LD block is a <script type="application/ld+json"> tag that can be placed anywhere in your page's <head> or <body>. Here is a minimal Organisation example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Your Company Name",
  "url": "https://yourwebsite.com",
  "logo": "https://yourwebsite.com/logo.png",
  "contactPoint": {
    "@type": "ContactPoint",
    "telephone": "+1-800-555-0100",
    "contactType": "customer service"
  }
}
</script>
Pro tip

You can stack multiple JSON-LD blocks on a single page. Each block is independent. Use one per schema type for cleaner code and easier maintenance.

The most valuable schema types for SEO

Schema.org defines hundreds of types, but a small subset drives the vast majority of SEO value. Prioritise these:

Organization / LocalBusiness

High priority

Establishes your brand entity. Required for Knowledge Panel generation. LocalBusiness adds address, hours, and geo-coordinates for local SEO.

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Your Business",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main St",
    "addressLocality": "Austin",
    "addressRegion": "TX",
    "postalCode": "78701",
    "addressCountry": "US"
  },
  "telephone": "+1-512-555-0100",
  "openingHours": "Mo-Fr 09:00-17:00",
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 30.2672,
    "longitude": -97.7431
  }
}

FAQPage

High priority

One of the highest ROI schema types. Generates expandable FAQ dropdowns directly in the SERP, doubling your search listing's vertical size.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "What is your return policy?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "We accept returns within 30 days of purchase."
    }
  }]
}

Product

High priority

Enables rich product snippets with price, availability, and star ratings in Google Shopping and organic results.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Product Name",
  "image": "https://example.com/product.jpg",
  "description": "Product description here.",
  "offers": {
    "@type": "Offer",
    "price": "29.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "124"
  }
}

Article / BlogPosting

Medium priority

Required for Google Top Stories carousel eligibility. Include datePublished, author, and headline for best results.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Your Article Title",
  "datePublished": "2026-01-15",
  "dateModified": "2026-02-01",
  "author": {
    "@type": "Person",
    "name": "Jane Smith",
    "url": "https://example.com/about/jane"
  },
  "image": "https://example.com/article-image.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "Your Site",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  }
}

BreadcrumbList

Medium priority

Replaces the plain URL in search results with a clean breadcrumb trail. Improves navigation context and CTR on inner pages.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://example.com/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "This Article",
      "item": "https://example.com/blog/this-article"
    }
  ]
}

WordPress: plugins and shortcuts

WordPress is the easiest platform for schema implementation thanks to a mature plugin ecosystem. You rarely need to touch code.

Recommended plugins

Rank Math SEOBest overall
Free + Pro

Automatically adds Organisation, WebSite, Article, BreadcrumbList, and Product schema. The free tier includes more schema types than Yoast's premium. Schema settings live under Rank Math → Titles & Meta.

Yoast SEOMost popular
Free + Premium

Handles Organisation, WebSite, Article, and BreadcrumbList automatically. FAQ and HowTo blocks in the Gutenberg editor automatically generate the corresponding schema. Premium adds more types.

Schema ProBest for agencies
Premium ($79/yr)

Dedicated schema plugin with 20+ schema types, conditional display rules, and WooCommerce integration. Ideal when you need full control over schema on complex sites.

WooCommerceE-commerce
Built-in

WooCommerce adds Product schema with price and availability by default. Pair with Rank Math or Yoast for AggregateRating and fuller product markup.

WordPress shortcut: manual JSON-LD without a plugin

If you prefer not to use a plugin, add JSON-LD directly to your theme's functions.php using wp_head():

add_action('wp_head', function() {
  if (is_front_page()) {
    echo '<script type="application/ld+json">' . json_encode([
      '@context' => 'https://schema.org',
      '@type'    => 'Organization',
      'name'     => get_bloginfo('name'),
      'url'      => home_url(),
      'logo'     => get_site_icon_url(),
    ]) . '</script>';
  }
});
Shortcut

Rank Math's Schema Generator (Rank Math → Schema → Add New Schema) lets you build and preview any schema type visually with no code. It is the fastest path to correct schema on WordPress.

Shopify: apps and theme editing

Shopify themes include basic Product schema by default, but the default implementation often misses AggregateRating, brand, and offer details that unlock richer results.

Recommended Shopify apps

JSON-LD for SEOMost comprehensive
Paid ($299 one-time)

The gold standard for Shopify schema. Adds 15+ schema types automatically including Product, Organisation, BreadcrumbList, Article, and FAQPage. One-time payment, no ongoing subscription.

Schema Plus for SEOBest free option
Free + $14.99/mo

Adds Organisation, Product with reviews, and BreadcrumbList on the free tier. Premium adds Article, FAQPage, and custom schema types.

TinyIMGImage SEO
Free + Paid

While primarily an image optimisation tool, TinyIMG adds product image schema and structured data for image search visibility.

Manual JSON-LD in Shopify themes

To add custom JSON-LD to a Shopify theme, edit theme.liquid (Online Store → Themes → Edit Code) and add your script block inside the <head> tag. Use Liquid variables for dynamic data:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "{{ shop.name }}",
  "url": "{{ shop.url }}",
  "logo": "{{ 'logo.png' | asset_url }}"
}
</script>

Wix and Squarespace

Wix

Wix automatically adds Organisation, WebSite, and BreadcrumbList schema for most sites. For additional schema types, use the Wix Structured Data Markup app or add custom JSON-LD via Settings → Custom Code → Add Code (place in the <head> section, all pages).

Wix's built-in SEO tools (Wix SEO Wiz) handle basic schema automatically. For product pages on Wix Stores, Product schema with price and availability is included by default.

Squarespace

Squarespace generates Organisation, WebSite, Article, and Product schema automatically on Business and Commerce plans. To add custom schema, go to Settings → Advanced → Code Injection and paste your JSON-LD in the Header section.

Limitation

Neither Wix nor Squarespace gives you full control over their auto-generated schema. If the built-in schema has errors, you may need to override it with custom code injection. Always scan your pages with CrispAudit to verify what is actually being output.

Custom HTML and headless sites

For custom-built sites, Next.js, Nuxt, SvelteKit, or static HTML — you have complete control. The pattern is the same regardless of framework: render a <script type="application/ld+json"> tag in the document head with your JSON object.

Next.js example

// In your _document.js or page component
const schema = {
  "@context": "https://schema.org",
  "@type": "WebPage",
  "name": "Page Title",
  "url": "https://yoursite.com/page"
};

// In your JSX:
<script
  type="application/ld+json"
  dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
/>

Dynamic schema for blog posts

For content-driven pages, generate schema dynamically from your CMS data:

const articleSchema = {
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": post.title,
  "datePublished": post.publishedAt,
  "dateModified": post.updatedAt,
  "author": {
    "@type": "Person",
    "name": post.author.name,
    "url": post.author.profileUrl
  },
  "image": post.coverImage,
  "url": `https://yoursite.com/blog/${post.slug}`
};

Enterprise CMS: Drupal, AEM, Sitecore, and Craft

Enterprise content management systems require a different approach to schema implementation than consumer platforms. These systems are typically managed by development teams, offer deeper programmatic control, and often serve sites with thousands of content templates. The key principle across all enterprise CMS platforms is the same: generate JSON-LD server-side from your content model, inject it into the document head, and keep it maintainable as content scales.

Drupal

Drupal has a mature structured data ecosystem built around its Schema.org Blueprints initiative, which maps Drupal entity types directly to schema.org types. The most recommended approach uses the Schema.org Blueprints module, which provides a comprehensive framework for mapping Drupal content types, paragraphs, and taxonomy terms to structured data automatically.

Schema.org BlueprintsRecommended
Free (drupal.org)

The official Drupal approach. Maps content types to schema.org types at the field level. Generates JSON-LD automatically for nodes, taxonomy terms, and users. Highly configurable via the Drupal admin UI.

Metatag moduleMeta + schema
Free (drupal.org)

The most widely installed Drupal SEO module. Includes structured data support alongside meta tags. Works well for Organization, WebSite, and BreadcrumbList schema on all page types.

Simple XML SitemapSitemap pairing
Free (drupal.org)

Best paired with schema modules to ensure crawlers can discover schema-enhanced pages efficiently.

For custom Drupal schema, implement a preprocess hook in your theme or custom module to inject JSON-LD into the page head:

// In yourmodule.module
function yourmodule_preprocess_html(&$variables) {
  $node = Drupal::routeMatch()->getParameter('node');
  if ($node instanceof Drupal
odeNodeInterface && $node->bundle() === 'article') {
    $schema = [
      '@context' => 'https://schema.org',
      '@type'    => 'Article',
      'headline' => $node->getTitle(),
      'datePublished' => $node->getCreatedTime(),
      'author' => ['@type' => 'Person', 'name' => $node->getOwner()->getDisplayName()],
    ];
    $variables['#attached']['html_head'][] = [
      ['#type' => 'html_tag', '#tag' => 'script',
       '#attributes' => ['type' => 'application/ld+json'],
       '#value' => json_encode($schema)],
      'article_schema'
    ];
  }
}
Drupal shortcut

The Schema.org Blueprints module can generate 80% of your structured data needs with zero custom code. Configure it at Admin → Configuration → Search and metadata → Schema.org blueprints. Use custom preprocess hooks only for edge cases the module does not cover.

Adobe Experience Manager (AEM)

Adobe Experience Manager is used by large enterprises and requires a developer-led approach to structured data. AEM does not have a dedicated schema plugin marketplace, so implementation relies on either custom Sling Models, HTL (HTML Template Language) components, or tag management via Adobe Launch / Google Tag Manager.

The recommended pattern for AEM is to create a dedicated SchemaService OSGi service that builds JSON-LD objects from page properties and content fragments, then exposes them via a Sling Model to your page template:

// SchemaModel.java (Sling Model)
@Model(adaptables = SlingHttpServletRequest.class)
public class SchemaModel {
  @SlingObject
  private Resource resource;

  public String getJsonLd() {
    Page page = resource.adaptTo(Page.class);
    Map<String, Object> schema = new LinkedHashMap<>();
    schema.put("@context", "https://schema.org");
    schema.put("@type", "Article");
    schema.put("headline", page.getTitle());
    schema.put("datePublished", page.getLastModified().toInstant().toString());
    return new Gson().toJson(schema);
  }
}

// In your HTL template (page.html):
// <script type="application/ld+json">${model.jsonLd @ context='unsafe'}</script>

For teams using Adobe Launch, structured data can be injected via a custom code rule that fires on page load and appends a JSON-LD script tag to the document head — useful for adding Organization and WebSite schema site-wide without a developer deployment cycle.

AEM tip

Use AEM's Content Fragment Models to create a structured data content type that authors can populate. Your SchemaModel reads from the fragment rather than hardcoding values. This gives content teams control over schema data without developer involvement for every update.

Sitecore

Sitecore XP and XM Cloud both support structured data implementation through a combination of rendering parameters, computed index fields, and custom pipelines. The most maintainable approach at Sitecore scale is to create schema as a rendering output rather than hardcoding it into templates.

For Sitecore XM Cloud with Next.js head application, the pattern mirrors standard Next.js implementation — generate JSON-LD in your page component from layout service data:

// In your Sitecore Next.js page component
export default function ArticlePage({ layoutData }) {
  const fields = layoutData.sitecore.route.fields;
  const schema = {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": fields.Title?.value,
    "datePublished": fields.PublishDate?.value,
    "author": {
      "@type": "Person",
      "name": fields.AuthorName?.value
    },
    "image": fields.HeroImage?.value?.src
  };
  return (
    <>
      <script type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
      />
      {/* rest of component */}
    </>
  );
}

For Sitecore XP with MVC or SXA, add schema via a Razor partial view or a dedicated structured data rendering. Use the Sitecore Content Editor to create a "Structured Data" template section where authors can populate key schema fields. Sitecore's Glass.Mapper or Sitecore.LayoutService can serialize item fields directly to a JSON-LD object.

Sitecore shortcut

For Sitecore SXA sites, use the Page Design system to inject a global Organization and WebSite JSON-LD block via a shared rendering applied at the page design level. This ensures every page gets base entity schema without per-template implementation.

Craft CMS

Craft CMS is developer-friendly and uses Twig templates, making JSON-LD injection straightforward. The recommended approach uses the SEOmatic plugin by nystudio107, which is the gold standard for structured data in Craft and provides comprehensive schema control through the Craft control panel.

SEOmaticRecommended
Free + $79 pro

Comprehensive SEO and schema plugin for Craft. Handles Organization, WebSite, BreadcrumbList, Article, and Product schema automatically. Control panel UI for non-developer schema management. The definitive Craft schema solution.

Sprout SEOAlternative
Paid

Full-featured SEO plugin with structured data support. Good for teams that prefer a different control panel UI pattern to SEOmatic.

For manual JSON-LD in Craft Twig templates, use the craft.app.request and entry variables to build schema dynamically:

{# In your _layout.twig #}
{% set schema = {
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": entry.title,
  "datePublished": entry.postDate | date("Y-m-d"),
  "dateModified": entry.dateUpdated | date("Y-m-d"),
  "author": {
    "@type": "Person",
    "name": entry.author.fullName
  },
  "image": entry.heroImage.one().url ?? null
} %}
<script type="application/ld+json">
  {{ schema | json_encode | raw }}
</script>
Craft shortcut

SEOmatic's Field Type allows you to attach SEO and schema configuration directly to Craft sections and entry types. Authors can override global schema values per entry from the control panel. This is the most scalable approach for Craft sites with diverse content types.

Pro tips and shortcuts

01

Use @id to link schema entities together

Give each schema entity a unique @id (a URL fragment works well, e.g. https://yoursite.com/#organization). Reference it from other blocks to build a connected entity graph. This helps Google understand relationships between your Organisation, WebSite, and content.

02

Priority order: FAQ → Product → Organisation → Article

If you are starting from zero, implement schema in this order for maximum immediate SEO impact. FAQPage and Product schema have the most visible rich result payoff. Organisation schema builds long-term entity authority.

03

Always include an image property

Google requires an image property for most rich result types. Articles need a 1200×630px image minimum. Products need at least one product image. Missing images are the most common reason rich results are withheld.

04

Test before deploying with a JSON linter

Paste your JSON-LD into jsonlint.com before adding it to your site. A single missing comma or unclosed bracket silently breaks the entire block. CrispAudit flags JSON-LD syntax errors, but catching them before deployment saves time.

05

Use sameAs to link your entity to external profiles

The sameAs property links your Organisation or Person entity to authoritative external profiles — LinkedIn, Twitter/X, Wikipedia, Wikidata, Crunchbase. This significantly strengthens your Knowledge Panel eligibility and entity authority.

06

Don't mark up content not visible on the page

Google penalises misleading schema — marking up FAQs that do not exist on the page, or product prices that differ from what is shown. Only mark up content that users can actually see. Schema must reflect visible page content.

07

Submit to Google Search Console after adding schema

After implementing schema, go to Google Search Console → URL Inspection → Request Indexing for your key pages. This accelerates recrawling and speeds up rich result appearances from weeks to days.

08

Use speakable schema for AI and voice readiness

The Speakable schema type marks sections of your content as suitable for text-to-speech. While not widely deployed yet, it positions your content well for voice search and AI assistant responses as these channels grow.

Frequently asked questions

What is the difference between JSON-LD, Microdata, and RDFa?

JSON-LD is a JavaScript snippet added to your page's head or body. It is Google's preferred format and the easiest to implement without touching your existing HTML. Microdata embeds schema attributes directly into your HTML tags. RDFa is an older attribute-based format. For most websites, JSON-LD is the best choice due to its simplicity and Google's official recommendation.

Does schema markup directly improve Google rankings?

Schema markup does not directly boost rankings as a ranking signal. However, it can significantly increase your click-through rate (CTR) by enabling rich results — star ratings, FAQs, breadcrumbs, and product details that appear in the SERP. Higher CTR leads to more traffic, which indirectly supports rankings over time.

What is the best schema plugin for WordPress?

Rank Math offers more granular schema control on the free tier, making it the best free option. Schema Pro is a premium dedicated plugin ideal for agencies managing complex sites. Yoast SEO is the most widely installed and handles the core schema types well on both free and premium tiers.

How do I add schema markup to Shopify?

Shopify themes include basic Product and Organization schema by default. For richer markup, edit your theme's Liquid files to inject JSON-LD directly, or install apps like JSON-LD for SEO or Schema Plus for SEO from the Shopify App Store.

How long does it take for Google to recognise new schema?

Google typically picks up new schema within a few days to two weeks after a page is recrawled. Submitting the URL via Google Search Console URL Inspection and requesting indexing can speed this up significantly.

What is the most valuable schema type for local businesses?

LocalBusiness schema (or a specific subtype like Restaurant, MedicalClinic, or LegalService) is the single most valuable type for local SEO. It communicates your address, phone, opening hours, and geo-coordinates directly to Google, supporting local pack and Knowledge Panel appearances.

Can I have multiple schema types on one page?

Yes — and you should. Most pages benefit from multiple schema blocks: a WebPage or Article type for the content, BreadcrumbList for navigation, and Organisation on every page to reinforce entity identity. Each JSON-LD block is independent. You can also use an @graph array to combine them in a single script tag.

Validate your schema markup now

Use CrispAudit to check whether your schema.org implementation is working correctly. Get an instant audit score and free fix-it report for any URL.

Run a free schema audit →