Schema Markup: The Complete Guide (2026)

Schema markup is one of the cheapest technical SEO jobs with a visible payoff. You add a JSON-LD block to a page, and if the page qualifies, Google can show it with richer results: prices, ratings, event dates, breadcrumbs, video thumbnails. The vocabulary is free and open at schema.org.

If you're here for the AI angle, Schema Markup for AI Search covers what the evidence says about that.

What Schema Markup Actually Is

Schema markup is a shared vocabulary for describing what a page is about. Schema.org was launched in 2011 by Google, Microsoft and Yahoo, with Yandex joining the same year, and has been developed through a W3C Community Group since 2015. The vocabulary defines more than 800 types and 1,500 properties for articles, products, events, people, organizations, recipes, reviews, software and more.

The vocabulary is just a taxonomy. The markup is how you add it to a page so crawlers can read it. For most sites today, that's JSON-LD: a script block that declares entities and their properties.

<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 block tells search engines: this page is an Article, here's the headline, here's the author, here's the publication date. Google can often work that out from the page anyway, but the markup makes it explicit, and for rich results it's required.

Schema markup isn't a ranking factor. Google has said so repeatedly, for example John Mueller in this answer covered by Search Engine Journal. What it does is make pages eligible for rich results, which can change how your listing looks and how often it gets clicked.

JSON-LD vs Microdata vs RDFa

Three formats exist, and Google supports all three.

JSON-LD (JavaScript Object Notation for Linked Data) sits in a <script type="application/ld+json"> block, in the <head> or the <body>. It's separate from the visible HTML, so you can add and edit it without touching the rest of the page. Google recommends JSON-LD where your setup allows it.

Microdata puts attributes directly into the visible HTML: itemscope, itemtype, itemprop. It works, but it clutters templates and makes changes harder to review. Older CMS plugins still output it. If it works, you don't have to rip it out, just make sure it doesn't contradict any JSON-LD you add.

RDFa is the W3C attribute format. Valid, but rarely used outside publishing and public-sector data.

The Schema Types That Matter Most

You don't need hundreds of types. Pick the ones that describe what your page actually is. These eight cover most business and content sites.

1. Article / BlogPosting

Editorial content: blog posts, news, guides. Google's Article documentation says the markup helps Google understand the page and show better title, image and date information. There are no required properties. Recommended are author, dateModified, datePublished, headline and image.

