This post is for the technical SEO owner or engineering lead at a hospital group or doctor-directory style site, where thousands of doctor profiles share a handful of templates. Structured data on such a site rarely fails loudly. A template change drops one property, a plugin update renames a node, a consent script stops injecting JSON-LD, and nobody notices until a report weeks later shows fewer enhancements or a lost feature.
The question is how to catch those breaks early. The answer is a scheduled crawl that extracts the structured data from every sampled page, stores a normalised snapshot, and diffs it against the last good snapshot by template. We describe the design, the checks, the alert rules and the failure modes. The scale in the title is 5,000 doctor pages; the same design works for 500 or 50,000. There are no client results here, and the example is hypothetical.
Our guides on healthcare schema markup, the implementation guide and advanced medical schema explain what to mark up. This piece assumes the markup exists and asks how you keep it alive.
Why Search Console alone is not enough
Google Search Console is where you will eventually see enhancement and error reports, and you should use it. But it is a lagging, sampled view. It reports what Google processed, after it recrawled the pages, for the features it supports. It does not warn you before a release goes out, and it says nothing about types Google does not turn into features. Google's structured data introduction points to testing tools and Search Console reports for this job, which is sensible, but those are checks on one URL at a time or on Google's own timetable.
Your own monitor does three things Search Console cannot.
- It runs on your schedule, including against staging before release.
- It checks all the nodes you care about, including medical types with no Google feature.
- It diffs against your last known good state, so the alert reads "the Physician
hospitalAffiliationdisappeared from this template" and not "errors went up".
Design the extraction
You need a crawler that fetches pages, finds structured data and parses it. Three decisions shape reliability.
Raw or rendered. If your JSON-LD is in the server HTML, a plain HTTP fetch is cheaper and more stable. If it is injected by a tag manager or a client-side script, you need a headless browser to see it. Google's JavaScript SEO basics confirm that JSON-LD can be generated by JavaScript, with a warning that errors are easy to introduce. Run raw first; for pages where it finds nothing, fall back to a rendered fetch and record which mode produced the data. A shift from "raw" to "rendered only" is itself a finding.
Formats. Extract JSON-LD, and also Microdata and RDFa if any legacy plugin still emits them. A page can carry two copies of the same entity in different formats.
Politeness. Doctor pages sit on the same server patients use to book. Crawl at a low concurrency, observe response time, back off on slow responses, and run outside peak hours. Four parallel requests is usually enough for 5,000 pages overnight.
Normalise into a snapshot
Raw JSON-LD is noisy. Two renderings of the same page can differ in key order, whitespace or array order. Normalise before storing.
- Parse every JSON-LD block. Record parse failures as findings; a block that fails to parse is invisible to every consumer.
- Flatten
@graphinto a list of nodes, each with@type,@idand its properties. - Sort keys and normalise arrays of types.
- Store, per URL, a compact record: template, fetch mode, status, final URL, list of node types, list of
@idvalues, a list of property paths present per node, and a hash of each node. - Keep the full normalised JSON for a rolling window so a diff can be inspected.
A snapshot per run, per URL, is a few kilobytes; 5,000 pages fit comfortably in a database table or a folder of files.
What to check on each page
Write checks as rules that can pass or fail. Group them in three levels.
Structural checks
- The page contains at least one parsable JSON-LD block.
- Every
@idreferenced is defined somewhere on the page or is a known site-level identifier. - No
@idappears twice on one page with different values. - No empty strings,
nullvalues or placeholder text such as "undefined" or "Lorem".
Template contract checks. For each template, define the nodes and properties it must emit. For a doctor template that might be: a Physician node with name, url, medicalSpecialty, hospitalAffiliation and image; a WebPage node that is about the Physician; and the site-level organisation reference. The contract is a short file kept with the template code.
Consistency checks. Compare markup to visible text: the doctor's name in markup equals the h1; the affiliation named in markup appears on the page; the specialty matches the visible specialty. Google's general guidelines say not to mark up content that is not visible, so a mismatch is also a policy risk.
If you use stable @id identifiers across pages, add a graph-level check: every campus @id the doctors reference has a full definition on its own page.
Diff against the last good snapshot
Checks tell you what is wrong now. Diffs tell you what changed. Compare each URL's snapshot with its last passing snapshot and classify the change.
| Change | Likely cause | Severity |
|---|---|---|
| Node type disappears | Template or plugin change | Critical |
| Property disappears | Field renamed or removed | High |
| Property value changes type (text to object) | Template refactor | High |
| Fetch mode changes from raw to rendered | Script moved to tag manager | Medium |
| New property appears | Template extended | Info |
| Value changes | Content edit | Info, unless in a protected field |
| Parse failure | Broken JSON, bad escaping | Critical |
Aggregate by template. A single page that changed is an edit. A template where hundreds of sampled pages lost the same property is a release regression. Report the share of affected pages as a plain count, "412 of 500 sampled pages in the doctor template".




