Does valid JSON-LD guarantee a rich result?

No. Valid JSON-LD that passes gap checking is a required foundation, not a guarantee. Rich result eligibility also depends on content quality and authority, whether the structured data matches the visible page content, Google's current support for the rich result type, and Google's content policies. Use Google's Rich Results Test for authoritative eligibility checking and Google Search Console for live rich result status.

Why does Google's Rich Results Test pass some markup but not show a result in search?

The Rich Results Test confirms that Google can detect and parse the structured data. It does not guarantee that the rich result will appear in search. Eligibility also depends on whether the page meets Google's quality and content standards, whether the rich result type is supported for the specific query context, and whether Google has crawled and processed the updated markup. Rich results can disappear even from previously eligible pages when Google's policies or feature coverage change.

What schema types does this tool check most deeply?

The gap checker provides the most detailed field-level analysis for: Product, SoftwareApplication, Article, BlogPosting, NewsArticle, JobPosting, Event, FAQPage, BreadcrumbList, Organization, and LocalBusiness. For other types, the tool validates JSON syntax and schema sanity (@context, @type) and provides a Google support context note, but does not run type-specific field checks.

Is FAQPage structured data still worth using?

Google significantly reduced FAQPage rich result visibility after 2023. Visible FAQ rich results now appear primarily for authoritative government and health content. FAQPage markup is still valid schema.org and may contribute to semantic content understanding, but should not be the primary rich result strategy for most sites. If FAQ-style content is genuinely present on the page, the markup is still worth including.

Can I fetch structured data from a live URL?

Yes. Switch to Fetch URL mode and enter a public URL. The tool uses a serverless fetch layer to retrieve the live HTML and extract all blocks. This works for any publicly accessible page. Structured data injected by JavaScript after the initial HTML response may not be captured — check the live page with Google's Rich Results Test for authoritative results.

Is my schema data uploaded to a server when I paste it?

No. Paste mode validation runs entirely in your browser using JavaScript. No JSON-LD content, field values, or URLs are sent to CodeAva servers. The tool is safe to use with draft structured data containing internal URLs or pre-launch content. Fetch URL mode uses a serverless layer to retrieve the live page HTML, but fetched content is not archived or stored.

What is the easiest way to fix missing JSON-LD fields?

Click any issue in the validation results to expand its detail. If a scaffold is available, click the 'Add ... scaffold' button to copy a placeholder JSON structure for that field. Paste it into your schema, replace placeholder values with real data, and re-run the validation. The Copy all JSON-LD button copies all parsed items in one action. After fixing, use the Test with Google button to check the updated markup in Google's Rich Results Test.

All tools

Structured Data Validator & Rich Result Gap Checker

Q: What is the difference between valid Schema.org and Google rich result eligibility?

Schema.org defines a broad vocabulary for structured data. A JSON-LD block is schema.org-valid if it uses the correct @type, property names, and value types. Google rich result eligibility is a narrower, higher bar: the structured data must match visible page content, the page must meet Google's content policies, Google must support a rich result feature for the type, and required fields defined in Google's own documentation must be present. Valid schema.org markup is a necessary starting point, not a sufficient condition for rich results.

Validate JSON-LD, extract structured data from live pages, and find missing fields that may block Google rich result eligibility.

Paste mode validation runs entirely in your browser — no schema data is sent to CodeAva servers. Fetch URL mode uses a serverless layer to extract JSON-LD blocks from live pages; fetched pages are not archived or stored.

Paste JSON-LD

⌘+Enter to validate

Paste JSON-LD or fetch a URL to start validation

Paste mode validation runs entirely in your browser — no JSON-LD, field values, or URLs are sent to CodeAva servers. Fetch URL mode uses a serverless layer to extract JSON-LD from live public pages. Fetched HTML is not archived or stored. The tool is safe to use with draft JSON-LD and pre-launch URLs that are accessible but not yet widely indexed.

Why valid schema is not the same as rich result eligibility

Syntactically valid JSON-LD is not the same as markup that is aligned with Google's rich result requirements. Schema.org defines a broad vocabulary of types and properties. Google supports a narrower subset of those types for search features — and each supported type has its own set of required or strongly expected properties that must be present for a rich result to be eligible. A JSON-LD block that passes JSON syntax checks and uses valid schema.org property names can still fail Google's eligibility checks if critical fields like image, offers.priceCurrency, or datePublished are missing.

