What Is Schema Markup?
Schema markup is structured data that uses the schema.org vocabulary — a shared library of types and properties like Product, Article, and Event — to describe a page’s content in terms search engines recognize. Added in a format such as JSON-LD, it labels entities on the page so engines can understand them and qualify the page for rich results.
- Schema.org is a shared vocabulary created by Google, Microsoft, Yahoo, and Yandex so that markup written once is understood by all the major search engines.
- Schema markup is the vocabulary; structured data is the general format concept — the terms are used interchangeably, but schema.org is the specific type-and-property library.
- A schema type is chosen from schema.org (for example
ProductorFAQPage) and its properties describe the entity; each property maps to a piece of content on the page. - Google recommends writing schema markup in JSON-LD, though it also accepts the same schema.org types expressed in Microdata or RDFa.
How Schema Markup Works
Schema markup solves a problem plain HTML can’t: HTML tags describe how content should look, but not what it means. Schema.org, in its own words, is “a collection of shared vocabularies webmasters can use to mark up their pages in ways that can be understood by the major search engines.” That shared vocabulary is the whole point. Because Google, Microsoft, Yahoo, and Yandex agreed on it together in 2011, a Product or Recipe you mark up once is interpreted the same way across their engines — you don’t tag your pages differently for each one.
The vocabulary is organized as a hierarchy of types and properties. A type is the kind of thing an entity is — Article, Product, Event, LocalBusiness, FAQPage. Each type has properties that describe it: a Product has name, image, offers, aggregateRating; an Event has startDate, location, performer. Marking up a page means choosing the type that matches its primary entity and mapping each visible piece of content to the right property.
That mapping is what turns text into meaning. Wrapping “$29.99” in a price property tells the engine this string is a price in a specific currency, not a random number. Once the engine can classify the page’s entities with confidence, it can qualify the page for a rich result — the enhanced listing with stars, images, or prices that stands out in the results.
Format vs Vocabulary
A recurring source of confusion is that schema markup involves two separable choices, and people collapse them:
- The vocabulary — schema.org. This decides which words you use: the type names and property names. This is the “schema” in schema markup.
- The format — JSON-LD, Microdata, or RDFa. This decides how those words are physically placed on the page.
You always pick both. Modern SEO almost universally pairs the schema.org vocabulary with the JSON-LD format, because JSON-LD keeps the markup in a single script block instead of tangling it through your visible HTML. Google recommends exactly this combination for most sites, while noting that the same schema.org types expressed in Microdata or RDFa are equally valid.
Example of Schema Markup
The most authoritative worked example is schema.org’s own founding case. The project’s getting-started documentation gives the canonical illustration of why a shared vocabulary is needed: the word “Avatar” on a page could refer to the James Cameron film or to a user’s profile picture, and standard HTML gives a search engine no way to tell them apart. Schema markup resolves the ambiguity — tagging the entity as a Movie with a director property named “James Cameron” tells the engine unmistakably which “Avatar” the page is about.
This example is instructive because it shows schema markup doing its core job before any rich result enters the picture: disambiguating entities. The engine’s first task is comprehension — knowing that a page about “Avatar” the movie is a different thing from a page about avatars the profile images. Only once that comprehension is in place can the engine confidently promote the page to a movie rich result with a poster, cast, and ratings.
The mechanism is fully documented and testable, which is what keeps it out of guesswork. The schema.org site publishes every type and its valid properties, and Google’s Rich Results Test reports exactly which required properties a given markup is missing. The lesson generalizes directly: schema markup is a precise description written in an agreed language. Choose the type that genuinely names the page’s main entity, fill the properties that correspond to what’s actually visible, and the engine gains the clarity it needs to both understand and showcase the page. Describe the page truthfully, and schema markup does the rest.
Where I see schema markup go wrong is teams marking up everything and validating nothing against the actual page. Schema is a description of reality, not a wish. If your markup declares a 4.9 rating from 240 reviews but the page shows no reviews, you haven’t earned a rich result — you’ve handed Google a reason to distrust the whole document and, in bad cases, a manual action for spammy structured data. The discipline is boring and it works: pick the one schema type that genuinely matches the page’s primary entity, fill only the properties that correspond to visible content, and run it through the Rich Results Test before you ship. Schema rewards accuracy, not ambition. The pages that win are the ones whose markup a skeptical reviewer could verify by simply looking at the page.
Schema Markup vs Structured Data
| Schema Markup | Structured Data | |
|---|---|---|
| What it names | The schema.org vocabulary — the types and properties | The general format/concept for machine-readable page meaning |
| Layer | The words (which type, which properties) | The container and syntax that holds them |
| Origin | schema.org, launched 2011 by the major search engines | A broad standard predating and extending beyond schema.org |
| Everyday use | “Add schema” = which vocabulary you’re marking up with | “Add structured data” = the whole markup task |
In practice SEOs use the two phrases interchangeably, and that’s usually fine — when someone says “add structured data” for search, they mean schema.org markup. The precise relationship is that structured data is the wider category, and schema markup is the specific, dominant vocabulary used inside it.
Frequently Asked Questions
What is schema markup used for?
Is schema markup the same as structured data?
Does schema markup improve rankings?
Who created schema.org?
The Bottom Line
Schema markup is the vocabulary layer of structured data — the agreed-upon set of types and properties that lets you describe a product, an article, or an event in words every major search engine reads the same way. It won’t lift a page up the rankings on its own, but it removes ambiguity about what the page is about and opens the door to a richer listing. Mark up only what’s truly on the page, validate it, and let the description be accurate rather than aspirational.
Sources
- Getting started with schema.org using Microdata — schema.org
- Introduction to structured data markup in Google Search — Google Search Central
Roborank checks your schema.org markup for missing properties and validation errors, then flags the pages that could earn a rich result but don’t.
Check your schema markup →Rank & Cash — the weekly SEO breakdown
One practical teardown a week on ranking in search and getting cited by AI. No fluff.
