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:
@contextnames the vocabulary, which ishttps://schema.orghere.@typepicks the type, spelled exactly as schema.org spells it:BlogPosting, notblogPosting.- Properties come from the type's page on schema.org, such as
headlineordatePublished. - Nested objects describe related things, like an
authorthat is itself aPerson. @graphand@idlet 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 type | What Google can show | Notes |
|---|---|---|
Article, NewsArticle, BlogPosting | Better title, image and date info | No required properties |
BreadcrumbList | The page's position in your site | Best for multi-level sites |
Product with Offer | Price, availability and ratings | For product pages |
Review, AggregateRating | Review snippet with a star rating | Attach to a supported item type |
Recipe | Recipe details such as ratings and cook time | Can appear in a carousel |
Event | Event listings with date and place | For concerts, talks and classes |
LocalBusiness | Business details such as hours | For physical locations |
Organization | Logo, address and contact details | Can show in knowledge panels |
VideoObject | Video results and key moments | Needs a name, thumbnail and upload date |
JobPosting | Listings in Google's job search | For individual jobs |
SoftwareApplication | App details and ratings | For 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:
| Feature | What happened | When |
|---|---|---|
| HowTo | Docs removed, no longer shown | September 14, 2023 |
| Sitelinks search box | Docs removed | November 29, 2024 |
| Course info, Estimated salary, Learning video, Special announcement, Vehicle listing | Phase-out announced, then docs removed | June 12 and September 9, 2025 |
| ClaimReview (fact check) | Being phased out of Search | Announced June 12, 2025 |
| Practice problem | Phase-out announced, then docs removed | November 5, 2025 and January 6, 2026 |
| FAQ | No longer shown in Google Search | From 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:
- Write the JSON-LD by hand and paste it into the page. Google's intro lists both the
headand thebodyas valid places for the script block. - 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.
- 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:
- Validate the block in the Schema Markup Validator and fix every error.
- Run the page through the Rich Results Test for the feature you want.
- After launch, use Search Console's URL Inspection tool to confirm Google found the markup.
- 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.