Schema Markup

TL;DR — Schema markup is code you add to a page that labels what your content means — “this is the price,” “this is the author,” “this is a review score” — so search engines don’t have to guess. It uses a shared vocabulary from a site called schema.org. Its main payoff is rich results: the star ratings, prices, and breadcrumbs you see in search listings. It does not directly make you rank higher — that’s the biggest myth about it.

What schema markup is

When you look at a web page, you can tell a phone number from a price from an author’s name just by reading. A search engine sees plain text and has to infer all of that. Schema markup spells it out in code: it tags each piece of content with what it actually is.

It uses a shared vocabulary published at schema.org — a list of “types” (like Product, Recipe, Event, Article) and the “properties” each one can have (a Product has a price, an Event has a startDate). Because every major search engine reads the same vocabulary, you label your content once and they all understand it. Evidence for this claim Schema.org defines shared types and properties that publishers can use to describe entities and content. Scope: Schema.org vocabulary; search engines decide independently which types power search features. Confidence: high · Verified: 2026-07-14 Schema.org: Getting started

You’ll also hear it called structured data. People use the two terms interchangeably. Technically, structured data is the broad idea, and schema markup is the specific case of using the schema.org vocabulary — but in everyday SEO talk they mean the same thing.

Why it matters: rich results

The visible reason to add schema is rich results (Google used to call them “rich snippets”). These are the enhanced search listings:

• ⭐ review star ratings under a product
• 💲 a price and “in stock” label
• 🍳 a recipe card with cook time and a photo
• 🧭 a breadcrumb trail instead of a raw URL

To get one, you mark up the matching content with the right schema type and all its required details, and your listing becomes eligible (never guaranteed) for that enhancement. Evidence for this claim Google uses supported structured data to understand page content and make pages eligible for certain search-result features. Scope: Google Search documentation; markup does not guarantee appearance or ranking improvement. Confidence: high · Verified: 2026-07-14 Google: Structured data introduction Rich results can make your listing stand out and earn more clicks.

The thing most people get wrong

Schema markup is not a ranking factor. Adding schema does not move you up the results. Google has said this over and over. What it can do is win you a rich result, and a more eye-catching listing can earn more clicks — but that’s different from ranking higher.

A couple more beginner traps:

• More schema isn’t better. Only mark up content that’s actually on the page and accurate. Marking up things a visitor can’t see breaks Google’s rules.
• Some types are retired. FAQ and HowTo “rich results” used to be popular, but Google has stopped showing them. Don’t spend time on markup that no longer earns anything.

How you write the code is its own topic — the recommended format is JSON-LD, a small block of code that sits in the page without changing how it looks. Want the full version, with the current rich-result types, the deprecations, entity markup, and how to validate? Switch to the Advanced tab.

TL;DR — Schema markup applies the schema.org vocabulary (a Google / Microsoft / Yahoo / Yandex collaboration) to label a page’s meaning. It does two distinct jobs: rich-result eligibility (visible SERP enhancements, requires specific types + all required properties) and entity understanding (helps engines and the Knowledge Graph identify who/what you are — Organization / Person + sameAs — with no visible signal). It’s not a direct ranking factor. Don’t conflate the vocabulary (schema markup) with the format (JSON-LD — recommended, but Microdata and RDFa also work). And watch the deprecation cycle: HowTo rich results went in 2023, seven feature types were retired June 2025, and FAQ rich results were deprecated in 2026. My rule: implement schema when it earns a search feature or genuinely helps entity understanding — not because more markup is automatically better.

Schema markup vs. structured data vs. JSON-LD

Three terms get muddled constantly, so let me separate them cleanly:

• Structured data is the general concept: any standardized way of annotating content so machines understand it.
• Schema markup is structured data that uses the schema.org vocabulary specifically. In practice these two are used interchangeably.
• JSON-LD is a format — one of three ways to write the markup. It is not a synonym for schema markup. You can express the same schema.org types in JSON-LD, Microdata, or RDFa.

Keeping the vocabulary (schema.org) separate from the format (JSON-LD) is the first thing that trips people up. The vocabulary is what you say; the format is how you write it.

What schema.org actually is

