Google's HealthTopicContent schema is a structured data type designed specifically for web pages that present authoritative health information to patients and the general public. Unlike a generic WebPage or Article schema, HealthTopicContent signals to Google and AI-powered search systems that a page contains medically relevant, patient-facing content – making it eligible for enhanced treatment in health-related queries and AI-generated answers. For health publishers, patient education teams, and any organization maintaining a health blog, implementing this schema correctly is one of the clearest signals of topical authority in the medical content space.

This guide documents every supported property, explains when to use HealthTopicContent instead of a general schema type, and walks through the full implementation process step by step.

What HealthTopicContent Is and When It Applies

HealthTopicContent is a Schema.org type that classifies a web page as containing health information written for a general or patient audience, rather than for clinical professionals. It extends the WebContent type and is used to signal that a page addresses a specific health topic – such as a condition, symptom, treatment, or wellness subject – in accessible, non-specialist language.

Google introduced HealthTopicContent as part of its broader effort to surface reliable health information from authoritative sources. The schema appears in Google's documentation alongside types like MedicalCondition, MedicalClinic, and Physician – all part of the healthcare-specific structured data ecosystem covered across the full range of schema types for medical websites.

Use HealthTopicContent when a page meets all three of the following criteria:

  • The page is written for a lay audience, not a clinical one
  • The content addresses a defined health topic (a condition, symptom, treatment, drug, or wellness subject)
  • The page's primary purpose is to inform or educate, not to transact or book appointments

Do not use it for physician profile pages (those take Physician schema), clinic location pages (MedicalClinic), or general blog posts that happen to mention health peripherally. The schema carries semantic weight precisely because it is applied selectively.

How HealthTopicContent Differs From General Web Page Schema

A standard WebPage schema tells Google that a URL exists and describes its general properties. An Article or BlogPosting schema adds authorship and publication metadata. Neither communicates anything specific about the medical nature of the content or its intended audience.

HealthTopicContent does three things those types cannot:

It Declares Patient-Facing Intent

The type itself encodes the audience signal. When Google and AI retrieval systems process the schema, they understand the page is addressed to people seeking health information – not professionals reviewing clinical literature. This matters for how the content is surfaced in health-specific search contexts and AI-generated answers.

It Enables Health-Specific Properties

HealthTopicContent supports properties that are either absent or irrelevant in WebPage and Article schemas. The hasHealthAspect property, for example, allows publishers to specify the aspect of the health topic the page addresses – whether that is symptoms, causes, treatments, prevention, living with a condition, or prognosis. This granularity is not available in general schema types.

It Contributes to AI Citation Eligibility in Health Queries

AI systems like Google AI Overviews, ChatGPT, and Perplexity prioritize content with strong entity and structured data signals when responding to health queries. A page with HealthTopicContent schema declares its subject matter unambiguously, which makes the content easier for AI systems to classify and, consequently, more likely to be cited. The relationship between structured data and AI search citations is direct: structured pages give AI systems machine-readable confirmation of what human readers can only infer from prose.

Step 1: Confirm the Page Qualifies

Before writing a single line of JSON-LD, verify the page genuinely warrants HealthTopicContent markup. Misapplying schema to pages that do not fit the type is a common error, and Google's quality systems penalize deliberate misrepresentation – a principle well documented in how Google evaluates schema accuracy.

Ask the following questions about the page:

  1. Is the primary audience a patient, caregiver, or member of the general public (not a clinician)?
  2. Does the page focus on a specific, nameable health topic?
  3. Is the page's purpose to inform or educate rather than to sell, book, or refer?
  4. Is the content accurate, current, and consistent with established medical guidance?

If any answer is no, either revise the page so it qualifies, or apply a different schema type. A general wellness article with passing health references belongs under Article or BlogPosting. A page dedicated to explaining Type 2 diabetes symptoms to newly diagnosed patients belongs under HealthTopicContent.

Step 2: Understand the Supported Properties

HealthTopicContent inherits properties from its parent types (WebContent, CreativeWork, and Thing) and adds a health-specific property of its own. The table below documents the properties most relevant to implementation.

