ClinikAPI vs. Medplum vs. Health Gorilla: Choosing the Right Healthcare Infrastructure in 2026

Quick Answer

These three platforms solve different problems. ClinikAPI is a managed FHIR platform with simplified JSON and pre-built React widgets — best for teams that want to ship clinical apps fast without FHIR expertise. Medplum is an open-source FHIR server you host yourself — best for teams with deep FHIR knowledge who want full control. Health Gorilla is a health data aggregation network — best for pulling patient records from existing EHRs and health systems, not for building your own data layer. Pick based on what you are actually building.

---

What Each Platform Actually Does

Before comparing features, let's be clear about what each platform is designed for. They are not direct competitors in every scenario — they solve overlapping but distinct problems.

ClinikAPI: Managed FHIR with Developer-Friendly API

What it is: A managed healthcare data platform that sits between your app and AWS HealthLake. You send simplified JSON, ClinikAPI converts it to FHIR R4, handles tenant isolation, audit logging, and encrypted storage.

Core value: You never write FHIR mapping code. You never configure HIPAA compliance infrastructure. You get a TypeScript SDK with 14 clinical resource namespaces and a React widget library for building clinical UIs.

Best for: Teams building new clinical applications (patient portals, telehealth platforms, clinical workflow tools) who want to ship fast without deep FHIR expertise.

Medplum: Open-Source FHIR Server

What it is: An open-source FHIR R4 server with a React component library. You can self-host it or use their cloud offering. It gives you a full FHIR server with direct FHIR API access.

Core value: Full control over your FHIR server. Open-source means you can inspect, modify, and extend the code. Strong community and active development.

Best for: Teams with FHIR expertise who want full control over their infrastructure, or organizations that need to self-host for regulatory reasons.

Health Gorilla: Health Data Aggregation Network

What it is: A health data exchange network that connects to thousands of EHRs, labs, pharmacies, and health information exchanges (HIEs). It pulls patient records from existing systems rather than storing your own clinical data.

Core value: Access to patient data that already exists in other systems. You do not build a data store — you query existing ones.

Best for: Teams that need to read patient records from external EHRs, aggregate data from multiple sources, or connect with labs and pharmacies.

---

Feature Comparison

Feature	ClinikAPI	Medplum	Health Gorilla
Primary function	Managed FHIR data store	Open-source FHIR server	Health data aggregation
FHIR R4 support	Yes (under the hood)	Yes (native)	Yes (for data exchange)
Simplified API	Yes — flat JSON, no FHIR knowledge needed	No — you work with raw FHIR	No — FHIR-based queries
TypeScript SDK	Yes (@clinikapi/sdk)	Yes (@medplum/core)	Limited
React components	Yes — 9 pre-built clinical widgets	Yes — UI component library	No
Self-hosting	No (managed only)	Yes (open-source)	No (managed only)
Cloud hosting	Yes (AWS HealthLake)	Yes (Medplum Cloud)	Yes
HIPAA BAA	Included on all production plans	Available on cloud plans	Available
Multi-tenancy	Built-in with sub-organizations	You build it	N/A
Audit logging	Automatic on every operation	You configure it	Available
Data aggregation	No — you store your own data	No — you store your own data	Yes — pulls from external EHRs
Lab/pharmacy network	No	No	Yes — connected to major networks
Pricing model	Per-request ($49-1,599/mo)	Open-source free, cloud pricing varies	Per-query, custom pricing
Free tier	Yes — 1,000 requests/month sandbox	Yes — open-source is free	No
Setup time	15 minutes	Hours to days (self-host) or minutes (cloud)	Days to weeks (network onboarding)

---

Deep Dive: ClinikAPI

What ClinikAPI Does Well

Simplified developer experience. This is ClinikAPI's biggest advantage. You do not need to understand FHIR resource structures, terminology system URIs, or Bundle parsing. You send flat JSON:

const { data } = await clinik.patients.create({
  firstName: 'Jane',
  lastName: 'Doe',
  email: '[email protected]',
  gender: 'female',
  birthDate: '1990-03-15',
});

Under the hood, this becomes a valid FHIR R4 Patient resource with proper name, telecom, and gender coding. You never see the FHIR unless you want to.

Pre-built React widgets. The @clinikapi/react library gives you 9 production-ready clinical UI components: PatientDashboard, AppointmentScheduler, PrescriptionForm, NoteEditor, IntakeForm, ConsentManager, VitalsWidget, LabResultsWidget, and PrescriptionWidget. Drop them into any React app with a proxyUrl prop.

Built-in multi-tenancy. Sub-organizations on Pro and Team plans get their own isolated data partitions. This is critical for multi-clinic platforms and SaaS products serving multiple healthcare organizations.

Transparent pricing. Sandbox is free. Starter is $49/month for 60,000 requests. Pro is $399/month for 600,000 requests. Overage is $0.003 per request. No hidden fees, no per-seat pricing, no surprise invoices.

Where ClinikAPI Falls Short

