Schema Markup: What It Is, JSON-LD Examples and Testing

November 11, 2026 · 12 min read

Schema Markup Explained: What It Is, With JSON-LD Examples

Schema markup is structured data, usually a JSON-LD block, that tells search engines what a page is about in a shared vocabulary from schema.org. It labels a page as an article, a product or an event, with properties like author and price. This guide shows real code, which types still earn Google rich results, and how to test them.

What Is Schema Markup? An Example You Can Read

Schema.org is a shared vocabulary of types and properties for describing things on the web. Google, Microsoft, Yahoo and Yandex founded it, and the W3C Schema.org Community Group has been its main forum since April 2015. At the time of writing, release 30.1 lists 826 types and 1,540 properties.

You'll sometimes see people ask for a "schema markup language". There isn't one. Schema.org is a vocabulary, and you write it using a data format such as JSON-LD. That makes it a different kind of thing from HTML or Markdown, which our Markdown vs markup explainer covers.

These schema markup examples use made-up data you can swap for your own. Here's a block for a blog post:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How We Cut Our Build Time in Half",
  "datePublished": "2026-11-02T09:00:00+00:00",
  "dateModified": "2026-11-05T14:30:00+00:00",
  "author": {
    "@type": "Person",
    "name": "Priya Raman",
    "url": "https://example.com/team/priya"
  },
  "image": "https://example.com/images/build-time.png"
}
</script>

Visitors never see this block. A crawler reads it as one BlogPosting with a headline, two dates, an image and an author who is a Person. Those are the properties Google recommends in its Article documentation, which has no required properties at all.

JSON-LD, Microdata and RDFa: Three Ways to Write the Same Data

You can express schema.org data in three formats. Google's introduction to structured data says all three are equally fine for Google as long as the markup is valid. It still recommends JSON-LD if your site's setup allows it.

JSON-LD sits in its own script block, apart from the visible HTML. Microdata does the opposite: it adds itemscope, itemtype and itemprop attributes to the elements readers already see. Here's the same organization in Microdata:

<div itemscope itemtype="https://schema.org/Organization">
  <span itemprop="name">Northwind Books</span>
  <a itemprop="url" href="https://example.com">example.com</a>
  <img itemprop="logo" src="https://example.com/logo.png" alt="Northwind Books logo">
</div>

The itemscope attribute starts a new item, and itemtype names its schema.org type. Each itemprop takes its value from the element: the text for the span, the href for the link and the src for the image.

And here it is as JSON-LD:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Northwind Books",
  "url": "https://example.com",
  "logo": "https://example.com/logo.png"
}

RDFa works like Microdata, with attributes such as vocab, typeof and property spread through the HTML. We prefer JSON-LD generated by the page template over attributes scattered through markup. A redesign can't silently delete a property when the data lives in one block.

How JSON-LD Schema Markup Is Built

Every JSON-LD block follows the same pattern. Learn these five pieces and you can read almost any example on schema.org:

  • @context names the vocabulary, which is https://schema.org here.
  • @type picks the type, spelled exactly as schema.org spells it: BlogPosting, not blogPosting.
  • Properties come from the type's page on schema.org, such as headline or datePublished.
  • Nested objects describe related things, like an author that is itself a Person.
  • @graph and @id let one block hold several entities and point between them.

The last one matters once a page describes more than one thing. In this block, the post's publisher refers back to the organization by its @id, so you don't repeat the organization's details:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#org",
      "name": "Northwind Books",
      "logo": "https://example.com/logo.png"
    },
    {
      "@type": "BlogPosting",
      "headline": "Spring Reading List",
      "datePublished": "2026-03-20",
      "publisher": { "@id": "https://example.com/#org" }
    }
  ]
}

The @id value is an identifier, not a page anyone visits. A URL with a fragment like #org is a common convention.

Many broken blocks fail on plain JSON syntax rather than on schema rules. Watch for trailing commas and curly quotes pasted from a word processor. Dates also need ISO 8601 form, such as 2026-03-20. If JSON itself is new to you, our JSON to Markdown guide shows how objects and arrays are shaped.

A syntax error won't crash your page. Browsers don't run a script block of type application/ld+json, so the page renders as normal. Parsers can't read the broken block either, so the data is lost without any visible sign. Search Console's Unparsable structured data report flags these blocks on pages Google has crawled.

Types of Schema Markup That Still Earn Google Rich Results

Schema.org has hundreds of types, but Google only turns some of them into rich results. Its search gallery listed 25 features when we checked in November 2026. These are the ones most sites use:

schema.org typeWhat Google can showNotes
Article, NewsArticle, BlogPostingBetter title, image and date infoNo required properties
BreadcrumbListThe page's position in your siteBest for multi-level sites
Product with OfferPrice, availability and ratingsFor product pages
Review, AggregateRatingReview snippet with a star ratingAttach to a supported item type
RecipeRecipe details such as ratings and cook timeCan appear in a carousel
EventEvent listings with date and placeFor concerts, talks and classes
LocalBusinessBusiness details such as hoursFor physical locations
OrganizationLogo, address and contact detailsCan show in knowledge panels
VideoObjectVideo results and key momentsNeeds a name, thumbnail and upload date
JobPostingListings in Google's job searchFor individual jobs
SoftwareApplicationApp details and ratingsFor apps and web apps

