Epic Integration

Get Your Product Into Epic.

From your first sandbox call on Epic on FHIR to a live customer go-live — SMART on FHIR apps, the Vendor Services → Showroom path, the Hyperspace→Hyperdrive migration, and the whole named ecosystem (Interconnect, Care Everywhere, Cosmos and the rest), demystified. Built on patterns that pass Inferno g10.

Explore the Epic ecosystem Book a scoping call

Epic on FHIRSMART on FHIRFHIR R4 / US CoreVendor ServicesShowroomInferno g10-validated · HIPAA · BAA available

SMART on FHIR app types we ship: provider, patient & backend

FHIR R4 / US Core (STU3 & DSTU2 still supported)

47/47

Inferno g10 conformance tests passing on our SMART server

1,000+

Epic hospitals live on TEFCA via Epic Nexus (Jun 2025)

Why Epic Is Its Own World

Epic Isn't an API. It's an Ecosystem.

"Does it integrate with Epic?" is the question that makes or breaks your enterprise deals — and the answer involves a dozen named products, a paid program tier, a security review at every customer, and a federated architecture with no central endpoint. The teams that ship fast are the ones who know the whole map before they start.

We've walked it — the sandbox, the client IDs, the immutable app record, Vendor Services, Showroom, the Hyperdrive migration. We build the integration and steer you through the machine.

Federated — no single endpoint.

Every Epic customer runs its own instance and decides which apps connect. You go live per-customer, not once.

App records are immutable.

Once you mark an app "ready for production," it's locked. Any change means registering a whole new app.

A dozen names, and only some are yours.