No self-hosting option. If your organization requires on-premise deployment for regulatory reasons, ClinikAPI cannot accommodate that today. All data lives in AWS HealthLake managed by ClinikAPI.

Newer platform. ClinikAPI is newer to market than Medplum. The community is smaller, and there are fewer third-party integrations and tutorials available.

No data aggregation. ClinikAPI stores your data. It does not pull records from external EHRs or connect to lab/pharmacy networks. If you need to read data from Epic, Cerner, or other existing systems, you need a different tool (like Health Gorilla) alongside ClinikAPI.

---

Deep Dive: Medplum

What Medplum Does Well

Full FHIR control. Medplum gives you a complete FHIR R4 server. You work directly with FHIR resources, search parameters, and operations. If you know FHIR well, this is powerful — you can do anything the FHIR spec supports.

Open-source. The code is on GitHub. You can inspect it, fork it, modify it, and contribute to it. This matters for organizations that need to audit their infrastructure code or have specific customization requirements.

Self-hosting option. You can run Medplum on your own AWS account, giving you full control over data residency, network configuration, and infrastructure management. This is important for organizations with strict regulatory requirements.

Active community. Medplum has a growing community of healthcare developers, active Discord, and regular releases. The team is responsive and the documentation is solid.

React component library. Medplum provides React components for building clinical UIs, though they are more FHIR-native (you work with FHIR resource types directly) compared to ClinikAPI's simplified widget approach.

Where Medplum Falls Short

FHIR expertise required. This is the flip side of "full FHIR control." You need to understand FHIR resource structures, search parameters, terminology systems, and Bundle handling. The learning curve is steep for teams new to healthcare.

Self-hosting complexity. Running your own FHIR server means managing infrastructure: database provisioning, scaling, backups, security patches, monitoring, and on-call rotation. This is significant ongoing work.

Multi-tenancy is DIY. Medplum does not provide built-in multi-tenant data isolation. If you are building a SaaS product serving multiple clinics, you need to implement tenant isolation yourself — either through separate Medplum instances or application-level data partitioning.

HIPAA compliance is partially DIY. On the cloud offering, Medplum handles some compliance. On self-hosted, you are responsible for encryption configuration, audit logging setup, access controls, and BAA management with your hosting provider.

---

Deep Dive: Health Gorilla

What Health Gorilla Does Well

Data aggregation from existing systems. This is Health Gorilla's core strength. It connects to thousands of EHRs, labs (Quest, LabCorp), pharmacies, and health information exchanges. You can pull a patient's medical history from their existing providers without building individual integrations.

Lab and pharmacy connectivity. Health Gorilla provides direct connections to major lab networks and pharmacy systems. You can order labs, receive results, and send prescriptions through their network.

Patient matching. Health Gorilla handles the complex problem of matching patient identities across different systems — finding the same patient in Epic, Cerner, and a local lab system.

Established network. Health Gorilla has been building their network for years. The connections are established and tested. This is not something you can replicate quickly.

Where Health Gorilla Falls Short

Not a data store. Health Gorilla is a data exchange network, not a place to store your own clinical data. If you are building an app that creates new patient records, encounters, and observations, you need a separate data layer (like ClinikAPI or Medplum).

Complex onboarding. Connecting to the Health Gorilla network involves credentialing, compliance verification, and network onboarding. This takes days to weeks, not minutes.

Custom pricing. Health Gorilla does not publish transparent pricing. You need to contact sales for a quote, and pricing is typically per-query or per-connection. This makes it harder to predict costs.

No frontend components. Health Gorilla is a backend data service. There are no pre-built UI components. You build all frontend yourself.

Developer experience. The API is functional but not as developer-friendly as ClinikAPI's simplified JSON approach. You work with FHIR-based queries and responses.

---

Which Platform Should You Choose?

Choose ClinikAPI if:

• You are building a new clinical application and need a data layer
• Your team does not have deep FHIR expertise
• You want to ship fast (days, not months)
• You need pre-built React components for clinical UIs
• You are building a multi-tenant SaaS serving multiple clinics
• You want transparent, predictable pricing
• You want HIPAA compliance handled without building it yourself

Common use cases: Patient portals, telehealth platforms, clinical workflow tools, practice management apps, health tech MVPs.

Choose Medplum if:

• Your team has strong FHIR expertise
• You need full control over your FHIR server
• You have regulatory requirements that mandate self-hosting
• You want to customize the FHIR server itself (not just the data)
• You have engineering resources for infrastructure management
• You are building a FHIR server as your core product

Common use cases: Custom EHR systems, FHIR-native platforms, organizations with strict data residency requirements, teams contributing to the FHIR ecosystem.

Choose Health Gorilla if:

• You need to read patient data from existing EHRs (Epic, Cerner, etc.)
• You need lab ordering and results (Quest, LabCorp)
• You need pharmacy connectivity for e-prescribing
• You are building a data aggregation or care coordination platform
• You need patient matching across multiple systems

Common use cases: Care coordination platforms, health data aggregators, clinical decision support tools that need external data, insurance/payer platforms.

Use ClinikAPI + Health Gorilla Together if:

• You need to store your own clinical data (ClinikAPI) AND pull records from external systems (Health Gorilla)
• You are building a comprehensive platform that creates new data and reads existing data
• Example: A telehealth platform that stores visit notes in ClinikAPI and pulls the patient's medication history from their primary care EHR via Health Gorilla

---

Pricing Comparison

Plan	ClinikAPI	Medplum (Cloud)	Health Gorilla
Free tier	1,000 req/month sandbox	Open-source (self-host free)	No free tier
Starter	$49/month (60K requests)	Contact for pricing	Contact for pricing
Growth	$399/month (600K requests)	Contact for pricing	Contact for pricing
Enterprise	$1,599/month (3M requests)	Contact for pricing	Contact for pricing
Overage	$0.003/request	Varies	Per-query pricing
BAA included	Yes (all production plans)	Yes (cloud plans)	Yes
Pricing model	Per-request, transparent	Varies	Per-query, custom

Cost for a typical startup (100K requests/month):

• ClinikAPI: $49/month (Starter covers 60K, overage for remaining 40K = $120 total)
• Medplum (self-hosted): $0 software + $200-500/month AWS infrastructure + engineering time
• Medplum (cloud): Contact for pricing (not publicly available)
• Health Gorilla: Contact for pricing (typically $500-2,000+/month depending on query volume)

---

Developer Experience Comparison

Creating a Patient

ClinikAPI:

const { data } = await clinik.patients.create({
  firstName: 'Jane',
  lastName: 'Doe',
  email: '[email protected]',
  gender: 'female',
  birthDate: '1990-03-15',
});

Medplum:

const patient = await medplum.createResource({
  resourceType: 'Patient',
  name: [{ given: ['Jane'], family: 'Doe' }],
  telecom: [{ system: 'email', value: '[email protected]' }],
  gender: 'female',
  birthDate: '1990-03-15',
});

Health Gorilla: N/A — Health Gorilla reads data from external systems, it does not create patient records in its own data store.

Building a Patient Dashboard (React)

ClinikAPI:

import { PatientDashboard } from '@clinikapi/react';

<PatientDashboard proxyUrl={`/api/patients/${id}`} />

Medplum:

import { ResourceTable } from '@medplum/react';

<ResourceTable value={patient} />
// Plus custom components for encounters, vitals, meds...

Health Gorilla: No pre-built components. Build everything from scratch.

Time to First Working Prototype

Platform	Time to Prototype	FHIR Knowledge Needed
ClinikAPI	1-2 hours	None
Medplum (cloud)	2-4 hours	Moderate
Medplum (self-host)	1-2 days	High
Health Gorilla	1-2 weeks	Moderate + network onboarding

---

Can You Switch Between Platforms?

From ClinikAPI to Medplum: Yes. ClinikAPI stores data as standard FHIR R4. Export via the API and import into Medplum. Your data is portable.

From Medplum to ClinikAPI: Yes. Export FHIR resources from Medplum and use ClinikAPI's raw FHIR endpoint (clinik.fhir.request()) to import them.

From Health Gorilla to either: Health Gorilla is a data exchange network, not a data store. There is nothing to "migrate" — you would just stop querying their network.

Data portability is a strength of the FHIR ecosystem. Because all three platforms use FHIR R4, moving data between them is straightforward.

---

Frequently Asked Questions

Can I use ClinikAPI and Health Gorilla together? Yes. This is a common pattern. Use ClinikAPI as your primary data store for clinical data your app creates (encounters, notes, prescriptions). Use Health Gorilla to pull existing patient records from external EHRs and labs. The two platforms complement each other.

Is Medplum really free? The open-source software is free. But self-hosting has real costs: AWS infrastructure ($200-500+/month), engineering time for setup and maintenance, and your own HIPAA compliance work. Medplum's cloud offering has pricing that is not publicly listed.

Which platform has the best developer documentation? All three have solid docs. ClinikAPI's docs are at docs.clinikapi.com and focus on the simplified API. Medplum's docs cover both the FHIR API and their React components. Health Gorilla's docs focus on their network APIs and data exchange patterns.

Do I need FHIR expertise for any of these? ClinikAPI: No — the simplified JSON API abstracts FHIR away. Medplum: Yes — you work directly with FHIR resources. Health Gorilla: Moderate — you query using FHIR-based parameters but do not build FHIR resources from scratch.

Which is best for a health tech startup MVP? ClinikAPI. The combination of simplified API, pre-built React widgets, transparent pricing ($49/month to go live), and zero infrastructure setup makes it the fastest path from idea to working product. You can always migrate to Medplum later if you need more control.

Which is best for a large health system? It depends on the project. For a new patient-facing app: ClinikAPI (fast to ship, managed compliance). For a custom internal FHIR server: Medplum (full control, self-hosting). For connecting to external systems: Health Gorilla (established network).

---

Related Reading

• What Is a Healthcare API? Developer's Guide
• FHIR R4 Made Simple
• HIPAA Compliance for Developers
• Build a Patient Portal in a Weekend
• ClinikAPI Documentation