Schema Markup for Rich Snippets: The Complete Guide

What Structured Data Actually Is (and Why JSON-LD Won)

Structured data is a labelling layer you add to a page so machines can read what humans already understand at a glance. A person looking at your product page knows instantly which number is the price, which stars are the rating, and which paragraph is the description. A crawler is parsing a wall of HTML and guessing. Schema markup removes the guessing: it says, in a vocabulary search engines have agreed on, “this is a Product, its price is 89 dollars Canadian, it’s in stock, and it has been reviewed 214 times.”

That shared vocabulary is Schema.org, a project founded by Google, Microsoft, Yahoo, and Yandex in 2011 so the industry wouldn’t end up with four competing labelling systems. It defines hundreds of types — Product, Article, Event, LocalBusiness, Recipe, JobPosting — and the properties each can carry. You’ll only ever use a dozen, but knowing the catalogue exists matters, because the type that fits your business is usually more specific than the one everybody defaults to.

There are three syntaxes for putting this vocabulary on a page: microdata and RDFa, which weave attributes into your existing HTML tags, and JSON-LD, which sits in a single self-contained script block, usually in the head. JSON-LD won, and Google says plainly that it’s the recommended format. The reason is practical: microdata entangles your markup with your template, so every theme change risks breaking it, while JSON-LD lives in one block you can generate, inject, and update without touching the visible page. Everything in this guide assumes JSON-LD.

The Rule Everything Else Hangs On: Eligibility Is Not a Guarantee

Before walking through the schema types, one rule reframes all of them: structured data makes a page eligible for a rich result. It does not entitle the page to one. Google decides, query by query, whether showing an enhanced result serves the searcher, and it routinely declines even when the markup is flawless. You can implement perfect Product markup and still see a plain blue link, because the algorithm weighs the page’s quality, the site’s track record, and what else is competing on that SERP.

The gap between eligibility and display is where most schema disappointment lives. Site owners add markup, wait two weeks, see nothing, and conclude schema “doesn’t work.” What actually happened is that they cleared the technical bar and not the trust bar — or marked up a page type Google has simply stopped enhancing, which we’ll get to with FAQ and HowTo.

The second framing rule: structured data is not a ranking factor in the direct sense. Google has said this consistently for years. A marked-up page doesn’t outrank an identical unmarked page. What schema changes is presentation — stars, prices, breadcrumbs, event dates rendered directly in the result — and presentation changes click-through rate. A result with visible ratings and a price occupies more vertical space and answers a pre-click question, so it tends to attract a larger share of the clicks available at its position. That’s the honest business case: schema doesn’t move you up the page, it makes the position you’ve earned work harder. Anyone selling it as a rankings lever is selling something else.

The Schema Types That Still Earn Visible Rich Results

Google’s gallery of supported rich results has been shrinking for years, so the useful question isn’t “what can I mark up” — almost anything — but “what still produces something a searcher can see.” For most businesses, six types carry nearly all the value.

Product is the heavyweight for anyone selling things. With offers, price, currency, availability, and aggregate ratings marked up, your listing can show stars, the price, and stock status right in the result — and the same feed of facts powers Google’s shopping surfaces. The required properties are strict, which is the point: incomplete Product markup validates as schema but qualifies for nothing.

Review and AggregateRating markup put star ratings on results for products, recipes, courses, and a handful of other types. The critical restriction: since 2019, Google ignores self-serving review markup — a business marking up reviews about itself on its own LocalBusiness or Organization entity. Stars on your homepage from your own testimonials page stopped working years ago, and faking your way around it is manual-action territory, covered later.

LocalBusiness is the one every service business should have and most implement lazily. Name, address, phone, opening hours, geo coordinates, and the most specific subtype that fits — Plumber, Dentist, Restaurant — all matching your Google Business Profile exactly. It rarely produces a flashy visual snippet, but it feeds the knowledge panel and helps Google connect your website to your map listing as one entity, which is where local rankings actually live.

Article markup — with headline, author, datePublished, and dateModified — feeds headline-and-image treatment in Top Stories and Discover, and it’s how you assert authorship and freshness in a machine-readable way. Breadcrumb markup is the quiet workhorse: it replaces the raw URL in your result with a readable path, costs almost nothing to implement sitewide, and almost always displays. Event markup, for venues, organizers, and anyone hosting anything, surfaces dates, locations, and ticket availability in results and in Google’s event experiences.

