
Healthie
Healthie Inc.
Healthie
API key + GraphQL backend-to-backend integration adapter for Healthie EHR. Supports server-to-server data access for patients, appointments, and webhook events. No OAuth required — uses a static API key with Basic Auth.
Overview
ConnectHealth's Healthie integration gives your application server-to-server access to patient and appointment data through Healthie's GraphQL API. ConnectHealth acts as the middleware layer — handling API key authentication, GraphQL execution, rate-limit retries, and webhook verification — so your team can focus on building features rather than managing Healthie-specific API details.
Unlike Epic or Elation, Healthie uses a static API key for all server-to-server operations. There is no authorization code flow, no redirect URI, and no token expiry. A single API key stored in your environment authenticates every request indefinitely.
On This Page
Supported Authentication Flows
Key Features
- Single GraphQL endpoint for all operations (patients, appointments, webhooks)
- No OAuth flow — simpler setup than Epic or Elation
- Webhook subscriptions for appointment and patient lifecycle events
- HMAC-SHA-256 signature verification on all incoming webhooks
- Automatic exponential backoff on rate limiting (HTTP 429)
- Audit logging for all operations
Before You Begin
Before you can use Healthie with ConnectHealth, you need an active Healthie account with API access enabled and an API key generated from the Healthie developer settings.
Prerequisites Checklist
- Healthie account with API access — Contact Healthie support to ensure your account has API access enabled
- API key generated — Created in your Healthie account settings (see below)
- Webhook URL ready (optional) — A publicly accessible URL on your ConnectHealth instance for receiving Healthie events
- Webhook secret configured (optional) — A shared secret for HMAC-SHA-256 webhook signature verification
Get Your Healthie API Key
Healthie API keys are generated directly from the Healthie account settings panel. There is no developer portal registration or app approval process.
Log in to Your Healthie Account
Go to securestaging.gethealthie.com (sandbox) or your production Healthie URL and sign in.
Open Account Settings → API
Navigate to your account settings. Look for an API or Developer section. Your API key will be displayed here. If API access is not visible, contact Healthie support to enable it for your account.
Copy Your API Key
Copy the API key value. Sandbox keys begin with gh_sbox_. Production keys have a different prefix.
Store the API key in AWS Secrets Manager or your environment variable management system. Never commit it to source control or expose it in client-side code. The key grants full API access to your Healthie account.
Set Environment Variables in ConnectHealth
Add the following to your ConnectHealth environment configuration:
HEALTHIE_API_KEY=gh_sbox_your_key_here
HEALTHIE_ENVIRONMENT=sandbox
HEALTHIE_SANDBOX_URL=https://staging-api.gethealthie.com/graphql
HEALTHIE_PRODUCTION_URL=https://api.gethealthie.com/graphql
Test the Connection
Call the health check endpoint to confirm your API key is working:
curl -X GET "https://<your-connecthealth-domain>/api/healthie/health" \
-H "x-api-key: YOUR_CONNECTHEALTH_API_KEY" \
-H "Accept: application/json"
A successful response returns the current Healthie API user details (id, email, firstName, lastName).
Sandbox Environment
Healthie provides a sandbox environment at staging-api.gethealthie.com for integration testing. Sandbox API keys begin with gh_sbox_ and work only against the sandbox endpoint.
Healthie Endpoints
| Environment | GraphQL Endpoint |
|---|---|
| Sandbox | https://staging-api.gethealthie.com/graphql |
| Production | https://api.gethealthie.com/graphql |
Sandbox vs Production Comparison
| Aspect | Sandbox | Production |
|---|---|---|
| GraphQL Endpoint | staging-api.gethealthie.com/graphql |
api.gethealthie.com/graphql |
| API Key Prefix | gh_sbox_ |
Different prefix — issued by Healthie |
| Data | Synthetic test data | Real patient data (HIPAA-covered) |
| Webhook IPs | 18.206.70.225, 44.195.8.253 |
Contact Healthie for production IPs |
| HEALTHIE_ENVIRONMENT value | sandbox |
production |
Configuration
Healthie only supports Backend (server-to-server) integration. There is no OAuth flow, no redirect URI, and no per-user token. Set the following environment variables in your ConnectHealth deployment.
Unlike Epic or Elation, Healthie does not require OAuth setup, redirect URIs, JWKS endpoints, or token refresh. Just set your API key in the environment and all requests are authenticated automatically.
Required Environment Variables
| Variable | Required | Description |
|---|---|---|
HEALTHIE_API_KEY |
Yes | Your Healthie API key. Sandbox keys begin with gh_sbox_. |
HEALTHIE_ENVIRONMENT |
Yes | Set to sandbox for testing or production for live data. Controls which endpoint is used. |
HEALTHIE_SANDBOX_URL |
Yes | Healthie sandbox GraphQL endpoint: https://staging-api.gethealthie.com/graphql |
HEALTHIE_PRODUCTION_URL |
Yes | Healthie production GraphQL endpoint: https://api.gethealthie.com/graphql |
HEALTHIE_WEBHOOK_URL |
No | Publicly accessible URL on your ConnectHealth instance where Healthie will POST events. Required to call POST /api/healthie/setup. |
HEALTHIE_WEBHOOK_SECRET |
No | Shared secret for HMAC-SHA-256 webhook signature verification. Required to receive and validate webhooks. |
Webhook Setup
Healthie can send real-time event notifications to your ConnectHealth instance via webhooks. ConnectHealth verifies each webhook's HMAC-SHA-256 signature before processing.
Supported Event Types
| Event Type | Triggered When |
|---|---|
appointment.created |
A new appointment is booked in Healthie |
appointment.updated |
An existing appointment is modified |
appointment.deleted |
An appointment is cancelled or removed |
patient.created |
A new patient record is created |
patient.updated |
A patient record is modified |
Registering Webhooks
Set Environment Variables
Ensure HEALTHIE_WEBHOOK_URL and HEALTHIE_WEBHOOK_SECRET are set in your environment.
HEALTHIE_WEBHOOK_URL=https://your-connecthealth-domain.com/api/healthie/webhooks
HEALTHIE_WEBHOOK_SECRET=your-shared-secret
Whitelist Healthie's Sandbox IPs (if using a firewall)
Allow inbound traffic from Healthie's sandbox webhook IPs:
18.206.70.22544.195.8.253
Call the Setup Endpoint
Call POST /api/healthie/setup once to register all 5 event types with Healthie. ConnectHealth automatically creates a createWebhookSubscription mutation for each event:
curl -X POST "https://<your-connecthealth-domain>/api/healthie/setup" \
-H "x-api-key: YOUR_CONNECTHEALTH_API_KEY" \
-H "Content-Type: application/json"
The response shows the registration status for each event type. A 207 status means some registrations failed — check the body array for details.
Webhook Signature Verification
ConnectHealth automatically verifies the X-Healthie-Hmac-SHA256 header on every incoming webhook using HMAC-SHA-256 with your HEALTHIE_WEBHOOK_SECRET. Webhooks with invalid signatures are rejected with HTTP 401 before any processing occurs.
Healthie retries failed webhook deliveries for up to 3 days with exponential backoff. ConnectHealth responds 200 immediately after signature verification to prevent retries — event processing happens asynchronously.
Use Cases
Automated Patient Data Sync
Scenario: Pull patient demographics from Healthie into your system on a schedule or in response to patient.created webhook events.
Endpoints Used: GET /api/healthie/patients, GET /api/healthie/patients/:id
Recommended Trigger: patient.created / patient.updated webhooks → fetch latest record
Appointment Notifications
Scenario: Trigger downstream workflows (e.g. send a reminder, update a calendar, notify a care team) when appointments are created or changed in Healthie.
Endpoints Used: POST /api/healthie/webhooks (incoming), GET /api/healthie/appointments/:id
Recommended Trigger: appointment.created / appointment.updated webhooks
Workflow Automation (Node-RED)
Scenario: Node-RED workflows inside ConnectHealth call GET /api/healthie/patients or GET /api/healthie/appointments as part of automated healthcare data pipelines.
No additional setup needed — the API key is shared at the environment level across all workflows.
API Endpoints
All ConnectHealth Healthie endpoints are prefixed with /api/healthie. Protected endpoints require a ConnectHealth API key in the x-api-key header. The webhook endpoint (POST /webhooks) is public — it uses HMAC signature verification instead of an API key.
All endpoints except POST /webhooks require a ConnectHealth API key passed as the x-api-key header. Create one from Settings → API Keys in the ConnectHealth dashboard.
Data Endpoints
| Method | Endpoint | Description | API Key |
|---|---|---|---|
GET |
/api/healthie/health |
Test the Healthie API connection. Returns the current API user's details. Use this to verify your API key is working. | Yes |
GET |
/api/healthie/patients |
Retrieve all patients from Healthie (paginated from offset 0). | Yes |
GET |
/api/healthie/patients/:id |
Retrieve a single patient by their Healthie ID. | Yes |
GET |
/api/healthie/appointments |
Retrieve all appointments from Healthie (paginated from offset 0). | Yes |
GET |
/api/healthie/appointments/:id |
Retrieve a single appointment by its Healthie ID. | Yes |
POST |
/api/healthie/setup |
Register webhook subscriptions for all 5 event types with Healthie. Call once during initial setup. Returns a per-event registration status. | Yes |
POST |
/api/healthie/webhooks |
Receive incoming webhook events from Healthie. HMAC-SHA-256 signature verified automatically. Returns 200 immediately; events are processed asynchronously. |
No (HMAC) |
Examples
Test Connection
Verify your API key and connection to Healthie.
curl
curl -X GET "https://<your-connecthealth-domain>/api/healthie/health" \
-H "x-api-key: YOUR_CONNECTHEALTH_API_KEY"
Response
{
"body": { "id": "12345", "email": "admin@yourpractice.com", "firstName": "Admin", "lastName": "User" },
"message": "Success",
"timestamp": 1749484800000
}
Get All Patients
curl
curl -X GET "https://<your-connecthealth-domain>/api/healthie/patients" \
-H "x-api-key: YOUR_CONNECTHEALTH_API_KEY"
Register Webhooks
Run once during onboarding. Registers subscriptions for all 5 event types.
curl
curl -X POST "https://<your-connecthealth-domain>/api/healthie/setup" \
-H "x-api-key: YOUR_CONNECTHEALTH_API_KEY"
Response (all succeeded)
{
"body": [
{ "eventType": "appointment.created", "status": "registered", "id": "wh_001" },
{ "eventType": "appointment.updated", "status": "registered", "id": "wh_002" },
{ "eventType": "appointment.deleted", "status": "registered", "id": "wh_003" },
{ "eventType": "patient.created", "status": "registered", "id": "wh_004" },
{ "eventType": "patient.updated", "status": "registered", "id": "wh_005" }
],
"message": "Webhook subscriptions registered successfully",
"timestamp": 1749484800000
}
External Resources
- Healthie API Documentation — Official Healthie GraphQL API reference
- Healthie GraphQL Sandbox Endpoint — Interactive GraphQL explorer
- Healthie Sandbox Login — Access the Healthie sandbox UI to generate test API keys
- Healthie Webhooks Documentation — Event types, payload structure, and retry behaviour