Schema Markup Validator: Test Structured Data Before It Goes Live

Why Validation Matters Before Deployment

Invalid schema markup costs you rich results without costing you rankings — and that distinction is critical. When Google encounters broken structured data, it silently ignores it. You will not see a manual action, a ranking penalty, or any warning in your normal analytics. Your page continues to rank exactly as it would without schema, but you miss every CTR gain that rich results provide: star ratings in the SERP, FAQ dropdowns, product prices, review counts, and breadcrumbs all disappear when schema is broken. Validation before deployment catches four categories of issues that cause this silent failure. JSON syntax errors — a missing comma, an unclosed brace, a stray backslash — make the entire script block unparseable. Missing required fields prevent Google from generating the rich result even if it can read the markup (Product schema without an offers block will never show a price in search). Wrong property types, such as using a text string where a Number is required, cause validation warnings that block eligibility. And mismatched content — schema claiming 150 reviews when no reviews appear on the page — triggers Google quality filters. Validate first, deploy second.

Google Rich Results Test

The Google Rich Results Test at search.google.com/test/rich-results is the primary tool for validating whether your schema qualifies for enhanced search features. It accepts two inputs: a live URL or a code snippet pasted directly. Use the URL mode to test pages already deployed — Google fetches the page as Googlebot would and identifies every JSON-LD and microdata block present. Use the code snippet mode to validate markup before you push it to production. The tool shows you two types of issues. Errors are hard blockers: Google cannot generate a rich result for the affected schema type even if everything else is correct. Warnings indicate missing recommended fields — the rich result can still appear, but it may be less complete or prominent. The output groups results by schema type, so a page with Article, BreadcrumbList, and FAQ markup will show separate result panels for each. When a URL test shows different results than a code snippet test, the page itself is likely blocking Googlebot — check your robots.txt and server response headers, and confirm the page returns 200 for crawlers.

Schema.org Validator

The Schema.org Validator at validator.schema.org provides broader coverage than Google's tool because it validates against the full Schema.org specification rather than only the subset Google has chosen to support for rich results. This distinction matters: Google supports around 30 schema types for rich results, but Schema.org defines hundreds of types covering everything from MedicalCondition to SoftwareApplication to MusicRecording. If you are implementing schema for entity disambiguation, knowledge panel optimization, or AI-assisted search (where structured data informs language models about your content), the Schema.org Validator is the right tool. It checks entity relationships — whether the values you assign to properties match the expected types — and flags property names that do not exist in the specification (which Google quietly ignores rather than reporting). Run your markup through both tools: the Schema.org Validator confirms structural correctness against the specification, while the Google Rich Results Test tells you specifically what Google will do with it. The Schema.org Validator does not show Google-specific rich result eligibility and cannot tell you whether a page will get stars or FAQ dropdowns in search results.

Google Search Console Enhancements Reports

Once your schema is live and Google has crawled your pages, Search Console surfaces aggregate validation data in the Enhancements section of the left navigation. Each schema type Google detects on your site gets its own report: you will see separate entries for FAQ, Product, Article, BreadcrumbList, Video, Event, and any other types present. Each report has three tabs — Error, Warning, and Valid — showing a count of affected pages and a graph of how that count has changed over time. Click into the Error tab to see the specific error message and which property is causing it. Google groups affected pages by error type, so if 40 product pages have the same missing required field, they appear together under a single error description. The most important limitation of Search Console for schema is timing: it can take days to several weeks for newly deployed schema to appear in these reports, and corrections can take equally long to be reflected after you fix them. This makes Search Console useful for ongoing monitoring and catching regressions at scale, but not for pre-deployment validation. Use the Rich Results Test for that, and use Search Console to confirm that your fixes held across your entire site after crawling.

Common Schema Validation Errors

