---
title: "Connect Elation Health to Claude: Manage Clinical Orders & Schedules"
slug: connect-elation-health-to-claude-manage-clinical-orders-schedules
date: 2026-11-10
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to build a secure Elation Health MCP server to give Claude AI agents read and write access to clinical orders, patient scheduling, and billing."
tldr: "A comprehensive engineering guide on connecting Elation Health to Claude via a managed MCP server. Automate clinical note retrieval, scheduling, and billing workflows using natural language while adhering to strict healthcare API schemas."
canonical: https://truto.one/blog/connect-elation-health-to-claude-manage-clinical-orders-schedules/
---

# Connect Elation Health to Claude: Manage Clinical Orders & Schedules


If your clinical operations team needs to connect Elation Health to Claude to automate patient scheduling, manage clinical orders, or retrieve encounter notes, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's JSON-RPC tool calls and Elation Health's REST API. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

If your team uses ChatGPT, check out our guide on [connecting Elation Health to ChatGPT](https://truto.one/connect-elation-health-to-chatgpt-update-patient-notes-billing/) or explore our broader architectural overview on [connecting Elation Health to AI Agents](https://truto.one/connect-elation-health-to-ai-agents-sync-care-gaps-vital-signs/).

Giving a Large Language Model (LLM) read and write access to an Electronic Health Record (EHR) system like Elation Health is an engineering challenge with zero margin for error. You have to handle secure token lifecycles, map massive healthcare schemas to MCP tool definitions, and deal with Elation's strict domain rules around clinical associations. Every time Elation updates a resource schema or deprecates an endpoint, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Elation Health, connect it natively to Claude Desktop, and execute complex clinical workflows using natural language.

> Want to give your AI agents secure, authenticated access to Elation Health and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Elation Health API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specialized healthcare APIs is painful. Elation Health is built to manage complex physician-patient relationships, [rigid clinical documentation, and strict billing codes](https://truto.one/connect-shiftcare-to-claude-sync-billing-payments-and-compliance/).

If you decide to build a custom Elation Health MCP server, here are the specific integration challenges you will face:

**Complex Record Associations and Required Keys**
Elation Health does not allow isolated record creation. Almost every write operation requires explicitly linking associated entities. For example, you cannot just create an appointment; you must pass a valid `patient` ID, `physician` ID, and `practice` ID. An LLM has no inherent context of your organization's internal primary keys. Your agent architecture must be designed to first search for the patient and physician, extract their numerical IDs, and then pass those specific IDs into the create payload.

**Legacy vs. EN2.1 Note Schemas**
Clinical documentation in Elation has evolved. When fetching or updating visit notes, you will encounter two distinct structures: legacy notes and EN2.1 sections-based notes. The legacy `/notes_v1/` endpoint expects a different payload structure than the newer `/notes/` endpoint. If an LLM attempts to update an EN2.1 note using the legacy schema, the API will reject it with a 400 error. The tools exposed to Claude must clearly guide the model to use the correct endpoint based on the note's underlying schema version.

**Rate Limits and 429 Passthrough**
Like any robust B2B platform, Elation enforces API rate limits. When a limit is breached, the API returns an HTTP 429 error. It is critical to understand that Truto does not absorb, retry, or throttle these requests. When the upstream API returns a 429, Truto passes that error directly back to the MCP caller. Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller (your AI agent framework or Claude client) is entirely responsible for reading these headers and implementing backoff and retry logic.

## How to Create the Elation Health MCP Server

Truto handles the heavy lifting of authentication, schema normalization, and dynamic tool generation. Once you have authenticated an Elation Health account (an "Integrated Account" in Truto), you can generate an MCP server URL in seconds.

Each MCP server is cryptographically tied to a single connected Elation Health tenant. You can create this server via the Truto UI or programmatically via the REST API.

### Method 1: Via the Truto UI

For teams who prefer a visual setup, generating an MCP server takes three clicks:

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Elation Health account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., name, method filters, tag filters, expiration).
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

For platform engineers who want to provision MCP servers dynamically - such as generating a dedicated server when a new clinic is onboarded - you can use Truto's REST API.

Send an authenticated `POST` request to the MCP generation endpoint. 

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Elation Clinical Ops Agent",
    "config": {
      "methods": ["read", "write"]
    }
  }'
