When a validator accepts your markup and search results still look plain, work through six checks in order: the Google feature, the live page, the properties, access and indexing, any manual action, and timing. Google says valid structured data makes a page eligible for an enhanced result, not that one will appear.

Each check rules out a different cause, so the order saves time. Start with whether the feature you want still exists, because Google has retired several displays. Google's documentation updates record that FAQ rich results stopped appearing in Google Search in May 2026, even though FAQPage is still a valid Schema.org type.

Typical causes are a retired feature, a missing property, a noindex tag, or a duplicate block from a plugin. Waiting comes last, because it only applies once everything else passes. You can run your code through the Schema Nova validator while you work through the list.

Key takeaways

  1. Valid is not shownGoogle says valid structured data makes a page eligible for an enhanced result but does not guarantee that one appears.
  2. Confirm the feature existsStart with Google's current documentation. FAQ rich results stopped appearing in May 2026, though FAQPage is still valid Schema.org vocabulary.
  3. Test the live pageCheck the rendered HTML, JSON syntax, visible facts and required properties, then run the Schema Markup Validator and the Rich Results Test.
  4. Check access and actionsLook for robots.txt blocks, noindex, canonical tags, duplicate plugin output and Manual Actions before assuming the markup is the cause.
  5. Allow timeGoogle's documentation describes a few days to a few weeks for finding and crawling pages, and a recrawl request carries no guarantee.
  6. Keep accurate markupMarkup that describes the page correctly can stay useful to other consumers even when Google shows no enhancement.

Valid, eligible and shown are three different states

A page can pass every test and still show a plain blue link, because each test answers a different question. Valid means the JSON-LD parses and the types and properties exist in the Schema.org vocabulary. Eligible means the markup meets the rules of one specific search feature, such as Google's Article or Breadcrumb features. Shown means the search engine actually picked the enhancement for one particular search.

Google says valid structured data enables eligibility but does not guarantee an appearance. In its general structured data guidelines, Google says it may choose a standard result, another feature or no enhancement, based on the query, device, location, search history, content quality and other signals. Treat markup as an input to eligibility, not a promise of rankings, traffic or display.

JSON-LD is a JSON-based way to write structured data inside a script element, defined in the W3C JSON-LD 1.1 recommendation. Google's structured data introduction lists JSON-LD, Microdata and RDFa as supported formats and recommends JSON-LD.

Confirm the Google feature still exists

Begin with the feature, not with the validator. Name the search appearance you were aiming for, then look it up in Google's structured data search gallery, which lists the features Google currently supports. A type can be perfectly valid Schema.org vocabulary and have no Google display attached to it.

Google has retired several displays over the last few years. In 2023 it announced changes to HowTo and FAQ rich results. In June 2025 its simplification announcement removed Course Info, ClaimReview, Estimated Salary, Learning Video, Special Announcement and Vehicle Listing from Search.

FAQ is the one most readers ask about. Google's documentation updates record that FAQ rich results stopped appearing in May 2026 and that the FAQ documentation was removed in June 2026. An old FAQPage block that no longer produces a display may be working exactly as written.

FAQPage remains a valid type on schema.org, and visible FAQ content still helps visitors. It no longer comes with a set of Google rich-result requirements to meet. The FAQ schema guide covers what the markup is still good for, and the guide to rich results and rich snippets shows which Google features are worth targeting.

Check the live HTML and the markup itself

Once the feature is confirmed, confirm the type matches the page's main subject. A product page should describe a product, an article should describe an article, and a page whose main subject is something else should not carry markup for a type chosen because it has a display. Google's guidelines also ask that markup represent the page's main content and not mislead, so a mismatch can be the whole problem.

Next, read the live HTML, not the CMS editor or the template. Open the published URL, view the rendered HTML and search for application/ld+json. Themes, SEO plugins and apps can add, change or strip blocks after you save. Shopify, Wix and Squarespace can also generate structured data on their own, according to their help documentation, so inspect the rendered page before you add custom code on top.

A man at a climbing gym front desk compares a printed page with a laptop
Figure 1. Comparing the published page with the markup is the first check after confirming the feature.

Then test the syntax by eye. JSON-LD needs matching braces and quotation marks, commas between properties but not after the last one, no comments, and an @context of https://schema.org. A single stray comma makes the whole block unreadable. If you build the script in Next.js, render it from a page or layout component, and sanitize any dynamic values so they cannot break out of the script element, as the Next.js JSON-LD guide describes.

Finally, compare every fact in the markup with the visible page. Names, dates, prices, availability, ratings and images should all match what a visitor sees. Google says markup describing content hidden from readers, or content that is misleading, fabricated or out of date, can make a page ineligible. If a plugin or template produces a second copy of the same item, the duplicate schema guide shows how to find and remove it, and the guide to checking whether a website has schema covers the inspection methods.

Compare your properties with the feature's rules

Required and recommended are words each provider defines for each feature. Google's guidelines say a missing required property makes an item ineligible for that feature, while recommended properties can improve the quality of the result. Schema.org describes the whole vocabulary but does not decide how Google Search behaves, so a property that Schema.org lists is not automatically required by Google.

