Idiomas

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.
 
     
  
  
 
 
 
 
   
   
Sobre a ferramenta
A marcação de esquema pode parecer correta e ainda faltar uma propriedade que bloqueia um resultado avançado. Valide a sintaxe JSON-LD, o vocabulário e os requisitos do Google de uma só vez.
A ferramenta valida JSON-LD, o formato recomendado pelo Google — não Microdata nem RDFa — e verifica o conteúdo estruturado encontrado.
Recursos
  • Validação em quatro camadas: sintaxe → vocabulário → requisitos do Google → grafo @id.
  • Detecta JSON-LD ou HTML completo e extrai cada bloco JSON-LD da página.
  • A marcação colada é validada localmente no navegador e não é enviada nem armazenada. No modo de URL ativa, somente a URL pública é enviada a um endpoint protegido para buscar o HTML; a validação continua local. O HTML buscado pode não conter marcação adicionada depois por JavaScript, portanto cole o HTML renderizado quando precisar verificar isso.
  • JSON-LD corrigido e pronto para copiar, com stubs Adicione e uma visualização das linhas adicionadas.
Como funciona
O validador executa quatro camadas em ordem: primeiro a sintaxe, depois o vocabulário, os requisitos de resultado avançado do Google e, por fim, as relações @id do grafo. Cada camada só avança quando a anterior permite uma interpretação segura, e cada achado aponta para a propriedade e a correção correspondente.
Limitações
  • O modo de URL ativa verifica HTML obtido pelo servidor e não executa JavaScript. Por isso, a marcação adicionada após a renderização inicial pode não aparecer.
  • A ferramenta valida a evidência fornecida; não garante um resultado avançado nem substitui a verificação da página renderizada.
Perguntas frequentes
A marcação válida garante um resultado avançado?
Não. A marcação válida pode atender aos requisitos documentados, mas a exibição também depende de políticas da funcionalidade, rastreamento, indexação e contexto da pesquisa. O Google não garante um resultado avançado.
O que a verificação do grafo @id faz?
Os dados estruturados frequentemente dividem entidades entre blocos e as conectam com @id — por exemplo, um Artigo que referencia seu autor Person por @id. A verificação confirma que essas referências resolvem para um nó definido, em vez de ficarem pendentes.
Qual é a diferença em relação ao teste de resultados avançados do Google?
O teste de resultados avançados do Google busca e renderiza uma URL ativa e informa quais resultados ela pode qualificar. Este validador executa localmente as quatro camadas de validação no navegador. Você pode colar JSON-LD ou HTML, inclusive rascunhos privados, ou pedir ao endpoint protegido que busque o HTML público. O modo de URL não renderiza JavaScript; use o teste do Google para a verificação final da página renderizada.
Devo usar JSON-LD, Microdata ou RDFa?
Esta ferramenta valida JSON-LD, o formato recomendado pelo Google; ela não valida Microdata nem RDFa.
Minha marcação é enviada ou armazenada?
O conteúdo colado permanece no navegador. No modo de URL, só a URL pública vai ao endpoint protegido; a validação continua local.