```

The response will contain the securely hashed `url` that your LLM client needs to connect.

```json
{
  "id": "mcp_8a9b0c1d",
  "name": "Elation Clinical Ops Agent",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## How to Connect the MCP Server to Claude

Once you have the Elation Health MCP URL, [connecting it to Claude requires zero additional coding](https://truto.one/how-to-connect-claude-to-saas-apis-via-mcp-zero-data-retention/). The URL encapsulates the target account, the authorized tools, and the authentication context.

### Method 1: Via the Claude UI (Desktop)

If you are using Claude Desktop (or equivalent settings in ChatGPT via custom connectors):

1. Open Claude Desktop and go to **Settings**.
2. Navigate to **Integrations** -> **Add MCP Server** (in ChatGPT this is under Settings -> Apps -> Advanced settings -> Developer mode -> Custom connectors).
3. Enter a name for the connection (e.g., "Elation Health").
4. Paste the Truto MCP URL into the Server URL field.
5. Click **Add**.

Claude will immediately perform an MCP initialization handshake, discover the available Elation Health tools, and make them available in your chat context.

### Method 2: Via Manual Config File (Claude Desktop)

If you prefer to configure Claude Desktop manually via its JSON configuration file, you can utilize the `@modelcontextprotocol/server-sse` proxy package to bridge Truto's HTTP endpoint.

Locate your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows).

Add the Truto server configuration:

```json
{
  "mcpServers": {
    "elation-health": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890"
      ]
    }
  }
}
```

Restart Claude Desktop. The "plug" icon will appear, indicating that the Elation Health tools are successfully registered.

## Elation Health Hero Tools for Claude

Truto dynamically derives MCP tools directly from Elation Health's API schema. The tool names are standardized into descriptive `snake_case` formats. Here are 6 high-leverage hero tools that transform Claude into a capable clinical assistant.

### 1. list_all_elation_health_patients
**Description:** Returns a paginated list of patients. This is almost always the first tool Claude must call to resolve a natural language name to a specific Elation `patient_id`.
**Contextual notes:** This tool accepts query parameters to filter by name or DOB. Pagination limit is inherited from the caller, max 100.

> "Search our patient database for John Smith born in 1985 and return his internal patient ID."

### 2. create_a_elation_health_appointment
**Description:** Creates a new appointment on the schedule.
**Contextual notes:** Claude must provide valid IDs for `patient`, `physician`, and `practice`, along with a valid `scheduled_date` in ISO format.

> "Schedule a follow-up appointment for patient ID 12345 with Dr. Evans (physician ID 88) at the downtown clinic (practice ID 12) for next Tuesday at 10:00 AM."

### 3. create_a_elation_health_lab_order
**Description:** Generates a new lab order for a patient.
**Contextual notes:** This requires `document_date`, `ordering_physician`, `patient`, and `practice`. Claude can look up the required IDs before executing this tool.

> "Draft a new comprehensive metabolic panel lab order for Sarah Connor. Her patient ID is 992. Order it under Dr. Evans at practice 12 with today's date."

### 4. get_single_elation_health_note_by_id
**Description:** Retrieves a specific visit note. This fetches a note without creating a snapshot, bypassing concurrent conflict resolution blocks for read-only checks.
**Contextual notes:** Requires the specific `id` of the note. For legacy notes, use `get_single_elation_health_notes_v_1_by_id` instead.

> "Retrieve the contents of visit note ID 77653 and summarize the physician's assessment and plan for the patient."

### 5. create_a_elation_health_caregap
**Description:** Creates a new care gap record under the Care Gaps API subsystem.
**Contextual notes:** Required fields include `quality_program`, `definition_id`, `patient_id`, `practice_id`, `created_date`, and `status`. This is vital for population health tracking.

> "Log an open care gap for patient 12345 regarding the annual diabetic retinal exam (definition ID 44) under the Medicare Advantage quality program."

### 6. list_all_elation_health_physician_availabilities
**Description:** Gets the availabilities for a specified physician.
**Contextual notes:** Requires `physician_id`. Essential for AI scheduling agents to ensure they don't double-book providers.

> "Check the availability schedule for Dr. Evans (physician ID 88) for the upcoming week and list the open time slots."

To see the complete inventory of available tools, required payloads, and JSON schemas, check out the [Elation Health integration page](https://truto.one/integrations/detail/elationhealth).

## Workflows in Action

Exposing individual endpoints as tools is helpful, but the true power of MCP emerges when Claude chains these tools together to execute complex, multi-step clinical workflows.

### Scenario 1: Pre-Visit Clinical Prep

**User Prompt:**
> "Pull up the chart for Jane Doe. Find her primary physician's schedule, retrieve her most recent visit note, and see if she has any open care gaps we need to address today."

**How Claude executes this:**
1. `list_all_elation_health_patients`: Claude searches for "Jane Doe" to retrieve her `id` and her assigned `primary_physician` ID.
2. `list_all_elation_health_physician_availabilities`: Claude uses the physician ID to check today's schedule to confirm the appointment time.
3. `list_all_elation_health_notes`: Claude queries the notes endpoint filtered by Jane Doe's patient ID to find the most recent encounter.
4. `list_all_elation_health_caregaps`: Claude queries the Care Gaps API for the patient to check for open compliance items (e.g., overdue mammogram).

**Result:** The medical assistant receives a synthesized summary of Jane's last visit and a flagged alert about an outstanding preventative care gap, allowing them to prep the exam room accordingly.

```mermaid
sequenceDiagram
  participant User as Medical Assistant
  participant Claude as Claude Desktop
  participant Truto as Truto MCP
  participant Elation as Elation Health API
  
  User->>Claude: "Find Jane Doe, get her last note and open care gaps."
  
  Claude->>Truto: tools/call list_all_elation_health_patients (name="Jane Doe")
  Truto->>Elation: GET /patients?first_name=Jane&last_name=Doe
  Elation-->>Truto: Patient ID: 405, Physician ID: 12
  Truto-->>Claude: JSON patient data
  
  Claude->>Truto: tools/call list_all_elation_health_notes (patient=405)
  Truto->>Elation: GET /notes?patient=405
  Elation-->>Truto: Latest Note ID: 8892
  Truto-->>Claude: JSON note summary
  
  Claude->>Truto: tools/call list_all_elation_health_caregaps (patient_id=405)
  Truto->>Elation: GET /caregaps?patient_id=405
  Elation-->>Truto: 1 open gap (Retinal Exam)
  Truto-->>Claude: JSON gap data
  
  Claude->>User: "Jane's last visit covered HTN. She has one open gap: Retinal Exam."
```

### Scenario 2: Post-Visit Order Routing

**User Prompt:**
> "I just saw Michael Scott (ID: 554). Create a new lab order for a Lipid Panel and draft a new bill for a level 3 established patient visit (CPT 99213)."

**How Claude executes this:**
1. `create_a_elation_health_lab_order`: Claude constructs the payload using the provided patient ID, infers the current date for `document_date`, and submits the request to Elation.
2. `create_a_elation_health_bill`: Claude formulates the billing payload, attaching the patient ID, the practice ID (inferred from context or a previous lookup), and the requested `cpts` array.

**Result:** The provider saves 5 minutes of clicking through menus. The lab order is routed, and a draft bill is prepped for the billing team to review and release to the PMS.

## Security and Access Control

When dealing with [Electronic Health Records, security and scoping are paramount](https://truto.one/the-hipaa-playbook-for-ai-accounting-api-integrations-zero-data-retention/). Handing an LLM unrestricted access to a production EHR is dangerous. Truto provides several mechanisms to lock down your MCP servers:

*   **Method Filtering:** Restrict servers to specific operational categories. By passing `config.methods: ["read"]`, Claude is physically prevented from invoking `create`, `update`, or `delete` operations, making the server perfectly safe for data extraction agents.
*   **Tag Filtering:** Limit the server's scope to specific API domains. You can configure an MCP server to only expose tools related to `billing` or `scheduling`, ensuring the LLM cannot accidentally query sensitive clinical notes.
*   **Extra Authentication (`require_api_token_auth`):** For shared environments, you can force the MCP client to pass a Truto API token in the Authorization header. This ensures that possession of the MCP URL alone is not enough to access patient data.
*   **Automatic Expiration (`expires_at`):** Ideal for contractors or temporary AI workflows. You can issue an MCP URL that automatically self-destructs at a specific ISO datetime, instantly revoking the LLM's access to the Elation Health instance.

## Moving Fast in Health Tech

Building a reliable, compliant AI integration against a complex EHR like Elation Health traditionally requires months of reading docs, handling OAuth token refreshes, and mapping nested schemas. 

By leveraging Truto's dynamic MCP generation, you skip the boilerplate entirely. You give your AI agents a standardized, strictly typed, and securely bounded interface to read and write clinical data. Stop building custom connectors and start building better healthcare workflows.