Schema Markup: The Complete Guide (2026)

Schema markup is the cheapest SEO win most sites never ship. You add a JSON block to the head of a page, you get richer Google results, clearer AI citations, and an entity graph that tells search engines exactly who wrote what and when. It is a solved problem with a free open vocabulary at schema.org. And yet, when I ran Lumina's Schema Validator against the 5 top-ranking guides on Google for schema markup, the pattern was bleak: zero of them ship FAQPage schema on a page about schema, the average dateModified staleness across all 5 is 380 days (Ahrefs leads at 963), and Umbraco's 9,563-word guide ships only a bare WebPage block — no Article, no BlogPosting, no Organization.

This guide is the complete evergreen reference for schema markup in 2026. What the vocabulary is, which formats Google actually wants, the eight types that cover 95% of sites, how to add schema by hand and through WordPress, how to validate it, which types Google quietly sunset, and the five mistakes I see on client audits every single week. Code examples throughout. No fluff. If you want the narrower AI-search-specific angle instead, read Schema Markup for AI Search — this one covers everything.

What Schema Markup Actually Is

Schema markup is a shared vocabulary for describing what a page is about. It was launched in 2011 and is governed today by schema.org, a project founded by Google, Microsoft, Yahoo, and Yandex and coordinated via the W3C Schema.org Community Group since 2015. The vocabulary now defines more than 800 types and 1,500 properties covering articles, products, events, people, organizations, recipes, reviews, software, courses, medical conditions, and more.

The vocabulary itself is just a taxonomy. The markup part is how you wire it into an HTML page so crawlers can read it. In 2026 that means JSON-LD: a small script block placed in the head of the page that declares entities and their relationships.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Schema Markup: The Complete Guide",
  "author": { "@type": "Person", "name": "Julien El-Bahy" },
  "datePublished": "2026-04-21"
}
</script>

That eight-line block tells every search engine and AI retriever on the web: this page is an Article, here is the headline, here is the author, here is when it was published. Without that block, Google reads your page as an HTML blob and has to guess at those answers from the body text. With the block, the answers are explicit. The ambiguity is gone.

Schema markup is not a ranking factor in the traditional "add it and move up 3 positions" sense. Google's Search Central team has said this on record repeatedly, most persistently via John Mueller across Search Off the Record episodes and SEO office-hours. What schema does is qualify you for rich results (the enhanced SERP blocks with stars, FAQs, prices, breadcrumbs, video thumbnails) and disambiguate your content for AI retrievers like ChatGPT Search, Perplexity, Claude, Gemini, and Google AI Overviews. Higher click-through rate on the same SERP position is not a ranking bump on paper, but the traffic looks identical.

JSON-LD vs Microdata vs RDFa

Three formats exist. One of them is the answer in 2026.

JSON-LD (JavaScript Object Notation for Linked Data) lives in a <script type="application/ld+json"> block in the head. It is separate from the visible HTML, which means you can add, edit, and validate it without touching the rest of the page. Google's Search Central docs explicitly recommend JSON-LD as the preferred format. Every major AI retriever parses it reliably.

Microdata sprinkles attributes directly into the visible HTML: itemscope, itemtype, itemprop. It works but it clutters your markup and makes diffs harder to read. Old CMS plugins still generate it. Leave them alone if they work; layer JSON-LD on top, the two coexist.

RDFa is the W3C-native format. Valid, rare, mostly used in academic publishing and government data portals. If your stack already emits it, fine. If you are starting fresh in 2026, you will not pick it.

The Schema Types That Matter Most

Schema.org defines 823 types. The top eight cover 95% of real websites. Rank them by what your page actually is, not by what looks impressive in a validator.

1. Article / BlogPosting

Editorial content. Blog posts, news, guides. Tells crawlers this is not a product, not a landing page: it's a piece of writing with a byline and a date. Required fields per Google: none. Recommended: headline, author, datePublished, dateModified, image, publisher. The most-used schema on the web after Organization.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Schema Markup: The Complete Guide",
  "datePublished": "2026-04-21",
  "dateModified": "2026-04-21",
  "author": { "@id": "https://your-site.com/#founder" },
  "publisher": { "@id": "https://your-site.com/#organization" }
}

2. Product

Anything for sale. Google rewards this with price, availability, and star-rating display in the SERP. Required: name plus one of review, aggregateRating, or offers. Skip it at your own risk on a product page. The CTR lift from a star snippet is real and measurable.

3. LocalBusiness

