Schema Markup: Complete Guide to Structured Data, Rich Results & AI Visibility (2026)
By the Marketing Scrappers Technical SEO Team · Reviewed July 2026
Schema markup is standardized structured data, most commonly implemented using JSON-LD, that helps search engines and AI systems understand the meaning, relationships, and context of website content. While schema markup is not a direct ranking factor, it improves machine readability, enables eligible rich results, strengthens entity understanding, and supports AI-powered search experiences when implemented correctly.
That definition hasn’t changed much over the years. What has changed is which schema types actually produce a visible result in Google Search — and 2026 has been the most disruptive year for that list since Google began pruning rich results in 2023. This guide covers what schema markup is, how it works, which types still earn rich results, how to implement and validate JSON-LD correctly, and how structured data fits into AI-powered search in 2026.
What Is Schema Markup?
Schema markup is code — almost always written in JSON-LD — that labels the entities on a webpage using a shared vocabulary called Schema.org. Instead of asking a search engine to infer that a page is about a specific product, article, or organization, schema markup states it directly: this block of text is a headline, this string is a price, this entity is the author, this date is when the page was published.
Three terms get used almost interchangeably, but they describe different layers of the same system:
- Structured data is the broad concept — any data organized in a predictable, machine-readable format.
- Schema.org is the shared vocabulary (the list of approved entity types and properties) maintained jointly by Google, Microsoft, Yahoo, and Yandex.
- JSON-LD is the syntax most commonly used to write that vocabulary into a webpage today, as a self-contained script block that doesn’t touch the visible HTML.
Put together: schema markup is structured data, written in the Schema.org vocabulary, most often delivered as JSON-LD.
Because Schema.org markup describes an entity in a standardized way, it also feeds directly into Google’s Knowledge Graph — the system that connects people, places, organizations, and concepts across the web. A well-marked-up “Organization” entity on your site doesn’t just help Googlebot parse the page; it helps Google associate your brand name with a consistent, disambiguated identity across every page where that entity appears. This is the same logic behind Entity SEO: structured data is one of the clearest signals you can give a search engine about what an entity is.
Here’s how that looks for a single defined concept, using the DefinedTerm type — the schema most relevant to glossary-style content:
{
“@context”: “https://schema.org”,
“@type”: “DefinedTerm”,
“name”: “Schema Markup”,
“description”: “Standardized structured data, typically written in JSON-LD, that helps search engines and AI systems understand the meaning, relationships, and context of webpage content.”,
“inDefinedTermSet”: “https://marketingscrappers.com/glossary/”,
“url”: “https://marketingscrappers.com/guides/schema-markup/”
}
Does Schema Markup Help SEO?
Indirectly, yes — but the honest answer requires a distinction most articles skip. Google has stated plainly that structured data is not a ranking factor on its own. Adding schema markup to a page will not, by itself, move that page up the results. What schema markup does instead is:
- Improve machine comprehension. It removes ambiguity about what a piece of content represents, which reduces the work Google’s systems have to do to classify and index the page correctly.
- Unlock eligibility for rich results. Certain schema types make a page eligible for enhanced search appearances — star ratings, breadcrumbs, event details — which can meaningfully improve click-through rate even without a ranking change. Eligibility is not a guarantee; Google still decides whether to show the enhancement based on query relevance and content quality.
- Strengthen entity signals. Consistent, accurate markup across a domain reinforces the relationships between your organization, your services, your authors, and your content — supporting the kind of topical and entity authority this article’s parent pillar, Technical SEO, is built around.
- Give AI systems a cleaner source to extract from. This matters more in 2026 than it did two years ago, and we cover it in detail later in this guide.
So the practical framing is: schema markup rarely wins you a ranking directly, but it removes friction between your content and every machine — search engine or AI model — trying to understand it. Skipping it doesn’t penalize you. Implementing it well removes a class of uncertainty that a competitor’s page may still carry.
Ready to Align Your Site with 2026 Technical SEO Standards?
Don’t let outdated schema markup hold back your search performance. Book a comprehensive Technical SEO Audit to identify structured data errors, entity gaps, and technical indexing issues.
Book a Technical SEO Audit →How Does Schema Markup Work?
When Googlebot crawls a page, it renders the HTML and looks for a <script type=”application/ld+json”> block — typically placed in the <head>, though Google accepts it anywhere in the document. Inside that script, the JSON-LD describes one or more entities using @type (the kind of thing being described, such as Article or Organization) and a set of properties (headline, author, datePublished, and so on).
Google’s indexing systems parse that JSON-LD alongside the visible content of the page. A few mechanical rules govern how seriously that markup is taken:
- The markup must describe content the user can actually see. Structured data describing information that isn’t present on the rendered page is treated as unreliable or ignored outright.
- Entities can be referenced, not just repeated. Using a stable @id (for example, https://marketingscrappers.com/#organization) lets one page’s WebPage schema point to the same Organization entity defined sitewide, rather than redeclaring it on every page. This is the same @graph pattern used in the combined example later in this guide.
- Absolute URLs are required. Relative paths inside @id or url fields are typically ignored.
Once parsed, that data feeds two systems simultaneously: Google’s Search index (which can surface eligible rich results and populate Search Console’s Enhancement reports) and the broader Knowledge Graph (which uses entity markup like Organization, Person, and sameAs links to build a disambiguated map of who and what exists on the web). Non-Google crawlers — Bingbot, PerplexityBot, and various retrieval-augmented-generation crawlers used by AI assistants — read the same JSON-LD independently, which is part of why structured data has taken on renewed importance for AI visibility, covered later in this guide.
JSON-LD vs. Microdata vs. RDFa: Which Should You Use?
Schema.org markup can technically be written in three syntaxes. In 2026, this isn’t really a live debate — Google explicitly recommends JSON-LD, and nearly all modern implementations use it — but understanding the difference matters if you’re auditing an older site or inheriting a legacy build.
| Format | How it’s written | Maintainability | Google’s stance |
| JSON-LD | Self-contained <script> block, separate from visible HTML | High — can be generated dynamically without touching page markup | Recommended for all new implementations |
| Microdata | Inline HTML attributes (itemscope, itemtype, itemprop) woven through visible tags | Low — breaks easily during redesigns and template changes | Still supported, not recommended |
| RDFa | Inline HTML attributes similar to Microdata, using vocab and property | Low — same fragility as Microdata, less common in CMS ecosystems | Still supported, rarely used |
JSON-LD wins for three practical reasons: it doesn’t require editing your visible template markup, it’s trivial to generate programmatically (which matters at MS’s production scale across hundreds of pages), and it degrades gracefully — a broken JSON-LD block won’t break your page layout the way malformed Microdata attributes can. Every example in this guide uses JSON-LD, and it’s the only format we recommend for new implementation work.
What’s Changed in 2026 (Schema & Rich Results Update)
This is the section to read even if you skip everything else, because a significant amount of schema advice still circulating online is now out of date.
FAQ rich results were discontinued on May 7, 2026. Google added a deprecation notice to its FAQ structured data documentation confirming that FAQ rich results — the expandable question-and-answer dropdowns that used to appear directly beneath a search listing — no longer show in Google Search. The phase-out continues in stages: Search Console’s FAQ appearance filter and rich result report, along with FAQ support in the Rich Results Test, are being removed in June 2026, and FAQ data in the Search Console API follows in August 2026.
This wasn’t entirely sudden. Google had already restricted FAQ rich results back in August 2023, limiting them to a narrow set of authoritative government and health websites. For the overwhelming majority of commercial and informational sites, FAQ rich results had been functionally invisible for nearly three years before the May 2026 change made that restriction permanent and universal.
Two things are important to get right about this change:
- FAQPage is still a valid Schema.org type. Google’s own documentation notes that unused or non-rich-result-eligible structured data does not cause problems for a page. You can leave existing FAQ markup in place without risk.
- The markup can still be read by other systems. Bingbot, PerplexityBot, and various AI retrieval crawlers still index FAQPage markup even though Google no longer displays it as a visual SERP feature.
FAQ isn’t the only casualty. HowTo rich results — step-by-step carousels for tutorial content — were removed from both desktop and mobile Search back in September 2023 and have not returned. Separately, in June 2025, Google announced the retirement of seven additional structured data types from rich results, effective September 2025: Book Actions, Course Info, Claim Review, Estimated Salary, Learning Video, and Special Announcement, and Vehicle Listing. None of those were core to a Technical SEO content strategy, but the pattern matters: Google has been steadily narrowing the list of schema types that produce a visible enhancement, while continuing to support (and in some cases expand) the underlying data model for entity understanding.
The practical takeaway for 2026: don’t build a schema strategy around chasing visual SERP real estate for every type in the Schema.org vocabulary. Build it around the smaller set of types that reliably produce a rich result today, plus the types that strengthen entity and AI comprehension regardless of whether a visual result ever appears. The next section maps out exactly where that line sits.
Download the 2026 Schema Markup Implementation Checklist
Audit your existing JSON-LD markup against 2026 eligibility rules. Ensure your entity graphs are valid, error-free, and fully optimized for search engines and AI engines.
Download Checklist (PDF) →Which Schema Types Still Matter in 2026? (Rich Results Eligibility Matrix)
Google’s Search Gallery documents eligibility criteria for dozens of Schema.org types, but only a subset reliably produces a visible rich result — and that subset has narrowed three times since 2023. Here’s where things stand:
| Schema Type | Search Feature | 2026 Status | Notes |
| Organization | Knowledge Panel enhancement, logo in results | Active | Sitewide; requires logo, benefits from sameAs |
| LocalBusiness | Local pack / Maps enhancements | Active | For businesses with a physical location or service area |
| Article / NewsArticle | Top Stories, enhanced headline display | Active | Requires headline, author, datePublished |
| Product | Price, availability, merchant listings | Active | Requires offers, image, and complete pricing data |
| Review / AggregateRating | Star ratings in snippets | Active | Must reflect genuine, verifiable reviews — never fabricate |
| BreadcrumbList | Breadcrumb trail replacing the raw URL | Active | Must match the page’s actual navigation hierarchy |
| VideoObject | Video thumbnail, key moments | Active | Requires thumbnailUrl, uploadDate, description |
| Event | Event date, location, ticketing details | Active | Requires startDate, location, name |
| JobPosting | Job listing rich result | Active | Requires salary and employment-type fields |
| WebSite + SearchAction | Sitelinks search box | Active, limited | Google decides eligibility; mainly larger, high-traffic sites |
| HowTo | Step-by-step rich result | Discontinued (Sept 2023) | Markup remains valid; produces no visual result |
| FAQPage | FAQ accordion in SERPs | Discontinued (May 7, 2026) | Markup remains valid; still useful for AI extraction |
| Book Actions, Course Info, Claim Review, Estimated Salary, Learning Video, Special Announcement, Vehicle Listing | Various | Discontinued (Sept 2025) | Retired as a batch of seven low-usage types |
| DefinedTerm | No dedicated SERP feature | Supports entity clarity | Valuable for glossary content and AI-source disambiguation |
The types worth prioritizing on a typical Technical SEO client site, in order, are Organization, BreadcrumbList, Article (for blog and guide content), and Product/Review where applicable. LocalBusiness moves to the top of that list for the hospitality and local-service clients this cluster increasingly supports.
The MS Structured Data Framework™
Chasing individual schema tutorials page by page produces inconsistent, hard-to-audit markup. The Scrapper Growth Engine™ — MS Structured Data Framework™ gives every page a repeatable five-step process, whether it’s being implemented by a senior strategist or an apprentice working from a production checklist.
1. Identify the page entity. Before touching code, define what the page is actually about in Schema.org terms. A service page is usually a Service; a guide like this one is an Article; a location page is a LocalBusiness. Getting this step wrong — describing a service page as a Product, for instance — creates the kind of deceptive-markup problem Google explicitly flags during review.
2. Select the appropriate schema type. Cross-reference the entity against the Rich Results Eligibility Matrix above. Choose the most specific applicable type (ItemPage for a single service detail page rather than a generic WebPage), and identify which secondary types support it — a BreadcrumbList and Organization reference belong on nearly every page type.
3. Implement JSON-LD with required and recommended properties. Write the markup using the @graph pattern so entities like Organization are declared once and referenced everywhere else via @id. Populate every required property first, then add recommended properties that strengthen entity completeness (sameAs, foundingDate, areaServed). Never invent a value — an unverifiable property should be left out rather than guessed.
4. Validate using Schema.org and Rich Results tools. Run the markup through Google’s Rich Results Test and the Schema Markup Validator before publishing, not after. Both are covered in detail in the validation workflow below.
5. Monitor Search Console enhancements and iterate. Structured data isn’t a set-and-forget asset. Search Console’s Enhancement reports flag new errors as Google’s requirements shift, and the 2026 FAQ deprecation is a clear example of why a quarterly audit cadence — not a one-time implementation — is the right operating model.
Schema Selection Decision Tree
For a fast, practical way to apply Step 2 of the framework above, work through this decision sequence for any page:
- Is the page about your company as a whole (homepage, about page)? → Implement Organization, referenced sitewide via @id.
- Does the page have a physical location or service area (a clinic, hotel, or local office)? → Add LocalBusiness alongside Organization.
- Is the page a blog post, guide, or research report? → Implement Article, plus BreadcrumbList and WebPage.
- Does the page walk through a numbered process or set of instructions? → Consider HowTo for entity clarity and AI extraction, understanding it will not produce a visible rich result.
- Does the page sell a physical product? → Implement Product, and add Review/AggregateRating only if genuine review data exists.
- Does the page describe a service (consulting, SEO, web development)? → Implement Service, referencing the Organization as provider.
- Does the page define a term or concept (glossary entry)? → Implement DefinedTerm, linked to a DefinedTermSet.
- Does the page answer common questions in visible text? → You may still add FAQPage for AI-crawler extraction and entity clarity, but set the expectation correctly: it will not produce a Google rich result in 2026.
- Every page, regardless of the above: → Add BreadcrumbList matching the actual navigation path.
Core Schema Types Every Business Should Implement (With JSON-LD Examples)
Organization
Declared once, referenced everywhere else on the site via @id. This is the foundation every other entity on the domain connects back to.
{
“@context”: “https://schema.org”,
“@type”: “Organization”,
“@id”: “https://marketingscrappers.com/#organization”,
“name”: “Marketing Scrappers”,
“url”: “https://marketingscrappers.com/”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://marketingscrappers.com/wp-content/uploads/logo.png”,
“width”: 512,
“height”: 512
},
“description”: “Marketing Scrappers is a growth engineering platform specializing in Technical SEO, Entity SEO, and AI Search Optimization for hospitality and mid-market brands.”,
“sameAs”: [
“https://www.linkedin.com/company/marketingscrappers”
]
}
Article (Guide and Blog Content)
The schema type this guide itself should carry. Note the publisher and author both reference the Organization entity above rather than redeclaring it.
{
“@context”: “https://schema.org”,
“@type”: “Article”,
“@id”: “https://marketingscrappers.com/guides/schema-markup/#article”,
“headline”: “Schema Markup: Complete Guide to Structured Data, Rich Results & AI Visibility (2026)”,
“description”: “Learn what schema markup is, which schema types still earn rich results in 2026, and how to implement, validate, and monitor JSON-LD correctly.”,
“author”: {
“@type”: “Organization”,
“@id”: “https://marketingscrappers.com/#organization”
},
“publisher”: {
“@id”: “https://marketingscrappers.com/#organization”
},
“datePublished”: “2026-07-30”,
“dateModified”: “2026-07-30”,
“mainEntityOfPage”: {
“@id”: “https://marketingscrappers.com/guides/schema-markup/#webpage”
}
}
BreadcrumbList and WebPage
Every guide page should carry both, cross-referenced to the Organization and to each other.
{
“@context”: “https://schema.org”,
“@graph”: [
{
“@type”: “WebPage”,
“@id”: “https://marketingscrappers.com/guides/schema-markup/#webpage”,
“url”: “https://marketingscrappers.com/guides/schema-markup/”,
“name”: “Schema Markup: Complete Guide to Structured Data, Rich Results & AI Visibility (2026)”,
“isPartOf”: { “@id”: “https://marketingscrappers.com/#website” },
“about”: { “@id”: “https://marketingscrappers.com/#organization” },
“breadcrumb”: { “@id”: “https://marketingscrappers.com/guides/schema-markup/#breadcrumb” },
“inLanguage”: “en-US”
},
{
“@type”: “BreadcrumbList”,
“@id”: “https://marketingscrappers.com/guides/schema-markup/#breadcrumb”,
“itemListElement”: [
{ “@type”: “ListItem”, “position”: 1, “name”: “Home”, “item”: “https://marketingscrappers.com/” },
{ “@type”: “ListItem”, “position”: 2, “name”: “Technical SEO”, “item”: “https://marketingscrappers.com/services/seo/technical-seo/” },
{ “@type”: “ListItem”, “position”: 3, “name”: “Schema Markup”, “item”: “https://marketingscrappers.com/guides/schema-markup/” }
]
}
]
}
HowTo (Implementation Walkthroughs)
Useful for genuine step-by-step content. Remember: this produces no visible Google rich result, but the structured step data remains valuable for AI extraction and internal content clarity.
{
“@context”: “https://schema.org”,
“@type”: “HowTo”,
“name”: “How to Implement JSON-LD Schema Markup on a Webpage”,
“step”: [
{ “@type”: “HowToStep”, “name”: “Identify the page entity”, “text”: “Determine what the page is fundamentally about — Article, Service, Product, or Organization.” },
{ “@type”: “HowToStep”, “name”: “Select the schema type”, “text”: “Match the entity to the most specific applicable Schema.org type.” },
{ “@type”: “HowToStep”, “name”: “Write the JSON-LD”, “text”: “Build the script using @graph with a stable @id for reusable entities.” },
{ “@type”: “HowToStep”, “name”: “Validate before publishing”, “text”: “Run the markup through Google’s Rich Results Test and the Schema Markup Validator.” },
{ “@type”: “HowToStep”, “name”: “Monitor in Search Console”, “text”: “Review the Enhancements reports on a quarterly cadence and correct new errors as they appear.” }
]
}
FAQPage (2026 Caveat)
Only implement this where genuine, visible Q&A content exists on the page — and set expectations correctly with any client or stakeholder before you do.
{
“@context”: “https://schema.org”,
“@type”: “FAQPage”,
“mainEntity”: [
{
“@type”: “Question”,
“name”: “Does schema markup still help SEO in 2026?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Yes, indirectly. Schema markup is not a ranking factor, but it improves machine comprehension, unlocks eligibility for remaining rich results, and strengthens entity signals that support both traditional and AI-powered search.”
}
}
]
}
Note what this markup will and won’t do in 2026: it will not produce an FAQ accordion in Google Search. It may still be read by Bing, Perplexity, and AI retrieval crawlers, and it costs nothing to maintain if the underlying Q&A content is genuinely useful to a human reader.
How to Implement Schema Markup: Step-by-Step Walkthrough
- Audit what’s already present. Before adding anything, run the target URL through the Rich Results Test and click through to view detected structured data. Many WordPress sites already emit Organization, WebSite, and BreadcrumbList schema through an SEO plugin (Yoast, Rank Math, AIOSEO) — duplicating those creates entity conflicts rather than reinforcing them.
- Fill the gaps the plugin doesn’t cover. Plugins rarely generate Service, HowTo, DefinedTerm, or product-specific schema automatically. This is where manual JSON-LD adds real value.
- Write the JSON-LD following the framework above. Use @graph and @id references rather than duplicating entity data across multiple script blocks.
- Place the script correctly. A single <script type=”application/ld+json”> block in the <head> is standard; Google also accepts it in the <body> if your CMS makes that easier.
- Validate before the page goes live, using the workflow in the next section.
- Document what was added, ideally in the same production log used for the rest of the page build, so future audits know which schema is manual versus plugin-generated.
How to Validate Schema Markup (Testing & Monitoring Workflow)
Validation is not optional, and it isn’t a one-time step. Three tools cover the full lifecycle:
Google’s Rich Results Test (search.google.com/test/rich-results) checks whether a live URL or a raw code snippet is eligible for any of Google’s supported rich result types. It separates findings into errors (which block eligibility entirely) and warnings (which don’t block eligibility but indicate missing recommended fields).
[Insert screenshot: Rich Results Test result showing valid Article and BreadcrumbList detection for this URL]
The Schema Markup Validator (validator.schema.org) checks markup against the full Schema.org vocabulary rather than only the subset Google uses for rich results. This is the right tool for confirming that a DefinedTerm, HowTo, or Service entity is technically well-formed even when it isn’t eligible for a visible SERP feature.
[Insert screenshot: Schema Markup Validator output showing zero errors for the Organization and Article graph]
Search Console’s Enhancement reports are the ongoing monitoring layer. Once markup is live, Search Console will surface new errors as Google’s requirements change — exactly the kind of shift that made the May 2026 FAQ deprecation visible to site owners who were paying attention. Reviewing these reports quarterly, alongside a fresh pass through the Rich Results Test on top-traffic URLs, keeps a site’s structured data current without waiting for a client to notice a problem.
Common Schema Markup Mistakes to Avoid
- Fabricating review or rating data. AggregateRating without genuine underlying reviews is treated by Google as deceptive markup and risks manual action, not just ignored data.
- Duplicating Organization or WebSite entities already emitted by an active SEO plugin, creating conflicting entity declarations.
- Using relative URLs inside @id or url fields. Every identifier and URL in structured data must be absolute.
- Marking up content that isn’t visible on the page, including FAQ text hidden behind JavaScript that requires interaction to render.
- Treating brand as a plain string instead of a proper Brand type object.
- Omitting dateModified on evergreen guides. Freshness signals matter for both traditional crawling and AI systems weighing which version of a page to trust.
- Skipping validation before publishing and only discovering an error weeks later through a Search Console report.
- Building an entire schema strategy around FAQPage or HowTo in 2026, when neither produces a visible Google rich result anymore.
Schema Markup Best Practices for 2026
- Default to JSON-LD for every new implementation; don’t maintain legacy Microdata unless a migration is already planned.
- Use the @graph pattern with stable @id values so entities are declared once per domain and referenced everywhere else.
- Prioritize Organization, BreadcrumbList, and Article/Service before investing time in narrower types.
- Keep FAQPage and HowTo markup only where the underlying content is genuinely useful to a reader — not as a rich-result tactic.
- Validate before publishing, not after a client asks why a rich result disappeared.
- Re-audit structured data on a quarterly cadence; Google has adjusted supported types in 2023, 2025, and 2026.
- Never populate a required property with a guessed or placeholder value in production markup — leave it out and flag it for follow-up instead.
- Treat schema as an entity-consistency system across the whole domain, not a per-page checklist item.
Is Schema Markup Important for AI Search?
This deserves a direct, unhyped answer, because a lot of the content published on this topic in 2026 overstates it.
Google has stated explicitly, in its own guidance on AI features, that no special schema markup is required to appear in AI Overviews or AI Mode — the same content and SEO fundamentals that earn traditional visibility apply. Structured data is not a documented citation trigger for Google’s AI-generated answers.
What structured data does provide is a comprehension and trust layer. Clean, accurate schema helps any system — Google’s indexing pipeline, Bing, Perplexity, or an AI retrieval crawler — parse a page’s entities faster and with less ambiguity. Several industry analyses in 2026 have observed correlations between well-structured pages and AI citation frequency, but the honest interpretation, and Google’s own framing, is that this is a supporting signal rather than a guaranteed lever. Treat schema markup as infrastructure that removes friction for machine readers generally, not as a targeted tactic for winning a specific AI answer box. For the broader strategy of earning visibility inside AI-generated answers, see AI Search Optimization, which builds on the entity foundation this guide establishes.
Frequently Asked Questions
What is schema markup? Schema markup is structured data written in the Schema.org vocabulary — most commonly as JSON-LD — that tells search engines and AI systems what a piece of content represents, rather than leaving them to infer it.
What is structured data? Structured data is any information organized in a predictable, machine-readable format. Schema markup is the specific, standardized implementation of structured data used across the web.
What is JSON-LD? JSON-LD (JavaScript Object Notation for Linked Data) is the syntax Google recommends for writing Schema.org markup. It lives in a self-contained script block, separate from a page’s visible HTML.
Does schema markup help SEO? Indirectly. It is not a ranking factor, but it improves machine comprehension, can unlock eligibility for rich results, and strengthens the entity signals search engines use to understand a brand.
How does schema markup work? Googlebot parses the JSON-LD block on a rendered page and matches its entities and properties against the visible content, feeding both the Search index and the Knowledge Graph.
Which schema types still matter in 2026? Organization, LocalBusiness, Article, Product, Review, BreadcrumbList, VideoObject, Event, and JobPosting all still produce rich results. FAQPage and HowTo remain valid Schema.org types but no longer generate a visible Google rich result.
How do I implement schema markup? Identify the page’s core entity, select the matching Schema.org type, write it as JSON-LD using the @graph pattern, validate it with Google’s Rich Results Test and the Schema Markup Validator, and monitor Search Console’s Enhancement reports going forward.
Is schema markup important for AI search? It’s supportive rather than essential. Google has confirmed no special schema is required for AI Overviews, but clean structured data helps any machine reader — including AI crawlers — parse a page’s entities more reliably.
What happened to FAQ rich results? Google discontinued FAQ rich results in Google Search as of May 7, 2026, following an earlier restriction in 2023 that had already limited them to a small set of authoritative sites. The FAQPage schema type remains valid; it simply no longer produces a visible SERP feature.
Key Takeaways
- Schema markup is structured data, written in the Schema.org vocabulary, most commonly delivered as JSON-LD.
- It is not a direct ranking factor, but it improves comprehension, rich result eligibility, and entity clarity.
- FAQ rich results ended May 7, 2026; HowTo ended in September 2023; seven minor types were retired in September 2025. Markup for all of these remains valid — it just no longer produces a visible Google rich result.
- Prioritize Organization, BreadcrumbList, Article, Service, and — for local and hospitality clients — LocalBusiness.
- Follow the MS Structured Data Framework™: identify the entity, select the type, implement JSON-LD, validate, and monitor.
- Structured data supports AI visibility as a comprehension layer, not as a guaranteed citation trigger.