Google's Article documentation lists no required properties and recommends author, datePublished, dateModified, headline and image when they apply. Its Breadcrumb documentation is stricter and requires itemListElement. Its Organization documentation lists no required properties and recommends relevant ones such as name, url, logo, sameAs and contact details. Check the current page for your feature before you edit anything, because requirements change. The guide to Search Console warnings about missing fields covers how to read those reports.

A BlogPosting example

This block describes an article page. Replace every example.com URL, the publisher name, the dates and the image paths with your own, and keep only facts a visitor can see on the page. The image array points to three crops of the same picture, and each image URL should be crawlable and indexable. Properties such as articleSection and inLanguage are valid Schema.org vocabulary but are optional for Google's Article feature.

json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": "https://example.com/blog/schema-rich-results-not-showing/#article",
  "url": "https://example.com/blog/schema-rich-results-not-showing/",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/schema-rich-results-not-showing/"
  },
  "headline": "Why Your Schema Isn't Showing Rich Results",
  "description": "Learn why valid schema may not produce rich results and how to diagnose eligibility, indexing, policy and display issues.",
  "image": [
    "https://example.com/images/schema-rich-results-1x1.jpg",
    "https://example.com/images/schema-rich-results-4x3.jpg",
    "https://example.com/images/schema-rich-results-16x9.jpg"
  ],
  "author": {
    "@type": "Organization",
    "name": "Example Publishing",
    "url": "https://example.com/about"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Publishing",
    "url": "https://example.com/",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/example-publishing-logo.png"
    }
  },
  "datePublished": "2026-11-12T09:00:00-06:00",
  "dateModified": "2026-11-12T09:00:00-06:00",
  "articleSection": "Testing and fixing",
  "inLanguage": "en-US"
}

A BreadcrumbList example

The breadcrumb trail below shows the required pieces for Google's Breadcrumb feature. Each ListItem carries a position and a name, and Google asks for item on every entry except the last one when the page URL can be worked out. The example includes item on all three for clarity. Swap in the real trail a visitor sees on the page, and note that the @id values connect this block to the article above when both sit in one graph.

json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "@id": "https://example.com/blog/schema-rich-results-not-showing/#breadcrumb",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Blog",
      "item": "https://example.com/blog/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Testing and fixing",
      "item": "https://example.com/blog/testing-and-fixing/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Why Your Schema Isn't Showing Rich Results",
      "item": "https://example.com/blog/schema-rich-results-not-showing/"
    }
  ]
}

For a deeper look at each type, see the guides to article schema and breadcrumb schema.

Run the Rich Results Test and the Schema Markup Validator

Run two different tests, because they answer two different questions. The Schema Markup Validator checks the code against the Schema.org vocabulary, so use it to confirm types and properties are spelled and shaped correctly. Google's Rich Results Test checks whether the page or code meets Google's requirements for its supported features, which is the eligibility question. Fix every missing required property it reports, then add the recommended properties that truthfully apply.

A pass in the Rich Results Test shows that the tested markup meets the technical conditions the test detects. It does not show that Google will display the feature for every search. That is why a page can pass and still look plain in results. The guide to the Rich Results Test and the Schema Markup Validator compares them in detail, and the guide to replacing the old Structured Data Testing Tool explains which check covers which question.

Check access, indexing and Search Console reports

A page Google cannot reach or index has no chance at an enhancement, whatever the markup says. Check robots.txt, noindex directives, canonical tags, redirects, login barriers and server responses. A Disallow rule for the section, a stray robots meta tag copied from a staging site, or a canonical tag pointing at a different URL are all ordinary causes, and so is a page that sits behind a login.

A page card with one path blocked by a gate and padlock and another open path reaching a stack of cards under a magnifier
Figure 2. A blocked path stops a page from reaching the index, whatever its markup says.

Both snippets below are examples of what to look for. The first is a robots meta tag that keeps a page out of Google's index, and the second is a robots.txt rule that blocks crawling of a whole section. Remove them only on pages you want crawled and indexed.

html
<meta name="robots" content="noindex">
text
User-agent: Googlebot
Disallow: /blog/

Then use Search Console. Open URL Inspection for the exact page and compare the indexed version with the live test, since the two can differ after you change something. Look at the Unparsable Structured Data report for syntax problems Google could not read, and open the enhancement report for the feature you are targeting to see errors, warnings and valid items. Check the Manual Actions report too, which the next section covers.

Diagnostic order, from feature to monitoring

  1. Choose a current featureConfirm the Google feature still exists in its documentation and gallery before checking anything else.
  2. Match type and visible factsPick the Schema.org type that fits the page's main subject and add only facts visitors can see.
  3. Validate vocabularyRun the code through the Schema Markup Validator to check types, properties and JSON syntax.
  4. Test Google eligibilityRun the Rich Results Test and fix every missing required property it reports.
  5. Inspect the live URLUse URL Inspection, then fix access, indexing and manual-action problems in Search Console.
  6. Recrawl and monitorRequest recrawling, watch the reports over days and weeks, and recheck other providers separately.