Any business with a physical address. Powers the Google Knowledge Panel, the Maps pack, opening hours display. Required: name and address. Recommended: telephone, openingHoursSpecification, geo, image, priceRange. The single highest-impact schema for any business with a storefront.

4. FAQPage

Question-answer blocks. Eligibility tightened in 2023. Google now only shows the FAQ rich result for authoritative government and health sites in most markets. But AI retrievers still quote FAQPage text directly when answering user queries. The strict rule: the schema question and answer text must match the visible HTML word-for-word. Drift revokes the rich result.

5. BreadcrumbList

Hierarchical navigation. Shows breadcrumbs in the SERP instead of the raw URL. Tiny visual win, non-negotiable on sites with a deep structure (e-commerce, large content hubs). Required: itemListElement array with position, name, and item per entry.

6. Organization

Your brand identity. Logo, URL, social profiles via sameAs, legal name, founding date. Declared once on your homepage at /#organization, referenced everywhere else via @id. The sameAs array is how AI models connect your brand to its Wikidata entry and broader entity graph.

7. Person

The author byline. Declared once at /about/#founder or similar, referenced on every article. Recommended: jobTitle, knowsAbout, sameAs pointing to LinkedIn, GitHub, Twitter. This is how AI resolves whether the byline is an actual expert on the topic.

8. Event

Anything with a start date and a location: webinar, concert, conference, sale event. Required: name, startDate, location. Recommended: endDate, eventStatus, eventAttendanceMode (online / offline / mixed), offers for paid events.

Niche-but-valuable types

• Recipe. Cooking content. Strong rich-result support with preparation time, calories, rating stars.
• HowTo. Step-by-step tutorials. Google sunset the rich result in September 2023 but Perplexity, Claude, ChatGPT still read it for step extraction. Keep it on tutorials.
• VideoObject. Any page where a video is the main content. Powers the video thumbnail in Google Search.
• SoftwareApplication / WebApplication. Apps and tools. Lumina's tool pages use WebApplication.
• Review / AggregateRating. User reviews of any reviewable thing. Usually embedded inside Product or LocalBusiness rather than standalone.
• Course. Google documented a "Course info" rich result in late 2023 and it remains supported today. Not deprecated, despite what some older guides still claim.
• JobPosting. Listings. Powers Google for Jobs.

What not to ship: schema types that do not match what your page actually is. A Dataset block on a blog post, a Vehicle block on a homepage, a MedicalCondition block on a marketing page. Irrelevant types add bytes and invite Google to flag your markup as misleading.

How to Add Schema Markup to a Page

Three common paths. Pick the one that matches your stack.

Plain HTML: paste and ship

If you control the HTML directly (static site, hand-coded page, framework template), add the JSON-LD block at the bottom of the <head>. One block per page, one @graph wrapping all entities, separate blocks for FAQPage if you have one:

<head>
  <!-- ...other head tags... -->
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "BlogPosting",
        "@id": "https://your-site.com/blog/post/#article",
        "headline": "...",
        "author": { "@id": "https://your-site.com/#founder" },
        "publisher": { "@id": "https://your-site.com/#organization" },
        "datePublished": "2026-04-21",
        "dateModified": "2026-04-21"
      },
      {
        "@type": "Person",
        "@id": "https://your-site.com/#founder",
        "name": "Author Name",
        "jobTitle": "Title",
        "sameAs": ["https://www.linkedin.com/in/..."]
      },
      {
        "@type": "Organization",
        "@id": "https://your-site.com/#organization",
        "name": "Your Brand",
        "url": "https://your-site.com",
        "logo": "https://your-site.com/logo.png"
      }
    ]
  }
  </script>
</head>

That one block handles an entire article page. Person and Organization are declared once, referenced via @id across every other article. No duplication.

WordPress — plugin or theme

If you run WordPress, schema is almost certainly already half-set-up. Yoast SEO, Rank Math, and The SEO Framework all emit baseline Article, Organization, WebSite, and BreadcrumbList schema out of the box. Rank Math and Yoast both ship dedicated FAQPage and HowTo blocks in the Gutenberg editor.

The gotcha: default plugin schema is generic. Organization.sameAs will be empty until you fill in social URLs in plugin settings. Author bios often ship as bare Person with only a name, no jobTitle, no sameAs. The fix is the Schema Settings page in whichever plugin you use, not custom code. Set it once per site, inherit everywhere.

For complex schema that plugins do not cover (LocalBusiness with multiple locations, Product variants with ProductGroup, Event series), use a Custom Fields plugin plus an add_action('wp_head', ...) hook in a child theme to inject hand-written JSON-LD. Do not fight the plugin; layer alongside it.