Property Type Description
@type Text Must be "HealthTopicContent"
name Text The title of the page or health topic
description Text A brief summary of what the page covers
url URL The canonical URL of the page
hasHealthAspect HealthAspectEnumeration The specific health aspect the page addresses (see values below)
about MedicalCondition or Thing The health topic the content is about
audience Audience or MedicalAudience Specifies the intended audience (typically PatientsWebsite)
datePublished Date ISO 8601 publication date
dateModified Date ISO 8601 last-modified date
author Person or Organization The author or authoring organization
publisher Organization The publishing organization
inLanguage Text Language code (e.g., "en")
mainEntityOfPage WebPage The URL of the page this schema describes

hasHealthAspect Enumeration Values

The hasHealthAspect property is what distinguishes HealthTopicContent from every other schema type. It accepts values from Schema.org's HealthAspectEnumeration. The most commonly used values are:

Value When to Use
SymptomsHealthAspect Page describes symptoms of a condition
CausesHealthAspect Page covers causes or risk factors
TreatmentsHealthAspect Page explains treatment options
PreventionHealthAspect Page covers prevention strategies
PrognosisHealthAspect Page discusses likely outcomes or recovery
LivingWithHealthAspect Page addresses day-to-day life with a condition
OverviewHealthAspect Page provides a general introduction to a topic
GeneticHealthAspect Page discusses genetic factors
ScreeningsHealthAspect Page covers screening or diagnostic tests
SelfCareHealthAspect Page addresses self-management strategies

A single page can declare multiple hasHealthAspect values. A page covering both symptoms and treatment options should include both SymptomsHealthAspect and TreatmentsHealthAspect.

Step 3: Draft the JSON-LD Markup

JSON-LD is the implementation format Google recommends for all structured data. It is placed in the <head> of the HTML document inside a <script type="application/ld+json"> tag and does not alter the visible page content.

Below is a complete, production-ready HealthTopicContent JSON-LD block. This example is for a patient education page on Type 2 diabetes symptoms.

<script type="application/ld+json">
{
 "@context": "https://schema.org",
 "@type": "HealthTopicContent",
 "name": "Type 2 Diabetes Symptoms: What to Look For",
 "description": "An overview of the most common symptoms of Type 2 diabetes, including fatigue, increased thirst, and frequent urination, written for patients and caregivers.",
 "url": "https://www.example.com/health/type-2-diabetes-symptoms",
 "mainEntityOfPage": {
 "@type": "WebPage",
 "@id": "https://www.example.com/health/type-2-diabetes-symptoms"
 },
 "hasHealthAspect": [
 "https://schema.org/SymptomsHealthAspect",
 "https://schema.org/OverviewHealthAspect"
 ],
 "about": {
 "@type": "MedicalCondition",
 "name": "Type 2 Diabetes",
 "url": "https://www.who.int/news-room/fact-sheets/detail/diabetes"
 },
 "audience": {
 "@type": "MedicalAudience",
 "audienceType": "PatientsWebsite"
 },
 "datePublished": "2024-03-15",
 "dateModified": "2025-01-10",
 "inLanguage": "en",
 "author": {
 "@type": "Person",
 "name": "Dr. Jane Okonkwo",
 "url": "https://www.example.com/authors/dr-jane-okonkwo"
 },
 "publisher": {
 "@type": "Organization",
 "name": "Example Health",
 "url": "https://www.example.com",
 "logo": {
 "@type": "ImageObject",
 "url": "https://www.example.com/logo.png"
 }
 }
}
</script>

Key Drafting Rules

Several properties require specific formatting to validate correctly.

`hasHealthAspect` must use full schema URIs. Do not write "SymptomsHealthAspect" as a bare string. Write the full URI: "https://schema.org/SymptomsHealthAspect". Some validators accept the shorthand, but the full URI is the technically correct form and ensures compatibility across all parsers.

`about` should reference a typed entity. Nesting a MedicalCondition, Drug, or similar typed object in the about field strengthens the entity signal. If the topic is a drug, use "@type": "Drug". If it is a medical procedure, use "@type": "MedicalProcedure". The MedicalCondition and MedicalProcedure schema types each carry their own supported properties and should be populated as completely as the page content allows.

Dates must follow ISO 8601 format. Use YYYY-MM-DD. Incorrect date formats cause validation warnings and reduce parser reliability.

`author` should reflect the actual author of the medical content. For health content specifically, authorship carries E-E-A-T weight. A physician or credentialed health professional listed as author strengthens the trust signal. The physician and doctor schema implementation covers how to connect author entities to their professional credentials using structured data.

Step 4: Combine With Supporting Schema Types

HealthTopicContent rarely performs at its best in isolation. Health pages that earn strong AI citation rates and Google rich result eligibility typically combine multiple schema types on the same page. This is not schema stacking for its own sake – each additional type adds a distinct layer of machine-readable context.

The most valuable combinations for health content pages are:

HealthTopicContent + FAQPage

Patient education pages almost always include a FAQ section. Adding FAQPage schema alongside HealthTopicContent makes individual questions eligible for Google's FAQ rich results and makes the Q&A pairs directly extractable by AI systems. The FAQ schema implementation process is straightforward and adds meaningful citation surface area without complicating the primary schema.

HealthTopicContent + BreadcrumbList

BreadcrumbList schema communicates site hierarchy, which helps Google understand where a health article sits within the broader site structure. For large health publishers with dozens of condition pages, this context signal supports both crawl efficiency and entity recognition.

HealthTopicContent + Article or MedicalWebPage

Google's documentation also recognizes MedicalWebPage as a complementary type. Some publishers nest HealthTopicContent within a MedicalWebPage wrapper to convey both the professional context of the site and the patient-audience orientation of the specific page. The combination is valid and can strengthen the overall structured data signal.

To combine schema types on a single page, place each type in a separate <script type="application/ld+json"> block. Attempting to merge distinct types into a single block is technically possible using arrays but is harder to maintain and more prone to validation errors.

At this stage of building out your health content schema stack, AuthorityStack.ai's AI-powered schema markup generator is worth noting – it reads the full content of a page and selects the correct schema types automatically, including the complete healthcare suite (MedicalCondition, Hospital, MedicalClinic, Physician, Drug, and more) that rules-based generators routinely misclassify.

Step 5: Add the Markup to the Page

Once the JSON-LD block is drafted and reviewed, it must be deployed to the live page. The method depends on how the site is built.

For WordPress Sites

Paste the <script type="application/ld+json"> block directly into the page's HTML <head> section. Most WordPress themes allow custom code in the head via the theme's functions.php file, a header injection plugin, or a dedicated schema plugin. The WordPress schema markup implementation guide covers all three methods with specific instructions for each.

For Custom CMS or Static Sites

Add the JSON-LD block to the <head> section of the page template. For pages generated dynamically, the schema values (URL, date, author, hasHealthAspect) should be populated programmatically from the content management layer rather than hardcoded. This enables consistent, scalable deployment across an entire health content library.

For Tag Manager Deployments

Google Tag Manager can inject JSON-LD schema onto pages without requiring code changes. Create a Custom HTML tag containing the full <script type="application/ld+json"> block and set the trigger to fire on the relevant page URLs. This approach works well for agencies managing health content schema across multiple client sites – a workflow explored in multi-client schema management for agencies.

For Sites Without Developer Access

Publishers who cannot access the page <head> directly can use schema markup implementation methods that require no developer – typically plugin-based approaches for common platforms or Tag Manager configurations.

Step 6: Validate the Markup

Deploying schema without validating it is a reliable way to introduce errors that persist undetected for months. Always validate before considering implementation complete.

Use Google's Rich Results Test

Google's Rich Results Test (available at search.google.com/test/rich-results) checks whether a page's structured data is eligible for rich results. Paste the page URL or the raw JSON-LD code directly. The tool returns detected schema types, any errors that will prevent rich results, and any warnings that may reduce eligibility.

Note that HealthTopicContent does not currently trigger a distinct rich result preview in the tool – Google uses the schema for search quality and AI systems rather than a specific SERP feature. The absence of a visual preview does not mean the schema is not working.

Use Schema.org's Validator

The Schema.org validator (validator.schema.org) checks structural correctness against the Schema.org specification. It will flag malformed JSON, unrecognized property names, and type mismatches. Run the markup here alongside the Rich Results Test to catch both specification-level and Google-implementation-level issues.

Common Errors to Fix Before Publishing

Several errors appear repeatedly in HealthTopicContent implementations:

  • hasHealthAspect written as a bare string instead of a full URI
  • datePublished in a non-ISO format (e.g., "March 15, 2024" instead of "2024-03-15")
  • about containing a plain text string instead of a typed entity object
  • Missing url or mainEntityOfPage fields
  • author listed as a string rather than a typed Person or Organization object

The structured data validation and error-fixing process covers these errors in detail, including how to interpret validator output and resolve each class of issue.

Step 7: Monitor Performance and Iterate

Deploying valid HealthTopicContent schema is the beginning of the process, not the end. Schema that is accurate at launch becomes inaccurate when content is updated and the structured data is not. Build monitoring into the workflow from the start.

Track Schema Coverage in Google Search Console

Google Search Console's Enhancements section reports on structured data detected across the site. For health publishers with large content libraries, this view identifies pages where schema is missing, malformed, or producing warnings. Address new errors promptly – stale or incorrect schema undermines the trust signal the markup is meant to build.

Monitor AI Citation Performance

HealthTopicContent schema contributes to AI citation eligibility, but confirming that the contribution is working requires measuring AI-sourced traffic and citation frequency directly. Without this data, publishers have no way to distinguish between pages that AI systems are citing and pages that are invisible despite valid schema. Tracking AI search visibility and brand citations across platforms like ChatGPT, Gemini, Perplexity, and Google AI Mode is the feedback loop that makes iterative GEO improvement possible.

Update Schema When Content Is Revised

Every time a health page is updated – new treatment information, revised symptom list, updated statistics – the dateModified field must be updated in the JSON-LD block. More significantly, if the page's health aspect changes (for example, a page that was purely symptoms-focused is expanded to cover treatment options), the hasHealthAspect array must be updated to reflect the new content. Schema that does not match the current page content creates a mismatch signal that validators and AI systems will detect.

HealthTopicContent Schema and AI Citation in Health Queries

Health is one of the highest-stakes categories in AI-generated search. Platforms like Google AI Overviews, Perplexity, and ChatGPT apply stricter source selection criteria to health queries than they do to most other topics, because the consequences of citing inaccurate health information are significant. This elevated scrutiny creates a direct advantage for publishers who invest in the structured data signals that communicate authority.

HealthTopicContent schema strengthens AI citation eligibility through three mechanisms. First, it gives AI retrieval systems a machine-readable declaration of patient-audience intent, which aligns with their filtering criteria for health queries. Second, the hasHealthAspect property enables precise topic matching – a system answering a query about diabetes symptoms can identify pages tagged with SymptomsHealthAspect far more reliably than it can infer the same from prose alone. Third, combined with strong authorship signals, MedicalCondition entity references, and well-structured content, HealthTopicContent schema is part of the authority layer that determines whether a health publisher appears in AI-generated answers or is bypassed in favor of better-structured competitors.

The broader relationship between schema markup and AI search citation extends well beyond health content, but the healthcare vertical is where structured data has the most concentrated impact, both because of the strictness of AI source filters and because of how clearly health topics map to typed schema entities.

FAQ

What Is HealthTopicContent Schema Used For?

HealthTopicContent is a Schema.org structured data type used to identify web pages that present health information for a general or patient audience. It tells Google and AI search systems that the page addresses a specific health topic – such as a condition, symptom, or treatment – in accessible language, rather than clinical or professional content. Google introduced the type to help surface reliable health information from authoritative publishers in both traditional search results and AI-generated answers.

Is HealthTopicContent the Same as MedicalWebPage?

No. MedicalWebPage is a broader Schema.org type that can describe any web page with medical content, including pages for clinical professionals. HealthTopicContent specifically identifies content written for patients and the general public and adds the hasHealthAspect property, which allows publishers to declare the specific dimension of a health topic the page addresses – such as symptoms, causes, or treatments. The two types are compatible and can be used together on the same page.

Does HealthTopicContent Schema Generate a Rich Result in Google?

HealthTopicContent schema does not currently trigger a distinct visual rich result (such as a star rating or FAQ accordion) in Google's search results. Google uses the schema primarily as a quality and classification signal – for health search features, AI Overviews, and source evaluation – rather than to render a specific SERP enhancement. This means the schema's impact is real but measured in citation frequency and search feature eligibility rather than in a visible change to the search listing appearance.

How Many hasHealthAspect Values Can a Single Page Declare?

A single HealthTopicContent schema block can declare multiple hasHealthAspect values by passing them as an array. A page covering both the causes and prevention of heart disease, for example, should include both CausesHealthAspect and PreventionHealthAspect. There is no documented upper limit on the number of values, but each value declared should accurately reflect content that is actually present on the page. Declaring aspects the page does not address is a misrepresentation and can affect schema quality signals.

Where Exactly in the HTML Should HealthTopicContent JSON-LD Be Placed?

The <script type="application/ld+json"> block containing HealthTopicContent markup should be placed in the <head> section of the HTML document. Google's documentation specifies that JSON-LD schema should appear in the <head> or <body> of the page, with <head> being the recommended location for structured data. Avoid placing the script block inside other HTML elements where parsers may not reliably reach it.

Can HealthTopicContent Schema Be Applied to Every Page on a Health Blog?

HealthTopicContent should only be applied to pages that genuinely qualify – those that address a specific health topic for a patient or lay audience. Applying it to author pages, category index pages, general about pages, or articles that only peripherally mention health topics is incorrect and risks introducing the kind of schema misrepresentation that Google's quality systems detect. Each page's schema type should accurately reflect that page's content and purpose.

How Does HealthTopicContent Schema Affect AI Citation Rates for Health Publishers?

Publishers that implement accurate HealthTopicContent schema on well-structured, authoritative health pages give AI retrieval systems a clear, machine-readable classification of the content's topic and audience. AI platforms applying source filters to health queries can identify and trust these pages more efficiently than pages with no structured data. Among the brands that have systematically implemented healthcare schema as part of a broader structured data strategy, the improvement in AI citation rates within 90 days has been measurable – consistent with the pattern seen across other authority-building implementations. The schema alone is not sufficient; it works in combination with strong authorship signals, accurate medical content, and thorough topical coverage.

Do I Need to Update HealthTopicContent Schema When I Revise the Page Content?

Yes. The dateModified field must be updated every time the page content is revised. Beyond the date field, the hasHealthAspect array and the about entity reference should also be reviewed whenever the page's scope changes. If a page originally covering symptoms only is expanded to include treatment information, the schema should add TreatmentsHealthAspect to reflect the updated content. Schema that no longer accurately represents the page's current content undermines the trust signal the markup is intended to establish.

What to Do Now

  1. Audit your existing health content pages to identify which ones address a specific health topic for a patient audience – those are your HealthTopicContent candidates.
  2. For each qualifying page, determine the correct hasHealthAspect values based on what the page actually covers.
  3. Draft the JSON-LD block using the template in Step 3, populating all available properties including author, publisher, and the about entity.
  4. Combine the HealthTopicContent block with FAQPage schema on pages that include a FAQ section, and with BreadcrumbList schema where the site uses a hierarchical health content structure.
  5. Validate every block using both Google's Rich Results Test and the Schema.org validator before deployment.
  6. Deploy to the page <head> using the method appropriate for your platform.
  7. Set a recurring review cadence – at minimum quarterly – to confirm schema remains accurate as content is updated, and to monitor AI citation performance for pages where the markup is live.

Building accurate HealthTopicContent markup manually at scale is time-consuming. Generate JSON-LD Schema using AuthorityStack.ai's schema generator to scan any page URL and produce complete, validated structured data in seconds.