---
title: "Connect Elation Health to ChatGPT: Update Patient Notes & Billing"
slug: connect-elation-health-to-chatgpt-update-patient-notes-billing
date: 2026-11-10
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to generate a secure MCP server for Elation Health using Truto and connect it to ChatGPT to automate clinical notes, billing, and patient records."
tldr: "Connect Elation Health to ChatGPT using Truto's managed MCP server. This guide covers UI/API setup, Truto's rate limit handling, hero tools, and real-world clinical workflows."
canonical: https://truto.one/blog/connect-elation-health-to-chatgpt-update-patient-notes-billing/
---

# Connect Elation Health to ChatGPT: Update Patient Notes & Billing


If you need to connect Elation Health to ChatGPT to automate clinical documentation, orchestrate medical billing, or pull patient histories, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server translates ChatGPT's natural language tool calls into Elation Health's strict Electronic Health Record (EHR) API requirements. You can spend weeks [building, hosting, and maintaining a custom MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or you can use a managed integration layer to dynamically generate a secure, authenticated MCP URL instantly.

If your team uses Claude, check out our guide on [connecting Elation Health to Claude](https://truto.one/connect-elation-health-to-claude-manage-clinical-orders-schedules/) 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 EHR system like Elation Health introduces massive engineering friction. You are dealing with highly structured clinical schemas, complex pagination, relational data (e.g., tying a CPT billing code to a specific visit note for a specific patient), and strict rate limits. Every time Elation Health updates a resource schema, your custom server code must be updated and redeployed. 

This guide breaks down exactly how to use Truto to generate a [secure, managed MCP server](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/) for Elation Health, connect it natively to ChatGPT, and execute complex clinical and administrative workflows using natural language.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Elation Health API

A custom MCP server is essentially a self-hosted integration middleware. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for LLMs to discover tools, implementing it against Elation Health's API requires significant operational overhead. 

If you decide to [build a custom MCP server for Elation Health](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), you own the entire integration lifecycle. Here are the specific integration challenges that make Elation Health a difficult API to map to static MCP schemas:

### Relational Complexity in Clinical Workflows
Unlike generic SaaS APIs where resources operate independently, Elation Health enforces strict relational constraints. You cannot simply "create a bill." A bill (`/api/2.0/bills/`) requires an array of CPT codes, a `patient` ID, a `physician` ID, a `practice` ID, and usually a signed `visit_note` ID. If an LLM attempts to generate a bill without first verifying the existence and signature status of the visit note, the API will reject the payload. Your MCP tools must be carefully scoped so the LLM understands it must query the patient, check the visit note, and *then* generate the bill.

### Dual Note Schemas (Legacy vs. V2)
Elation Health supports two distinct note schemas. There are legacy notes (created before the sections schema) and modern EN2.1 sections-based layout notes. The API exposes separate endpoints for these (`/api/2.0/notes/` vs `/api/2.0/notes_v1/`). If an LLM tries to update an EN2.1 note using the V1 endpoint, it throws an HTTP 400 error. The MCP server must dynamically expose the correct schemas and descriptions so the LLM knows which endpoint to call based on the note format.

### Strict Rate Limiting and Client-Side Backoff
Elation Health strictly enforces API rate limits to protect EHR stability. A critical architectural detail when using Truto as your MCP layer is that **Truto does not retry, throttle, or apply backoff on rate limit errors.** When Elation Health returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the caller (ChatGPT). 

To help you handle this, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (your LLM client or agent framework) is entirely responsible for reading these headers and implementing retry/backoff logic. Do not build an integration expecting the middle tier to absorb HTTP 429s.

## Step 1: Create the Elation Health MCP Server

To connect ChatGPT to Elation Health, we first need to generate an MCP server URL scoped to a specific authenticated Elation practice account. 

Truto dynamically derives the MCP tool definitions directly from the integration's documentation and resource schemas. This means you don't write custom JSON-RPC handlers; the tools exist because the API documentation exists.

First, authenticate the Elation Health account via the Truto dashboard (Integrated Accounts -> New Integrated Account). Once connected, you can generate the MCP server using either the UI or the API.

### Method A: Via the Truto UI
1. Navigate to the **Integrated Account** page for your Elation Health connection in the Truto dashboard.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., allow `read` and `write` methods, filter by tags like `patients` or `billing`).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3...`).

### Method B: Via the Truto API
You can programmatically generate this server for any connected practice using a single POST request. This is ideal if you are provisioning AI workspaces dynamically.

```bash
curl -X POST https://api.truto.one/integrated-account/<INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Elation Health Clinical Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["patients", "notes", "billing", "appointments"]
    }
  }'