schema.org is a shared vocabulary launched in 2011 and maintained collaboratively by Google, Microsoft (Bing), Yahoo, and Yandex. It defines a hierarchy of types (e.g., Thing → CreativeWork → Article → NewsArticle) and the properties each type can carry. The search engines agree on the vocabulary, then each decides independently which types it consumes and which it turns into rich results. That last point matters: schema.org lists far more types than any single engine surfaces. Evidence for this claim A property can be valid in Schema.org without being required, recommended, or consumed for a specific Google rich result. Scope: Schema.org vocabulary compared with Google Search feature requirements. Confidence: high · Verified: 2026-07-14 Google: Structured data feature guide

The two jobs schema does (and why people only think about one)

Most guides treat schema as a rich-results lever and stop there. It actually does two separate things:

1. Rich-result eligibility. Mark up content with a supported type and all its required properties, and your listing becomes eligible for a visible SERP enhancement (stars, price, breadcrumbs, recipe card). This is the part everyone chases.

2. Content and entity understanding. Google states it uses structured data “to understand the content of the page, as well as to gather information about the web and the world in general.” Organization, Person, and similar types — especially with sameAs pointing at authoritative profiles — help engines confidently identify which entity a page is about and feed the Knowledge Graph. There’s no visible badge for this; the benefit is comprehension.

The practical consequence: a type that produces no rich result can still be worth marking up if it sharpens entity understanding. Organization is the classic example.

The formats: JSON-LD, Microdata, RDFa

All three are supported by Google. JSON-LD is the recommended choice, and the reasons are concrete:

• It lives in a <script type="application/ld+json"> block, not interleaved with your HTML, which makes nested data far easier to express and to maintain as templates change.
• Google can read JSON-LD even when it’s dynamically injected by JavaScript or a CMS widget — that’s Google’s own documented behavior, not a universal rendering guarantee. Other search engines and AI crawlers may render (or fail to render) injected JSON-LD differently, so test each consumer you actually care about instead of assuming parity.

Microdata and RDFa are inline attributes woven into your HTML markup. They are not penalized or parsed worse — that’s a myth. They’re just harder to maintain. Use them only when a legacy CMS or a specific platform forces inline markup.

Schema is not a ranking factor

This is the single most important correction in the topic. Google reps have been unambiguous and consistent for years — see the Quotes lens for the exact statements. Danny Sullivan has called structured data “optional” with “no impact on ranking in web search.” The benefit is indirect: rich results can lift click-through rate, and better entity understanding can make relevance matching easier. Neither is a ranking boost from the markup itself.

This is exactly why my own framing has always been pragmatic. In my Ahrefs enterprise SEO guide I put it this way: “I’m a fan of schema markup as long as it gets you a search feature.” Translation: prioritize types with confirmed rich-result eligibility (or clear entity value), and don’t spray markup across every page hoping it does something.

The most useful schema types in 2026

Google’s search gallery is the source of truth for what currently produces rich results. The types worth your time, roughly in order of how commonly they pay off:

• Product — price, availability, and review ratings; the highest-value type for ecommerce.
• Review snippet / AggregateRating — star ratings on the eligible content.
• BreadcrumbList — the breadcrumb trail in place of a raw URL.
• Article (news/blog/sports) — eligible for article-enhanced display. Top Stories is a separate, more restrictive surface with its own publisher and content-policy requirements; Article markup is necessary but doesn’t by itself put a page there.
• Organization — entity establishment. It can feed the logo/details Google shows in panels, but valid markup doesn’t guarantee a Knowledge Panel appears — entity understanding is the reliable part, even where no panel or rich result shows.
• LocalBusiness — local panel details, hours, and contact info.
• Event, Recipe, Job posting, Video (VideoObject), Q&A, Software app, Dataset, Discussion forum, Course list — each maps to a specific gallery feature.

If you implement nothing else, Organization, BreadcrumbList, and (for the relevant business) Product or LocalBusiness cover the highest-leverage cases.

The deprecation wave — stop implementing dead types

The supported set genuinely changes, and chasing retired features is the most common way to waste dev time. The recent history:

