My schema passes the Rich Results Test. Why am I still not getting rich results in search?

Passing the Rich Results Test confirms eligibility, not guarantee. Google applies quality thresholds before showing rich results — pages with thin content, low E-E-A-T signals, or poor user engagement often clear validation but don't earn the snippet. Additionally, some types (HowTo, Review) only appear on certain device types or query formats. Check GSC → Enhancements for that schema type to see if impressions are growing — if impressions are nonzero but CTR is low, the rich result is showing but not being clicked, which is a different problem.

Does FAQPage schema still produce rich results in 2026?

No. FAQ rich results stopped appearing in Google Search on May 7, 2026 — for all websites, including the government and health sites that had retained them since the 2023 restriction. Google is also removing FAQ support from the Rich Results Test and the Search Console rich-result report (June 2026), with API support ending in August 2026. So don't expect the Rich Results Test to even report on FAQPage anymore. The schema type still exists and is valid on Schema.org, and Google has confirmed it still parses FAQ markup to understand pages — plus AI engines like ChatGPT and Perplexity extract Q&A pairs from it to build cited answers. Keep the markup if GEO (AI-search visibility) matters; just don't test it expecting a Google snippet.

What's the difference between the Schema.org Validator and the Google Rich Results Test?

Schema.org Validator (validator.schema.org) checks whether your markup is structurally valid per the Schema.org specification — correct types, recognized properties, valid syntax. It doesn't know about Google's requirements. The Google Rich Results Test goes further: it tells you whether your markup qualifies for specific Google rich result types and flags missing required fields per Google's documentation (which is stricter than Schema.org's spec). Use both: the Schema.org Validator first to catch syntax and type errors, then the Rich Results Test to check Google-specific requirements.

My JSON-LD validates but Google Search Console shows errors. What's happening?

The most common cause is JavaScript rendering. Validators test the markup you paste or the page's HTML response — if your JSON-LD is injected by client-side JavaScript, Googlebot may not execute it during the crawl. Check by viewing page source (not Inspect) — if the JSON-LD block isn't in the raw HTML, it's client-side and unreliable. Move it to server-rendered HTML. A second cause: GSC errors fire on your live indexed pages, which may differ from the URL you tested if canonicalization or redirects are involved.

How do I validate schema for AI search engines (GEO), not just Google?

There's no equivalent of the Rich Results Test for ChatGPT or Perplexity — they don't publish a validator. The practical proxy is: (1) ensure your JSON-LD is in static HTML (not JS-injected), (2) use the Schema.org Validator to confirm properties are standard and machine-readable, (3) run your URL through SEOPulse's AI Search Audit (/ai-search-audit) — it checks GEO signals including structured data, factual answer placement, and AI-citation readiness.

How to Validate Your Schema Markup: 3 Free Tools That Actually Work (2026)

TL;DR

Valid schema ≠ working schema. Here’s the three-tool workflow:

Tool	What It Catches	URL
Schema.org Validator	Syntax errors, invalid property names, wrong @type	validator.schema.org
Google Rich Results Test	Missing required fields, Google-specific eligibility	search.google.com/test/rich-results
GSC Enhancements	Live errors on indexed pages, rendering issues	Search Console → Enhancements

Run them in this order. Each catches different failure modes.

This post covers validation — the “does it work?” step. If you’re still deciding which schema types to add, start with Schema Markup for Small Business Owners: Which Types Actually Matter (2026) first.

Why Passing One Tool Isn’t Enough

A JSON-LD block can fail at three independent layers:

Syntax — the JSON is malformed, a property name isn’t in the Schema.org vocabulary, or a required field is missing per the spec
Google eligibility — Google’s requirements for a given rich result type are stricter than Schema.org’s spec; a Schema.org-valid block can still miss required Google fields
Rendering — the markup exists in your code but Googlebot never sees it because it’s injected by JavaScript after the initial HTML response

Most guides only mention the Rich Results Test. That skips the syntax layer (so you’re debugging Google errors without knowing if the JSON itself is even valid) and doesn’t surface rendering issues.

Tool 1: Schema.org Validator — Catch Syntax and Type Errors First

URL: validator.schema.org

This is the right first stop because it’s tool-agnostic — it validates against the Schema.org specification, not Google’s subset of it. Paste your raw JSON-LD (without the surrounding <script> tags) and run it.

What it catches:

JSON syntax errors (unescaped quotes, trailing commas, missing brackets)
Invalid property names (e.g., openingHours instead of openingHoursSpecification)
@type values that don’t exist in the Schema.org vocabulary
Properties used on the wrong @type (e.g., isbn on a Recipe)