Next.js, React, Vue, Astro: framework patterns

Every modern framework has a head-injection primitive. Next.js: next/head or the App Router's metadata API with a <Script> of type application/ld+json. React with React Helmet: <Helmet><script type="application/ld+json">{JSON.stringify(schema)}</script></Helmet>. Vue Nuxt: useHead composable with a script entry. Astro: plain <script> tag in the component head, with Astro stripping framework overhead so the markup ships as static HTML.

Common mistake across all frameworks: dangerouslySetInnerHTML with a JSON string that has been double-stringified, producing escaped quotes inside the output and an invalid block. Always pass a plain object through JSON.stringify() once, never twice. If you see " in the rendered HTML, you double-encoded somewhere.

Does Schema Markup Still Help SEO in 2026?

Direct answer: it does not push your blue-link position up the page. It does three other things that still matter.

Rich results. Qualifying schema types reveal enhanced SERP blocks: stars on products, prices on offers, FAQ accordions on qualifying government and health sites, recipe cards with prep time and calories, breadcrumb trails replacing the raw URL, video thumbnails for VideoObject. CTR on rich-result listings is measurably higher than plain blue links at the same position across every third-party study I have seen (Ahrefs, SISTRIX, Backlinko, Rockdove among them). The exact lift varies by rich-result type and industry, but the direction is consistent.

AI citation. ChatGPT, Claude, Perplexity, and Gemini all parse JSON-LD when ingesting pages. The clearer your entity graph, the more likely your brand is cited by name (rather than summarized anonymously) in AI answers. There is no public study quantifying this yet. AI referral traffic in GA4 is still a single-digit-percent slice for most sites, but the trend line is what matters, not the current month. In Lumina's own GEO Readiness Checker, schema signals account for ~35% of the 42-check audit score: JSON-LD presence (weight 10), Organization schema (weight 8), absolute @id (5), WebSite schema (3), Person schema (3), sameAs array (3), FAQPage (3).

Knowledge Graph. Organization and Person schema with a strong sameAs array (LinkedIn, Wikidata, GitHub, Crunchbase, Twitter, industry directories) is how Google connects your brand to its Knowledge Graph entity. Once you have an entity, you get the blue-check brand panel in the SERP, your logo shows in answer cards, your name resolves without disambiguation.

What schema does not do: it does not fix thin content, broken internal links, slow pages, or a site that is not crawlable. If the underlying page is weak, no JSON-LD block rescues it.

Deprecated & Sunset Schema Types

Google has quietly deprecated a handful of schema types. Guides published in 2022 still list them as current. Lumina's Schema Validator tracks seven in its DEPRECATED_TYPES list, plus ClaimReview as a special case. Four categories cover every state a schema type can be in:

Active and fully supported. The big eight above (Article, Product, LocalBusiness, FAQPage, BreadcrumbList, Organization, Person, Event) plus Recipe, VideoObject, Review, AggregateRating, Course, JobPosting, QAPage, DiscussionForumPosting, ProfilePage, MathSolver, ProductGroup. All qualify for current rich results. Keep shipping.

Active but with eligibility restrictions. FAQPage rich result is now limited to authoritative government and health sites in most markets. The schema is still valid for every site; the SERP accordion just will not appear for most. HowTo rich result was sunset by Google on September 14, 2023; the schema remains valid and Perplexity, Claude, and ChatGPT still read it for step extraction. ClaimReview is being phased out of Google Search display but remains supported by Google's Fact Check Explorer Tool.

Sunset entirely from Google Search. The exact list in Lumina's Schema Validator as of 2026-04-21: HowTo, EducationalOccupationalCredential, Vehicle, PracticeProblems, SpecialAnnouncement, EstimatedSalary, LearningVideo. All seven are valid schema.org markup and some still help AI retrievers with entity understanding, but none trigger a dedicated Google rich result anymore. If your CMS still ships SpecialAnnouncement blocks from the COVID era, clean them out on the next touch.

