What is Schema.org structured data?

Schema.org structured data is a shared vocabulary of machine-readable tags that tells search engines and AI models what your content means. It is added to web pages as JSON-LD, Microdata, or RDFa, with JSON-LD being the recommended format.

Do I need Schema.org for SEO?

While not required, Schema.org structured data significantly improves how search engines and AI tools understand your content. Pages with valid schema are more likely to earn rich results in Google and citations in AI answers.

What is the easiest Schema.org type to implement?

FAQPage schema is the easiest to implement and has the highest impact for AI citation. You simply list your questions and answers in JSON-LD format inside a script tag in your page's HTML head.

How do I test my Schema.org structured data?

Use Google's Rich Results Test at search.google.com/test/rich-results to validate your schema. You can paste a URL or raw HTML. The tool shows which schema types were detected and flags any errors.

What is the difference between Schema.org and JSON-LD?

Schema.org is the vocabulary — the list of types and properties like BlogPosting, FAQPage, and Organization. JSON-LD is the format used to write that vocabulary. JSON-LD is a script tag containing Schema.org data written in JSON notation.

What is the @graph pattern in JSON-LD?

The @graph pattern is a JSON-LD structure that lets you define multiple schema entities in a single script block and link them by @id references. It is the recommended approach when a page has multiple schema types (e.g., Article + FAQPage + BreadcrumbList).

Which schema types generate Google rich results?

Schema types most likely to generate Google rich results include Article, FAQPage, HowTo, Product, Recipe, Event, LocalBusiness, and Review. Not all schema types produce visible rich results — some feed the knowledge graph without a visual enhancement in the SERP.

What are common Schema.org implementation errors?

Common errors include: JSON syntax mistakes (missing commas, unclosed brackets), JavaScript-injected schema that AI crawlers can't read, duplicate @type declarations, missing required properties, and orphaned entity references. Always validate with Google's Rich Results Test before deploying.

Schema.org Structured Data: A Complete Step-by-Step Implementation Guide

Schema.org structured data is a machine-readable vocabulary that tells AI engines what your content means — not just what it says. Adding valid JSON-LD schema to your pages is the single highest-impact technical action you can take for AI citation. This guide provides copy-paste JSON-LD for every major schema type, a validation workflow, and a list of the 8 most common errors to avoid.

What schema.org structured data actually does

When an AI engine crawls your page, it reads two things: the visible text (what humans read) and the machine-readable signals (what bots parse). Schema.org structured data is the second layer — a standardized vocabulary that defines entities, relationships, and content types.

Without it, an AI reads: "John published an article about recipe tips."

With schema.org: "This is a Recipe by John Smith, published 2026-03-10, with 4 ingredients, a 30-minute cook time, and 480 calories per serving."

That precision is why schema-tagged content gets cited. The engine can extract facts with confidence.

For a conceptual explanation of Schema.org's history and why it was created, see What Is Schema.org? How It Works and Why It Matters for SEO. This guide focuses entirely on how to implement it.

Step 1 — Identify your content entities

Before writing any JSON-LD, read your page and list the primary entities:

Is this a blog post? → BlogPosting or Article
Is this a how-to guide? → HowTo
Is this a product or service page? → Product or Service
Does this page have Q&A content? → FAQPage
Is this your homepage? → Organization + WebSite
Does this page show breadcrumb navigation? → BreadcrumbList

One page can — and usually should — have multiple schema types. A blog post is typically BlogPosting + FAQPage + BreadcrumbList, all nested in a single @graph block.

Step 2 — Select the correct schema type

Content	Recommended schema type
Blog post / article	`BlogPosting`
News article	`NewsArticle`
How-to guide	`HowTo`
FAQ section	`FAQPage`
Company homepage	`Organization` + `WebSite`
Product page	`Product`
Event	`Event`
Recipe	`Recipe`
Local business	`LocalBusiness`
Person/author page	`Person`
Review	`Review`
Course	`Course`

Visit schema.org for the full type hierarchy. Use the most specific subtype available — BlogPosting is better than Article; LocalBusiness is better than Organization for a physical storefront.

Step 3 — Write the JSON-LD (copy-paste examples)

Organization + WebSite (homepage — implement this first)