Interconnect, Chronicles, Cosmos, Care Everywhere… knowing which you actually touch (and which you don't) is half the battle.

Interactive · Epic Ecosystem Explorer

Every Name, Decoded — And What You Actually Touch

Epic has its own vocabulary. Here's the map, sorted by what a third-party integrator really connects to versus what lives inside the customer's system. Pick a layer.

These are the surfaces a third-party product actually connects to. Standards-based (FHIR + SMART) is the modern default; the rest cover legacy and network exchange.

Epic on FHIRYour front door

Epic's free developer program: sandbox, self-service app registration, and FHIR docs at fhir.epic.com. Where every integration starts.

FHIR R4 APIsYou integrate

Read & write the chart via US Core-profiled R4 resources. R4 is recommended; STU3 and DSTU2 are still supported for legacy.

SMART on FHIRYou integrate

OAuth 2.0 launch in three flavors: provider EHR-launch (in-chart), patient standalone (MyChart), and backend system-to-system (JWT).

InterconnectYou call it

Epic's web-services server — the endpoint your FHIR and web-service calls actually hit. Customer-operated, one per Epic instance.

CDS HooksYou integrate

Epic calls your service at workflow moments (e.g. order entry) and renders your "cards" back to the clinician in real time.

FHIR Bulk DataYou integrate

Asynchronous $export of population-scale FHIR data for analytics and warehousing.

BridgesLegacy · you integrate

Epic's interface engine for HL7 v2 / point-to-point interfaces (ADT, ORU, ORM). Still how a lot of real-time data moves.

Care Everywhere / Epic NexusNetwork exchange

Epic's HIE, and Epic Nexus — Epic's designated TEFCA QHIN (Dec 2023; 1,000+ hospitals live by Jun 2025) for national exchange.

The commercial and distribution layer. Epic overhauled this in 2022–2024 — the old "App Orchard" name is retired; here's what replaced it.

Epic on FHIRFree · dev

The free developer tier — sandbox, client registration, documentation. No cost to build and test.

Vendor ServicesPaid · support

Epic's paid developer-support program: expert help choosing integration tech, an expanded sandbox, tutorials. Former App Market members auto-transitioned. (reported ~$1,900/yr)

Connection HubSelf-report

Open to any vendor with a live Epic connection — self-attest your integration; no program membership required. (small annual listing fee reported)

ShowroomMarketplace

Epic's public storefront (launched Jan 2024) where customer orgs discover products & services. The successor to App Orchard / App Market.

open.epicPublic catalog

Epic's public catalogue of APIs and tutorials — the FHIR interface list, client-ID guides, and the API Subscription Agreement.

UserWeb / GalaxyCustomer-gated

Epic's deep documentation — but access-gated to Epic customers and their staff, not open to third-party developers.

Where clinicians and patients actually work. Your app either launches inside these (provider/patient) or needs to survive their changes (the Hyperdrive migration).

HyperdriveYour apps run here

Epic's web client (Chromium-based) that replaced the Hyperspace desktop. Most orgs migrated in 2022–23. Standards-based apps carry over; legacy COM ones don't.

HyperspaceBeing retired

The classic Windows desktop client. Aging out in favor of Hyperdrive — relevant mainly if you have old COM-based integrations.

MyChartPatient-app target

Epic's patient portal — the authorization surface for patient (standalone) SMART on FHIR apps and patient-mediated data access.

Haiku · Canto · RoverEpic mobile

Epic's provider mobile apps (phone / tablet / inpatient). Context for where your embedded launches may appear.

Share EverywherePatient-shared

Lets a patient grant any provider temporary, view-only access to their record. A patient-driven exchange path, not a dev API.

The names you'll hear most and touch least. These live inside the customer's system — you almost never integrate with them directly; data reaches you through FHIR APIs, not the database. Knowing they exist helps you scope conversations.

ChroniclesCustomer-internal

Epic's live operational database (runs on InterSystems Caché / IRIS). The source of truth — you read it via FHIR, not directly.

ClarityCustomer-internal

Epic's SQL relational reporting database, ETL'd from Chronicles nightly. A customer's analysts' world, behind their firewall.

CaboodleCustomer-internal

Epic's data warehouse (part of Cogito) for enterprise analytics. Again, customer-side — reachable only with their access.

CogitoCustomer-internal

Epic's analytics & BI suite (Reporting Workbench, dashboards, Caboodle). Something customers run, not a third-party API.

CosmosResearch dataset

Epic's de-identified, aggregated research dataset across participating orgs. Accessed through Epic research programs, not vendor APIs.

NebulaEpic cloud

Epic's cloud (Azure-based) offering for hosting and compute. Infrastructure context, not a direct integration point.

Developer-integration facts verified July 2026 against Epic's primary docs (fhir.epic.com, open.epic, epic.com). Ecosystem descriptions are general orientation; program names change — we track them.

How You Connect to Epic

The Integration Methods That Matter

Standards-based is the default; legacy and network paths cover the rest. We pick — or combine — the right one.

Method

What it is

Use it when

SMART · EHR launchprovider / in-chart

Your app launches inside the chart in the clinician's Hyperdrive session with patient + user context.

You need to live in the provider workflow — decision support, documentation, ordering.

SMART · standalonepatient / MyChart

The patient authorizes your app against MyChart from outside Epic.

Patient apps, PHR, engagement, patient-mediated data access.

SMART · backendsystem-to-system

No user — server-to-server auth with an asymmetric JWT (public key uploaded to the app record).

Automated pipelines, IPS queries, $match, analytics.

FHIR R4 RESTUS Core

Read/write FHIR resources — R4 recommended; the R4 surface even splits Patient-Chart vs Outside-Record reads.

The core of nearly every modern Epic integration.

CDS Hooksreal-time

Epic invokes your service at workflow events and shows your cards to the clinician.

In-workflow guidance and alerts at the point of care.

Bridges / HL7 v2legacy · real-time

Interface-engine feeds (ADT, ORU, ORM) — still ubiquitous in live Epic sites.

Real-time events and where FHIR coverage is partial.

The Vendor Journey

From Sandbox to a Live Epic Customer

Epic's path is self-service — but the gates are real. Here's the sequence, including the two that trip people up.

Register

Create the app on fhir.epic.com — you're issued both a production and a non-production client ID.

Build in Sandbox

Develop against example data with the non-prod ID and the "Try It" test patients.

Ready for Production

Mark the app ready — required before any customer can use it.▲ locks the record

List & Support

Vendor Services for support; Connection Hub / Showroom for discovery.

Per-Customer Activation

Share client IDs with each licensed customer; they request delivery into their own instance.▲ per-customer

Review & Go-Live

Pass the customer's security/technical review, then production go-live & monitoring.

Hyperspace → Hyperdrive

The Migration That Quietly Breaks Integrations

Epic moved end users from the classic Hyperspace desktop to the web-based Hyperdrive client (most orgs in 2022–23). What it means for your integration is very specific:

Carries Over — No Changes Needed

SMART on FHIR launches (provider, patient, backend)
HL7 v2 interfaces & Web Services
DICOM, XML file drop, outgoing command-line

Must Be Updated

COM-based API integrations that hooked into Hyperspace
Web apps hosted within/launched from Hyperspace may need rework
The takeaway: build standards-based and Hyperdrive is a non-event

Cost & Timeline

How Much Does Epic Integration Cost — And How Long Does It Take?

The honest answer: it depends on your app type, and — more than anything — on each customer's review cycle, not the code. Here are the ranges teams actually see. They're commonly cited across the industry, not Epic's official pricing; we scope your project specifically on a call.

Scenario

Typical timeline

What drives it

Read-only FHIR appUS Core reads

~2–4 months

One surface, standard scopes, sandbox → first customer. The fastest path onto Epic.

Bidirectional (read + write)FHIR R4

~4–8 months

Write-backs, more scopes, more validation and testing before production.

Full build: FHIR + HL7 v2multi-surface

~6–14 months

Multiple data flows, interfaces, and environments. Commonly reported at ~$18K–$80K+ for the build; enterprise programs run higher.

Each customer go-liveper-site

+ weeks each

The real variable: the health system's own security / technical review and activation, repeated per organization.

Ongoing maintenanceannual

continuous

Typically ~15–20% of the build per year — version upgrades, monitoring, and onboarding new customers.

These are industry-reported ranges, not a quote — and Epic sets its own program fees. The single biggest lever on your timeline is each customer's review queue, which is exactly the part we manage for you.

Use Cases

What Teams Actually Build on Epic

The most common Epic integrations we ship — each maps to a specific SMART launch type and a set of FHIR resources.

Remote Patient Monitoring (RPM)

Push device vitals, glucose, and ECG into the chart as FHIR Observations — backend or provider-launch — so clinicians see them in Epic, not another app.

ObservationBackendRPM billing

Patient Apps (MyChart)

Standalone SMART apps that patients authorize against MyChart — records access, PHR, and patient-mediated data for engagement products.

StandaloneMyChartUS Core

Referrals & Orders

Close referral loops and order flows with ServiceRequest, Task, and HL7 v2 SIU — send, track, and reconcile across organizations.

ServiceRequestTaskSIU

Scheduling & Registration

Real-time appointment and demographics sync via HL7 v2 SIU/ADT and FHIR — for access, booking, and patient-flow products.

AppointmentADTSIU

Documentation & CDS

Provider-launch apps and CDS Hooks that write notes, surface guidance, and show cards to clinicians at the point of care.

EHR launchCDS HooksDocumentReference

Analytics & Population Health

Move populations of data out via FHIR Bulk $export and backend services for reporting, risk, and quality measures.

Bulk $exportBackendPop health

Build vs Buy

Direct Epic Integration vs a Middleware (Redox, Health Gorilla)

Both are legitimate — and we do both. Here's the honest trade-off so you choose with eyes open, not by default.

Direct / native Epic

Middleware (Redox, Health Gorilla)

Cost model

Higher build effort, no per-transaction fee. Cheaper at scale once live.

Lower build effort, ongoing subscription / per-transaction fees you don't control.

Time to first EHR

Slower — you build and certify the connection yourself.

Faster — pre-built connectors get you live sooner.

Many EHRs (Epic + Cerner + athena…)

Slower — repeat per vendor (we build a normalization layer to help).

Fast — write once, deploy to many normalized connectors.

Depth (writes, proprietary APIs)

Full access — anything Epic exposes, including deep write workflows.

Limited to what the connector supports; deep/edge cases can hit a ceiling.

Best when

One or few EHRs, deep integration, cost-sensitive at scale, or you want to own the connection.

Many EHRs fast, a small team, and standard read/write is enough.

We build native Epic integrations and onboard you through Redox / Health Gorilla when that's genuinely the better call — vendor-neutral advice, because we don't sell the middleware.

What We Build

Epic Integration, End to End

From a single SMART app to a certified, Showroom-listed product — engineered and shepherded through Epic's program.

SMART on FHIR Apps

Provider EHR-launch, patient (MyChart) standalone, and backend apps — OAuth 2.0, launch context, US Core, validated against Inferno g10.

SMARTOAuth 2.0US Core

Epic FHIR & Web Services

Read/write the chart across R4 (and legacy STU3/DSTU2), plus Interconnect web services and CDS Hooks.

FHIR R4InterconnectCDS Hooks

Vendor Services & Showroom Onboarding

App registration, dual client IDs, "ready for production," and getting you listed on Connection Hub / Showroom.

Vendor ServicesShowroomClient IDs

Hyperdrive Migration

Move legacy COM / Hyperspace-hosted integrations to Hyperdrive-safe patterns — or re-platform onto SMART.

HyperdriveCOM→SMART

HL7 v2 & Bridges Interfaces

ADT, ORU, ORM feeds via interface engines — for real-time events and sites where FHIR coverage is partial.

HL7 v2BridgesMirth

Care Everywhere / TEFCA

Network exchange via Care Everywhere and Epic Nexus (Epic's TEFCA QHIN) for cross-organization data.

Care EverywhereEpic NexusTEFCA

Proof, Not Promises

The Bar Epic Apps Have to Clear

Production integration engineering, held to the same standards Epic requires.

SMART on FHIR

Inferno G10-Passing SMART Server

Built a standalone SMART on FHIR server (RS256) passing 47/47 ONC g10 conformance tests — the bar an app must meet to launch inside a certified EHR like Epic.

47/47

g10 tests

US Core

conformant

Legacy modernization

HL7 v2 → FHIR R4 Migration

Migrated 52 healthcare interfaces from HL7 v2 to FHIR R4 with zero downtime — the same discipline Epic's Hyperspace→Hyperdrive and legacy→SMART moves demand.

interfaces

downtime

Cross-vendor sync

Cross-Hospital Clinical Data Sync

Synchronized clinical data across independent facilities in real time via a FHIR canonical layer — federated integration, the way Epic customers actually run.

Real-time

cross-site

FHIR

canonical

Engagement Models

Work with Us the Way That Fits

A fixed scope with a fixed price, or a dedicated Epic-integration team as an extension of yours.

Model 01

Fixed-Price Epic Integration

Best when the app type and use case are clear. Share the requirement, get a discovery call, and receive a fixed estimate and timeline — milestone-billed, through go-live.

One app type, to a live customer
Vendor Services / Showroom onboarding included
Inferno g10-validated build

Share your requirement

Model 02

Dedicated Epic Team

Best for an ongoing Epic roadmap. Dedicated FHIR / SMART / HL7 engineers with 160 focused hours each per month — an extension of your team.

160 focused hours / engineer / month
Multi-customer per-org onboarding
Complimentary Delivery Manager

Build your team

FAQ

Epic Integration, Answered

The questions every team asks before they start building for Epic.

Is Epic Integration Free? What Happened to App Orchard?

Epic on FHIR — the developer program, sandbox, and docs on fhir.epic.com — is free to build and test on. App Orchard is retired. Epic overhauled the model: paid Vendor Services for developer support, the Connection Hub self-report directory (open to any vendor with a live Epic connection), and the Showroom marketplace (launched Jan 2024) where customers discover products. Production access and listings carry modest fees; the build itself doesn't.

Why Does Epic Issue Two Client IDs, and Why Can't I Edit My App?

Every app registered on fhir.epic.com gets both a non-production (sandbox) and a production client ID. You develop against the non-prod ID; the prod ID only works once you mark the app "ready for production." And once you do, the app record is immutable — any change means registering a whole new app record. We design your scopes, redirect URIs, and app structure up front so you're not re-registering later.

Is There One Epic Endpoint I Connect To?

No — Epic is federated. Every customer runs its own Epic instance (its own Interconnect endpoint) and controls which apps connect. You go live per-customer: you share your client IDs with each licensed organization, and they request delivery into their environment, usually after their own security/technical review. Going live at one health system doesn't unlock the next.

What's the Difference Between a Provider App, a Patient App, and a Backend App?

A provider app uses SMART EHR launch — it opens inside the chart in the clinician's Hyperdrive session with patient/user context. A patient app uses SMART standalone launch, authorized against MyChart. A backend app has no user — it authenticates server-to-server with an asymmetric JWT (you upload a public key / X.509 cert to the app record). Each has different scopes, review, and consent.

We're Migrating to Hyperdrive — Will Our Epic Integration Break?

It depends on how you integrated. Standards-based integrations carry over untouched — SMART on FHIR, HL7 v2, Web Services, DICOM, XML file drop, and outgoing command-line all keep working. What breaks is legacy COM-based API integrations that hooked into the Hyperspace desktop (and some web apps hosted inside Hyperspace). If that's you, we re-platform onto Hyperdrive-safe patterns or SMART.

How Do We Exchange Data Across Organizations — Care Everywhere and TEFCA?

Care Everywhere is Epic's health-information-exchange network. For national exchange, Epic Nexus is Epic's designated TEFCA QHIN (Qualified Health Information Network) — by mid-2025, 1,000+ hospitals and 22,000+ clinics on Epic were live on TEFCA through it. We help you use these paths for cross-organization records rather than negotiating one-off connections.

What Data and FHIR Resources Does Epic Expose?

Epic exposes a broad FHIR API surface — hundreds of resource endpoints across DSTU2, STU3, and R4 simultaneously (R4 is recommended). In practice you'll work with US Core resources like Patient, Encounter, Observation, Condition, MedicationRequest, AllergyIntolerance, DocumentReference, ServiceRequest, and Appointment. The R4 surface even splits some reads into "Patient Chart" vs "Outside Record" (aggregated outside data). We map your use case to exactly the resources and scopes you need.

Do I Have to Be in App Orchard / Showroom to Integrate with Epic?

No — App Orchard is retired anyway. You build and test for free on Epic on FHIR, and you can go live with a customer who has licensed your product without a marketplace listing. Showroom (Epic's storefront) and Connection Hub (a self-report directory of live connections) help customers discover you, and Vendor Services gives you paid Epic support — but the integration itself is gated by each customer's authorization and review, not by a marketplace listing.

Can I Build a Patient-Facing App for Epic MyChart?

Yes. Patient apps use SMART on FHIR standalone launch — the patient authorizes your app against MyChart with OAuth 2.0, and you receive access to their US Core data within the scopes they grant. It's the standard path for PHRs, engagement, and patient-mediated data products. We build it to the same Inferno g10-validated patterns Epic's certification expects.

Should We Integrate with Epic Directly or Use Redox / Health Gorilla?

It depends on your roadmap. Middleware (Redox, Health Gorilla) gets you to many EHRs fast with pre-built connectors, at an ongoing per-transaction / subscription cost you don't control. Direct Epic integration takes more up-front work but gives you full access (including deep writes and proprietary APIs), no per-transaction fee, and lower cost at scale. We do both and give vendor-neutral advice — see the build-vs-buy comparison above.

How Do We Get an Epic Sandbox to Start Building?

Epic's sandbox is self-service and free on fhir.epic.com. You register an app (which issues your non-production and production client IDs), then test your FHIR calls and SMART launch against Epic's example "Try It" test patients before any real customer is involved. We stand this up with you and design the app record correctly the first time — because once it's marked ready for production, it can't be edited.

How Much Does It Cost and How Long Does It Take?

The build itself is scope-dependent — a read-only US Core FHIR app is fastest (often ~2–4 months), while bidirectional and multi-surface builds take longer (~6–14 months), and every customer go-live adds its own security review. Full builds are commonly reported around $18K–$80K+, with maintenance ~15–20%/year — but those are industry ranges, not a quote. Epic program fees (Vendor Services, Connection Hub) are relatively modest versus the real gating factor: each customer's review and activation. We scope your specific app on a call and give you a realistic timeline before you commit. (See the cost & timeline section above.)

Let's Get You Into Epic

Tell Us What You're Building for Epic.

Book a scoping call — we'll map your app type (provider / patient / backend), the right integration method, the program path, and a realistic route to a live customer. Reviewed by an integration engineer, not a sales queue.

+1 (669) 649-0706

hello@nirmitee.io

USA

Iselin, NJ 08830

India

Baner, Pune, MH 411045

Thanks — We've Got It.

A Nirmitee integration engineer will reach out within one business day.