Five errors account for the majority of schema failures found during validation. The most common is a missing required field: Product schema requires an offers property for price rich results, and Recipe schema requires cookTime and recipeYield — omitting these blocks the corresponding rich result entirely even if the rest of the markup is perfect. The second most frequent is a wrong value type: aggregateRating.ratingValue must be a Number, not a Text string in quotes, even though JSON technically allows both (Google's validator distinguishes between them). Third is incorrect date formatting: datePublished and dateModified must use ISO 8601 format, meaning YYYY-MM-DD or full datetime with timezone — a date like "May 1, 2026" will fail. Fourth is relative image URLs: the image property on any schema type must be an absolute URL beginning with https:// — a relative path like /images/product.jpg will be rejected. The fifth and most SEO-damaging error is a mismatch between schema and visible page content: if your Product schema claims aggregateRating of 4.8 from 300 reviews but no reviews are visible on the page, Google's quality systems will suppress the rich result even if the markup is technically valid. All schema must accurately reflect what a user can see on the page.

Testing JSON-LD Syntax

Before running your markup through Google's validator, confirm the JSON itself is valid. A single syntax error makes the entire script block unparseable and all schema in it invisible to Google. Common JSON errors in schema markup include: a missing comma between properties, an extra closing bracket that ends the object early, and — the most insidious — curly quotes substituted for straight quotes by word processors or rich text editors. When you draft schema in Microsoft Word, Google Docs, or any email client and then copy it into your HTML, the typographic quotation marks (" and ") replace the ASCII straight quotes (" and ") that JSON requires. Every property name and string value breaks. Paste your JSON-LD block into jsonlint.com or another JSON linter before sending it to Google's tool. The linter will show you the exact line and character position of syntax errors, which Google's validator sometimes reports less precisely. After confirming valid JSON, run it through the Rich Results Test. This two-step approach — JSON linter first, Google validator second — dramatically reduces the back-and-forth of debugging schema issues, especially for complex types like HowTo or Event with nested objects.

Testing Before vs After Deployment

The Google Rich Results Test code snippet mode is specifically designed for pre-deployment validation. Paste your complete JSON-LD block — including the surrounding script tags — into the input field to see exactly what Google would detect if you published the markup today. This lets you confirm rich result eligibility before committing a deployment. If you have a staging environment, use the URL test mode against your staging domain, but be aware that Google's tool needs to be able to reach the URL — staging sites behind HTTP authentication or IP restrictions will not work with the URL mode. When testing, pay close attention to the distinction between required and recommended fields. Required fields control eligibility: if they are missing, you get an Error and no rich result. Recommended fields control display completeness: if they are missing, you get a Warning and may still get a rich result, but it might show fewer details. For Product schema, offers is required for price display; brand and aggregateRating are recommended but improve how the rich result appears. Check the Google Search Central documentation for your specific schema type to see the current required vs recommended field list, as Google updates these requirements periodically.

Validating at Scale

For sites with hundreds or thousands of pages, individual URL testing is impractical. Three tools provide schema validation at scale. Google Search Console Enhancements reports are the most accessible: they crawl your entire site over time and surface aggregate error counts per schema type, letting you see whether a template bug is affecting 500 product pages simultaneously. Screaming Frog SEO Spider has a structured data extraction feature that crawls your site and exports all detected schema markup to a spreadsheet — you can filter by schema type, check for missing required fields across all pages, identify pages that should have schema but do not, and export individual JSON-LD blocks for validation. Configure Screaming Frog to crawl your sitemap URLs to ensure full coverage. Ahrefs Site Audit includes structured data checks in its crawl, flagging schema errors and invalid markup across your entire domain. When scaling schema validation, focus first on template-level errors: if your product page template generates incorrect schema, fixing one template fixes all affected pages simultaneously. Individual page errors require page-by-page fixes and are less urgent unless they affect high-traffic pages.

When Valid Schema Does Not Get Rich Results

Passing validation is a necessary condition for rich results, not a sufficient one. Google applies several additional filters before granting enhanced search features. The page must be indexed: schema on a noindex page or a page blocked by robots.txt will never generate rich results regardless of how correct the markup is. The content must meet Google's quality standards: thin pages, pages with low authority, or pages Google considers untrustworthy for a specific topic may be excluded from rich results even with perfect schema. The schema type itself must be one Google currently supports for the market and query type: FAQ rich results were significantly reduced in late 2023 and are now displayed far less frequently than they were previously. Review star rich results are restricted to specific site types under Google's review snippet policies — general content sites that aggregate third-party reviews are typically ineligible. Product rich results for Shopping ads require a Merchant Center feed in addition to schema. If your markup passes validation but rich results are not appearing, check whether the page is indexed, confirm the schema type is still supported by Google for your site category, and allow 2-4 weeks for Google to re-evaluate after any changes.

Fixing Schema Errors in Search Console

When Search Console shows schema errors in the Enhancements reports, the fix workflow follows a consistent sequence. Start in the Enhancements report for the affected schema type and click into the Error tab. Select the error message to see the list of affected pages. Open one of the affected pages in a browser and view source (Ctrl+U or Cmd+Option+U), then search the page source for the JSON-LD script block — it will be a script tag with type="application/ld+json". Copy the JSON-LD content and paste it into the Google Rich Results Test code snippet input to reproduce and confirm the error. Identify the specific property causing the error — it will match the error message in Search Console — and correct it in your CMS template or code. After deploying the fix, return to the Rich Results Test and validate the corrected markup again to confirm the error is resolved. Then go to Google Search Console and request reindexing of an affected page using the URL Inspection tool and the "Request Indexing" button. This signals Google to re-crawl the page sooner, typically within days rather than weeks. Once Search Console detects the fix across enough pages, the error count will decrease and eventually the Enhancements report will show the pages as valid.

Minimal Valid Product Schema Example

The following is a minimal valid Product schema with all required fields for price and rating rich results. Every required property is present, values use correct types, the image URL is absolute, and ratingValue is a Number-compatible string. Use this as a baseline and add your own data.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Your Product Name",
  "image": "https://example.com/product.jpg",
  "description": "Product description here.",
  "offers": {
    "@type": "Offer",
    "price": "29.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "127"
  }
}

To use this on a live page: wrap it in a script tag with type="application/ld+json", replace the placeholder values with your actual product data, and validate with the Rich Results Test before deploying. Confirm that the ratingValue and reviewCount match what is visible on the page, and that the image URL returns a 200 response and is at least 696 pixels wide for Google's image requirements.