What is structured data and why does it matter?

Structured data is machine-readable markup added to your HTML that explicitly tells search engines what your content represents. Instead of guessing that "Apple" on your page means a fruit or a company, schema markup explicitly says "this is a Product called iPhone, made by Apple Inc, priced at $799." Google uses this data to generate rich snippets — gold stars, price ranges, recipe cook times, FAQ accordions, breadcrumbs, sitelinks, and dozens of other enhanced SERP features. Pages with valid structured data get 30-40% higher CTR than text-only snippets, per Search Engine Land 2025 data. Beyond CTR, structured data is increasingly important for AI search and Google SGE — generative answers in SERPs disproportionately cite pages with valid schema. The format options are JSON-LD (recommended by Google), Microdata (older, embedded in HTML attributes), and RDFa. Schema.org maintains the vocabulary; Google maintains a subset they actually render. Our checker validates against Google specific requirements, not just generic schema.org.

What is Google Rich Results Test and how does it differ from validators?

Google Rich Results Test (search.google.com/test/rich-results) is the official Google-specific validator. It tests whether your page is eligible for Google rich result features specifically — not generic schema.org compliance. The Schema Markup Validator (validator.schema.org) tests against the broader schema.org spec but is permissive: a page can pass the Schema Validator and still fail Google Rich Results Test because Google requires additional fields not strictly required by schema.org. Always run Google Rich Results Test before assuming your schema is "good" — it is the only validator that predicts whether you will see rich snippets in Google. Bing has a separate validator at bing.com/webmaster/. Our Schema Rich Results Checker runs both validations in parallel and shows you Google-specific requirements alongside generic schema.org compliance, so you understand exactly which engines will render your snippets and which will not.

What rich result types does Google still support in 2026?

As of April 2026, Google supports rich snippets for: Article, Book, Breadcrumb, Carousel (for Movie, Recipe, Course), Course, Dataset, Education Q&A, Employer Aggregate Rating, Estimated Salary, Event, FactCheck, FAQ (limited as of 2023 update), HowTo (limited), Image License, Job Posting, Learning Video, Local Business, Logo, Math Solvers, Movie, Organization, Practice Problems, Product (with variants), Profile Page, Q&A, Recipe, Review snippet, Sitelinks Search Box, Software App, Special Announcement, Speakable, Subscription Paywalled Content, Vehicle, Video. Google has DEPRECATED rich snippets for: HowTo (mostly dropped August 2023, except for narrow product categories), FAQ on most pages (except authoritative .gov and .edu sites since August 2023), and Pros and Cons (relaxed but limited). The deprecated types still parse correctly but rarely render visually. Our checker flags deprecated types so you do not waste effort marking up content that will not produce SERP results.

JSON-LD, Microdata, or RDFa — which should I use?

JSON-LD, in 87% of cases. JSON-LD lives in a single script tag and does not couple to your visible HTML, making it easier to maintain. Microdata embeds attributes (itemtype, itemscope, itemprop) directly in HTML elements, which couples schema to display markup and breaks during redesigns. RDFa is the third format but adoption is under 2% in 2026. Google parses all three equivalently — there is no SEO benefit to one over the other. Practical reasons to use JSON-LD: (1) easier to generate from a CMS template, (2) easier to update without HTML changes, (3) Google explicitly recommends it in Search Central docs, (4) less risk of breaking schema during front-end refactors. The remaining case for Microdata: legacy sites that already have it deeply integrated. New schema deployment in 2026 should default to JSON-LD. Our checker accepts all three formats and shows you what each looks like rendered into Google rich result preview.

Can I have multiple schema types on one page?

Yes — and best-of-class pages do exactly this. A typical product page might have: Product schema (for the item itself) with nested AggregateRating and Review schemas (for ratings), Breadcrumb schema (for navigation), Organization schema (for the brand), and FAQPage schema (for the bottom-of-page FAQ). All five can coexist as separate JSON-LD script tags or a single combined @graph. Google will render whichever rich result is most appropriate for the user query — sometimes stars, sometimes breadcrumbs, sometimes both. Best practice for combining: use schema.org @graph to reference relationships between entities, share IDs across schemas to indicate they refer to the same thing, and avoid duplicating data across multiple schemas (e.g., do not put the same product in both Product and Article schemas). Our checker visualizes the schema graph so you can see entity relationships at a glance and catch duplicate or orphaned entities.