```

The API will return a JSON object containing the secure `url`. This single URL handles all routing, schema translation, and authentication for ChatGPT. Treat it like a production secret.

## Step 2: Connect the MCP Server to ChatGPT

Now that you have your Truto MCP URL, you need to register it with your LLM client. We will cover both the ChatGPT UI method and the manual configuration file method.

### Method A: Via the ChatGPT UI
*(Note: Custom connectors require a ChatGPT Pro, Plus, Business, Enterprise, or Education account with Developer Mode enabled).* 

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** on.
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. **Name:** Enter a descriptive name (e.g., "Elation Health Automation").
5. **Server URL:** Paste the `https://api.truto.one/mcp/...` URL generated in Step 1.
6. Click **Save**. ChatGPT will immediately ping the endpoint, execute the handshake, and load the Elation Health tools.

*(If you are configuring this for Claude Desktop instead, the path is: Settings -> Integrations -> Add MCP Server -> Paste URL -> Add).* 

### Method B: Via Manual Config File
If you are using an agentic framework or a local MCP client (like Claude Desktop via config or a custom LangChain setup), you can configure the server manually using the standard SSE transport command.

Add the following to your `mcp_config.json` (or `claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "elation_health": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<YOUR_TRUTO_MCP_TOKEN>"
      ]
    }
  }
}
```

Restart your client. The agent will read the config, establish the Server-Sent Events (SSE) connection, and pull the tool schemas.

## Elation Health Hero Tools for ChatGPT

When ChatGPT connects to the Truto MCP server, it inherits a massive inventory of proxy tools. Instead of exposing everything, you should use Truto's method and tag filtering to restrict the LLM to high-leverage operations. Here are the core "hero tools" that unlock the most value for clinical and administrative workflows.

### Retrieve a Patient Profile
`get_single_elation_health_patient_by_id`

This tool fetches the core demographics, primary physician data, and metadata for a specific patient. It is the mandatory first step in almost any workflow, as downstream endpoints (like notes and bills) require a validated `patient_id`.

> "Find the patient record for ID 554321 and summarize their primary care physician assignment and demographic details."

### Create a Clinical Visit Note
`create_a_elation_health_visit_note`

Generates a new visit note in Elation. The LLM must supply the `patient`, `physician`, `chart_date`, and the actual note `bullets`. Because Truto automatically injects required schema definitions, ChatGPT knows exactly how to format the nested bullet objects.

> "Create a new visit note for patient 554321 with today's date. The chief complaint is a mild tension headache. Add an assessment bullet noting no neurological deficits, and a plan bullet recommending over-the-counter ibuprofen."

### Generate a Patient Bill
`create_a_elation_health_bill`

Creates and stores a bill in Elation Health, ready for downstream Practice Management System (PMS) consumption. This requires the LLM to provide `cpts` (billing codes), `patient`, `physician`, `practice`, and optionally the `visit_note` ID. 

> "Draft a bill for patient 554321 for today's visit. Attach CPT code 99213 to the bill. Assign it to physician ID 887 and practice ID 102."

### Schedule an Appointment
`create_a_elation_health_appointment`

Books a new appointment. The LLM must navigate date formatting requirements and supply the correct provider and practice references. 

> "Book a follow-up appointment for patient 554321 on November 15th at 10:00 AM with Dr. Smith (physician ID 887) at the main clinic (practice ID 102)."

### Add a Clinical Problem
`create_a_elation_health_problem`

Adds a diagnosis or clinical problem to the patient's record. The LLM must supply the `description`, a valid `dx` (diagnosis code data), the `patient` ID, and the `status` (e.g., active or resolved).

> "Add 'Essential Hypertension' to the problem list for patient 554321. Mark the status as active and set the start date to today."

### List Upcoming Appointments
`list_all_elation_health_appointments`

Fetches a paginated list of appointments. Because Truto standardizes the cursor-based pagination, ChatGPT is explicitly instructed by the generated tool description to pass the `next_cursor` back unchanged if it needs to read beyond the first 100 results.

> "List all appointments scheduled for tomorrow at practice ID 102. If there are more than 100, paginate through the results and give me a complete summary."

To view the complete inventory of available proxy tools, including endpoints for lab orders, medications, allergies, and care gaps, check out the [Elation Health integration page](https://truto.one/integrations/detail/elationhealth).

## Workflows in Action

Connecting tools to an LLM is only useful if the agent can chain them together to solve real business problems. Here are two concrete, multi-step workflows ChatGPT can execute autonomously using the Elation Health MCP server.

### Workflow 1: Post-Visit Documentation & Billing

**Persona:** Clinical Scribe / Medical Assistant

> "Patient ID 88912 came in for a routine checkup today. Everything was normal. Create a visit note documenting a healthy exam. Then, add a resolved problem for 'seasonal allergies' to their chart. Finally, create a bill for this encounter using CPT code 99214 and release it to the PMS."

**Execution Steps:**
1. ChatGPT calls `create_a_elation_health_visit_note` to draft the clinical note, passing the `patient`, `physician`, and examination bullets.
2. The agent extracts the generated `visit_note` ID from the response.
3. ChatGPT calls `create_a_elation_health_problem` to add "seasonal allergies" with a `status` of "resolved".
4. ChatGPT calls `create_a_elation_health_bill`, passing the `patient`, `cpts` (99214), and the `visit_note` ID.
5. Finally, the agent calls `elation_health_bills_release_to_pms` using the newly generated bill ID to push it to the external billing system.

**Result:** The LLM successfully documents the visit, updates the patient's medical history, and orchestrates the revenue cycle - all in one conversational prompt.

```mermaid
sequenceDiagram
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant Elation as Elation Health API

    ChatGPT->>TrutoMCP: call(create_a_elation_health_visit_note)
    TrutoMCP->>Elation: POST /api/2.0/visit_notes/
    Elation-->>TrutoMCP: 201 Created (Note ID: 443)
    TrutoMCP-->>ChatGPT: Tool Result
    
    ChatGPT->>TrutoMCP: call(create_a_elation_health_problem)
    TrutoMCP->>Elation: POST /api/2.0/problems/
    Elation-->>TrutoMCP: 201 Created
    TrutoMCP-->>ChatGPT: Tool Result
    
    ChatGPT->>TrutoMCP: call(create_a_elation_health_bill)
    TrutoMCP->>Elation: POST /api/2.0/bills/
    Elation-->>TrutoMCP: 201 Created (Bill ID: 992)
    TrutoMCP-->>ChatGPT: Tool Result
```

### Workflow 2: Morning Patient Briefing

**Persona:** Primary Care Physician

> "Look up all my appointments for today. For the first two patients on the schedule, retrieve their profiles and list any active drug intolerances or allergies they have so I'm prepared for the visits."

**Execution Steps:**
1. ChatGPT calls `list_all_elation_health_appointments`, filtering by today's date and the physician's ID.
2. The agent extracts the `patient` IDs for the first two appointments in the array.
3. For Patient A, the agent calls `get_single_elation_health_patient_by_id` to get baseline context, followed by `list_all_elation_health_allergies` and `list_all_elation_health_drug_intolerances`.
4. The agent repeats step 3 for Patient B.
5. ChatGPT synthesizes the JSON responses into a clean, readable briefing.

**Result:** The physician receives a targeted, human-readable summary of critical safety data for their upcoming appointments without ever clicking through the EHR interface.

## Security and Access Control

Giving an AI agent access to sensitive Electronic Health Records requires strict governance. Truto's MCP servers provide granular access controls natively:

*   **Method Filtering:** Configure `config.methods: ["read"]` to ensure the MCP server only exposes `GET` and `LIST` tools. This creates a strictly read-only AI agent, preventing accidental data modification.
*   **Tag Filtering:** Use `config.tags: ["appointments", "patients"]` to restrict the agent's scope. If you don't want the agent touching billing or prescriptions, simply exclude those tags during server creation.
*   **API Token Authentication:** By default, anyone with the Truto MCP URL can connect. To secure it, set `config.require_api_token_auth: true`. The client must then pass a valid Truto API token in the `Authorization` header, adding a critical second layer of identity verification.
*   **Expiration (`expires_at`):** You can set a precise ISO datetime for the MCP server to self-destruct. This is perfect for granting temporary agent access to a contractor or auditor (e.g., "access revokes on Friday at 5 PM").

## Simplify Healthcare Integrations with Truto

Building a custom MCP server for an EHR like Elation Health requires deep knowledge of clinical data models, pagination state management, and rate limit orchestration. 

With Truto, you bypass the infrastructure build entirely. Truto automatically generates the tools, handles the JSON-RPC lifecycle, normalizes the rate-limit headers for your client, and enforces granular security controls - all through a single API endpoint. 

Whether you are building an AI scribe, an automated billing agent, or a clinical intelligence dashboard, Truto provides the fastest path to production.

> Ready to connect your AI agents to Elation Health? Let Truto manage the infrastructure so you can focus on building intelligent clinical workflows.
>
> [Talk to us](https://truto.one/book-a-demo/)