What it misses: Google-specific required fields. Schema.org’s spec makes most properties optional; Google adds its own required fields on top. A block can be Schema.org-valid and still fail the Rich Results Test.

Tool 2: Google Rich Results Test — Eligibility Check

URL: search.google.com/test/rich-results

Use the URL testing mode (not code snippet), because it tests the actual rendered page — catching JavaScript-injection issues and CMS plugins that modify markup at build time.

How to read the results:

Detected items shows which schema types Google found
Eligible for rich results (green check) means the required fields are present; it doesn’t guarantee Google will display the rich result
Errors (red) on a detected item show exactly which required properties are missing; fix these first
Warnings (yellow) flag optional-but-recommended fields that improve your eligibility

One important note: if a type you expect to see doesn’t appear in the detected items at all, the markup isn’t reaching Google in rendered form. Check your page source.

Tool 3: Google Search Console Enhancements — Your Live Site Reality

The Rich Results Test tells you about one URL. GSC Enhancements tells you about your entire site.

Open GSC → left sidebar → Enhancements. Any schema type Google has detected and is tracking appears here. For each type, you’ll see:

Valid — items Google confirmed are eligible
Valid with warning — eligible but missing recommended fields
Error — pages with blocking issues; these items are definitely not earning rich results

The key insight: GSC errors appear on your live indexed pages, which may have drifted from what you last tested. This is where you catch issues like a plugin update that broke your markup, or a CMS migration that stripped JSON-LD from template files.

The Most Common Schema Errors (and the Fix)

1. Rendering via JavaScript Most common root cause of “validates but doesn’t show in GSC.” Move JSON-LD to server-rendered HTML.

2. @id string mismatches If your Organization node is "@id": "https://example.com/#org" but your BlogPosting author references "@id": "https://example.com/#organization" — those are two different nodes. The entity graph breaks silently. Standardize all @id strings across templates.

3. Missing required fields for the specific rich result type LocalBusiness requires name — but a Product rich result requires name, at least one Offer, and a url. Check Google’s structured data reference at developers.google.com/search/docs/appearance/structured-data/search-gallery for the per-type required fields.

4. Duplicate JSON-LD blocks CMS plugins (Yoast, Rank Math, RankIQ) often emit their own schema alongside theme-level schema. Running two FAQPage blocks on the same page confuses parsers. Check page source for duplicates.

5. Stale schema after content changes You updated a page’s FAQ section but the JSON-LD wasn’t updated to match. Mismatched visible content vs. schema content is a quality signal Google considers.

FAQPage in 2026: Why the Validator Stopped Reporting It

This one trips people up specifically during validation. FAQ rich results stopped appearing in Google Search on May 7, 2026 — for every site, ending the narrow government-and-health exception that had survived the 2023 restriction. Google is now pulling FAQ support out of the testing tools themselves:

Rich Results Test and the Search Console FAQ rich-result report lose FAQ support in June 2026
Search Console API support for FAQ data ends in August 2026

So if you paste FAQPage markup into the Rich Results Test and it no longer flags it as eligible — or stops mentioning it at all — that’s expected, not a bug in your code. Don’t chase a “fix.”

FAQPage still isn’t useless, though:

Google confirmed it will keep parsing FAQ markup to understand pages, even without showing the rich result
AI search engines (ChatGPT Browse, Perplexity, Google AI Overviews, Gemini) parse FAQPage markup to extract structured Q&A pairs and include them in cited answers
The schema organizes content in a machine-readable format that’s significantly easier for LLMs to extract than flowing prose

The practical rule: keep FAQPage markup if you care about AI-search visibility (GEO), and validate its syntax with the Schema.org Validator — but don’t expect Google’s tools to test it for rich-result eligibility anymore.

Validating for AI Search (GEO)

No formal validator exists for AI search engines like ChatGPT or Perplexity — they don’t publish a specification. The practical checklist:

Static HTML delivery — AI crawlers have the same JS-rendering limitation as Googlebot
Standard Schema.org types — LLMs are trained on Schema.org data; non-standard or invented properties are ignored
@id entity graph — correctly linked @id nodes (Article → author Organization, Product → Offer) give AI engines connected facts, not isolated snippets
Factual answer in the first 200 words — schema helps, but a direct prose answer above the fold is equally important for AI extraction

SEOPulse’s AI Search Audit checks all of these signals — including schema, factual answer placement, and AI-citation readiness — in a single automated report.

Related reading: How to get cited by ChatGPT and Perplexity — structured data is step one; these are the content signals AI engines weight just as heavily. For a complete technical SEO foundation (mobile, Core Web Vitals, crawlability), see Technical SEO for local businesses.