Webmaster tools

JSON-LD validatorfor local preflight

Edit raw JSON-LD and inspect a formatted copy, term hints and the nodes visible in this input.

JSON-LD validator

JSON-LD input

Formatted result

Your JSON-LD stays in this browser tab. No URL or remote context is fetched.

Options

Schema.org vocabulary snapshot 30.1

Strict JSON, visible nodes and term existence only; no Google eligibility check.

Nodes: 2 · Notes: 0

Diagnostics

Schema.org 30.1 term lookup applied.

No issues found.

Nodes in this input

Showing 2 of 2

  • /@graph/0 · Type: WebSite · ID: https://example.com/#site
  • /@graph/1 · Type: WebPage · ID: https://example.com/#page
Explicit references: 1
  • https://example.com/#page · isPartOf → https://example.com/#site · Target in this input
Open Schema.org ValidatorOpen Google Rich Results Test

A template can emit valid JSON yet miss a type, misspell a property or point to another entity that is hard to see in one code block. This JSON-LD validator puts those separate observations beside the original text before you publish.

You can check JSON-LD online here with a frozen Schema.org vocabulary list and local processing. It does not decide Google eligibility; use the official Rich Results Test after this preflight.

Why use this JSON-LD validator

See a readable copy and an honest explanation of what the local checks can establish.

Follow entity links without expanding RDF

The JSON-LD validator lists nodes from a top-level array, nested objects or @graph and shows explicit @id references. A target absent from the pasted fragment is labelled outside this input, not invalid.

Two JSON-LD entities connected by an explicit @id reference are listed as nodes and a relation.

Separate a typo from a search promise

Schema.org 30.1 term hints identify names missing from the bundled snapshot. A custom context is left unchecked, and a hint never claims that Google would reject a rich result.

A misspelled Schema.org property receives a local vocabulary hint while the original code stays untouched.

Check the fragment before the live page

01

Keep the raw source

Paste JSON-LD text, including a top-level array or @graph. This page does not extract scripts from HTML or fetch a URL; copy the code inside the script tag first.

  • Load the two-node example to see an @id relation without sending a request.
02

Read each layer separately

Auto-check runs 350 ms after edits and prints two-space JSON beside syntax, structure and Schema.org 30.1 hints. Turn it off for a manual check with Ctrl/Cmd+Enter.

  • An unknown term is a snapshot hint; another @context switches vocabulary checking off.
03

Verify the published page elsewhere

Copy or download the current formatted text only while the result is fresh. Open Schema.org Validator for generic markup checks or Google Rich Results Test for Google-specific eligibility.

  • Official links open empty: paste code there deliberately if you choose.

Syntax, terms and visible entity relations

Strict parsing with a usable location

Duplicate JSON keys and malformed punctuation are errors with a line and column. The input line is highlighted, while valid numbers and object key order survive formatting.

A versioned vocabulary lookup

The structured data tester compares plain Schema.org types and properties with the bundled 30.1 current-term list. Custom mappings and other remote contexts are not judged by that lookup.

A bounded graph summary

Nodes show their source path, @type and @id. Explicit references show whether their target is also present in this paste; the list is not JSON-LD expansion or a canonical RDF graph.

What the local report does not certify

No Google eligibility verdict
The JSON-LD validator does not apply Google feature rules, render a live page or guarantee indexing and rich results. Use Google’s official test for those questions.
Only pasted JSON-LD is read
No URL crawl, HTML script extraction, Microdata or RDFa parsing runs here. Nothing in your input is sent to either official site by opening its blank link.
The vocabulary list is a snapshot
Schema.org 30.1 is bundled offline. An unknown name is a warning about this version, not proof that a custom extension or future term is invalid; domain and range are not hard constraints.
References are local observations
An @id absent from this fragment may be defined in another block or document. Repeated identifiers can describe the same node; neither condition is a fatal JSON-LD error here.

JSON-LD validator questions

Is this the same as Google’s Rich Results Test?

No. This JSON-LD validator checks local syntax and a fixed vocabulary snapshot; the Google tool applies current feature requirements to code or a page. The official link opens without transmitting your draft.

What is the difference between an error and a warning here?

An error means strict JSON could not be parsed or the root is not an object or array. Warnings describe missing structure or terms absent from the 30.1 snapshot; fix the source and compare with official tools.

Does it support @graph?

Yes, as a visible input summary. It lists @graph nodes and explicit @id links but does not expand contexts, generate triples or claim full JSON-LD 1.1 validation.

Can I place multiple types of structured data on one page?

Yes, JSON-LD can use an array or @graph for multiple entities. This page summarizes the nodes in the pasted fragment; it does not fetch other script blocks from your page.

How can I confirm that Google actually recognizes my structured data correctly?

Test the deployed URL in Google Rich Results Test and inspect Search Console. A green local JSON-LD validator result cannot confirm what Google crawls or displays.

Found a missing case?

Try the JSON-LD validator

Start with the linked-node sample, then run the JSON-LD validator on your own markup and take the fresh formatted result to the official tests.