FHIR Validator

The validator parses a StructureDefinition—the blueprint for a profiled resource—and checks that every element in the instance matches the defined cardinality, data type, and mustSupport rules. It verifies that required fields are present and that no prohibited elements are included.

• Validates against base FHIR resources (e.g., Patient, Observation)
• Enforces constraints from US Core, mCODE, or custom profiles
• Flags missing mandatory elements like Patient.name or Observation.subject

The validator enforces binding strength defined in a profile, ensuring coded elements use values from the correct ValueSet. It checks if a supplied code is valid within the bound CodeSystem and whether the binding is required (must use this code) or extensible (use this code or a local equivalent).

• Validates SNOMED CT, LOINC, ICD-10, and RxNorm codes
• Resolves ValueSet expansions to check membership
• Rejects invalid display names that don't match the code

Complex constraints written in FHIRPath are evaluated against the resource instance. The validator executes these expressions to check co-occurrence rules, conditional logic, and mathematical invariants that can't be expressed in simple StructureDefinitions.

• Evaluates rules like 'if status is final, then value must be present'
• Checks cross-element constraints (e.g., Observation.value vs Observation.dataAbsentReason)
• Supports custom invariants defined in the profile's constraint element

The validator ingests an entire ImplementationGuide resource, which acts as a manifest bundling all related artifacts—profiles, extensions, value sets, and examples—into a single conformance package. It resolves all internal dependencies to create a complete validation context.

• Loads all StructureDefinition, ValueSet, and CodeSystem resources
• Resolves canonical URL references across the IG
• Validates example instances against the IG's own profiles

Validators operate in multiple modes to support different workflows. JSON/YAML/XML parsing checks syntax first, then structural validation verifies the profile, and terminology validation checks codes. Some validators also support FHIRPath-only evaluation for custom rule testing.

• CLI mode for CI/CD pipelines (e.g., validator_cli.jar)
• RESTful API mode for real-time validation in EHR integrations
• Batch mode for validating thousands of resources in bulk data exports

Validation outcomes are categorized by severity to distinguish blocking issues from warnings. Errors indicate a violation of a mandatory constraint (cardinality, required binding). Warnings flag best-practice violations or extensible binding mismatches. Information messages provide guidance on optional improvements.

• error: Resource is non-conformant and must be fixed
• warning: Resource is conformant but may have quality issues
• information: Advisory notes for implementers

The foundational FHIR resource that defines the rules and constraints for how a base resource is used in a specific context. It forms the blueprint for profiling and is the primary artifact validated against.

• Snapshot: A fully computed view of all inherited constraints
• Differential: Declares only the changes relative to a base definition
• Key Properties: Cardinality, slicing, mustSupport, and invariant constraints (expressed in FHIRPath)

The validator loads these definitions to check that resource instances conform to all structural rules, data type constraints, and co-occurrence rules.

A path-based navigation and extraction language, analogous to XPath for XML, designed specifically for evaluating expressions against FHIR data structures. It is the engine behind most advanced validation logic.

• Invariants: Constraints like resource.descendants().count() < 10
• Slicing Conditions: Discriminating between alternative element definitions
• Search Parameter Extraction: Defining computed search indices

The FHIR Validator executes FHIRPath expressions to enforce complex co-occurrence rules, mathematical constraints, and cross-field validation that simple cardinality checks cannot express.

A FHIR resource that acts as a manifest for a collection of related conformance artifacts—profiles, extensions, value sets, and examples—published as a cohesive set of rules for a specific use case.

• Dependency Management: Declares which other IGs must be loaded
• Global Profiles: Rules applied to all resources in the guide
• Page Content: Narrative documentation for human readers

The validator uses the ImplementationGuide to resolve all dependencies and assemble the complete set of conformance rules needed to validate a resource against a specific regulatory or project context, such as US Core.

A FHIR resource defining a curated set of codes drawn from one or more CodeSystems, intended for use in a specific clinical context. Validation ensures coded elements contain only permissible values.

• Intensional Definition: Rules that algorithmically define membership (e.g., all descendants of a SNOMED CT concept)
• Extensional Definition: An explicit enumerated list of codes
• Binding Strength: Ranges from required (must use these codes) to example (suggestion only)

The validator checks that codes in resource instances are members of the bound ValueSet, using terminology server capabilities to expand intensional definitions and verify membership.

A FHIR resource that describes the set of capabilities a FHIR server or client supports, including which resources, operations, and security protocols are available. It serves as a machine-readable contract for conformance.

• Resource Interactions: Declares supported operations like read, search, create
• Search Parameters: Lists queryable fields and their types
• Security Schemes: Documents authentication and authorization protocols

While the FHIR Validator primarily validates resource instances, a CapabilityStatement can itself be validated to ensure it correctly declares capabilities against the base specification, enabling automated conformance testing of server endpoints.

The most widely deployed open-source Java implementation of the FHIR validation engine, built on the HAPI FHIR library. It provides both a command-line interface and an embeddable library for programmatic validation.

• Instance Validation: Checks resources against base spec and profiles
• Terminology Validation: Integrates with external terminology servers
• IG Packaging: Supports loading NPM-format implementation guide packages
• Output Formats: Produces structured OperationOutcome resources

It is the reference implementation used by the official HL7 validator wrapper and is integrated into most FHIR server implementations for real-time validation on create and update operations.