Sprachen

Schema Markup Validator

Free, no signup. A schema block can look fine and still miss the one property blocking your rich result. This validator checks yours in four layers — JSON-LD syntax, schema.org vocabulary, Google's rich-result requirements, and cross-block @id graph resolution — then hands you back a corrected, copy-pasteable version.

Built by Patrick Stox

Reproduce this result in an agent

Uses the same inputs as the result above. No request is made from this panel.

MCP tool

Arguments

 
  Set up the connector → 
 
 
    
 
 or fetch a live URL    
 
The fetched HTML is checked for JSON-LD and visible-content matches. JS-injected content cannot be evaluated; paste rendered markup when needed.
 
Example data — replace with your own
 
  Requests are processed by our server and are not stored after processing. Only live-URL retrieval uses this service; pasted markup and all validation stay in your browser. Anonymous run-level outcome counters may be used for aggregate research; URLs, domains, IPs, and identifiers are never included, and no statistic is released below 100 runs. 
 
 
 Feedback 
 
 Report a bug 
Found something broken in Schema Validator? Let us know what happened — this goes straight to a private triage queue, not a public list.
 
      
 What will be sent 
 No tool inputs, uploads, pasted source, complete results, query parameters, or URL fragments are attached automatically. You can edit or remove the selected passage above. Browser and anti-abuse metadata is processed for spam prevention. 
  
 
  
 
 
  
 
 
   
 
Sample report Example data — real, engine-verified result
 
Paste a small graph — an article, its author, and an unrelated product:
 
 
{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "BlogPosting", "@id": "#article", "headline": "How rich results actually work", "image": "https://example.com/hero.jpg", "datePublished": "2026-07-01T09:00:00Z", "author": { "@id": "#author" }, "publisher": { "@id": "#org" } },
    { "@type": "Person", "@id": "#author", "name": "Patrick Stox" },
    { "@type": "Product", "name": "Example Widget" }
  ]
}
 
 
…and Validate returns three detected entities:
    
     
  • The Product blocks its rich result — no offers, review,
            or aggregateRating, so it lands in "Blocks rich
            result", the only tier that stops a rich result outright.
    •  
  • The dangling @id is the subtle one. publisher points
            at #org, but no node with that @id exists anywhere in the graph — the
            graph-resolution layer catches it even though the JSON itself is perfectly valid.
    •  
  • The Person is fine, just irrelevant. It's valid schema.org with
            "no Google rich-result feature applies" — not every type needs to chase a rich result.
    •  
  • Corrected JSON-LD fixes all of it at once — stubs for offers,
brand, sku, image, description,
author.url, and dateModified, each marked ADD: for you to
            fill in.
    •  
  • Building this from scratch instead of pasting? Use a schema generator to produce valid JSON-LD
            for a type from a simple form.
    •  
 
 
 