Every site should have Organization and WebSite schema on the homepage. This defines your brand entity in the AI knowledge graph.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://yoursite.com/#organization",
      "name": "Your Brand Name",
      "url": "https://yoursite.com",
      "logo": {
        "@type": "ImageObject",
        "url": "https://yoursite.com/logo.png",
        "width": 512,
        "height": 512
      },
      "foundingDate": "2024",
      "description": "One-sentence description of what your company does.",
      "sameAs": [
        "https://twitter.com/yourbrand",
        "https://linkedin.com/company/yourbrand",
        "https://github.com/yourbrand"
      ]
    },
    {
      "@type": "WebSite",
      "@id": "https://yoursite.com/#website",
      "url": "https://yoursite.com",
      "name": "Your Brand Name",
      "publisher": { "@id": "https://yoursite.com/#organization" }
    }
  ]
}

The sameAs array is critical for AEO — it links your on-site entity declaration to your verified presences across the web, reducing entity ambiguity for AI knowledge graphs.

BlogPosting (individual articles)

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://yoursite.com/articles/your-slug#article",
      "headline": "Your Article Title",
      "description": "A one-sentence summary. This is what AI engines cite as your answer.",
      "datePublished": "2026-03-20",
      "dateModified": "2026-05-21",
      "isAccessibleForFree": true,
      "inLanguage": "en",
      "url": "https://yoursite.com/articles/your-slug",
      "author": {
        "@type": "Organization",
        "@id": "https://yoursite.com/#organization"
      },
      "publisher": {
        "@id": "https://yoursite.com/#organization"
      },
      "image": {
        "@type": "ImageObject",
        "url": "https://yoursite.com/articles/your-slug-og.png",
        "width": 1200,
        "height": 630
      },
      "keywords": "keyword one, keyword two, keyword three",
      "speakable": {
        "@type": "SpeakableSpecification",
        "cssSelector": ["h1", ".article-summary"]
      }
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://yoursite.com" },
        { "@type": "ListItem", "position": 2, "name": "Articles", "item": "https://yoursite.com/articles" },
        { "@type": "ListItem", "position": 3, "name": "Your Article Title", "item": "https://yoursite.com/articles/your-slug" }
      ]
    }
  ]
}

FAQPage (highest impact for AI citation)

For the complete FAQPage guide including best practices for answer writing, see FAQPage Schema: How to Get Your FAQs Cited by AI Answer Engines.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is [your topic]?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A complete, factual answer in plain text. No HTML tags. 40–160 words."
      }
    },
    {
      "@type": "Question",
      "name": "How do I [action related to your topic]?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Step-by-step answer. Each step on its own sentence."
      }
    }
  ]
}

HowTo (step-by-step guides)

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to [accomplish the goal]",
  "description": "A one-sentence summary of what this guide achieves.",
  "totalTime": "PT10M",
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Step name",
      "text": "Detailed instruction for this step."
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Step name",
      "text": "Detailed instruction for this step."
    }
  ]
}

Product

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Product Name",
  "description": "Product description.",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand"
  },
  "offers": {
    "@type": "Offer",
    "price": "47.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://yoursite.com/product"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "42"
  }
}

Step 4 — Validate your markup

Before deploying, always validate. A single JSON syntax error silently invalidates the entire block.

Validation tools:

Schema.org Validator — validator.schema.org — checks structural correctness and flags missing required properties
Google Rich Results Test — search.google.com/test/rich-results — checks eligibility for rich results in Google Search

Validation workflow:

Paste your raw JSON-LD into the Schema.org Validator. Fix any errors.
Paste the page URL into Google Rich Results Test. Confirm detected schema types match what you intended.
View page source in your browser (Ctrl+U / Cmd+U). Confirm the JSON-LD appears in the raw HTML, not injected after load.
Deploy to staging. Run Rich Results Test again with the staging URL.
Deploy to production. Submit for re-indexing in Google Search Console.

Step 5 — Inject in `<head>` as static HTML

Place the <script type="application/ld+json"> tag inside the <head> of your HTML. This is not optional — it must be static HTML, not JavaScript-injected.

