The Schema.org Entity Relationship Visualizer turns JSON-LD structured data into a readable entity map. Use URL mode to fetch a public webpage and extract <script type="application/ld+json"> blocks, or switch to Raw JSON-LD mode and paste the JSON directly. When valid Schema.org-style entities are found, the tool builds a relationship diagram, entity detail cards, and a formatted raw-data view for review.
This is a debugging and documentation aid, not a rich-result eligibility checker. It helps you see how typed objects relate to each other, which properties are simple values, and where nested objects become separate entities. It does not promise search rankings, validate every Schema.org property, confirm that markup matches the visible page, or guarantee that Google, Bing, or another consumer will use the data.
What the visualizer actually does
The inspected implementation has two input modes. In Website URL mode, the server normalizes the address, requires a public http:// or https:// URL, resolves the hostname, rejects private, local, and reserved network targets, and then fetches the page with redirects disabled. It searches the returned HTML for JSON-LD script tags with a DOM/XPath pass first, then a regex fallback for pages whose HTML is difficult to parse. For YouTube-style pages, it includes a specific fallback that can construct a basic VideoObject from available player microformat data when JSON-LD scripts are not exposed in the usual way.
In Raw JSON-LD mode, the pasted JSON is submitted to the application and decoded as JSON. The parser accepts common JSON-LD shapes including one root object, a root array, an @graph array, nested typed objects, and string or array @type values. It identifies an entity when it encounters an object, assigns the displayed type from @type or falls back to Thing, chooses the visible name from name, headline, title, or the type, and records simple scalar properties on the entity card.
When a property value is another object or an array of objects with @type, the tool treats that value as a sub-entity and adds a labeled graph edge from the parent to the child. The generated graph uses Mermaid flowchart syntax and is rendered in the browser after the server returns the results. Entity type and name labels are HTML-escaped, newlines are collapsed, and relationship labels derived from JSON property keys are escaped after double quotes and line breaks are removed. A verified test on September 16, 2026 used a quote-bearing property key and confirmed that the graph label was generated without breaking the Mermaid edge label.
How to use the Schema.org visualizer
- Open the Schema.org Entity Relationship Visualizer.
- Choose Website URL if the JSON-LD is already published on a public page, or choose Raw JSON-LD if you want to test a copied snippet.
- For URL mode, enter the full target URL in the Target URL field. If you omit the scheme, the implementation attempts to add
https://before validation. - For JSON mode, paste valid JSON-LD into the Paste JSON-LD textarea. Paste the JSON object or array itself, not an entire HTML page.
- Click Visualize Schema Relationship and wait for the parser to build the result.
- Use Relationship Diagram to inspect the graph, Entity Details to review types, IDs, names, and simple properties, and Raw Data to see the formatted parsed JSON.
- Click Download SVG after the diagram renders if you need a local copy of the visual graph for documentation or issue reports.
The result area has three tabs. The diagram tab is best for spotting entity relationships quickly. The entity details tab is better when you need to compare IDs, type names, scalar fields, and nested-object boundaries. The raw tab is useful when URL mode extracted more than one JSON-LD block and you want to see the combined decoded data that the parser used.
Inputs, outputs, and limits
| Area | Supported behavior | Important limitation |
|---|---|---|
| URL mode | Fetches a public HTTP or HTTPS webpage, then looks for JSON-LD script blocks. | Private, local, reserved, and unresolved targets are rejected. Automatic redirect following is disabled, so a redirect response can produce a fetch-status error instead of following the destination. |
| Pasted JSON mode | Decodes valid JSON and parses root objects, root arrays, @graph, and nested typed objects. |
Invalid JSON is rejected before visualization. Script-wrapped HTML is not the intended input for this mode. |
| Entity detection | Creates entity cards from objects and uses @type, @id, name, headline, or title where available. |
Objects without an explicit type may appear as Thing. The tool visualizes structure; it does not judge whether the type is appropriate for the page. |
| Relationships | Creates graph edges from parent properties whose values contain typed nested objects. | References expressed only as matching @id strings are not deeply resolved into a full semantic graph. |
| Properties | Shows simple values in entity cards and summarizes untyped arrays as item counts. | Long text, large arrays, and deeply nested untyped data may be easier to inspect in the raw-data tab than on cards. |
| Diagram output | Renders a Mermaid flowchart and offers an SVG download named schema-diagram.svg. |
Very large graphs may be visually crowded, and the SVG download works only after Mermaid has finished rendering in the browser. |
Example: Article with a nested author
For a quick pasted-JSON test, use a small Article object with a nested Person author:
{
"@context": "https://schema.org",
"@type": "Article",
"name": "How to Audit Structured Data",
"author": {
"@type": "Person",
"name": "Avery Stone"
},
"datePublished": "2026-09-16"
}The visualizer identifies two entities: an Article named "How to Audit Structured Data" and a Person named "Avery Stone." The diagram shows an edge from the Article to the Person labeled author. The Article detail card lists simple properties such as name and datePublished, while the nested typed author becomes its own entity instead of being flattened into the Article card. This is the kind of quick relationship check that makes the tool useful during template QA.
URL mode versus pasted JSON mode
Choose URL mode when you need to inspect what a published page exposes to the application. It is useful after deploying a template, editing a CMS page, or confirming that a JSON-LD script tag is present in the delivered HTML. Because the request is made by the DigitalDomainKit server, it may see a different response than your browser sees. Authentication walls, bot protections, consent pages, redirects, geotargeting, caching, and server-side user-agent handling can all change what is returned.
Choose Raw JSON-LD mode when you already have the markup in an editor, pull request, CMS field, or validator. This mode avoids a page fetch and focuses on the JSON text you paste. It is usually the better choice for unpublished drafts, local templates, sensitive staging URLs, and cases where a production page blocks automated fetches. The pasted content is still submitted to the server for parsing, so do not paste secrets, private customer data, access tokens, or unpublished details you are not comfortable sending to the site.
Validation, privacy, and security notes
The visualizer uses server-side parsing. URL mode necessarily sends the target URL to DigitalDomainKit so the server can request the page. Raw JSON-LD mode sends the pasted JSON to DigitalDomainKit so the Livewire component can decode it and return the graph data. The current tool does not upload local files, create a saved project, or provide an account history view for visualizations, but normal web-server logs, request handling, sessions, analytics, and browser traces may still exist. Treat the tool as a convenient public web utility rather than a private structured-data vault.
The URL guard is intentionally conservative. A production test on September 16, 2026 submitted http://127.0.0.1 and the component returned "Private, local, and reserved network targets are not allowed" before producing results. That behavior matters because URL fetchers can otherwise become server-side request tools. The implementation also disables automatic redirect following during the HTTP request, so a public page that redirects may need to be tested at its final public URL instead.
The graph renderer is Mermaid running in the browser. The application escapes displayed entity labels and relationship labels before inserting them into graph syntax, but the output should still be considered a visualization for inspection rather than a sanitizer for publishing arbitrary user-generated markup. If you are reviewing structured data from an untrusted source, inspect the raw data carefully and avoid copying unfamiliar values into production templates without review.
Troubleshooting common results
| Message or symptom | Likely cause | What to try next |
|---|---|---|
No JSON-LD structured data found on this page. |
The fetched HTML did not contain parseable application/ld+json script data. |
View the page source, confirm the JSON-LD is server-rendered, or paste the JSON-LD directly in Raw JSON-LD mode. |
Failed to fetch the URL. Server returned status ... |
The target returned an error, redirect, access challenge, blocked automated request, or other non-success status. | Test the final canonical public URL, remove redirects where possible, or use pasted JSON mode for the snippet. |
Private, local, and reserved network targets are not allowed. |
The URL points to localhost, a private IP range, a reserved address, or a hostname resolving to one of those addresses. | Use a public routable test URL or paste the JSON-LD instead of asking the server to fetch a private environment. |
Could not identify any valid Schema.org entities... |
The decoded JSON did not contain objects the parser could treat as entities. | Check for an object, root array, or @graph containing Schema.org-style typed nodes. |
| The SVG button shows an alert. | The Mermaid diagram has not finished rendering or no SVG exists in the diagram container yet. | Wait for the diagram to appear, stay on the Relationship Diagram tab, then click Download SVG again. |
How it fits into structured-data QA
A relationship visualizer is most useful before or after formal validation. First, generate or collect the JSON-LD. Next, visualize the entity model to make sure the page, organization, author, product, offer, breadcrumb, video, or event nodes are connected in the way you expect. Then run a syntax and policy-focused validator to catch required fields, recommended fields, warnings, and search-specific eligibility rules. The visual map helps humans reason about the model; validators help check machine-readable requirements.
For background on the vocabulary, see the official Schema.org project. For the JSON-LD format itself, see the W3C JSON-LD 1.1 specification. For search-feature testing and eligibility details, use search-engine documentation such as Google Search structured data documentation. Those references are important because this DigitalDomainKit tool visualizes relationships; it does not replace the primary specifications or search documentation.
Related DigitalDomainKit tools
- Schema.org (JSON-LD) Generator creates starter JSON-LD for common content types before you visualize or validate it.
- JSON-LD Validator & Auto-Fixer checks pasted JSON-LD syntax and reachable entity markers when you need validation instead of a diagram.
- JSON-LD to Microdata Converter helps compare JSON-LD with inline Microdata markup for migrations or documentation.
- Microdata to JSON-LD converts older inline structured data into JSON-LD that can be reviewed in this visualizer.
- SEO Tags Generator helps draft page-level metadata that often sits beside structured-data work in a template QA checklist.
- SERP Simulator previews title and meta-description appearance separately from structured-data relationships.
Editorial and testing notes
This page was prepared for DigitalDomainKit and last tested on September 16, 2026. The reviewed implementation is a Laravel Livewire component backed by server-side PHP parsing, public-target URL validation through a shared network guard, an HTTP fetch with redirects disabled, DOM/XPath and regex JSON-LD extraction, recursive entity processing, Mermaid graph generation, and browser-side SVG download from the rendered diagram.
Report a problem through the DigitalDomainKit contact page if the visualizer rejects a public URL you believe should be allowed, fails to display a valid JSON-LD shape, produces a confusing diagram, or returns an error that does not explain what to change. Include whether you used URL mode or Raw JSON-LD mode, the visible error message, and a minimal sample when you can share one safely.