Beyond these six, check Google’s search gallery against your actual page types — JobPosting, Recipe, Course, and VideoObject all still earn enhancements for the sites they fit.

FAQ and HowTo: A Cautionary Tale in Two Acts

No schema story illustrates Google’s willingness to take toys away like FAQ and HowTo, and it’s worth telling accurately because outdated advice about both is still everywhere.

FAQ markup, introduced for general use in 2019, let any page with question-and-answer content earn expandable Q&A dropdowns directly in the search result. It was wildly popular — partly because it worked on almost any page, and partly because those dropdowns made a listing two or three times taller than its neighbours. That popularity was its undoing. SERPs filled with accordion-stuffed results, sites bolted FAQ blocks onto pages that weren’t really FAQs, and the feature stopped helping searchers. In August 2023, Google announced that FAQ rich results would only be shown for well-known, authoritative government and health websites. For everyone else — agencies, retailers, SaaS companies, local businesses — the visual treatment is gone. You can still include FAQPage markup, and the question-and-answer content itself remains genuinely useful on the page, but if someone promises you FAQ dropdowns in Google results in 2026, they’re working from a 2021 playbook.

HowTo fared worse. The markup powered step-by-step rich results for instructional content, complete with images per step. In the same August 2023 announcement, Google restricted HowTo rich results to desktop only — and then, in September 2023, deprecated them entirely. No site, however authoritative, gets a HowTo rich result anymore. The markup type still exists in the Schema.org vocabulary, but it earns nothing visible in Google search.

The lesson isn’t “schema is futile.” It’s that rich result features are rented, not owned, and Google has demonstrated it will revoke a feature when it stops serving searchers — the sitelinks search box was similarly retired in 2024. Build your schema strategy around the durable core from the previous section, treat any newly launched rich result type as a bonus with an uncertain lifespan, and never let a deprecated feature’s ghost markup linger in your templates pretending to do work.

The New Reason to Care: Entities, AI Assistants, and Machine Readability

If schema were only about rich snippets, the FAQ and HowTo story might argue for caring less. The opposite is happening, because the audience for structured data is expanding beyond the classic search results page.

Search engines have spent a decade shifting from indexing strings to understanding entities — distinct things in the world with names, properties, and relationships. Your business is an entity. Schema markup is the most direct way you get to describe your own entity in machine-readable terms: this Organization has this legal name, this logo, this address, these social profiles, this founder, and it’s the same entity as that Google Business Profile and that LinkedIn page. The sameAs property, linking your Organization markup to your profiles elsewhere, does quiet consolidation work that no amount of body copy can. When Google is confident about who you are, everything downstream — knowledge panels, local results, brand-query SERPs — gets cleaner.

Then there’s the AI layer. Answers from AI search experiences and assistants are assembled by systems that retrieve, parse, and synthesize web content at speed, and content whose key facts are explicitly structured is simply easier to extract correctly than content where the facts are buried in prose. Schema doesn’t guarantee inclusion in an AI-generated answer any more than it guaranteed a rich snippet — the eligibility-versus-guarantee rule survives intact — but it stacks the deck toward being understood accurately: the right price, the right hours, the right attribution. Unambiguous machine-readable facts reduce the odds of being misquoted by the machines doing the quoting.

The practical takeaway: the presentation payoff of schema fluctuates with Google’s feature decisions, but the comprehension payoff compounds. Marking up your pages is increasingly less about decorating a search listing and more about maintaining an accurate machine-readable record of what your business is — for whichever system, search engine or assistant, comes asking.

Implementation: Four Ways In, From Plugins to Hand-Rolled JSON-LD

There are four realistic paths to getting JSON-LD onto your pages, and the right one depends on your platform and how many templates you’re marking up.

If you’re on WordPress, Shopify, or a similar CMS, start with what’s already running. Most modern SEO plugins and commerce themes emit baseline schema automatically — Article on posts, Product on product pages, often Organization sitewide. The job is auditing rather than authoring: confirm what’s being output, fill the gaps, and watch for the classic failure where a plugin and a theme both inject markup and disagree about what the page is. Duplicate, conflicting blocks are one of the most common findings in technical audits.