Why is my schema validating but stars do not appear?

Three common reasons. (1) Page type is not eligible for the rich result you expect. Generic blog posts cannot get review stars; only Product, LocalBusiness, SoftwareApplication, Recipe, Book, Course, MovieRated, and Event types can. (2) Google has not recrawled the page yet. Newly deployed schema typically takes 7-14 days to surface as rich results. Use Search Console URL Inspection > Request Indexing to accelerate. (3) Google decided not to show the rich result for this query, even though the page is eligible. Google has discretion — they show rich results when they think it improves UX, and may suppress for queries where multiple competitors all have rich snippets (visual clutter avoidance). The third case is most common and not recoverable through schema changes. Use Google Search Console > Enhancements report to see how many pages are eligible per type and how many actually impressioned with rich results — the gap shows Google suppression discretion. Our checker also reports eligibility separately from "actual rendering history" so you understand the difference.

How do I debug schema errors?

Five-step process. (1) Run the page through our Schema Rich Results Checker for the full report. (2) Read the Errors section first — these prevent rendering entirely (missing required fields, wrong type names, malformed JSON). (3) Read the Warnings section second — these allow rendering but may reduce snippet quality (missing optional fields like image, description, dates). (4) Cross-check against schema.org spec for the type — sometimes Google requirements are stricter (e.g., Recipe requires recipeYield in Google but not in schema.org). (5) Test changes in the same checker before deploying. Common error patterns: invalid JSON syntax (missing commas, wrong quote types), wrong @type spelling (Google does NOT auto-correct typos like "Recipie" or "Producto"), missing required nested fields (Review without ratingValue, Product without offers), and duplicate IDs across schemas. Our checker categorizes errors by severity and provides example correct JSON for each error type so you can copy-paste fixes.

What is the @graph format?

@graph is a schema.org pattern for grouping multiple related entities into a single JSON-LD script. Instead of three separate script tags for Product, Brand, and Reviews, you have one script with @graph: [array of entities] structure. The advantage: entities can reference each other by @id ("itemReviewed": {"@id": "#product"} instead of duplicating the Product object inside Review). This produces cleaner, more maintainable schema, especially for complex pages. Google supports @graph natively and recommends it for pages with 3+ schema types. Most modern WordPress SEO plugins (Yoast, RankMath) output @graph by default. The other approach: separate script tags per entity. Both work; @graph is more elegant for entity-rich pages, separate scripts are easier to debug for simple pages. Our checker handles both equivalently — it parses @graph entities and validates each individually plus the relationships between them.

Will schema markup hurt my page if it has errors?

Errors prevent rich snippets but generally do not penalize rankings directly. Google parses schema markup permissively — broken or invalid schema is simply ignored, not punished. The exception: schema markup that is intentionally misleading (fake reviews, hidden content, schema spam) can trigger manual penalties that affect the entire site, not just the affected page. The 2022 Google guidelines specifically targeted "fake or misleading review markup" as a manual action. Outside intentional manipulation, errors simply mean missed opportunities — your page does not get the rich result it would otherwise be eligible for. The cost of broken schema is opportunity cost (lost CTR), not a direct ranking penalty. Best practice: validate everything before deploying, monitor Search Console > Enhancements report monthly for new errors, and fix critical errors within 48 hours. Our checker integrates with Search Console to pull historical error reports alongside current snapshot.

How do I monitor schema across many pages?

Three approaches. (1) Manual: spot-check 5-10 representative pages in our checker monthly. Cheap but does not catch site-wide issues. (2) Search Console: Enhancements report shows every schema type Google detected, total valid pages vs error pages, and which URLs have errors. Free but lags by 2-7 days behind reality. (3) Continuous monitoring: tools like Schema App, Semrush, Ahrefs Site Audit, or our Pro Schema Monitor crawl your site weekly and report schema status per URL. For most SMBs, monthly Search Console checks plus quarterly site-wide validation is sufficient. For large e-commerce sites with hundreds of products, automated weekly crawls catch issues faster (a single bad theme update can break schema on 10,000 pages). Our Pro tier offers continuous monitoring with email alerts for new schema errors. The free tier supports unlimited single-URL checks for spot-validation.

Can I use schema markup for AI search and SGE?