Commonly miscategorized as deprecated. Two trip people up. Course is the big one. Google documented a "Course info" rich result in late 2023 and it remains supported today, and Coursera, edX, MIT OpenCourseWare currently rank for it. Some 2022 guides still list it as sunset; they are wrong. QAPage is the other: its rich result is smaller than it used to be but the type remains supported (I wrongly had it in my own Schema Validator's DEPRECATED_TYPES list until an external-URL audit caught it on 2026-04-12). If a validator flags either of these as deprecated in 2026, the validator is out of date.

The Most Common Schema Mistakes

I have audited more than a hundred client sites and dogfooded Lumina's Schema Validator against 72 internal pages and 21 external sites spanning recipes, news, shopping, tutorials, reviews, and reference content. Five patterns produce most of the production failures.

1. FAQ drift. Schema declares five questions; the visible HTML has six. Or the schema's acceptedAnswer.text is a summary of the visible answer rather than the exact text. Google revokes FAQ rich result eligibility on this. Their validator enforces word-for-word text match. A single word edit in the HTML without a parallel edit in the schema is enough to break it. The fix is process, not code: strict-sync the schema and the HTML in the same commit, run a verify script before every deploy.

2. Orphan Person or Organization. You declare a Person block with author metadata but never link it via @id from Article.author. Or the Article's author is {"@type":"Person","name":"Author"} inline, while a separate Person block with the real sameAs array sits unconnected on the same page. AI retrievers treat the inline byline and the orphan block as two different people. Entity signal fragments. The fix: one canonical Person declaration, referenced via @id from every article.

3. Stale dateModified. Two mirror-image bugs. Version A: content changes, dateModified does not. AI retrievers and Google both use dateModified as a freshness signal, and they compare it against your actual last-edit date in their crawl history. A schema that says "modified 2023" on a page that visibly got a 2026 rewrite is a mismatch. Version B, equally bad: dateModified bumps on every touch. CSS-only changes, typo fixes in HTML comments, nav-menu updates. Google learns your freshness signal is unreliable and discounts it entirely. Fix: bump dateModified only on meaningful content changes.

4. Invented fields. applicationArea does not exist on schema.org. Neither does targetAudience on Article. Neither does coverImage. Inventing fields does not throw an error in most validators (they silently ignore unknown properties), but Google's Rich Results Test flags them and strict AI-parser pipelines discount the whole block. Use only schema.org-documented fields. When in doubt, check the vocabulary page for the type you are using.

5. Schema breadth without schema relevance. You ship 14 schema types on a blog post. Article, BlogPosting, WebPage, WebSite, Organization, Person, ImageObject, BreadcrumbList, ListItem, PropertyValue, DefinedTerm, ReadAction, EntryPoint, SearchAction. Half of those do not describe what the page is. They are hedges. Adding a DefinedTerm block when the page is not defining a term signals to Google that your markup is padding rather than describing. Ship 3-5 well-linked entities, not 14 drive-by ones.

How to Validate Schema Markup

Three tools, three distinct jobs. Every schema-touching commit should run through all three, since they catch different failure classes.

• Google Rich Results Test. The Google-specific source of truth. Takes a URL or a code snippet, reports which rich result types you qualify for, and flags missing required fields. This is what Google's crawler actually sees. Use it on every schema-touching commit to a production page.
• Schema.org Validator. The vocabulary-level source of truth. Reports syntax errors, invalid fields, and ambiguous type references against the full 823-type schema.org vocabulary. Catches "invented fields" faster than the Google tester does.
• Lumina Schema Validator. Free, no signup, bulk mode, and three checks the others do not run. Full breakdown below.

Lumina's Schema Validator exists because the other two miss three production failure classes I kept hitting on client audits:

• FAQPage strict-sync against visible HTML. The validator extracts both the JSON-LD and every visible .faq-item on the page, compares them question-by-question, answer-by-answer. Google's tester passes schema that mismatches the visible text; Google Search then quietly revokes the rich result weeks later. Lumina's tool catches the mismatch before the deploy.
• Cross-page @id resolution. If your Article's author is {"@id":"https://your-site.com/#founder"} (the canonical pattern), the validator follows that reference to the actual declaration on your homepage or about page, then validates the resolved Person entity. Google's tester validates each page in isolation and misses this entirely.
• Up-to-date deprecation catalog. Built from Google's current structured-data docs, not generic schema.org theory. Flags HowTo as sunset, ClaimReview as phasing out, warns against invented fields like applicationArea. Does not wrongly flag Course or QAPage as deprecated (I fixed those during my own Schema Validator sweep on 2026-04-12).

The workflow: validate with Schema.org while you are writing the block, spot-check with Google Rich Results Test before you ship, run Lumina's Schema Validator on the live URL after deploy. Bulk audits across a site always go through Lumina's tool, since neither of the others does batch.

FAQ

Where to Start

Five moves, in order. Fewer than 90 minutes of work for a small site, two to three hours for a medium one: