]*type=["']?application\/ld\+json["']?[^>]*>([\s\S]*?)<\/script>/gi)]
.map((m) => m[1].trim());
// Top-level entities: the root object, members of a top-level array, members of @graph.
function roots(node, out = []) {
if (Array.isArray(node)) node.forEach((n) => roots(n, out));
else if (node && typeof node === 'object') {
if (node['@type']) out.push(node);
if (Array.isArray(node['@graph'])) roots(node['@graph'], out);
}
return out;
}
const present = (v) =>
v != null && !(typeof v === 'string' && !v.trim()) && !(Array.isArray(v) && !v.length);
let failed = false;
for (const src of process.argv.slice(2)) {
const blocks = blocksOf(await load(src));
console.log(`${src}: ${blocks.length} JSON-LD block(s)`);
const seen = new Map();
blocks.forEach((raw, i) => {
let data;
try {
data = JSON.parse(raw);
} catch (e) {
failed = true;
return console.log(` block ${i + 1}: does not parse: ${e.message}`);
}
for (const entity of roots(data)) {
for (const type of [].concat(entity['@type']).map((t) => String(t).replace(/^.*[/#:]/, ''))) {
const id = entity['@id'] ?? entity.url ?? entity.name ?? '';
seen.set(`${type} ${id}`, (seen.get(`${type} ${id}`) ?? 0) + 1);
const missing = (REQUIRED[type] ?? []).filter((p) => !present(entity[p]));
if (missing.length) failed = true;
console.log(` block ${i + 1}: ${type} ${missing.length ? `missing ${missing.join(', ')}` : 'ok'}`);
}
}
});
for (const [key, n] of seen) if (n > 1) console.log(` note: ${key} appears ${n} times`);
}
process.exit(failed ? 1 : 0);
```
On a page with a valid `@graph`, a broken Article block and a second, incomplete Organization it prints:
```text
page.html: 3 JSON-LD block(s)
block 1: Organization ok
block 1: Product ok
block 2: does not parse: Expected double-quoted property name in JSON at position 140 (line 6 column 1)
block 3: Organization missing url
note: Organization https://example.com/#org appears 2 times
```
In CI, run it against the built pages of a static site, or against a staging URL for a server-rendered one. A GitHub Actions step:
```yaml
- name: Check structured data
run: node scripts/check-jsonld.mjs dist/index.html dist/blog/first-post/index.html dist/products/winter-boot/index.html
```
The step fails the build when a template starts printing broken JSON or drops a required property, which is exactly the regression nobody notices by eye. The map is deliberately small: add the types and properties your templates promise, not every property schema.org defines.
### 6. Confirm eligibility with Google, last
Once layers 1 and 2 pass, run the Rich Results Test on one URL per template. It renders the page like Googlebot, lists the rich result types it detected, and separates critical issues (the item is invalid and will not show) from non-critical ones (recommended properties that would make it richer). Only then check Search Console's rich result reports for the whole site over the following weeks.
### Microdata and RDFa
getReport's validator parses JSON-LD fully and counts microdata: the microdata finding lists the `itemtype` values it found, as information only. RDFa is not parsed. Microdata still works for Google, but when you next touch the template, move the same data into one JSON-LD block and remove the attributes; it is easier to validate, and it cannot be broken by a designer moving a ``.
## Platform notes
### WordPress
Yoast SEO, Rank Math and WooCommerce each print JSON-LD, and most syntax errors on WordPress come from content passing through a filter into the block (quotes in a product title, an HTML entity in a description). Test a product with a quote in its name. When two plugins both print an Organization, keep the schema output in one of them.
### Sites that inject schema with JavaScript
getReport reads the HTML your server sends. A block added by a tag manager or a client-side framework after load does not appear in its findings, although Google may read it after rendering. To see what the browser ended up with, paste this into the DevTools console on the page:
```js
[...document.querySelectorAll('script[type="application/ld+json"]')].forEach((s, i) => {
try { JSON.parse(s.textContent); console.log(`block ${i + 1}: parses`); }
catch (e) { console.log(`block ${i + 1}: ${e.message}`); }
});
```
Printing the block in the server HTML is the more reliable choice: every consumer sees it, not only the ones that run JavaScript.
## Verify
- The schema validator shows "All N JSON-LD blocks parse", the required-properties finding as passed for each type, and the eligibility finding listing the types you expect.
- `node scripts/check-jsonld.mjs https://example.com/products/winter-boot/` exits with `0` (`echo $?` prints `0`).
- The Rich Results Test detects the same types with no errors, and Search Console's enhancement reports show valid items growing.
## Common mistakes
- **Validating the source when JavaScript injects the block.** Symptom: your validator finds nothing, the Rich Results Test finds the block, or the reverse. Check the rendered DOM with the console snippet, and prefer server-printed JSON-LD.
- **One entity per script versus a `@graph`, mixed.** Symptom: the same Organization appears in three blocks with slightly different names. Both styles are valid; pick one and give shared entities a single `@id`.
- **Trusting a plugin's green tick.** Symptom: the plugin says schema is on, the parse finding says a block fails. Plugins check their settings, not the output after other plugins and filters have touched it.
- **Treating non-critical issues as errors.** Symptom: hours spent on "recommended" properties while a required one is missing. Fix required properties first; recommended ones make a result richer, not possible.
- **Assuming valid means visible.** None of these tools check that the marked-up content is real and visible on the page, which [Google's structured data guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies) require. Ratings, prices and FAQs must match what a visitor sees.