Guide

Schema markup that earns rich results in 2026

Schema markup only earns rich results for a short list of types now. Here's which ones still display, how to write the JSON-LD, and the visible-match rule.

Key takeaways
  • Start with Product, BreadcrumbList and Organization markup, since those types still display in Google results; skip FAQ markup unless you are a government or health site.
  • Generate every JSON-LD block from the same fields that render the visible page, so price, date and rating can never drift apart.
  • Validate with Google's Rich Results Test and the Schema Markup Validator, then check the Search Console Enhancements reports after every deployment.

Most sites that add schema markup see no change in their search results. The usual causes are two mistakes: they marked up a type Google stopped displaying years ago, or they described content the visitor never sees on the page. Both are cheap to fix. This guide covers which types still earn rich results in 2026, how the JSON-LD is built, and the one rule that decides whether your markup helps you or gets you in trouble.

What schema markup does, and what it doesn’t

Schema markup is a shared vocabulary from schema.org for labeling what a page contains. This is an article. This is its author. This is the price of this product, and this is the question and its answer. You write those labels as JSON-LD, add them to the page, and search engines read them as a second, machine-readable description of the same content.

Two misunderstandings cost people the most time.

The first is that markup makes a page rank higher. It doesn’t. Google has said repeatedly that structured data is not a direct ranking signal. What it does is make your page eligible for enhanced display: a price and star rating under the link, or a breadcrumb trail in place of a raw URL. The usual payoff is better click-through, which is an indirect effect on traffic, not a ranking boost.

The second is that eligibility means display. It doesn’t. Google decides, query by query, whether to show a rich result, and it can retire a display type altogether. Treat markup as a bet on a feature that may disappear, not as a permanent asset you install once and forget.

Which types still earn rich results in 2026

Google has spent several years shrinking the list of structured data types it displays. HowTo rich results were removed from Search in 2023. FAQ rich results were restricted that same year to well-known, authoritative government and health websites. In mid-2025, Google announced it was phasing out support for several more, including Book Actions, Course Info, Estimated Salary and Vehicle Listing. The direction is clear: fewer types, displayed more selectively.

Check the Search Central structured data gallery before you build anything new, because the list changes. The table below reflects the state of play as far as this guide can verify. It’s organized around what each type can actually change on a results page, which is the question that matters when you’re deciding where to spend a developer’s afternoon.

Type What it can change in results Core requirement Realistic expectation
Product Price, availability and star ratings under the link Name, image, and offers or genuine reviews Strongest commercial case, and the most likely to display
BreadcrumbList Breadcrumb trail replaces the raw URL Position, name and URL for each level Low effort, low risk, steady display
Article Clarifies headline, date, author and image for features like Top Stories and Discover Headline, image, datePublished, author Helps eligibility and understanding; no visible badge
Organization Brand logo and profile information Name, url, logo, sameAs profiles Worth doing once; no guaranteed knowledge panel
FAQPage Expandable questions and answers under your result Visible Q&A, on an eligible site type Restricted to government and health sites; most will not display

Product: where the payoff is clearest

Product markup earns its keep because shoppers scan for price, availability and ratings before they click. It also has the strictest rules. For a product snippet, Google expects a name and an image, plus at least one of offers, reviews or an aggregate rating. Any rating you show must come from real reviews of that exact product. A five-star average borrowed from a different product line, or from reviews nobody can see on the page, is the fastest way to lose the rich result and, with it, the page’s credibility.

Put Product markup on the product page itself. A category page with twelve products is a list, not a product. Mark it up as a list, or leave it alone.

BreadcrumbList: small, safe, and easy to get right

Breadcrumb markup is the lowest-risk type in the set. Each level needs a position, a name and a URL. Positions start at 1 and increase by one. The names must match the labels a visitor sees in the breadcrumb trail, and the URLs should be the canonical versions of those pages. Ship it on every page that shows a visible breadcrumb, and it will rarely cause you trouble.

Article: clarity, not a visible badge

