FHIR API Integration
FHIR R4 APIs, SMART on FHIR apps, and Bulk FHIR export.
Explore FHIR API IntegrationWe build HL7 v2 interfaces that connect Epic, Oracle Health, MEDITECH, and clinical systems — ADT feeds, order routing, result delivery, and HL7 to FHIR bridging — and we run the integration engine underneath.
From single-point ADT feeds to enterprise-wide message routing, FHIR-bridge modernization, and the integration engine underneath — Saga IT covers the whole HL7 stack. Plus a free reference + toolkit for the engineers doing the work.
Saga IT builds and supports HL7 v2 interfaces for healthcare providers and third-party vendors connecting to Epic, Oracle Health, MEDITECH, and other EHR platforms. Whether you're a health system consolidating ADT feeds across departments or a software vendor building HL7 interfaces into your product — we handle specification, development, testing, and go-live support.
Four distinct integration shapes — each with its own message-type mix, latency profile, and certification path. Pick the one that matches your project.
For hospitals running Epic, Oracle Health, MEDITECH, or a mix — we consolidate ADT feeds across departments, route orders and results to ancillary systems, and submit to HIEs, state immunization registries, and syndromic surveillance. Most engagements involve 5–25 simultaneous interfaces with dedicated MLLP listeners, custom Z-segments, and 24/7 monitoring on Mirth Connect or Rhapsody.
For software vendors selling INTO health systems — we build the HL7 v2 + FHIR R4 layer that connects your product to every EHR your customers run. App Orchard / Connect Hub publishing for Epic, Cerner Code submissions, MEDITECH Greenfield development, plus the integration SDKs your customers can self-serve. We also handle the certification paperwork (ONC HTI-1, USCDI v3) and the security review checklist health systems demand before turning on a feed.
Ancillary systems live and die on the order/result loop. We build the bidirectional HL7 layer — ORM/ORR for orders, ORU for results — between EHR CPOE and your lab/pharmacy/imaging system, plus LOINC/SNOMED/RxNorm code mapping, abnormal-result routing, embedded PDF report delivery, and DFT^P03 charge posting back to the revenue cycle. We also wire the device middleware (instrument-to-LIS) where needed.
Medical devices push observations at clinical-decision-support latency — sometimes thousands per second across a critical-care unit. We build the device middleware (Capsule, BioMedical Systems, custom MLLP listeners) that aggregates raw telemetry, transforms it to HL7 v2 ORU^R01 or FHIR R4 Observation resources, and lands it in the EHR or downstream analytics platform. Includes IEC 62304 software lifecycle for SaMD-class deliverables and FDA 21 CFR Part 820 traceability.
Need an HL7 interface built? Let's talk.
Book a ConsultationFrom single-point ADT feeds to enterprise-wide message routing — we build reliable HL7 v2 interfaces for every major message type. Open the reference + toolkit below for parser, segment docs, and sample messages.
Real-time patient movement tracking that keeps demographics synchronized across your clinical ecosystem. We build A01 through A44 trigger event handlers including merge handling (A40) and pre-admit workflows. ADT message reference →
Lab, radiology, pathology, and microbiology results delivered directly into the ordering provider's workflow. We handle structured OBX values, embedded PDFs, and result status tracking. ORU message reference →
Bidirectional order messaging between CPOE systems and ancillary departments — lab, radiology, and pharmacy. Full order lifecycle from placement to completion. ORM message reference →
Appointment synchronization between scheduling systems, EHRs, and departmental applications. We build handlers for the full S12–S26 event lifecycle. SIU message reference →
Charge posting interfaces bridging clinical systems and revenue cycle management. We capture procedure codes, diagnosis codes, and charge details from ancillary systems for billing.
Clinical document routing for transcriptions, operative reports, clinical notes, and scanned documents. Embedded PDF/RTF content with provider-based routing rules. MDM message reference →
Free browser tools and open documentation for HL7 v2 — message and segment reference, sample messages, parser, integration engine downloads, and version control for your Mirth Connect channels. Built by the same engineers who do this for a living.
New to HL7? Our plain-English explainer covers the message structure, segments, and the protocol — start with the docs hub →
Both standards are alive and well in 2026 — and most production environments use them together. The right choice depends on what you're moving (real-time clinical event vs. on-demand resource), where it's going (hospital interface engine vs. patient-facing app), and which mandate is driving the work.
| Feature | HL7 v2.x | FHIR R4 |
|---|---|---|
| Transport | MLLP over persistent TCP | HTTPS REST |
| Payload format | Pipe-delimited segments (ER7) | JSON or XML |
| Interaction model | Push — event-driven | Pull — REST + subscriptions |
| Data unit | Message (with trigger event) | Resource (versioned, RESTful) |
| Real-time clinical events | Native (ADT, ORU, ORM) | Subscriptions / polling |
| Patient-facing apps | Not designed for this | Native (SMART on FHIR) |
| Hospital interface engines | Universal (Mirth, Rhapsody, etc.) | Increasing — most engines speak both |
| EHR coverage today | ~95% of US hospitals | Required by ONC HTI-1 / USCDI v3 |
| Regulatory drivers | Internal hospital workflows | CMS-9115 · TEFCA · USCDI · ONC HTI-1 |
| Versioning | v2.3 → v2.5.1 → v2.8 | DSTU2 → STU3 → R4 → R5 → R6 |
| Idempotency | No — duplicate ACKs / re-sends | Yes — version IDs + If-Match |
| Best for | Hospital-internal real-time messaging | API integrations · patient apps · regulatory |
The short answer: if you're moving real-time clinical events between systems already inside a hospital, HL7 v2 wins on coverage — almost every EHR speaks it natively, and integration engines are built around it. If you're building a patient-facing app, integrating with non-EHR systems, or satisfying CMS-9115 / TEFCA / USCDI regulatory mandates, FHIR R4 is the right answer — modern, REST-based, and required by 2027 deadlines. Most production environments end up running both, with an HL7 v2 ↔ FHIR bridge in the integration engine for the hand-off.
Acute care · academic
OrAcute care · federal
MtCommunity hospitals
eCAmbulatory · primary care
NxSpecialty · ambulatory
AtAmbulatory · cloud-native
Don't see your EHR? We build HL7 interfaces for any system. Get in touch to discuss your integration.
An HL7 integration engine is the listener, transformer, and router that runs your interfaces — Mirth Connect, Rhapsody, Cloverleaf, Iguana, OIE, and InterSystems are the dominant choices. We support all of them, and help you pick when starting fresh.
For a deep comparison of the major integration engines — performance characteristics, licensing model, support footprint, and migration paths between them — see our dedicated engines service page. We also publish on-prem and cloud reference architectures, plus migration playbooks for teams moving from Mirth Connect to Open Integration Engine (OIE) or commercial alternatives.
Compare integration enginesProduction HL7 v2 → FHIR R4 bridges, USCDI v3 mapping, and CMS-9115 / TEFCA endpoint exposure — the engagement model for modernizing without ripping out v2. Need help deciding when to bridge versus rebuild? See the v2 vs FHIR comparison above.
HL7 v2 to FHIR R4 conversion services for healthcare technology vendors and health systems modernizing their integration stack. We build production HL7-to-FHIR bridges in Mirth Connect, OIE, or your existing interface engine — converting ADT to Patient/Encounter, ORU to Observation/DiagnosticReport, ORM to ServiceRequest, and SIU to Appointment with bidirectional sync where the workflow demands it. Per-EHR conformance handled separately so Epic, Oracle Health, Meditech, and Athena all map cleanly.
HL7 v2 message mapping services across vendor variants — the same ADT^A04 message looks different from Epic vs Oracle Health vs Meditech, and your downstream consumer needs a normalized view. We build mapping libraries (Mirth transformers, OIE channels, JavaScript scripts) that abstract the vendor differences, so your downstream EHR / data warehouse / analytics platform sees consistent data regardless of source. Includes Z-segment handling, custom OBX value-typing, and the documentation your QA team needs to certify the mapping.
HL7 EHR integration and HL7 EMR integration projects across Epic, Oracle Health (Cerner), Meditech, eClinicalWorks, NextGen, and Athena. Each EHR has its own HL7 v2 implementation guide — message types accepted, segment requirements, ack expectations, and the operational quirks that aren't in any spec doc. Saga IT's interface engineers have shipped HL7 v2 interfaces against all six major US EHRs, so we bring vendor-specific working knowledge to your integration build.
Order-to-result loops between the EHR, RIS, PACS, and imaging modalities — the spot where HL7 v2 and DICOM meet and have to translate cleanly. We bridge HL7 v2 ORM/SIU into DICOM Modality Worklist (DMWL), fire ORU result-return messages on study completion with RIS-rendered report payloads, and reconcile DICOM patient context (StudyInstanceUID, AccessionNumber) back to the EHR's PID. IHE SWF.b conformance, charge capture via DFT^P03, and bidirectional EHR/RIS/PACS workflows for both hospitals and freestanding imaging centers. For deeper DICOM/PACS work see our medical imaging integration services.
Build, harden, and run the integration engine that all of the above depends on. Greenfield Mirth Connect, OIE, or Rhapsody deployments with HA + DR topology; channel version control through MirthSync so every channel change ships through your normal PR workflow; major-version migrations (Mirth 3 → 4, Mirth → OIE); and ongoing 24/7 managed services covering queue-depth alerting, failed-ACK response, retry-loop monitoring, and on-call coverage during cutovers and upstream EHR upgrades. For a deeper engine comparison see our integration engines page.
Strategic HL7 integration consulting for healthcare organizations and digital-health vendors planning multi-quarter integration programs — current-state assessment, target-state architecture, engine + vendor selection, interface inventory + sequencing, build-vs-buy analysis, and the multi-year roadmap that ties it all together. We engage as advisor (paid discovery + architecture, no implementation commitment) or pair the consulting with the build through to go-live. The right call before you sign with a vendor, before a merger consolidates interface estates, or before a v2 → FHIR modernization program kicks off.
Every HL7 integration starts with a clear spec and ends with on-call coverage during stabilization. The steps below are how a typical engagement plays out — and why our average ADT interface lands in 2–4 weeks.
Existing interface inventory, message-type matrix, vendor responsiveness, and certification path. We surface the unknowns before they cost you weeks.
Interface spec documents, Z-segment definitions, mapping tables, ack strategy. Every field, every event, every retry path written down before any code runs.
Channels coded in your engine (Mirth, OIE, Rhapsody, Iguana), automated tests, and parallel-run validation against production-shape data before any cut-over.
Cut-over coordination with your vendor team, on-call coverage during stabilization, ongoing interface monitoring, and Z-segment / mapping updates as upstream EHRs evolve.
How we build, integrate, and deploy clinical software that transforms patient care.
A healthcare system deployed a new point-of-care diagnostic device that generates multiple vital signs and lab values. Raw data points from the device are transformed into standardized FHIR Observation resources and stored directly in the EHR system, enabling real-time clinical decision support without manual data entry.
An HL7 ADT (Admit, Discharge, Transfer) message is the event-driven notification an EHR sends when a patient is admitted, discharged, transferred, registered, or has demographics updated. ADT is the most common HL7 v2 message type, moving millions of times per day across US hospitals over MLLP/TCP connections. Each ADT carries a trigger event code (A01 = admit, A03 = discharge, A04 = register outpatient, A08 = update patient info, A11 = cancel admit, A40 = merge patient IDs). Message structure includes MSH (header), EVN (event), PID (patient identifiers), PV1 (visit info), and optionally NK1, AL1, DG1, GT1, IN1 depending on use case. Downstream systems consume ADT to keep their patient lists in sync — labs, PACS, billing, registration kiosks, and quality measurement all depend on the ADT feed. See our HL7 ADT documentation for full segment-by-segment annotation.
An HL7 interface engine is healthcare middleware that receives HL7 v2 messages over MLLP, applies transformation rules, routes them to destination systems, and handles ACK/NACK delivery confirmation. The terms "interface engine" and "integration engine" are used interchangeably in healthcare IT — "interface engine" is the older HL7-era term; "integration engine" became dominant as engines expanded into FHIR R4, X12 EDI, and DICOM. Common HL7 interface engines: Mirth Connect (most widely deployed), Open Integration Engine (OIE) (community fork after NextGen's 2025 licensing change), Rhapsody (enterprise commercial), Iguana, Corepoint, and InterSystems IRIS / Ensemble. See our healthcare integration engines comparison for tradeoffs.
HL7 integration is the practice of connecting healthcare systems using the HL7 family of standards — primarily HL7 v2 (the pipe-delimited messaging standard used inside roughly 95% of US hospital interfaces) and HL7 FHIR (the modern RESTful API standard increasingly mandated by CMS and ONC). A working HL7 integration links an EHR, lab, pharmacy, radiology system, scheduling system, or HIE to whatever downstream system needs the data — typically through an integration engine that listens, transforms, routes, and monitors every message. See our HL7 reference documentation for the full message-type and segment breakdown.
A single point-to-point ADT interface typically takes 2–4 weeks including specification, development, testing, and go-live. Bidirectional order/result interfaces (ORM/ORU) with custom Z-segments generally require 4–8 weeks. Enterprise-wide projects spanning multiple message types across numerous systems can take 3–6 months. The largest variables are vendor responsiveness during testing and the completeness of interface specifications — factors we help manage through structured project planning.
HL7 v2 uses pipe-delimited messages transmitted over persistent MLLP/TCP connections — it is event-driven and handles approximately 95% of real-time clinical data exchange in US hospitals. FHIR uses RESTful APIs with JSON over HTTPS, designed for web applications, patient portals, and regulatory requirements like the CMS Interoperability rules. Most organizations use both — HL7 v2 for existing clinical messaging and FHIR for new API-based integrations. We help you bridge both standards with dual-protocol interfaces.
An HL7 integration engine is the listener, transformer, and router that runs every interface in your environment — Mirth Connect, Open Integration Engine (OIE), Rhapsody, Cloverleaf, Iguana, and InterSystems Health Connect are the most common choices. For new deployments we typically recommend Mirth Connect or OIE (its actively-maintained open-source successor) — both are free, have large communities, and handle the same channel/transformer model. For high-throughput enterprise environments with formal vendor support, Rhapsody or InterSystems are the established options. We work with all of them; see our integration engine comparison for a deep tradeoff analysis.
For Epic, HL7 integration usually uses Epic Bridges (their internal HL7 v2 platform) with v2.5.1 messages over MLLP, plus increasingly FHIR R4 APIs via the App Orchard / Open Epic program for patient-facing apps. For Oracle Health (formerly Cerner), it is typically Millennium HL7 v2 over MLLP, with FHIR R4 endpoints exposed for regulatory use cases. Both vendors require a project-specific spec exchange, test-environment provisioning, and vendor coordination during validation — we manage that process end-to-end. See our Epic integration and Oracle Health integration service pages for vendor-specific depth.
Practically none — the terms EHR (Electronic Health Record) and EMR (Electronic Medical Record) are used interchangeably in HL7 integration work. The technical pattern is the same: HL7 v2 messages (ADT for patient context, ORM/ORU for orders and results, SIU for scheduling, MDM for documents) flow between the EHR/EMR and whatever downstream system needs the data — typically through an integration engine. EHR is the slightly more current term and tends to imply a broader record (multi-encounter, multi-facility); EMR more often refers to a single-practice record. The integration engineering is identical.
Yes — HL7 v2 → FHIR migration is one of our most common engagements. The typical path is not "rip out v2" but "bridge v2 to FHIR" inside the integration engine: ADT^Axx → Patient + Encounter + Coverage, ORU^R01 → Observation + DiagnosticReport, ORM^O01 → ServiceRequest, SIU → Appointment + Slot. The v2 interfaces keep running for internal clinical messaging while FHIR endpoints get exposed for patient-facing apps, regulatory reporting, and external API consumers. Most organizations end up running both standards in parallel for years. See our FHIR API integration service for the FHIR side of the bridge.
Yes — Z-segments are a core part of most HL7 implementations. We develop Z-segment specifications, mapping documents, and implementation guides for site-specific data elements like custom patient identifiers (ZPD), insurance plan details (ZIN), clinical trial enrollment data, and facility-specific billing codes. Every Z-segment we build includes complete field definitions, data type documentation, and optionality rules for consistent implementation.
Yes — EHR-to-ancillary integration is one of our most common engagements. We build HL7 interfaces between EHR systems (Epic, Oracle Health, MEDITECH, athenahealth) and laboratory information systems, pharmacy systems, radiology platforms, and Health Information Exchanges. This typically involves ADT feeds for patient context, ORM/ORU for order/result workflows, and sometimes SIU for scheduling synchronization. See our HIE integration services for exchange connectivity.
Yes — alongside greenfield interface builds, we offer ongoing HL7 integration support and managed-services engagements: 24/7 interface monitoring, on-call response for failed acknowledgments and dropped connections, queue-depth alerting, channel-version upgrade work, and Z-segment / mapping changes as your upstream EHRs release new versions. Most of our managed-services customers come to us after a one-time build engagement and stay on for ongoing run-the-bank operations.
We build interfaces for all standard HL7 v2 message types: ADT (patient movement), ORU (clinical results), ORM (orders), SIU (scheduling), MDM (documents), DFT (financial transactions), RDE (pharmacy), VXU (immunizations), and ACK (acknowledgments). Each message type has specific trigger events and segment structures — for example, ADT^A01 for admissions and ORU^R01 for lab results. See our HL7 message reference for detailed breakdowns of every type.
Related Services
Keep reading
From ADT feeds to complex message routing — let's build your HL7 interfaces.
Book a 30-min call · or email us and we'll reply within one business day.
Stop your contact information from being used in advertising audiences. Enter the email you used when you contacted Saga IT.
We've recorded your request. You'll be removed from advertising audiences within 24 hours.
We don't sell personal information. We do "share" hashed contact info with Google Ads for Customer Match. Opting out removes you from that audience within ~24h. To request full deletion of your data, email info@saga-it.com.