---
title: "Connect Coviu to Claude: Automate Bookings and Clinical Recordings"
slug: connect-coviu-to-claude-automate-bookings-and-clinical-recordings
date: 2026-06-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to build a secure MCP server to connect Coviu to Claude. Automate virtual waiting rooms, participant rostering, and clinical recording extraction."
tldr: "Connect Coviu to Claude using Truto's managed MCP server to automate telehealth operations. This guide covers bypassing complex Coviu API state machines, handling clinical recording binaries, and securing LLM access."
canonical: https://truto.one/blog/connect-coviu-to-claude-automate-bookings-and-clinical-recordings/
---

# Connect Coviu to Claude: Automate Bookings and Clinical Recordings


If you need to connect Coviu to Claude to orchestrate telehealth waiting queues, automate session rostering, or extract clinical recording files, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM tool calls and Coviu'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 OpenAI, check out our guide on [connecting Coviu to ChatGPT](https://truto.one/connect-coviu-to-chatgpt-manage-sessions-participants-and-queues/) or explore our broader architectural overview on [connecting Coviu to AI Agents](https://truto.one/connect-coviu-to-ai-agents-orchestrate-call-queues-and-submissions/).

Giving a Large Language Model (LLM) read and write access to a sensitive environment like a [clinical video platform](https://truto.one/how-to-build-hipaa-compliant-integrations-for-healthcare-saas/) is a high-stakes engineering problem. You have to handle OAuth 2.0 lifecycles, parse binary video streams into accessible metadata, enforce strict immutability rules on session state, and map complex nested JSON arrays into flat schemas that an LLM can reliably execute. Every time Coviu introduces a new webhook event or modifies a call queue state, you have to update your server code, redeploy, and test.

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

## The Engineering Reality of the Coviu API

A custom MCP server is a self-hosted API mapping layer. While the open MCP standard provides a predictable framework for models to discover tools, the reality of implementing it against Coviu's API requires dealing with deep domain-specific quirks. 

If you decide to build a custom MCP server for Coviu, you are responsible for the entire API lifecycle. Here are the specific challenges you will encounter when exposing Coviu to AI models:

**Complex Call State Lifecycles**
A Coviu waiting room call is not a static object - it is a multi-stage state machine. The `list_all_coviu_waiting_queue_calls` endpoint returns records containing timestamps for `joinedAt`, `answeredAt`, `transferredAt`, and `finishedAt`. If you expose this raw schema directly to Claude without clear descriptions, the LLM will struggle to accurately determine if a patient is actively waiting, currently in a consultation, or already discharged. Truto injects specific documentation instructions into the generated MCP schemas, guiding the LLM on exactly how to interpret these lifecycle timestamps to derive the true call state.

**Strict Participant and Session Immutability**
Coviu enforces strict business logic around session mutations. You cannot add a participant to a session that has already finished. You cannot delete a participant belonging to a session that has already started. If your LLM attempts these invalid operations, the API will fail. Truto dynamically attaches context to the tool descriptions to explicitly warn the LLM about these state dependencies, reducing hallucinated tool execution failures.

**Binary Payload Extraction**
Many integration platforms fail when tasked with extracting actual clinical recordings. Fetching submission files (`get_single_coviu_submission_file_by_id`) does not return JSON. It returns binary `video/webm` or `audio/webm` streams (often via HTTP 206 Partial Content). A standard custom MCP implementation will crash if it tries to stringify this payload into the standard JSON-RPC response format. Truto handles the pass-through proxy execution properly, ensuring the binary references are managed and the LLM receives actionable metadata rather than a crashed server context.

**Handling Rate Limits and 429s**
Coviu enforces API quotas on concurrent sessions and polling operations. When an LLM iterates through paginated historical sessions too aggressively, it will trigger an HTTP 429 error. **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream API returns a 429, Truto passes that error directly back to Claude. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller is completely responsible for executing retry and backoff logic. Your AI agent must be architected to observe these limits.

Instead of building this complex translation layer from scratch, you can use Truto. Truto derives MCP tool definitions dynamically from Coviu's resource endpoints and executes them through a stateless JSON-RPC router.

```mermaid
sequenceDiagram
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Router
    participant Proxy as Truto Proxy API
    participant Coviu as Coviu REST API
    
    Claude->>MCP: POST /mcp/TOKEN (tools/call: create_a_coviu_session)
    Note over MCP: Validates token & flattens args<br>into query/body schemas
    MCP->>Proxy: Forward normalized request
    Proxy->>Coviu: POST /sessions (with OAuth credentials)
    Coviu-->>Proxy: 201 Created (Session Data)
    Proxy-->>MCP: Normalized JSON Response
    MCP-->>Claude: JSON-RPC 2.0 tool result
```

## Step 1: Generate the Coviu MCP Server

Truto creates MCP servers scoped to a single integrated account. This means the server URL contains a cryptographic token that securely encodes the target Coviu account, the permitted tools, and the expiration time. You do not need to configure OAuth parameters in Claude - the URL handles authentication seamlessly.

You can generate the MCP server through the Truto user interface or programmatically via the API.

### Method A: Via the Truto UI

1. Navigate to the **Integrated Accounts** page for your connected Coviu instance in the Truto dashboard.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server name, select any specific method subsets (e.g., restricting access to only `read` operations), and set an optional expiration date.
5. Copy the generated secure MCP server URL.

### Method B: Via the API

If you are provisioning MCP environments for your end-users dynamically, you can use the Truto API to generate the server. The API securely stores the token in distributed KV storage and returns a ready-to-use URL.

**Request:**
```bash
curl -X POST https://api.truto.one/integrated-account/<COVIU_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer <TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Coviu Telehealth Ops",
    "config": {
      "methods": ["read", "write", "list"],
      "tags": ["clinical", "scheduling"]
    }
  }'
```

**Response:**
```json
{
  "id": "mcp-token-xyz-123",
  "name": "Coviu Telehealth Ops",
  "config": {
    "methods": ["read", "write", "list"],
    "tags": ["clinical", "scheduling"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abc123def456..."
}
```

## Step 2: Connect Coviu to Claude

Because Truto exposes the integration natively over HTTP via JSON-RPC 2.0 (using the Server-Sent Events / SSE transport standard supported by the MCP specification), connecting Claude requires zero additional backend code.

### Method A: Via the Claude UI

If you are using Claude's web interface or enterprise admin console that supports UI-based custom connectors:

1. Open **Settings** -> **Integrations** (or **Connectors**).
2. Select **Add MCP Server**.
3. Paste the Truto MCP URL generated in Step 1.
4. Click **Add**. Claude will instantly execute a `tools/list` handshake and discover the Coviu API operations.

### Method B: Via the Configuration File

If you are using Claude Desktop locally or configuring an automated agent infrastructure, you need to map the server in your MCP configuration file (`claude_desktop_config.json`). 

You will use the official `@modelcontextprotocol/server-sse` runner to transport the local Claude requests over HTTP to the remote Truto server.

```json
{
  "mcpServers": {
    "coviu-telehealth-ops": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_TRUTO_TOKEN_HERE"
      ]
    }
  }
}
```
Restart Claude Desktop. The application will initialize the connection, verifying capabilities and dynamically loading the Coviu tools into the context window.

## Coviu Hero Tools for Claude

Truto automatically generates tool definitions by deriving them from the integration's documented `Resources` and `Methods`. Out of dozens of available operations, here are six high-leverage "hero tools" to automate your Coviu clinical workflows.

### `list_all_coviu_waiting_queue_calls`
Retrieves the live state of the virtual waiting room for a specific Coviu queue. This tool returns the critical timestamps (`joinedAt`, `answeredAt`, `finishedAt`) required to track patient flow, enabling the LLM to triage active patients versus completed consultations.

> "Claude, pull the current waiting room queue for team ID 8901. Tell me how many patients have been waiting for more than 15 minutes without an answeredAt timestamp."

### `create_a_coviu_session`
Provisions a new discrete Coviu telehealth session. The tool requires `session_name`, `start_time`, and `end_time`, and can optionally configure advanced UI parameters via `feature_flags` (such as `disable-menu` or `return-url`).

> "Schedule a new 45-minute multi-disciplinary review session named 'Oncology Board Review' starting tomorrow at 10 AM. Ensure the menu is disabled for external participants."

### `list_all_coviu_participants`
Fetches the complete roster of participants for a given session. Crucial for auditing who has been invited, determining their roles (host vs guest), and retrieving their unique entry URLs for distribution.

> "List all participants currently rostered for the 'Oncology Board Review' session (session ID 4455). Give me the entry URL for Dr. Smith so I can email it to her."

### `create_a_coviu_participant`
Adds a new participant to an existing session. The LLM must supply the `session_id` and the user's `display_name`. Note: The API enforces state immutability, meaning the LLM cannot execute this tool if the session has already been marked finished.

> "Add 'John Doe - Interpreter' to session 4455. Generate his secure entry link and draft a brief email inviting him to join the consultation."

### `list_all_coviu_submissions`
Retrieves the metadata for data collections and file submissions tied to a team and collection ID. This includes the `created_at` timestamp and array of associated files generated during a telehealth session.

> "Fetch all file submissions for the secure collection 9922 over the last 7 days. Summarize the number of files generated per session."

### `get_single_coviu_submission_file_by_id`
Retrieves the specific binary recording file (audio or video stream) for a clinical submission. The agent can use this reference to pipe the recording into transcription or clinical NLP analysis services downstream.

> "Get the binary video recording file for submission ID 505 and file ID 77. Extract the payload reference so we can send it to AssemblyAI for transcription."

To view the complete inventory of available Coviu operations, query schemas, and object definitions, visit the [Coviu integration page](https://truto.one/integrations/detail/coviu).

## Workflows in Action

Exposing an MCP server to Claude transforms static API endpoints into dynamic, multi-step orchestration workflows. Here are three practical scenarios illustrating how the agent executes tools in sequence.

### 1. Managing the Virtual Waiting Room
In high-volume telehealth clinics, triage nurses spend massive amounts of time monitoring screens. You can instruct Claude to act as a virtual waiting room monitor.

> "Review the Coviu waiting queue for Team 404. Find any patients who have joined but have not been answered yet. If anyone has been waiting longer than 10 minutes, format an alert summary."

1. Claude calls `list_all_coviu_waiting_queue_calls` passing `team_id: "404"` and `waiting_queue_id: "primary"`.
2. The model analyzes the JSON array, calculating the delta between the current time and the `joinedAt` timestamp for records where `answeredAt` is null.
3. Claude outputs a prioritized triage table indicating exactly which `callId` needs immediate attention.

### 2. Automating Telehealth Bookings and Rostering
Administrators often need to spin up ad-hoc consultation rooms and distribute links to external specialists.

> "Create a new session for 'Emergency Cardiology Consult' starting in 15 minutes and lasting for 1 hour. Once created, add 'Dr. Evans (Cardiologist)' and 'Sarah Connor (Patient)' as participants. Give me their direct entry URLs."

1. Claude calls `create_a_coviu_session` with the calculated ISO-8601 timestamps and session name.
2. It parses the returned `session_id`.
3. Claude calls `create_a_coviu_participant` for "Dr. Evans" using the newly acquired `session_id`.
4. Claude calls `create_a_coviu_participant` again for "Sarah Connor".
5. The model formats the final output, providing the discrete `entry_url` for each party so the administrator can distribute them immediately.

### 3. Extracting and Analyzing Clinical Recordings
Post-consultation operations require extracting clinical artifacts for compliance, transcription, or EMR ingestion.

> "Find the session summary for session ID 8810. Then look up its associated collection submissions. If there is a video recording attached, fetch the recording file reference."

1. Claude calls `get_single_coviu_session_summary_by_id` to verify the session details and `actual_end_time`.
2. Claude calls `list_all_coviu_submissions` filtering by the appropriate date range or session context.
3. Upon locating the target submission, Claude calls `get_single_coviu_submission_by_id` to inspect the nested files array.
4. Finally, it invokes `get_single_coviu_submission_file_by_id` to retrieve the stream reference for the actual `video/webm` file.

```mermaid
flowchart TD
    A["Claude Prompt:<br>Fetch recording for session 8810"] --> B["get_single_coviu_session_summary_by_id"]
    B --> C{"Session Completed?"}
    C -->|Yes| D["list_all_coviu_submissions"]
    C -->|No| E["Return status:<br>Consultation still active"]
    D --> F["get_single_coviu_submission_by_id"]
    F --> G["get_single_coviu_submission_file_by_id<br>(Fetch binary reference)"]
```

## Security and Access Control

Connecting an autonomous AI to a clinical platform requires [strict governance](https://truto.one/the-2026-saas-hipaa-implementation-playbook-templates-for-integrations/). Truto MCP servers support highly granular access controls embedded directly into the cryptographic token URL:

* **Method Filtering:** Use `config.methods` to enforce read-only execution. Setting this to `["read"]` ensures the server will only generate tools for `get` and `list` operations, physically blocking the LLM from executing a `create` or `delete` action.
* **Tag Filtering:** Coviu resources can be tagged in the Truto integration config. You can restrict a server using `config.tags` (e.g., `["scheduling"]`) to only expose session-related tools, hiding clinical recording and submission tools entirely.
* **Time-to-Live (TTL):** Set an `expires_at` ISO datetime when generating the server. Once expired, the underlying KV storage automatically purges the token, and the URL will instantly return a 401 Unauthorized error.
* **Require API Token Auth:** For high-security environments, setting `require_api_token_auth: true` means possession of the URL is not enough. The MCP client must also pass a valid Truto API token in the `Authorization` header, enforcing a dual-layer identity check before tools are executed.

## Automate Telehealth at Scale

Building custom API translation layers for LLMs is expensive, fragile, and inherently risky when dealing with sensitive clinical states. By leveraging a managed MCP server, you eliminate the boilerplate of OAuth lifecycles, cursor pagination, and schema mapping. Truto dynamically interprets Coviu's API definitions, rendering them as reliable, tightly-scoped tools that Claude can execute securely.

Stop writing custom integration code to parse waiting room logic. Connect your clinical platforms natively and let your AI orchestrate the workflows.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"}  
Ready to automate your telehealth and clinical operations with Claude? Talk to our engineering team to architect your [zero-data-retention AI infrastructure](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/).
:::