Article markup (Article, BlogPosting or NewsArticle) does not turn a blog post into a rich result. Its job is to remove ambiguity about the page. Which date is the publication date? Who wrote it? Which image represents it? The headline, image, datePublished, dateModified and author fields answer those questions for systems like Top Stories and Discover, and they help Google display bylines and dates correctly.

Be careful with dateModified. Setting it to today every time you fix a typo is a mismatch with the page, because the visible date doesn’t change. Update it when the content meaningfully changes, and let the visible “last updated” line say the same thing.

Organization: a profile, not a guaranteed panel

Put Organization markup on your homepage: name, url, logo, and a sameAs array linking to your official profiles elsewhere on the web. Knowledge panels depend on Google’s understanding of your brand as an entity. Markup helps by connecting that entity to profiles Google can already verify, which is why sameAs matters more than any other property in this block. Don’t add the block and expect a knowledge panel next week.

FAQPage: write it for readers, not for the rich result

FAQ markup is the most common disappointment. Since 2023, FAQ rich results have been limited to well-known government and health sites, so a SaaS blog or a local business will not see the expandable questions under its result, no matter how well the markup validates. The Q&A content can still help the page, because a clearly headed FAQ section answers questions a reader actually has. Just don’t build it as a rich-result play.

If you want the answer box instead, that’s a content-structure problem, not a markup problem. How to win featured snippets walks through earning it with the copy on your page alone.

JSON-LD basics, with a worked example

Google recommends JSON-LD over microdata and RDFa, and the reason is practical. It lives in one script block, so you can add or change it without touching the visible HTML. A JSON-LD block has four parts you need to understand.

  • @context tells the parser which vocabulary you mean. For schema.org types, it’s always “https://schema.org”.
  • @type names the entity: Article, Product, Organization, BreadcrumbList.
  • Properties are the fields: headline, datePublished, price. Values are strings, numbers, ISO 8601 dates, URLs or nested objects.
  • @id gives an entity a stable identifier you can reference from other blocks. If your Organization appears on every page, define it once with an @id such as “https://example.com/#organization” and point to that ID elsewhere. The parser then sees one company, not a new one on every page.

Here’s a minimal Article block for a post like this one. Swap the example.com values for your own.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Schema markup that earns rich results in 2026",
  "image": "https://example.com/images/schema-markup-guide.jpg",
  "datePublished": "2026-10-12",
  "dateModified": "2026-10-12",
  "author": {
    "@type": "Person",
    "name": "Example Author",
    "url": "https://example.com/authors/example-author"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Co",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  }
}
</script>

Every value in that block corresponds to something a visitor can see. The headline matches the H1, the dates appear in the byline, the author is named on the page, and the logo sits in the header. That correspondence is the whole point, and it leads straight into the rule that matters most.

The golden rule: markup must match what the visitor sees

Markup must match the page: if the JSON says $49 and the page shows $59, search engines read that as a mismatch, not a typo.

Structured data is a description of the page, and the page is what a visitor sees. Google’s structured data guidelines say the same thing in plainer terms: mark up content that is visible on the page, and don’t mark up content that isn’t. Violations are rarely deliberate. They usually come from automation drifting out of sync with the page. These are the ones that show up most often:

  • Price or availability. The page shows a sale price, but the markup holds the list price from the product database. Or the markup was correct on launch day and nobody has touched it since.
  • Ratings with no reviews behind them. An aggregateRating of 4.8 from 1,200 reviews, on a page that shows none. Or a rating imported from a different product entirely.
  • FAQ questions that exist only in the code. Questions written to carry keywords and never rendered for a visitor.
  • Self-serving reviews. Google does not accept a business marking up reviews it wrote about itself.
  • Dates that moved without the content. A dateModified that changes every time the template rebuilds while the visible “updated” line stays put.

Visibility has a practical definition. Content inside a tab or accordion counts as visible when a visitor can reveal it with a normal click. Content that exists only inside a script tag, or in a hidden element nobody can open, does not.

The consequences escalate. The mild outcome is that rich results stop appearing for the affected pages. The serious one is a manual action for spammy structured data, which Search Console reports and which can suppress rich results across the site until you fix the problem and request a review.