• 2023 — HowTo rich results removed from desktop and mobile. Still recommended in countless outdated guides; it earns nothing now.
• June 2025 — seven feature types retired: Book Actions, Course Info (old format, replaced by Course list), Claim Review, Estimated Salary, Learning Video, Special Announcement, and Vehicle Listing.
• 2026 — FAQ rich results deprecated. The expandable Q&A under listings stopped appearing for most sites. FAQPage schema is still valid and Google still parses it for understanding — but the visual enhancement that made everyone implement it is gone.

John Mueller’s framing on the 2026 round is the right one: “Google is not killing schema… markup types come and go, but a precious few you should hold on to.” The takeaway isn’t “schema is dying” — it’s “implement against the current gallery, not a 2021 tutorial.”

Entity markup and the Knowledge Graph

Beyond rich results, schema is how you help an engine disambiguate your entity — to be sure your “Apple” is the company, not the fruit, and that your author is a specific real person. The mechanism is the sameAs property: you point your Organization or Person markup at authoritative identifiers — Wikipedia, Wikidata, LinkedIn, Crunchbase, official social profiles.

Done right, this feeds the Knowledge Graph and strengthens how confidently search engines (and, downstream, AI systems) recognize you. Done carelessly, it backfires: a sameAs pointing at the wrong Wikipedia page or a different company’s profile can cause an engine to conflate unrelated entities. Test your sameAs values as carefully as you’d test a canonical.

Schema and AI search — the right expectation

Schema is often sold as an AI-citation lever. It isn’t, directly. LLMs don’t reliably parse your JSON-LD and reward you with citations — a large study found no significant lift in AI citations from schema coverage. What schema does is the same entity-understanding job described above, and even that comes with a caveat: Google documents that Organization/Person + sameAs feed its own Knowledge Graph and search understanding. Whether — and how much — other AI providers lean on that same entity signal is a provider-specific question, not something any vendor has documented as guaranteed; treat a cross-provider AI-citation benefit as an unverified hypothesis, not an implementation benefit schema delivers on its own. Think of it as entity infrastructure for Google’s own systems, not a universal citation switch. I cover that angle in depth in Schema Markup for AI — it’s a different question (citation lift) from this article (the vocabulary, the types, and implementation).

Implementation priorities

If you’re starting from scratch, do it in this order:

1. Organization (sitewide) with accurate name, logo, url, and verified sameAs — the entity foundation.
2. BreadcrumbList on templated pages — cheap, broadly eligible, improves the listing.
3. Product (ecommerce) or LocalBusiness (local) — the highest-value business-specific type.
4. Article on editorial content.
5. Only then, niche types that map to a confirmed current gallery feature.

Two non-negotiables from Google’s guidelines: only mark up content that’s visible on the page, and favor “fewer but complete and accurate” required properties over every possible property filled in badly.

Validate before you ship

• Rich Results Test — for types that produce rich results; tells you eligibility and required-property errors.
• Schema Markup Validator — for any schema.org type, including ones that don’t produce rich results. Evidence for this claim Google recommends validating feature eligibility with the Rich Results Test and broader schema syntax with Schema.org tooling. Scope: Google Search deployment workflow; passing a validator does not guarantee display. Confidence: high · Verified: 2026-07-14 Google: Structured data introduction
• Google Search Console rich-result reports — monitor eligibility and errors at scale post-deploy.
• Ahrefs Site Audit — flags structured-data issues across a whole site.

A required-property error makes that page ineligible for the corresponding rich result; recommended-property gaps are usually tolerated. Validate, then deploy — not the reverse.

Keep the layers straight, because passing one doesn’t imply passing the next: valid markup (a validator parses it without errors) → supported vocabulary (schema.org recognizes the type) → feature support (Google’s gallery documents a matching rich result right now) → eligibility (every required property present, policy followed) → indexing (the page is indexed at all) → display (Google chooses to show the enhancement) → ranking (unaffected by any of the above). A green validator only proves the first step.

For where this sits in the bigger picture, see the broader structured data hub this article lives under.

AI summary

A condensed take on the Advanced version:

• What it is: schema markup applies the schema.org vocabulary to label a page’s meaning. “Structured data” is the broad concept; “schema markup” is the schema.org-specific case (used interchangeably). JSON-LD is a format, not a synonym — don’t conflate vocabulary with format.
• schema.org: a shared vocabulary launched 2011, maintained by Google, Microsoft, Yahoo, and Yandex; defines types + properties. Lists far more types than any engine surfaces as rich results.
• Two jobs: (1) rich-result eligibility — visible SERP enhancements, requires the right type + all required properties; (2) entity understanding — helps engines/Knowledge Graph identify who you are (Organization/Person + sameAs), no visible signal.
• Not a ranking factor: Google reps state this consistently (Sullivan: “optional… no impact on ranking in web search”). Benefit is indirect — CTR from rich results, easier relevance matching.
• Formats: JSON-LD recommended (not interleaved with HTML, JS-injectable); Microdata + RDFa also fully supported, just harder to maintain. They’re not parsed worse.
• Top types in 2026: Product, Review/AggregateRating, BreadcrumbList, Article, Organization, LocalBusiness, plus Event/Recipe/JobPosting/VideoObject/Q&A/etc.
• Deprecation wave: HowTo rich results removed 2023; seven types retired June 2025 (Book Actions, Claim Review, Estimated Salary, Learning Video, Special Announcement, Vehicle Listing, old Course Info); FAQ rich results deprecated 2026 (schema still parsed, no visible enhancement).
• Entity markup: sameAs (Wikipedia/Wikidata/LinkedIn/etc.) disambiguates your entity for the Knowledge Graph; a wrong sameAs can conflate entities — test it.
• AI search: not a direct citation lever (a large study found no significant lift); it’s entity infrastructure for Google’s own systems. Whether other AI providers rely on the same entity signal is unverified, provider-specific — not a documented guarantee. See the dedicated Schema Markup for AI article.
• Priorities: Organization → BreadcrumbList → Product/LocalBusiness → Article → niche current-gallery types. Mark up only visible content; “fewer but complete and accurate.” Validate with Rich Results Test (rich-result types) and schema.org Validator (everything).

Official documentation

Primary-source documentation from the search engines.

Google

• Intro to structured data markup — what structured data is, the JSON-LD recommendation, and how Google uses it to understand the page and the web.
• Structured data search gallery — the source of truth for which features currently produce rich results.
• General structured data guidelines — the quality and spam rules: don’t mark up invisible content, use the most specific type, keep it accurate.
• Rich Results Test — official test for rich-result-eligible types.
• Schema Markup Validator — validates any schema.org type (run by schema.org).
• schema.org documentation — the vocabulary itself: every type and property.

Bing / Microsoft

• Bing Webmaster Guidelines — markup — Bing’s support for schema.org structured data and JSON-LD.
• Bing Webmaster Tools — Markup Validator / URL Inspection — test how Bing reads your structured data.

Quotes from the source

On-the-record statements from Google and Bing. Where a page exposes the text, the link is a deep link that jumps to the quoted passage.

Google docs — what structured data does

• “Google uses structured data that it finds on the web to understand the content of the page, as well as to gather information about the web and the world in general.” Jump to quote
• On JSON-LD: “A JavaScript notation embedded in a <script> tag in the page head or body. The markup is not interleaved with the user-visible text… Also, Google can read JSON-LD data when it is dynamically injected into the page’s contents, such as by JavaScript code or embedded widgets.” Jump to quote
• “You must include all the required properties for an object to be eligible for appearance in Google Search with enhanced display.” Jump to quote

Google guidelines — quality and spam

• “Don’t mark up content that is not visible to readers of the page.” Jump to quote
• “Use the most specific applicable type and property names defined by schema.org for your content.” Jump to quote

Google reps — schema is not a ranking factor

• John Mueller: “Using schema doesn’t give you a ranking boost. Just having more detailed markup doesn’t mean it ranks better.” SEJ coverage
• Danny Sullivan, Google Search Liaison: structured data is “optional” and has “no impact on ranking in web search.” Relayed via industry coverage of Sullivan’s 2020 statements; confirm against the original post before treating the phrasing as final.

John Mueller — on deprecations (2026)

• “Google is not killing schema.” And: “Understand that markup types come and go, but a precious few you should hold on to, like title and meta robots.” Coverage Relayed via Stan Ventures’ coverage of Mueller’s 2026 remarks; treat the wording as transcribed secondary reporting.

