MedicalCondition Schema

No Comments
Medicalcondition schema

Element Code: RI-026

TL;DR: If a page describes a specific disease, disorder, or syndrome, mark it up with schema.org's 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.
Schema Type
MedicalCondition
Vocabulary
schema.org / health-lifesci
Applies To
Disease / symptom pages
Google Support
No dedicated rich result, but feeds AI Overviews and knowledge panels
Priority
High on YMYL health sites

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, alternateName and code (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+json and "@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.

MedicalCondition

name / alternateName

associatedAnatomy

cause / riskFactor

code (ICD-10 / UMLS)

signOrSymptom

possibleTreatment

epidemiology

differentialDiagnosis

Result: parsed entity a search or AI system can cite directly

Key properties reference

PropertyPurpose
nameThe condition's primary name, required, should match the page's main entity.
alternateNameClinical synonyms or lay terms, helps disambiguate the entity across naming conventions.
associatedAnatomyBody structure(s) affected, references an AnatomicalStructure or AnatomicalSystem entity.
causeWhat triggers or causes the condition, references a MedicalCause entity or plain text.
riskFactorFactors that increase likelihood of the condition, references MedicalRiskFactor.
signOrSymptomObservable signs and reported symptoms, references MedicalSignOrSymptom.
possibleTreatmentTreatment options, references MedicalTherapy or DrugClass/Drug.
epidemiologyPrevalence and incidence data, who is affected and how commonly.
differentialDiagnosisRelated conditions that must be ruled out or distinguished from this one.
codeStandardized medical coding (ICD-10, UMLS CUI, etc.) via MedicalCode.
naturalProgressionHow 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:

  1. Confirm the page is genuinely about one condition. If it covers three conditions in one article, either split the content or use multiple MedicalCondition blocks tied to distinct sections, do not force one block to represent three diseases.
  2. 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.
  3. Fill the core properties first: name, signOrSymptom, cause, possibleTreatment, riskFactor. These carry the most practical weight for both search and AI extraction.
  4. Add code if you have access to accurate ICD-10 or equivalent coding. Do not fabricate a code, an incorrect medical code is worse than no code.
  5. 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.
  6. 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.

DO

  • 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
DON'T

  • 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?
No. Per Google Search Central, there is no dedicated rich result snippet tied specifically to a bare MedicalCondition block. Its value is in disambiguation, knowledge panel eligibility for high-authority sources, and giving AI systems a structured fact set to cite from.
Can I use MedicalCondition schema without medical credentials on staff?
You can technically add the markup, but on a YMYL topic Google's quality guidelines expect medically reviewed content. Schema without genuine expertise behind it does not raise trust, it just formats unreviewed claims more clearly, which is not the goal.
What is the fastest way to audit MedicalCondition schema across a large health site?
Run a Screaming Frog crawl with structured data extraction turned on. It pulls every page's JSON-LD types in one pass, so you can filter for condition pages missing the type, or flagging parsing errors, without opening each URL individually.
Should every symptom, cause, and treatment be its own nested object?
Where practical, yes. Using the proper sub-types (MedicalSignOrSymptom, MedicalCause, MedicalTherapy) instead of plain strings gives search engines more to work with than a flat text list, and it is what schema.org's own documentation demonstrates.
Does adding this schema fix a page that Google isn't ranking?
No, and be skeptical of anyone who says otherwise. Schema clarifies what a page is about, it does not manufacture authority or content quality that is not there. Fix the content and authorship signals first, add schema as reinforcement, not as a rescue plan.
Want a full audit of your site's structured data, not just one schema type?

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.

Subscribe to our newsletter!

More from our blog