Schema Markup

Schema markup is code added to a page that labels its content using the Schema.org vocabulary, so a search engine knows this number is a price, this string is a recipe's cook time, this block is a job posting. It's the difference between Google guessing what your page is about and Google being told, and it's the entry ticket for rich results, which can lift your click-through rate without your ranking moving an inch.

Vocabulary first, format second

People conflate two separate things. Schema.org is the vocabulary: a shared dictionary of types (Product, Article, Recipe, LocalBusiness, Event, over 800 of them) and the properties each type accepts, maintained jointly by Google, Microsoft, Yahoo and Yandex since 2011. Schema markup is the act of applying that vocabulary to a real page. The vocabulary tells you a Product can have an offers property; the markup is you actually declaring that your trail shoe costs $120.

The format you write it in is a third thing entirely. Google accepts Microdata and RDFa, but the format that won is JSON-LD, a self-contained script block that never touches your visible HTML. This page covers what to say; the JSON-LD entry covers how to say it.

A real example

Here's a Product markup block the way it should actually look on a live e-commerce page, nested Offer, real currency, a rating backed by genuine reviews:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Ridgeline Trail Running Shoe",
  "image": "https://example.com/img/ridgeline-blue.jpg",
  "description": "Lightweight trail shoe with 6mm lugs and a rock plate.",
  "brand": { "@type": "Brand", "name": "Ridgeline" },
  "offers": {
    "@type": "Offer",
    "price": "120.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://example.com/shoes/ridgeline-trail"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "212"
  }
}
</script>

Every value in that block must describe content a user can actually see on the page. Mark up a 4.6 rating that appears nowhere on the page and you're violating Google's structured data guidelines, that's manual action territory, not a growth hack.

Which types are worth your time

Not all schema types pay off equally. Some unlock a visible rich result, some feed entity understanding quietly, and a few used to pay off but Google has since pulled the plug. Here's the honest map as of 2026:

How to check it on your own site

1. Run your key templates (one product page, one article, homepage) through the Rich Results Test at search.google.com/test/rich-results. This checks Google eligibility specifically, it only reports on types Google actually uses.
2. Run the same URLs through the Schema Markup Validator at validator.schema.org. This checks vocabulary correctness for everything, including types Google ignores. A page can pass one and fail the other.
3. Open Search Console → Enhancements (and the Shopping tab for Product). These reports show what Google found at scale across your site, with item counts, errors, and warnings, errors kill eligibility, warnings just cap it.
4. Spot-check that the values in the markup match what's rendered on the page. Validators verify syntax, not honesty. A price that went stale in the markup while the page shows a sale price is a mismatch only a human catches.
5. If your markup is injected by JavaScript, confirm it survives rendering: URL Inspection in Search Console → View crawled page → search the rendered HTML for ld+json.

Common mistakes

• Marking up content that isn't on the page. The single most common guideline violation found in audits: aggregate ratings with no visible reviews, FAQ markup for questions that appear nowhere. Fix: markup mirrors the page, always.
• Site-wide markup pasted on every URL. LocalBusiness or aggregateRating stamped into the global footer means every blog post claims to be a rated business. Fix: Organization on the homepage or about page; page-level types only where they apply.
• Wrong type selection. A category page marked up as Product (it's a list, use ItemList), a service page marked up as Product to chase stars. Fix: pick the type that describes what the page is, not the rich result you want.
• Required properties missing, nobody notices. Structured data fails silently, no error page, no ranking drop, just no rich result. Fix: check the type's required-property list in Google's documentation, then confirm in the Enhancements report.
• Set-and-forget rot. Templates change, markup doesn't. Prices drift, author names change, and the markup quietly lies. Fix: generate markup from the same data source that renders the page, and re-validate after every template release. When rich results stop showing, work through a structured debugging process instead of re-guessing.

FAQ

Does schema markup improve rankings?

Not directly, and Google has said so repeatedly. It improves eligibility for rich results, which can improve click-through rate, and it helps search engines and AI systems disambiguate your content. Treat it as a presentation and comprehension layer, not a ranking lever.

Which format should I use?

JSON-LD, in almost every case. It's Google's stated recommendation, it doesn't tangle with your visible HTML, and it's the easiest to template and maintain. Microdata still validates fine, but there's no reason to start a new implementation with it.

How much markup is too much?

Mark up what the page genuinely is and stop. Stacking six loosely-applicable types on one URL doesn't multiply anything, it muddies the entity signal and increases the odds one of them violates a guideline. One primary type per page, plus structural helpers like BreadcrumbList, covers nearly every site.

Do AI systems actually use schema markup?

Increasingly, yes. LLM-based crawlers and answer engines lean on structured data to extract facts with confidence, an explicit price beats a scraped one. That's a reason to keep FAQPage and other "no rich result" types around even after Google stopped rewarding them visually.

Do I have to write it by hand?

No. A schema markup generator gets you a valid starting block; your job is wiring it to real page data so it never drifts out of date.