Fabrice Canel, Microsoft Bing

• “Schema markup helps Microsoft’s LLMs understand content” (for Copilot). Coverage Relayed via Search Engine Land’s April 2025 coverage; attributed to Canel, not a verbatim primary source — confirm before quoting as exact.

Schema types cheat sheet

Which types still earn rich results (as of 2026)

Retired / deprecated — don’t implement for rich results

• HowTo — desktop & mobile rich results removed 2023.
• FAQPage — rich results deprecated 2026 (schema still valid for understanding).
• Retired June 2025: Book Actions, Claim Review, Estimated Salary, Learning Video, Special Announcement, Vehicle Listing, old Course Info.

Fast facts

• Vocabulary = schema.org (Google, Microsoft, Yahoo, Yandex; since 2011).
• Format ≠ vocabulary: JSON-LD (recommended), Microdata, RDFa — all supported.
• Not a direct ranking factor; payoff is rich results (CTR) + entity understanding.
• Required properties = eligibility gate; recommended = quality, usually tolerated.
• sameAs (Wikipedia/Wikidata/LinkedIn/Crunchbase) = entity disambiguation lever.
• Validate: Rich Results Test (rich-result types) + schema.org Validator (any type).
• Rule: only mark up content visible on the page; “fewer but complete and accurate.”

JSON-LD examples for the implementation priorities

Four annotated JSON-LD snippets, one for each type this article names as a starting priority — Organization, BreadcrumbList, Product, and Article — plus a broken-vs-fixed pair showing the sameAs mistake called out above.

1. Organization — the entity foundation

This is the sitewide markup the article lists as priority #1: name, logo, url, and sameAs pointing at authoritative profiles.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Acme Consulting",
  "url": "https://www.example.com/",
  "logo": "https://www.example.com/images/logo.png",
  "sameAs": [
    "https://en.wikipedia.org/wiki/Acme_Consulting",
    "https://www.linkedin.com/company/acme-consulting",
    "https://www.crunchbase.com/organization/acme-consulting"
  ]
}
</script>

• name, url, logo — the required properties Google’s docs ask for; these produce no rich result but establish the entity.
• sameAs — each URL must genuinely identify this company. As the Advanced lens warns, a sameAs pointing at the wrong profile can conflate your entity with an unrelated one, so verify each link resolves to the right page before shipping.

2. BreadcrumbList — cheap and broadly eligible

The article’s priority #2. Each item in the list is one crumb; position must be sequential starting at 1.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://www.example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://www.example.com/blog/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Schema Markup",
      "item": "https://www.example.com/blog/schema-markup/"
    }
  ]
}
</script>

• The last crumb (the current page) can omit item per Google’s docs, but including it doesn’t hurt — Google ignores it for the final entry.
• Getting position out of sequence, or skipping a level, is the most common reason this type fails the Rich Results Test.

3. Product — the highest-value ecommerce type

The article names Product as the type with price, availability, and review ratings — “the highest-value type for ecommerce.” A minimal eligible example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wireless Trail Headphones",
  "image": "https://www.example.com/images/headphones.jpg",
  "offers": {
    "@type": "Offer",
    "priceCurrency": "USD",
    "price": "89.99",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "212"
  }
}
</script>

• offers and its price/availability are what makes the listing eligible for the price and stock-status display the beginner lens describes.
• aggregateRating must reflect ratings that actually exist on the page — the article’s “only mark up content that’s actually on the page” rule applies directly here; an invented rating count is exactly the kind of markup Google’s guidelines prohibit.

4. Article — for editorial content

The article’s priority #4, for the blog/news content this lens system itself runs on.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Schema Markup: Win Rich Results and Feed AI Search",
  "datePublished": "2026-06-26",
  "dateModified": "2026-07-13",
  "author": {
    "@type": "Person",
    "name": "Jane Author",
    "sameAs": "https://www.linkedin.com/in/jane-author"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Acme Consulting",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.example.com/images/logo.png"
    }
  }
}
</script>

• author.sameAs does the same entity-disambiguation work as Organization’s sameAs — it’s the Person version of the same lever.
• dateModified should track real edit dates, the same discipline this site applies to its own updated frontmatter — don’t bump it without a real change.

Broken vs. fixed: the sameAs mistake

The Advanced lens warns that a sameAs pointing at the wrong profile can cause an engine to conflate unrelated entities. Here’s what that looks like in practice.

Broken — sameAs points at a same-named but unrelated company:

{
  "@type": "Organization",
  "name": "Acme Consulting",
  "sameAs": ["https://en.wikipedia.org/wiki/Acme_Corporation"]
}

Acme Corporation is the Looney Tunes prop company’s Wikipedia page, not this business — a real risk whenever a brand name is common or generic.

Fixed — sameAs verified to resolve to the actual entity being described:

{
  "@type": "Organization",
  "name": "Acme Consulting",
  "sameAs": ["https://en.wikipedia.org/wiki/Acme_Consulting_(software_company)"]
}

Before shipping any sameAs value, open the link yourself and confirm it describes the same organization, person, or brand your markup names — the same scrutiny the article recommends giving a canonical tag.

Test yourself: Schema Markup

Five quick questions on schema markup, the schema.org vocabulary, and what it does (and doesn’t) do. Pick an answer for each, then check.

Resources worth your time

My schema markup writing

• Schema Markup for AI — the AI-search angle: why schema isn’t a direct citation lever but is entity infrastructure (a different question from this article).
• The Beginner’s Guide to Technical SEO — where I frame schema as code that helps engines understand content and “powers many features that can help your website stand out.”
• Enterprise SEO — my pragmatic take: “I’m a fan of schema markup as long as it gets you a search feature.”
• On-Page SEO Checklist — schema as code that “helps search engines understand the information on a page” and powers rich snippets that can earn more clicks.
• What Is Schema Markup? How to Add It & Why It Matters — Ahrefs’ dedicated guide to the main types and implementation.

From around the industry

• Google retires 7 structured data features (June 2025) — coverage of the Book Actions / Claim Review / Estimated Salary / Learning Video / Special Announcement / Vehicle Listing / old Course Info removals.
• Google drops FAQ rich results from search (Search Engine Journal) — the FAQ deprecation and what it means for sites that relied on it.
• Schema markup and AI search: no hype (Search Engine Land) — a grounded look at what schema does and doesn’t do for AI search, with the Fabrice Canel context.
• Is schema markup a ranking factor? (Search Engine Journal) — the rep statements and evidence behind “not a direct ranking factor.”
• John Mueller on the 2026 schema update — “Google is not killing schema… markup types come and go.”
• schema.org documentation — the vocabulary itself, straight from the source.

Schema Markup

Schema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor.

Related: Structured Data, Rich Results, JSON-LD

Schema Markup

Schema markup is code added to a page that uses the schema.org vocabulary to describe the page’s content in a machine-readable way — labeling that a string is a price, a publish date, an author, a star rating, or a step in a recipe. It lets search engines understand the explicit meaning of content rather than inferring it from the words alone, and it’s what makes a page eligible for rich results (the enhanced listings, like review stars, product prices, and breadcrumbs, that appear in search).

“Schema markup” and “structured data” are used interchangeably, but they’re not quite the same thing. Structured data is the broad concept — any standardized way of annotating content. Schema markup specifically means using the schema.org vocabulary, and that vocabulary is separate from the format you write it in. Three formats are supported — JSON-LD (a <script> block, Google’s recommended choice), Microdata, and RDFa — and all three work. JSON-LD wins on maintainability because it isn’t interleaved with your HTML and can be injected by JavaScript.

schema.org itself is a collaborative vocabulary launched in 2011 and maintained by Google, Microsoft (Bing), Yahoo, and Yandex. The search engines agree on the shared vocabulary; each then decides independently which types it uses and which produce rich results.

Two things to keep straight:

• It’s not a direct ranking factor. John Mueller and Danny Sullivan have said this repeatedly. Any benefit is indirect: rich results can lift click-through rate, and better entity understanding can help relevance.
• Supported types change. HowTo rich results were removed in 2023, seven feature types were retired in June 2025, and FAQ rich results were deprecated in 2026. Implement based on what’s currently eligible — and remember Google still reads many types it doesn’t surface as rich results, using them for general content and entity understanding.

Related: Structured Data, Rich Results, JSON-LD

Changelog