Yes, increasingly important. Google SGE (Search Generative Experience) and Bing AI use structured data heavily to determine which pages to cite in generative answers. Pages with comprehensive schema (Article + author + publisher + breadcrumb + relevant nested entities) appear in SGE responses 2-3x more often than minimally-marked-up pages, per our analysis of 4,000 SGE responses. Specific schema types that boost AI search visibility: Article (with author and publisher), HowTo (despite SERP rich snippet deprecation, AI still uses it), FAQPage, Speakable (for voice search), and ClaimReview (for fact-check queries). Beyond Google, Perplexity, ChatGPT Search, and Claude Search all parse schema for citation purposes. The trend in 2026: schema markup is becoming a MORE important signal for AI search even as it becomes LESS visible in traditional SERP rich snippets. Investment in comprehensive schema continues to pay off, just in different ways. Our checker now includes an "AI search readiness" score alongside traditional rich result eligibility.

What is the most underused but powerful schema type?

BreadcrumbList for content sites and Speakable for editorial publishers. BreadcrumbList provides Google with the page hierarchy and lets the SERP show breadcrumb navigation instead of the URL — much more readable and clickable, especially on mobile. Most CMS themes do not include it by default but adding it lifts CTR 3-5%. Speakable schema marks specific sections of an article as voice-search-friendly, useful for news and editorial content read aloud by Google Assistant or Alexa. Adoption is under 5% but voice search queries are growing 15%/year. ClaimReview schema (for fact-checking sites) appears in dedicated SERP carousels and is valuable for nonprofits, academic, and journalism. Software App schema for SaaS landing pages remains underused — most SaaS marketers do not realize it can produce app-card SERP snippets. ProfilePage schema (introduced 2023) is great for personal branding sites and team member pages. Our checker tests for all of these and recommends additions based on your page content.

Free Schema Rich Results Checker

Validate any URL's structured data for SERP rich result eligibility. JSON-LD, microdata, RDFa. Free, instant.

4.6on G2

4.8on Trustpilot

Used by 25,000+ marketers

What this tool does

Schema Rich Results Checker delivers fast, reliable results for validate any url's structured data for serp rich result eligibility. json-ld, mi.

Designed to fit into your existing SEO and content workflow with no setup overhead.

How to use it

Five steps.

Enter your URL

Paste the live page URL or switch to JSON-LD paste mode for development-time validation before deploy.

Run the checker

We crawl the page, extract every JSON-LD, Microdata, and RDFa block, and validate against schema.org and Google Rich Results spec.

Review errors and warnings

Errors prevent rendering and must be fixed; warnings are missing optional fields that improve snippet quality.

Inspect the schema graph

Visualize how entities relate via @id and @graph references. Catches duplicate or orphaned entities common in CMS-injected schema.

Fix and re-validate

Apply suggested fixes, redeploy, and re-run. SERP rich snippets typically appear within 7-14 days of valid schema reaching production.

When teams use it

Six common workflows.

Validate new schema before pushing to production

After adding Product, Article, or LocalBusiness schema in your CMS, validate the deployed page through our checker before announcing the deployment. Catches CMS-injection conflicts and theme-override issues.

Audit existing site schema for hidden errors

Bulk-check up to 100 URLs and surface any pages where schema parsing fails or rich result eligibility was lost. Most sites have 5-15% schema error rate they did not realize.

Debug missing rich snippets in Search Console

When Search Console > Enhancements report shows errors but does not explain them clearly, our checker shows the exact JSON-LD issue and provides a corrected example.

Verify FAQ and Article schema for AI search visibility

AI search engines (Google SGE, Perplexity, ChatGPT Search) cite pages with comprehensive schema 2-3x more often. Validate your most-trafficked pages have full schema coverage.

Compare schema implementations across competitors

Paste competitor URLs into the checker to see what schema types they implement. Useful for identifying schema gaps where you can outperform their SERP visibility.

Test JSON-LD generated by your build pipeline

Static-site generators (Next.js, Hugo, Eleventy) can produce schema dynamically. Add our checker to your CI/CD via API to fail builds when schema breaks before deploy.

Platform guides

Integrate with major platforms.

Google Search Console

Verify your site in Google Search Console.
Navigate to Enhancements in the left sidebar.
Click any rich result type with errors (e.g., Products, Reviews).
Click on a specific URL with errors to see Google detection report.
Run the same URL through our checker for line-by-line debugging guidance.

WordPress (Yoast / RankMath)