What to do about a manual action

A structured-data manual action is a Google enforcement action. Google says it can cause the structured data on a page to be ignored for rich-result eligibility while the page stays indexed, and says it does not affect the page's ordinary web-search ranking. Common causes in Google's guidelines include marking up content visitors cannot see, fake or self-serving reviews, misleading, irrelevant or fabricated properties, markup that impersonates a person or organization, and spammy content.

If the Manual Actions report lists one, work through it in this order.

  1. Open the Manual Actions report in Search Console and read the affected examples and the policy explanation.
  2. Remove or correct the offending markup and the visible content it describes.
  3. Retest the page with the Rich Results Test and URL Inspection.
  4. Submit a reconsideration request in Search Console with a short, plain explanation of what you changed.

Review time varies, and a reconsideration request carries no guaranteed completion time. If the report shows no manual action, you can cross it off and move on to timing.

How long changes take

Rich-result changes follow Google's own schedule. Google's documentation on site names, for example, says a change can take from a few days to a few weeks to be found and crawled, and its Article documentation says a recrawl request does not guarantee immediate indexing or an appearance. After a page is crawled, Google may still need time to process the markup and decide whether to show a feature.

Platforms add their own estimates. Wix's rich-result troubleshooting guidance says indexing after a recrawl request can take up to a week, which is platform advice and not a Google guarantee. Broader quality changes follow their own pace, and Google's core updates documentation describes updates to its ranking systems separately from markup processing.

The practical plan is simple. Check technical access right away, request a recrawl once the page is corrected, and watch Search Console over the following days and weeks. Do not expect a rich result on a specific day, and do not keep changing the markup every hour while Google is still processing the last change.

Test in Bing and open the page to AI crawlers

A Google pass tells you nothing about other consumers, and a missing Google display does not mean the markup is wasted. Bing reads JSON-LD and Microdata, so the same block serves both engines. Check it in Bing Webmaster Tools, and see Bing's guidance on marking up your site with structured data. DuckDuckGo's results sources page says its traditional links are largely sourced from Bing. Yandex has its own structured-data validator, and its displays and requirements are separate from Google's.

If you want ChatGPT search and Perplexity to reach the page, allow OAI-SearchBot (OpenAI crawler documentation) and PerplexityBot (Perplexity crawler guide) in robots.txt. OpenAI says placement in ChatGPT search is not guaranteed. See whether AI uses schema markup for the full comparison.

Keep accurate markup, then decide what to change

If every check passes, the markup may simply be waiting, or Google may be choosing a standard result for the searches you try. Keep markup that accurately describes the page. It can still be read by other consumers, and it keeps the page's facts in a form software understands.

A retired Google display does not make its Schema.org type invalid. Decide on accuracy before you remove anything: if the markup still describes the visible page truthfully, leave it. Remove or correct markup that is wrong, out of date, or describes content visitors cannot see. Avoid adding properties for a display only because you saw them in someone else's results.

When you are ready to tidy the whole site, the schema markup best practices checklist covers the habits that keep markup accurate. To run your code again after any fix, use the Schema Nova validator.

Questions people ask

Does schema markup improve rankings?

Google describes structured data as a way to make a page eligible for enhanced appearances, and says a valid block does not guarantee one. Treat it as a way to describe the page clearly, not as a ranking lever, and judge changes by what appears in your reports over time.

Does Google require JSON-LD?

No. Google's structured data introduction lists JSON-LD, Microdata and RDFa as supported formats. It recommends JSON-LD, which is also the easiest to keep separate from your visible HTML, so that is the format used in the examples above.

What should I check when the Rich Results Test passes but Search Console shows no enhancement?

Open URL Inspection and compare the indexed version with the live test, since Google may not have crawled your latest change. Then look at the enhancement report for your feature and the Manual Actions report, and allow time for processing. A passing test shows eligibility, not selection.

How do I check whether Google indexed my structured data?

Inspect the exact URL in Search Console and confirm the page is indexed. Then open the Unparsable Structured Data report and the enhancement report for your feature. If the page was indexed before you added markup, request recrawling and look again after Google has processed it.

Is the Schema Markup Validator the same as the Rich Results Test?

No. The Schema Markup Validator checks vocabulary against Schema.org, so it accepts types Google has no feature for. The Rich Results Test checks Google's feature requirements, so it only reports the types Google supports. Run both, because a pass in one does not stand in for the other.

Quick check: valid, eligible and shown

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

A Rich Results Test says your Article markup is valid, but Google shows a normal blue-link result. What is the most accurate conclusion?

Question 2 of 3

Which check tells you whether markup meets the rules of a specific Google feature?

Question 3 of 3

Google has retired the display for a type you use. What should decide whether you remove the markup?

Glossary

Select a term to see its definition.

Structured data. Machine-readable information that describes the content of a page.