{
  "@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. Product markup can show price, availability and ratings in results. For product snippets Google requires name plus one of review, aggregateRating or offers. Merchant listings have their own, stricter requirements.

3. LocalBusiness

Businesses with a physical location. The markup can give Google details like opening hours, address and phone number. Required are name and address; telephone, openingHoursSpecification, geo and url are recommended. For Maps and the local pack, your Google Business Profile matters far more than markup.

4. FAQPage

Question-answer blocks. Google restricted FAQ rich results to authoritative government and health sites in 2023, then stopped showing them entirely on 7 May 2026 (details in the deprecated section). The markup is still valid. If you keep it, keep the text identical to the visible FAQ, so the page doesn't contradict itself.

5. BreadcrumbList

Your site hierarchy. Google shows breadcrumb trails in results on desktop; since January 2025, mobile results show only the domain. Each itemListElement needs position and name, and every item except the last needs item.

6. Organization

Your brand: name, logo, URL, contact details and sameAs links to official profiles. Google's Organization documentation says the markup can help Google understand your organization's details and disambiguate it, and it can influence which logo is shown. Declare it once, for example on the homepage at /#organization, and reference it by @id elsewhere.

7. Person

The author. Useful as the author of articles, with name, url, jobTitle and sameAs links to profiles. Google's Article docs recommend marking up the author with a name and URL. Person has no standalone rich result.

8. Event

Anything with a start date and a location: webinars, concerts, conferences. Required are name, startDate and location. Recommended include endDate, eventStatus, eventAttendanceMode and offers for paid events.

Other types worth knowing

• Recipe. Cooking content, with rich results for time, ratings and images.
• VideoObject. Pages with video, for thumbnails and key moments in Google results.
• SoftwareApplication / WebApplication. Apps and tools. Lumina's tool pages use WebApplication.
• Review / AggregateRating. Usually nested inside Product, LocalBusiness or another reviewable type.
• Course list. Still supported for pages listing several courses.
• JobPosting. Job listings in Google's job search experience.

Don't add types that don't match the page. A Dataset block on a blog post or a Vehicle block on a homepage describes nothing real, and Google's policies say markup must not be irrelevant or 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, add the JSON-LD block to the page. One block with a @graph can hold all entities:

<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>

Person and Organization are defined once with an @id and referenced from the article. That keeps the markup consistent and easy to maintain. Validators generally check each page on its own, so include the full entity on any page where you want it validated.

WordPress: plugin or theme

On WordPress, schema is usually half set up already. Yoast SEO and Rank Math output Article, Organization, WebSite and BreadcrumbList markup by default, and both offer FAQ and HowTo blocks in the editor. The SEO Framework adds Article markup only through its Articles extension.

The catch: default plugin markup is generic. Organization.sameAs stays empty until you add social profiles in the plugin settings, and author markup often has only a name. Fix that in the plugin's settings rather than in code.

For markup the plugin doesn't cover (multiple locations, product variants with ProductGroup, event series), add hand-written JSON-LD through a wp_head hook in a child theme. Work alongside the plugin, and make sure you don't output the same entity twice with different values.

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

Next.js recommends rendering a native <script type="application/ld+json"> in your page or layout component, with the object passed through JSON.stringify() and < replaced by < to prevent script injection:

<script
  type="application/ld+json"
  dangerouslySetInnerHTML={{
    __html: JSON.stringify(jsonLd).replace(/</g, '\\u003c'),
  }}
/>

In Nuxt, use the useHead composable with a script entry. In Astro, a <script type="application/ld+json" set:html={JSON.stringify(jsonLd)} /> in the component works and ships as static HTML.

A common React mistake: rendering the JSON as a text child instead of through dangerouslySetInnerHTML. React escapes it, and the output contains " instead of quotes, which isn't valid JSON. Check the rendered HTML, not your component code.

Does Schema Markup Still Help SEO in 2026?

It doesn't push your position up. It does two things that still matter.

Rich results. Qualifying markup makes pages eligible for enhanced results: product prices and ratings, recipe cards, event details, video thumbnails, breadcrumbs on desktop. Eligibility isn't a guarantee; Google decides when to show them. Google's own case studies report effects like a 25% higher click-through rate for Rotten Tomatoes pages with structured data and an 82% higher click-through rate for Nestlé pages that show as rich results. Those are vendor-selected examples, but they show the kind of effect rich results can have.

Understanding your entities. Organization and Person markup with sameAs links helps Google connect your pages to the right organization or person. That can influence the logo and details Google shows for your brand. There's no guaranteed knowledge panel and no "verified" badge.

What about AI search? Google says AI Overviews and AI Mode need no special structured data, and a controlled Ahrefs study found no citation lift from adding JSON-LD. Don't add markup expecting AI citations. Schema Markup for AI Search has the details.

And what schema can't do: fix thin content, broken internal links, slow pages or a site that isn't crawlable. If the page is weak, no JSON-LD block rescues it.

Deprecated & Sunset Rich Results

Google has removed a lot of rich results since 2023. The schema.org types still exist and validate; what disappears is the Google feature. Here's where things stand, based on Google's documentation updates.

Still supported (examples). Article, Breadcrumb, Event, Job posting, Local business, Logo via Organization, Product snippets and merchant listings, Recipe, Review snippet, Video, Course list, Discussion forum, Profile page, Q&A (for pages where users submit answers), Math solver, Dataset. Google's search gallery is the current list.

Removed:

• HowTo: rich result removed in September 2023.
• Sitelinks search box: removed in November 2024, so SearchAction markup no longer does anything in Google.
• June 2025 cleanup: Google announced it would phase out Book Actions, Course info, ClaimReview, Estimated salary, Learning video, Special announcement and Vehicle listing. ClaimReview stays supported in the Fact Check Explorer tool.
• FAQ: rich result gone since 7 May 2026, docs removed in June 2026.

Speakable is a different case: still a beta, limited to news publishers in US English.

The Most Common Schema Mistakes

I've dogfooded Lumina's Schema Validator against Lumina's own pages and a range of external sites. These six patterns cause most real problems.

1. Markup that doesn't match the page. Reviews, prices or FAQ answers that only exist in JSON-LD, or schema text that says something different from the visible content. Google's structured data policies require markup to represent the page, and violations can lead to a manual action. For FAQ markup, the simple fix is a process rule: change HTML and schema in the same commit and check them against each other before deploy.

2. Duplicate or disconnected entities. The article's author is {"@type":"Person","name":"Author"} inline, while a separate Person block with the real details sits unconnected on the same page. Or a plugin and a hand-written block both output an Organization with different logos. Define each entity once and reference it by @id.

3. Unreliable dateModified. Two mirror-image bugs. Content changes but the date doesn't, or the date changes on every CSS tweak. Google asks for accurate dates and warns against artificially refreshing them. Bump dateModified only for meaningful content changes.

4. Invented properties. applicationArea doesn't exist on schema.org, and neither does coverImage. Unknown properties are ignored. The Schema Markup Validator flags them, while Google's Rich Results Test only checks the properties relevant to Google features. When in doubt, check the type's page on schema.org.

5. Breadth without relevance. Fourteen types on a blog post, from DefinedTerm to ReadAction, when half of them don't describe the page. It adds maintenance work and room for contradictions. Three to five well-connected entities that match the page are easier to keep correct.

6. Raw HTML tags inside text fields. If an FAQ answer mentions tag names like <nav> or <main>, parsers may treat them as markup and drop them, leaving "elements such as , ," in the text. I found this on Lumina's own site on May 9, 2026, in 14 of 656 FAQ answers across 102 files. Escape angle brackets as < and > when you mean them as text.

How to Validate Schema Markup

Three tools that catch different problems:

• Google Rich Results Test. Checks a URL or code snippet for the rich results Google supports, and flags missing required and recommended properties. It only covers Google features, so it no longer tests FAQ markup.
• Schema Markup Validator. Checks markup against the full schema.org vocabulary and reports unknown types and properties.
• Lumina Schema Validator. Free, no signup. Checks JSON syntax and required and recommended fields for Google features, warns about types whose rich results Google removed, and compares FAQPage text with the visible FAQ on the page.

That FAQ comparison is the part the other two don't do. Lumina's validator extracts the JSON-LD and the visible FAQ items, then compares them question by question and answer by answer, including count, order and wording. It checks each page on its own and doesn't follow @id references to other URLs.

A practical workflow: check vocabulary with the Schema Markup Validator while writing, test Google eligibility with the Rich Results Test before shipping, and run Lumina's validator on the live URL after deploy to catch FAQ drift.

FAQ

Where to Start

Five steps, in order. About an hour or two for a small site: