
Element Code: RI-026
MedicalCondition type in JSON-LD. It gives Google and AI answer engines a structured map of symptoms, causes, and treatments, which matters a lot on YMYL health pages where trust signals decide who gets cited.What MedicalCondition schema actually is
MedicalCondition is a type in the schema.org health-lifesci extension. It is built to describe a specific disease, disorder, injury, or syndrome in a machine-readable way: what it is called, what part of the body it affects, what causes it, what signs and symptoms show up, how it is diagnosed, and how it is treated. Per schema.org, it sits alongside related types like MedicalSignOrSymptom, MedicalTherapy, and MedicalRiskFactor, all part of the same medical vocabulary originally built with Health on Schema.org (a joint effort involving Google, Mayo Clinic, and others).
This is not a cosmetic tag. It is a structured summary of the same information a doctor would want on an intake form: name, cause, associated anatomy, symptoms, treatment options, risk factors, and standardized medical codes. When you mark a page up correctly, you are telling crawlers and language models, in a format they can parse without guessing, "this page is specifically about condition X, and here is the clinical shape of it."
Why it matters for SEO, crawling, and AI visibility
Health content is squarely YMYL: Your Money or Your Life. Per Google's Search Quality Rater Guidelines, YMYL pages get evaluated against a stricter E-E-A-T bar (Experience, Expertise, Authoritativeness, Trustworthiness) because bad medical information can cause real harm. Structured data does not replace E-E-A-T, and it will not fix a page with no clinical review or no named author. What it does is act as a trust and clarity signal layered on top of good content: it tells search systems the page is organized the way a legitimate reference source organizes disease information, not the way a thin affiliate page throws words at a topic.
There is no dedicated Google rich result snippet type for a bare MedicalCondition block the way there is for Recipe or FAQ. What it does influence:
- Knowledge panel eligibility. Google has historically pulled MedicalCondition-style data (symptoms, related conditions) into health knowledge panels for well-established, high-authority sources.
- AI Overview and answer engine citation. Generative answer systems favor pages where facts are already segmented (symptom vs. cause vs. treatment) because it reduces the model's own extraction risk. A page with clean MedicalCondition JSON-LD gives an LLM a pre-parsed answer key instead of a wall of prose to interpret.
- Entity disambiguation. If a condition has a common name and several clinical synonyms,
alternateNameandcode(ICD-10, UMLS, etc.) help search engines tie your page to the correct medical entity instead of a loosely related one. - Crawl efficiency and content classification. Structured data gives Googlebot a fast, unambiguous read on topical intent, which matters when a domain publishes a large volume of condition pages that could otherwise look templated or thin.
None of this means "add the schema and rankings go up." It means: on a page that already has solid, reviewed medical content, this markup removes ambiguity for the systems deciding whether to trust and surface it.
How to detect whether a page has or needs this schema
Do not guess. Check directly:
- View-source / Inspect Element: search the raw HTML for
application/ld+jsonand"@type": "MedicalCondition". If it is only in the rendered DOM and not the source, confirm it is not stripped by server-side rendering issues. - Google's Rich Results Test: paste the URL in and check what structured data Google's parser actually extracts. This tells you if the JSON-LD is valid and readable, not just present.
- Schema Markup Validator (validator.schema.org): the vendor-neutral schema.org validator. Useful for checking full property coverage against the spec, since Google's tool only flags what it currently supports for rich results.
- Search Console: check the Enhancements section and any structured data reports for parsing errors across the site, plus Page Indexing to confirm the page is actually being crawled and indexed in the first place.
- Screaming Frog: run a crawl with structured data extraction enabled (Configuration > Spider > Extraction > Structured Data) to pull every page's JSON-LD types in bulk. This is the fastest way to audit a site with hundreds of condition pages and find which ones are missing MedicalCondition markup, have malformed JSON, or have duplicate/conflicting schema blocks.
If a page is clearly "about" a single medical condition (has a name in the H1, describes symptoms, causes, or treatment), and none of the above tools find a MedicalCondition block, that is a real gap, not a nice-to-have.
MedicalCondition property map
Below is a diagram of how the core properties relate to the condition entity. It mirrors how you should structure the JSON-LD: one root condition object, with arrays or nested objects for anatomy, symptoms, treatments, and risk factors.
Key properties reference
| Property | Purpose |
|---|---|
name | The condition's primary name, required, should match the page's main entity. |
alternateName | Clinical synonyms or lay terms, helps disambiguate the entity across naming conventions. |
associatedAnatomy | Body structure(s) affected, references an AnatomicalStructure or AnatomicalSystem entity. |
cause | What triggers or causes the condition, references a MedicalCause entity or plain text. |
riskFactor | Factors that increase likelihood of the condition, references MedicalRiskFactor. |
signOrSymptom | Observable signs and reported symptoms, references MedicalSignOrSymptom. |
possibleTreatment | Treatment options, references MedicalTherapy or DrugClass/Drug. |
epidemiology | Prevalence and incidence data, who is affected and how commonly. |
differentialDiagnosis | Related conditions that must be ruled out or distinguished from this one. |
code | Standardized medical coding (ICD-10, UMLS CUI, etc.) via MedicalCode. |
naturalProgression | How the condition typically develops if untreated, useful for prognosis content. |
Implementing it: a working JSON-LD example
Place this in a single <script type="application/ld+json"> block, ideally in the page head or right before the closing body tag. Do not split it across multiple scripts unless you have a specific templating reason.
{
"@context": "https://schema.org",
"@type": "MedicalCondition",
"name": "Type 2 Diabetes",
"alternateName": ["T2D", "Adult-onset diabetes"],
"associatedAnatomy": {
"@type": "AnatomicalStructure",
"name": "Pancreas"
},
"cause": {
"@type": "MedicalCause",
"name": "Insulin resistance combined with reduced insulin secretion"
},
"riskFactor": [
{ "@type": "MedicalRiskFactor", "name": "Obesity" },
{ "@type": "MedicalRiskFactor", "name": "Family history of diabetes" },
{ "@type": "MedicalRiskFactor", "name": "Sedentary lifestyle" }
],
"signOrSymptom": [
{ "@type": "MedicalSignOrSymptom", "name": "Increased thirst" },
{ "@type": "MedicalSignOrSymptom", "name": "Frequent urination" },
{ "@type": "MedicalSignOrSymptom", "name": "Fatigue" }
],
"possibleTreatment": [
{ "@type": "MedicalTherapy", "name": "Metformin" },
{ "@type": "MedicalTherapy", "name": "Lifestyle and dietary modification" }
],
"epidemiology": "Accounts for the large majority of diagnosed diabetes cases worldwide, per World Health Organization data.",
"code": {
"@type": "MedicalCode",
"codingSystem": "ICD-10",
"codeValue": "E11"
}
}Steps to implement or fix this on a real page:
- Confirm the page is genuinely about one condition. If it covers three conditions in one article, either split the content or use multiple
MedicalConditionblocks tied to distinct sections, do not force one block to represent three diseases. - Pull real clinical facts from your on-page content. Every value in the JSON-LD should already exist as visible text on the page. Schema is a structured echo of the content, never a place to add facts that are not written out for the reader.
- Fill the core properties first:
name,signOrSymptom,cause,possibleTreatment,riskFactor. These carry the most practical weight for both search and AI extraction. - Add
codeif you have access to accurate ICD-10 or equivalent coding. Do not fabricate a code, an incorrect medical code is worse than no code. - Validate with the Schema Markup Validator and Rich Results Test before publishing, then re-check in Search Console a few days after the page is recrawled.
- Pair it with visible E-E-A-T signals: a named author with relevant credentials, a "medically reviewed by" line with a reviewer's credentials, and a last-updated date. The schema supports the content, it does not substitute for it.
What good implementation looks like
A well-built MedicalCondition page has three things lined up: the visible content actually explains the condition in plain, accurate language; the JSON-LD mirrors that content property by property with no invented values; and the page carries clear authorship and review signals outside the schema entirely (author bio, credentials, review date). Sites that only paste in a schema generator's boilerplate JSON-LD without matching page content tend to get flagged in manual review or simply ignored, because Google's systems cross-check structured data against the visible text. If the two disagree, structured data loses.
- Match every schema property to visible on-page content
- Use specific sub-types (MedicalSignOrSymptom, MedicalTherapy, MedicalRiskFactor)
- Validate with both Google's Rich Results Test and the Schema Markup Validator
- Pair schema with named, credentialed authorship and a review date
- Re-audit condition pages after any content refresh
- Invent symptoms, causes, or codes not stated in the copy
- Stack multiple unrelated conditions into one schema block
- Use ICD codes you have not verified against a real coding source
- Treat schema as a substitute for medical review or expert authorship
- Leave broken or duplicate JSON-LD blocks live after a template change
FAQ
Does MedicalCondition schema guarantee a rich result in Google Search?
Can I use MedicalCondition schema without medical credentials on staff?
What is the fastest way to audit MedicalCondition schema across a large health site?
Should every symptom, cause, and treatment be its own nested object?
Does adding this schema fix a page that Google isn't ranking?
Our Advanced SEO Audit checks schema coverage, YMYL content signals, and crawlability across your whole site, not just one page at a time.
Claude Vincent is a technical SEO consultant focused on crawlability, rendering, and AI-search visibility. He writes the field guides and case studies at SEO ProCheck, with a bias toward the durable, unglamorous work that decides whether search engines and AI answer engines can actually read and cite a site.
About SEO ProCheck
Technical SEO consulting and GEO strategy with 20 years of enterprise experience. Case studies, resources, and tools for search and AI visibility.
Work With Me
Technical SEO audits, GEO strategy, site migrations, and international SEO. Hourly consulting for teams who need hands-on support, not just reports.