Many SEOs and developers get stuck between these two layers. Schema.org documentation covers the full vocabulary. Google's structured data documentation covers what Google actually uses for search features — and the two are related but not identical. A page can have a perfectly structured Organization block that validates against schema.org and still never produce a rich result, because Organization does not directly trigger a Google rich result snippet. The gap checker makes this distinction explicit for each detected type.

A fast local validator with a live URL extractor is useful in real SEO and development workflows because it catches missing-field gaps before running Google's Rich Results Test. Finding that a Product block is missing offers here takes seconds. Finding it during a post-deployment Rich Results Test review — after a sprint cycle — takes much longer. The fetch-URL mode also lets you extract and inspect structured data from any live page without switching between browser source view, DevTools, and a validator tab.

What is the difference between valid Schema.org and Google Rich Result eligibility?

A JSON-LD block is schema.org-valid if it uses @context: "https://schema.org", declares a recognised @type, and uses property names and value types that schema.org defines for that type. Google rich result eligibility is a higher, narrower bar: the structured data must match the visible page content, the page must meet Google's content policies, Google must currently support a rich result feature for the schema type and context, and required fields defined in Google's own documentation must be present. Passing schema.org validation is a necessary starting point, not a sufficient condition.

Rich result gap cheat sheet

Schema type	Required / strongly expected fields	Useful recommended fields	Practical note
Product	`name, image, offers (priceCurrency required inside)`	`description, brand, aggregateRating, review`	Google Shopping features require a live Offer with price and priceCurrency.
SoftwareApplication	`name, applicationCategory, operatingSystem` + offers or rating	`aggregateRating, offers.price`	Both offers and aggregateRating are strongly expected for visible app snippets.
Article / BlogPosting	`headline, image, datePublished, author`	`dateModified, publisher, description`	Images in 1:1, 4:3, and 16:9 ratios are recommended. Headline max 110 chars.
JobPosting	`title, description, datePosted, hiringOrganization, jobLocation`	`validThrough, employmentType, baseSalary`	Expired listings without validThrough may continue appearing in Google for Jobs.
Event	`name, startDate, location, eventStatus, eventAttendanceMode`	`image, organizer, endDate, offers`	Virtual events need eventAttendanceMode: OnlineEventAttendanceMode and a url in location.
FAQPage	`mainEntity[] (each with name + acceptedAnswer.text)`	—	Rich result visibility significantly reduced since 2023. Markup remains valid but visible FAQ results are limited in practice.
Organization	No hard-required fields in Google documentation	`name, url, logo, sameAs, contactPoint`	Guidance-oriented. Useful for Knowledge Panel entity understanding, not a direct rich result trigger.

Adding JSON-LD in React and Next.js

In Next.js App Router, add JSON-LD using a <script> tag with dangerouslySetInnerHTML inside your page component. Derive the schema object from the same data that renders the visible page content to ensure they match — a common cause of Google rejecting structured data is a mismatch between what the markup says and what the page shows.

// app/products/[slug]/page.tsx
export default function ProductPage({ product }) {
  const jsonLd = {
    "@context": "https://schema.org",
    "@type": "Product",
    name: product.name,
    image: product.images,
    description: product.description,
    offers: {
      "@type": "Offer",
      priceCurrency: product.currency,
      price: product.price,
      availability: "https://schema.org/InStock",
      url: `https://example.com/products/${product.slug}`,
    },
  };

  return (
    <>
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
      />
      {/* page content */}
    </>
  );
}

After deployment, validate the live URL with Google's Rich Results Test to confirm the structured data is detected correctly from the rendered page.

What this tool helps with

Good uses

Validating pasted JSON-LD before deploymentcatch JSON syntax errors, missing @context or @type, and Google-critical field gaps before the code ships — without waiting for a post-deployment crawl.
Extracting and inspecting structured data from live pagespaste a URL into Fetch mode to see exactly which JSON-LD blocks are in the live HTML source, their detected types, and any validation issues — without digging through DevTools.
Diagnosing why structured data is valid but not producing rich resultscheck whether the detected schema type is actually supported for Google rich results, and whether the required fields for that type are present and correctly formed.
Preparing code before running Google's Rich Results Testfix critical errors and fill recommended fields using the scaffold helpers, then test the corrected code with Google — reducing validation round-trips.
Checking Product, Article, SoftwareApplication, Event, and JobPosting markup for field gapsget type-specific guidance for the schema types most commonly associated with high-value Google rich results and Shopping features.