The gallery also covers less common features, including Q&A, Discussion forum, Profile page, Course list, Math solver and Vacation rental.

The list keeps shrinking. Google's Search Central changelog records these retirements:

FeatureWhat happenedWhen
HowToDocs removed, no longer shownSeptember 14, 2023
Sitelinks search boxDocs removedNovember 29, 2024
Course info, Estimated salary, Learning video, Special announcement, Vehicle listingPhase-out announced, then docs removedJune 12 and September 9, 2025
ClaimReview (fact check)Being phased out of SearchAnnounced June 12, 2025
Practice problemPhase-out announced, then docs removedNovember 5, 2025 and January 6, 2026
FAQNo longer shown in Google SearchFrom May 7, 2026

ClaimReview isn't gone everywhere: Google's ClaimReview page says Fact Check Explorer still supports the markup. Retired types also stay valid schema.org data and still pass a schema.org validator. They just stop producing anything visual in Google Search.

Does Schema Markup Help SEO?

Google describes two jobs for structured data. It helps Google understand what a page contains, and it can make the page eligible for rich results. Eligibility isn't a promise, though. Google's structured data policies say it doesn't guarantee your markup will show up, even when it tests as valid.

The same policies set the rules. Don't mark up content that readers can't see, and keep the markup representative of the page. Breaking them can lead to a manual action, which removes the page's eligibility for rich results. Google says that action doesn't affect how the page ranks in web search.

Be wary of any guide that promises a click-through lift or more AI citations from schema markup for SEO. Google's AI features documentation says there's no special schema.org structured data you need to add to appear in AI Overviews or AI Mode. Its only structured data advice there is that your markup should match the visible text on the page.

This is the limitation to plan around. Valid markup earns a chance at a rich result, and Google decides whether to use it. Mark up what a feature actually supports, and don't expect markup to fix a thin page.

How to Add Schema Markup to Your Website

You have three practical routes. Pick the one that matches how your site is built:

  1. Write the JSON-LD by hand and paste it into the page. Google's intro lists both the head and the body as valid places for the script block.
  2. Use your CMS. Many CMS themes and SEO plugins output Article, Organization and Breadcrumb markup for you. Check what they emit before adding your own, so you don't publish two conflicting blocks.
  3. Generate it in your site template. Each page fills the same block from its own data, so every post gets correct markup without copying and pasting.

Route three suits static sites that turn Markdown into HTML at build time. Each post often carries its title, date and author in front matter already, which our Markdown front matter guide explains:

---
title: Spring Reading List
date: 2026-03-20 09:00:00 +0000
author: Priya Raman
---

A Jekyll layout can then turn those fields into JSON-LD. Treat this as a sketch to adapt, since other generators use their own template syntax:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": {{ page.title | jsonify }},
  "datePublished": {{ page.date | date_to_xmlschema | jsonify }},
  "author": {
    "@type": "Person",
    "name": {{ page.author | jsonify }}
  }
}
</script>

The jsonify filter wraps each value in quotes and escapes characters that would break the JSON. The date_to_xmlschema filter outputs an ISO 8601 date. Hugo, Eleventy and Astro can all do the same with their own functions.

Google can also read JSON-LD that JavaScript injects, as long as it's in the rendered page. Test those pages by URL, not by pasted code.

For the tags that sit next to schema, our meta tag generator builds meta and Open Graph tags in your browser. It can also build FAQPage JSON-LD from ## Question headings written in Markdown. It doesn't produce other schema types or test your markup.

How Do You Find and Test Schema Markup on a Page?

To find the structured data on any page, open its source and search for application/ld+json. For Microdata, search for itemtype; for RDFa, search for typeof. Your browser's developer tools work too, and they show JSON-LD that JavaScript added after load.

Two free validators do different jobs, so use both:

  • Rich Results Test checks a live URL or a code snippet. It reports which Google rich results the page can get, and it only reports types Google supports.
  • Schema Markup Validator checks any schema.org markup in JSON-LD, Microdata or RDFa. Use it for types Google has retired or never supported.

Here's a short checklist before and after you publish:

  1. Validate the block in the Schema Markup Validator and fix every error.
  2. Run the page through the Rich Results Test for the feature you want.
  3. After launch, use Search Console's URL Inspection tool to confirm Google found the markup.
  4. Watch the rich result status reports in Search Console for new errors and warnings.

Warnings usually flag a missing recommended property. Errors, which Search Console calls critical issues, make the item ineligible for that rich result, so fix those first.

FAQPage Markup After May 2026

FAQPage is still a valid schema.org type, and a short block looks like this:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do you ship to Canada?",
      "acceptedAnswer": { "@type": "Answer", "text": "Yes, in 5 to 8 business days." }
    }
  ]
}

What changed is Google's side. The FAQ rich result stopped appearing in Google Search from May 7, 2026, and Google removed its FAQ documentation on June 15, 2026. Other tools that read schema.org can still parse the block, but it won't add expandable questions to your Google result. Our meta tag generator outputs this kind of FAQPage block if you still want one. For a fuller example, a Markdown workflow and testing, see our tutorial on writing FAQPage JSON-LD.

Quick Answers on Structured Data

Good schema markup is short, accurate and generated from the same data as the page it describes. Start with the types Google still shows, validate every block, and don't expect retired features to change how your result looks. If you publish from Markdown, keep titles and dates in your files, write and preview posts in the editor, and let your template build the JSON-LD.