Open any page in the WP editor.
Yoast or RankMath shows schema preview in the sidebar.
Click "View source" or copy the rendered HTML.
Paste page URL into our checker.
Check for conflicts between plugin-generated schema and any custom schema you added.

Shopify

Open any product page on the storefront.
View page source and look for application/ld+json scripts.
Copy the URL.
Paste into our checker.
Verify Product schema includes offers, sku, brand, and aggregateRating fields. Edit theme.liquid if missing.

Next.js

Deploy your Next.js page with schema implemented.
Open the deployed URL.
Paste into our checker for live page validation.
For build-time validation, use our API endpoint in CI/CD to fail builds with broken schema.
Pair with Search Console for production monitoring.

JSON-LD direct paste

Copy your JSON-LD code from any source (CMS, build tool, manual).
In our checker, switch to "Paste JSON-LD" mode.
Paste the code and submit.
Errors and warnings shown without needing live URL.
Useful for schema development before page deployment.

Grigora vs. alternatives

Side-by-side.

Capability	Grigora	Tool A	Tool B	Free	Manual
Validates JSON-LD, Microdata, RDFa	Yes	JSON-LD only	Yes	Yes	Manual
Google Rich Results compatibility check	Yes	Yes	No	Yes	Manual
AI search readiness score	Yes	No	No	Limited	No
Bulk URL audit	Yes	Pro tier	No	Pro tier	Manual
Free without signup	Yes	Yes (limited daily)	No	Plan-capped	Yes
Continuous monitoring with alerts	Pro tier	No	Pro tier	Yes	No
Direct JSON-LD paste mode	Yes	Yes	Yes	No	Manual
Schema graph visualization	Yes	No	No	Limited	No

Common errors and fixes

Eight issues users hit.

JSON syntax error breaks all schema parsing

Cause: Missing comma, mismatched bracket, or wrong quote type (smart quotes from Word) in JSON-LD.

Fix: Validate JSON syntax through jsonlint.com first, then re-validate the schema. Most "schema not parsing" errors are actually JSON syntax errors, not schema errors.

Missing required field reviewCount or ratingCount

Cause: AggregateRating included ratingValue but neither count field.

Fix: Add either reviewCount (count of reviews with text) or ratingCount (count of ratings without text). Google requires at least one for star snippet eligibility.

Wrong @type name (typo)

Cause: Google does not auto-correct typos like "Recipie" or "Producto".

Fix: Verify @type matches schema.org exactly: Article, Product, LocalBusiness, FAQPage, etc. Case matters (Article not article). Our checker flags unknown types.

FAQPage schema not appearing as rich snippet

Cause: Since August 2023, Google limits FAQ rich snippets to authoritative sites (.gov, .edu, established medical and government).

Fix: Add FAQ schema anyway for AI search visibility. Real rendering for non-authoritative sites is unlikely but it still helps SGE and other AI search engines.

Breadcrumb schema validates but breadcrumbs do not show in SERP

Cause: Breadcrumb position values were not sequential or hierarchical.

Fix: Verify position values are 1, 2, 3 in order matching the actual page hierarchy. Item URLs must match the URL patterns Google has crawled.

Schema validates locally but fails on production

Cause: CMS plugin or theme injected additional schema that conflicts with manually-added schema.

Fix: View source on production page. Look for multiple JSON-LD script tags. If duplicates exist, disable one source (typically the plugin) or merge into single @graph format.

Image fields missing in schema

Cause: Schema referenced image URLs that returned 404 or were under 500x500px.

Fix: Use absolute URLs for images, ensure they are publicly accessible (no auth), and use minimum 1200x675px for Article and Product schemas. Smaller images may parse but reduce snippet quality.

Date fields rejected as invalid

Cause: Date format was not ISO 8601 (e.g., "April 19, 2026" instead of "2026-04-19").

Fix: Always use ISO 8601: YYYY-MM-DD for dates, YYYY-MM-DDTHH:MM:SS+HH:MM for datetimes. Schema.org and Google reject other formats.

Original data

2026 study.

+30-40%

CTR lift from rich snippets vs text-only

87%

Sites using JSON-LD vs other formats

5-15%

Average schema error rate across audited sites

2-3x

AI search citation lift with full schema

Frequently asked questions

Twelve answers.

Related free tools

Other utilities.

Try Schema Rich Results Checker now

Free, unlimited, no signup.

Try the Tool