Limitations to know

Guaranteeing rich result appearance from a passing scorethis tool checks for field presence and structure based on Google's documentation. Rich result eligibility also depends on content quality, visible-page-content alignment, Google's content policies, and Google's current ranking of the page. A passing gap check is not a guarantee.
JavaScript-rendered structured data extractionFetch URL mode extracts raw JSON-LD from HTML source. Structured data injected via JavaScript after initial render — including some React and SPAs — may not appear in the fetched source. Check the live page with Google's Rich Results Test for authoritative results.
Full schema.org vocabulary validationthis tool validates the properties that matter most for Google rich result eligibility, not the complete schema.org vocabulary. For comprehensive schema.org conformance checking, use validator.schema.org.

How to validate and fix structured data

1
Paste JSON-LD or switch to Fetch URL mode
In Paste Code mode, paste raw JSON-LD or a full <script type="application/ld+json"> block. The tool extracts content from script tags automatically if pasted. In Fetch URL mode, enter a live public URL to extract all JSON-LD blocks from the page HTML.
2
Review detected types and Google support context
Each detected @type is listed with a Google support context label: Supported rich result type, Limited visibility, Guidance-oriented, or Not covered. This tells you upfront whether the type can produce a Google rich result at all.
3
Work through critical errors first
Critical errors are the gaps most likely to prevent rich result eligibility. Click any issue to expand the detail. Use 'Add ... scaffold' buttons to copy placeholder structures for missing fields — clearly labelled as scaffolds requiring real values.
4
Address warnings and recommendations
Warnings flag issues that may reduce eligibility or completeness. Recommendations flag fields that improve markup quality and may increase rich result appearance probability without being strictly required.
5
Copy the updated JSON-LD and test with Google
Use 'Copy all JSON-LD' to copy the current parsed output, or 'Test with Google' to open Google's Rich Results Test. Paste the corrected JSON-LD directly or test the live URL after deployment.

Common issues and how to fix them

Structured data passes schema.org validation but fails Google's Rich Results Test

Schema.org validity and Google rich result eligibility are different bars. A Product block without offers.priceCurrency is schema.org-valid (priceCurrency is a schema.org property, not a schema.org required field) but fails Google's product snippet requirements. Focus on the Google-gap analysis layer, not just schema sanity checks.

Malformed JSON in a JSON-LD block

Common causes: unescaped quotes inside string values, trailing commas after the last property in an object or array (invalid in JSON), single quotes instead of double quotes, and unbalanced brackets. Use the Prettify JSON button to reformat, which will expose the parse error location.

Product markup missing offers and priceCurrency

Google requires an Offer object with priceCurrency (ISO 4217 code) for product snippet eligibility. Use the 'Add offers scaffold' button to copy a starter structure, then replace placeholder values with real product data.

Article or BlogPosting missing image or datePublished

Google requires at least one image and a datePublished (ISO 8601 format) for Article rich results. Provide images in multiple aspect ratios (1:1, 4:3, 16:9) for maximum surface coverage. datePublished must match what is visible on the page.

FAQPage markup present but not producing visible FAQ rich results

Google significantly reduced FAQPage rich result visibility after 2023. The markup may be structurally correct, but visible FAQ rich results now appear primarily for authoritative government and health content. FAQPage markup still provides semantic value but should not be the primary rich result strategy.

Organization treated as if it has hard required fields

Google's documentation for Organization is guidance-oriented, not required-field-heavy. Organization markup does not directly produce a rich result snippet on its own. Focus on completeness — name, url, logo, sameAs — for Knowledge Panel and entity understanding purposes, rather than chasing a validation pass.

Frequently asked questions

Schema.org JSON-LD Generator URL Indexability Inspector Meta Tag & SERP Previewer Canonical URL Builder & Checker Robots.txt Checker Website Audit All developer tools