Why this matters: Most AI crawlers (GPTBot, PerplexityBot, ClaudeBot) do not execute JavaScript. If your schema is injected by a tag manager or React useEffect, these bots receive a page with no structured data. Your schema is invisible to the crawlers you most need to reach.

Platform guides:

WordPress + Rank Math / Yoast SEO — schema is injected server-side automatically in <head>
Webflow — Page Settings → Custom Code → Head section
Framer — Page Settings → Custom Code → <head>
Ghost — Settings → Code injection → Site header
Next.js — Use dangerouslySetInnerHTML in a Server Component (renders at build time, not client-side)

The @graph pattern: linking multiple entities

When a page has multiple schema types, wrap them in a single @graph array. This lets engines understand relationships — that the article was published by the organization, and the breadcrumb shows its place in the site hierarchy.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://yoursite.com/articles/slug#article",
      "headline": "...",
      "author": { "@id": "https://yoursite.com/#organization" }
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://yoursite.com/articles/slug#breadcrumb",
      "itemListElement": [...]
    },
    {
      "@type": "FAQPage",
      "@id": "https://yoursite.com/articles/slug#faq",
      "mainEntity": [...]
    }
  ]
}

The @id fragments are stable identifiers that let the engine reference entities across the graph without ambiguity. Using #article, #breadcrumb, #faq etc. is a convention that keeps the graph readable.

Schema priority by business type

Blogger or content publisher: Must-have: BlogPosting + FAQPage + BreadcrumbList on every article; Organization + WebSite on homepage.

SaaS product: Must-have: Organization + WebSite + SoftwareApplication on homepage; BlogPosting on blog; FAQPage on pricing/features pages.

E-commerce store: Must-have: Product with Offer and AggregateRating on product pages; Organization on homepage; BreadcrumbList on category/product pages.

Local business: Must-have: LocalBusiness with address, phone, and hours on homepage; Review or AggregateRating if applicable.

Service business: Must-have: Service or ProfessionalService with area served; FAQPage on service pages; Organization on homepage.

The 8 most common Schema.org errors (and how to fix them)

Error 1: JSON syntax mistake A missing comma, unclosed bracket, or extra quote silently invalidates the entire block. The page looks normal but bots skip the schema.

Fix: Always paste your JSON-LD into jsonlint.com before deploying.

Error 2: Schema injected by JavaScript If your JSON-LD only appears after JavaScript executes, AI crawlers miss it.

Fix: Confirm your schema appears in browser View Source (Ctrl+U), not just in DevTools Elements panel.

Error 3: Missing required properties BlogPosting requires headline and author at minimum. Product requires name. Missing these fields cause validation failures.

Fix: Check the Schema.org type documentation for required vs. recommended properties. Google's Rich Results Test flags missing required fields.

Error 4: Stale dateModified For time-sensitive queries, AI engines deprioritize content with old modification dates — even if the content is accurate.

Fix: Update dateModified every time you meaningfully revise a page. Display the update date visibly to users.

Error 5: Duplicate schema blocks Some CMS plugins automatically generate schema AND you've added custom schema. The page has two @type: "Organization" blocks — this causes ambiguity.

Fix: Check your CMS plugin settings and disable automatic schema generation for any types you are manually managing.

Error 6: HTML tags inside text fields FAQ answer text must be plain text. <strong>, <a>, <em> inside acceptedAnswer.text fields can break parsing.

Fix: Strip all HTML from the answer body. Use plain prose only.

Error 7: Mismatched @id references An entity that references "@id": "https://yoursite.com/#organization" but that ID isn't defined anywhere in the graph creates an orphaned reference.

Fix: Ensure every @id you reference is defined in the same @graph block or on a page that's been crawled and indexed.

Error 8: No schema on key pages Many sites add schema to the homepage but forget article pages, product pages, and FAQ pages — the pages that most benefit from it.

Fix: Audit every public page type. Confirm schema is present on: homepage, every article, every product/service page, and every FAQ page.

What to do after adding schema

Validate with Schema.org Validator and Google Rich Results Test
Deploy to production
Submit affected URLs in Google Search Console → URL Inspection → "Request Indexing"
Monitor the Rich Results report in Search Console for eligibility status
Run a quarterly audit — schema that was valid can break after CMS updates or HTML structure changes