How to use it
 
     
  1. Paste your JSON-LD (starts with  or [) or a whole
HTML page — Auto-detect figures out which you gave it, or force a mode with the
            tabs.
    2.  
  2. Press Validate. Detected entities appear first, then any issues grouped by how
            badly they hurt.
    3.  
  3. Open Corrected JSON-LD to copy your markup back with stubs added for every
            missing property — each line to fill in is marked ADD:.
    4.  
  4. Use Copy shareable link to send a colleague the exact markup and its results.
    5.  
 
 
 
       
     
       
 
How it works
 

The validator runs four layers, in order, because each one only matters if the one before it
          passes:

 
     
  1. JSON-LD syntax — is it parseable JSON, in a valid @context/@graph
shape?
    2.  
  2. schema.org vocabulary — are the types and properties real, and used on types that
            actually define them?
    3.  
  3. Google rich-result requirements — does each type carry the required and
            recommended properties Google documents for its rich result?
    4.  
  4. @id graph resolution — do cross-block references (@id pointers between
            entities) actually resolve, or dangle?
    5.  
 

The validation engine runs in your browser. Markup you paste, including private
          drafts, is not uploaded or stored. Live-URL mode sends only the public URL to a guarded server
          endpoint to retrieve its HTML, then runs the same local checks against that response.

 
What the result groups mean
 
     
  • Blocks rich result — invalid markup or a missing required property. No rich
            result is possible until you fix these.
    •  
  • Limits rich result — valid, but a missing recommended property leaves eligibility
            or display on the table.
    •  
  • Valid, but missed opportunity — nothing wrong; properties or caveats worth
            knowing about.
    •  
 
Common validation errors
 
Most broken rich-result markup is valid JSON but incomplete: a Product lacks an Offer price, an Article omits a headline or author, or an @id points to an entity that was never defined. The corrected output makes those gaps concrete with ADD: stubs, but only fill a stub with information that is genuinely shown to users.
 
That last check matters for both search quality and answer systems: schema is a claim about the page, not a hidden source of extra facts. In HTML and URL modes, this tool compares visible text with selected names, prices, and ratings so a mismatch is easy to investigate.
 
 
 
 Which validator should you use?  
 NeedBest first checkWhy 
   
 Draft or private markup This Schema ValidatorDetailed JSON-LD, vocabulary, graph, and corrected-output checks stay in your browser. 
 Published URL and Google rendering Google Rich Results TestGoogle fetches the live page and reports its own supported enhancements. 
 Which feature is one field away Rich-Result Eligibility CheckerIt groups the requirements by rich-result type and prioritizes near misses. 
  
 
 
 Source: Tool guidance; Google decides live rich-result display. · Updated: 2026-07-12 
 
 

One honest caveat the tool repeats: meeting every documented requirement makes a rich result
possible, never guaranteed. Google decides at query time.

 
Features
 
     
  • Four-layer validation: syntax → vocabulary → Google requirements → @id graph.
    •  
  • Auto-detects JSON-LD vs full HTML; extracts every JSON-LD block from a page.
    •  
  • Corrected, copy-pasteable JSON-LD with ADD: stubs and an added-line diff view.
    •  
  • Shareable link that encodes your markup and its results.
    •  
  • Local validation — pasted markup stays private; live-URL mode sends only the URL for HTML retrieval.
    •  
 
Limitations
 

It validates JSON-LD, the format Google recommends — not Microdata or RDFa. It checks the
documented requirements for the rich-result types it knows; a novel or beta type may not be
          covered. Live-URL mode checks server-fetched HTML and does not execute page JavaScript, so markup
          injected by a tag manager or client-rendered app may be missing. Paste rendered HTML when needed,
          and use Google's Rich Results Test to confirm Google's rendered view of a published page.

 
Frequently asked questions
 
How is this different from Google’s Rich Results Test?
Google’s Rich Results Test fetches and renders a live URL, then reports which Google rich results it may qualify for. This validator runs its four validation layers locally in your browser. You can paste JSON-LD or HTML (including private drafts), or ask the guarded server endpoint to retrieve a public URL’s HTML before the same local checks run. URL mode does not render JavaScript, so use Google’s test for the final rendered-page check.
Does valid schema guarantee a rich result?
No. Valid markup can satisfy documented markup requirements, but display also depends on supported feature policies, crawling, indexing, and the search context. Google does not guarantee a rich result.
Should I use JSON-LD, Microdata, or RDFa?
Google recommends JSON-LD, and it is the easiest format to maintain because the markup lives in a single script block separate from your HTML. This tool validates JSON-LD (including the JSON-LD blocks extracted from a pasted HTML page).
What does the @id graph check do?
Structured data often splits entities across blocks and links them with @id — for example an Article that references its author Person by @id. The graph check confirms those references actually resolve to a defined node instead of dangling, which is a common and hard-to-spot mistake.
Is my markup uploaded or stored anywhere?
Pasted markup is validated locally in your browser and is not uploaded or stored. If you use live-URL mode, only the public URL is sent to a guarded server endpoint so it can retrieve the page HTML; validation still runs locally. Fetched HTML may omit markup added later by JavaScript, so paste rendered HTML when you need to check it.
 
 
← All free tools
 
 
   
Next stepSchema Markup Generator — generate valid JSON-LD for the page instead of hand-editing markup.

People also explore
ToolRich-Result Eligibility CheckerToolEntity Coverage AnalyzerToolGoogle Knowledge Graph ExplorerArticleJSON-LDArticleItemList SchemaArticleImageObject Schema
 
 
 
Feature requests for Schema Validator
 

Upvote what you want most. New ideas can be submitted from the floating Feedback menu;
      requests appear here once approved, and the most-wanted rise to the top.

   
Loading…
  
  ➕ Request a feature   
New requests are reviewed before they appear here.
 
     
  
  
 
 
 
 
   
   
Über das Tool
Füge JSON-LD oder eine vollständige HTML-Seite ein und prüfe strukturierte Daten in vier Schichten: Syntax, schema.org-Vokabular, Google-Anforderungen für Rich Results und @id-Graphauflösung.
Die lokale Analyse bleibt im Browser; im URL-Modus wird nur eine öffentliche URL an den geschützten Abrufdienst gesendet.
Funktionen
  • Automatische Erkennung von JSON-LD und vollständigem HTML mit Extraktion aller JSON-LD-Blöcke
  • Nach Schweregrad gruppierte Befunde mit Zeilenangaben und konkreten Korrekturhinweisen
  • Prüfung von @id-Referenzen über mehrere Blöcke und erkannten Entitäten
  • Korrigierter, kopierbarer JSON-LD-Block mit ADD-Stubs und Export-/Share-Link
Funktionsweise
Die Engine führt Syntax-, Vokabular-, Google- und @id-Graphprüfungen in dieser Reihenfolge aus. Jede Schicht baut auf der vorherigen auf und liefert nachvollziehbare Befunde; fehlende Eigenschaften werden im korrigierten JSON-LD mit ADD markiert.
Einschränkungen
  • Der Validator prüft dokumentierte Anforderungen, garantiert aber kein Rich Result. Google entscheidet zusätzlich anhand von Crawling, Indexierung, Richtlinien und Suchkontext.
  • Im Live-URL-Modus wird JavaScript nicht ausgeführt; später durch Tag-Manager oder Client-Code eingefügtes Markup kann fehlen.
  • Private Entwürfe bleiben lokal, sofern du nicht den optionalen öffentlichen URL-Abruf verwendest.
Häufig gestellte Fragen
Garantiert gültiges Schema-Markup ein Rich Result?
Nein. Gültiges Markup kann dokumentierte Anforderungen erfüllen, aber die Anzeige hängt auch von unterstützten Funktionen, Crawling, Indexierung und Suchkontext ab.
Was prüft die @id-Graphschicht?
Sie prüft, ob Querverweise zwischen Blöcken tatsächlich auf definierte Knoten zeigen, statt als verwaiste @id-Zeiger zu enden.
Ist JSON-LD, Microdata oder RDFa besser?
Google empfiehlt JSON-LD, weil das Markup in einem separaten Script-Block liegt. Dieses Werkzeug validiert JSON-LD, nicht Microdata oder RDFa.
Wird mein Markup hochgeladen oder gespeichert?
Eingefügtes Markup wird lokal im Browser geprüft und nicht gespeichert. Im URL-Modus wird nur die öffentliche URL an den geschützten Abrufdienst gesendet; die Validierung bleibt lokal.