For one-off pages and smaller sites, free schema generator tools are the fastest route: pick a type, fill in a form, and copy a valid JSON-LD block into your page or tag manager. We built a free schema generator at SearchPod for exactly this workflow, and several other reputable free generators exist — the output is standard JSON-LD either way, so use whichever fits your hand. Generators are ideal for LocalBusiness markup, an Organization block, or a single event, where the facts rarely change and a hand-maintained snippet is no burden.

At scale, generate from templates. If you have four hundred products, you don’t write four hundred snippets — your template builds the JSON-LD from the same database fields that render the visible page. This is the gold standard, because it makes drift impossible: when the price changes in the database, it changes in the markup and on the page simultaneously. Modern frameworks make this trivial; even older stacks can usually template a script block.

The fourth path is injecting JSON-LD through Google Tag Manager. It works, and it’s sometimes the only option when you can’t touch the codebase, but treat it as a last resort: the markup only exists after JavaScript runs, it lives outside the page’s natural deployment process, and it’s easy to forget it’s there. Wherever the markup comes from, one rule is absolute — the structured data must describe content that’s visibly on the page. Markup that says things the page doesn’t is a guideline violation, not a clever shortcut.

Validation: Test Before Launch, Monitor After

Schema fails silently. A malformed block doesn’t break the visible page — it just quietly qualifies you for nothing — so validation has to be deliberate, and it has two distinct phases.

Before launch, two tools answer two different questions. Google’s Rich Results Test answers “is this page eligible for Google’s rich result features?” — paste a URL or raw code and it lists every detected type, flags missing required fields as errors, and missing recommended fields as warnings. The Schema.org validator answers the broader question, “is this valid structured data at all?” — useful because you may be marking up things Google doesn’t currently enhance but other consumers can still read. Run key templates through both. Errors block eligibility and must be fixed; warnings cap your potential and should be worked down where the data genuinely exists. Don’t invent values to silence a warning — an empty field is honest, a fabricated one is a violation.

After launch, Search Console becomes the monitor. Its enhancement reports track every recognized schema type across the whole indexed site, which is how you catch the failure modes a one-page test never sees: a template change that broke markup on every product at once, a plugin update that started emitting duplicates, valid items drifting into the error column after a redesign. Check these reports as part of your regular SEO cadence, and especially after any deploy that touches templates.

Two habits round out the practice. First, when markup is healthy but rich results aren’t showing, use the URL Inspection tool to confirm Google’s rendered version of the page actually contains your JSON-LD — markup injected client-side sometimes never makes it into what Google processes. Second, measure outcomes in Search Console’s performance report, where filtering by search appearance lets you compare click-through rates for enhanced results against plain ones. That’s the number that justifies the work.

The Ways to Get Punished: Spammy Markup and Manual Actions

Structured data is one of the few areas of SEO where Google still issues old-fashioned manual actions — a human reviewer flags your site, a notice appears in Search Console, and your rich results vanish sitewide until you fix the problem and pass a reconsideration review. The violation category is called spammy structured markup, and it’s entirely avoidable, because every offence boils down to the same sin: markup that lies.

Fake and self-serving reviews top the list. Marking up ratings no customer ever gave, hardcoding a 4.9 aggregate score with no underlying reviews on the page, or routing around the self-serving review restriction with creative entity nesting — reviewers see all of it constantly, and it’s easy to spot precisely because the marked-up numbers don’t correspond to anything visible.

Invisible content is the second classic: structured data describing material that users can’t see on the page. Q&A markup for questions that appear nowhere in the visible content, event markup for events the page never mentions, marked-up “articles” wrapping thin commercial pages. The governing rule has already appeared twice in this guide because it’s the rule: markup must reflect the visible page. Related offences include marking up irrelevant or misleading content — calling a sales page a Recipe because recipes got rich results — and impersonating another organization in your markup.

If a manual action lands, the path back is unglamorous: fix every instance across the site, not just the example cited, then file a reconsideration request. Recovery happens, but you’ve burned weeks of enhanced visibility.

The broader close: schema markup is unusual in SEO in that the honest version is also the easy version. Describe what your pages truly are, in the most specific types that fit, in JSON-LD, validated before launch and monitored after. Skip the deprecated features, ignore anyone promising stars they can’t deliver, and treat the markup as what it’s become — your business’s machine-readable public record, read by more kinds of machines every year.