The fix is structural rather than a matter of discipline. Don’t rely on a writer remembering to update the price in two places. Generate both from the same field.

1. Writethe visiblepage copy2. DeriveJSON-LD fromone data field3. ValidateRich Results+ validator4. MonitorSearch ConsoleEnhancementsSteps 1 and 2 share one sourceEdit the field once and both outputs update
Generate the markup from the same field that renders the visible page, so the two cannot drift apart.

How to roll out schema markup without breaking your pages

  1. Inventory templates, not pages. Most schema comes from a template, and one broken template can invalidate markup across thousands of URLs. Audit the templates that produce your article, product, category and homepage layouts before you touch anything else.

  2. Match each type to the primary entity on the page. Article for an article, Product for one product, BreadcrumbList for any page with a visible path, Organization once on the homepage. If a page is about one thing, mark up that thing and leave the rest alone.

  3. Generate the JSON-LD from the same data that renders the page. Price, date, author and rating should each come from the field that draws the visible page. Two outputs from one source is what keeps the golden rule true without anyone having to remember it.

  4. Validate before you deploy. Use Google’s Rich Results Test to see whether a page qualifies for Google’s features. Use the Schema Markup Validator at validator.schema.org to check syntax against schema.org, which is the right test for types Google no longer displays. Errors block rich results. Warnings flag optional fields you may want to fill. Fix errors first.

Validate the JSON first: one trailing comma makes the whole block unreadable. The page looks identical to visitors while the markup quietly disappears.

  1. Deploy to a sample, then the rest. Roll out to one template and a few dozen URLs, wait for Google to recrawl them, and then expand. It’s cheap to catch a mistake on fifty pages and expensive on fifty thousand.

  2. Watch the Enhancements reports in Search Console. Each supported type gets its own report with valid, warning and error counts. A sudden drop in valid items after a release almost always means a template change broke the JSON, so check the release log before you check the content.

The failure modes that quietly cost you

Most schema problems never produce an error message. They produce a page that looks fine and a report that slowly gets worse. These are the ones worth checking on every audit.

  • Duplicate blocks from themes and plugins. Themes and SEO plugins often print their own Organization, Article or BreadcrumbList blocks, and the template may print another on top. Two Article blocks with different dates give the parser conflicting facts. View the rendered HTML, search for every application/ld+json script, and decide which block owns each type.
  • The wrong type for the page. An Article block on a product page, or a Product block on a category page, describes the wrong entity. Mark up the primary thing the page is about, and let anything secondary be described through nesting or left out.
  • Hardcoded values. A price typed into a template in March is still there in October, long after the product changed. Pull values from the data layer every time the page renders.
  • Markup on pages that aren’t indexed. Noindex pages, login screens and empty tag archives can carry perfect markup and still never display anything. Fix indexing first, then worry about the structured data.

Schema and AI answers: a clarity tool, not a lever

Schema has become a standard recommendation for AI visibility, and the claims are running ahead of the evidence. Google’s documentation for its AI features in Search says those features don’t require special markup, and it repeats the same rule as everywhere else: structured data should match the visible content. Public evidence that schema makes ChatGPT or Perplexity cite a page more often is thin. Markup does make entities, authors and dates unambiguous, which can’t hurt, but it isn’t a citation switch. Be skeptical of any vendor who sells AI citations as a schema outcome. For how the AI features actually choose their sources, read how Google AI Overviews choose their sources.

The honest wrap-up

Schema markup is a narrow tool. It earns a handful of rich results for a short list of types, it helps machines read your pages without ambiguity, and it breaks quietly the moment it stops matching the page. Spend your effort on Product, BreadcrumbList and Organization, where the display payoff is real. Write FAQ content for readers. And generate every block from the data that draws the page, so the golden rule holds without anyone having to remember it.

The discipline behind all of that, research first, a human voice, and a quality check on every page before it goes live, is what AutoSEO Stack automates for your content. If you want to see that running on your own site, start with the features overview.