---
title: "Connect Whereby to Claude: Automate Summaries, Recordings & Themes"
slug: connect-whereby-to-claude-automate-summaries-recordings-themes
date: 2026-07-08
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Whereby to Claude using a managed MCP server. Automate meeting summaries, manage video recordings, and control room themes with AI."
tldr: "A complete engineering guide to connecting Whereby to Claude using a Truto MCP server. Learn how to bypass complex Whereby API quirks like asynchronous background jobs and transient room lifecycles to automate meeting creation, transcription generation, and bulk recording management via natural language."
canonical: https://truto.one/blog/connect-whereby-to-claude-automate-summaries-recordings-themes/
---

# Connect Whereby to Claude: Automate Summaries, Recordings & Themes


If you need to connect Whereby to Claude to automate meeting creation, transcription analysis, room branding, or usage reporting, 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 tool calls and Whereby's REST APIs. You can either build and maintain this complex infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) URL. If your team uses OpenAI, check out our guide on [connecting Whereby to ChatGPT](https://truto.one/connect-whereby-to-chatgpt-control-meetings-analytics-transcripts/) or explore our broader architectural overview on [connecting Whereby to AI Agents](https://truto.one/connect-whereby-to-ai-agents-track-meeting-metrics-participant-data/).

Giving a Large Language Model (LLM) [read and write access](https://truto.one/how-to-safely-give-an-ai-agent-access-to-third-party-saas-data/) to a video conferencing platform like Whereby is an engineering challenge. You have to map highly specific schemas to MCP tool definitions, deal with asynchronous background jobs, and properly handle rate limiting. Every time Whereby updates an endpoint or deprecates a field, 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 Whereby, connect it natively to Claude, and execute complex workflows using natural language.

## The Engineering Reality of the Whereby 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 using JSON-RPC 2.0, the reality of implementing it against vendor APIs is painful. You are not just integrating a generic database - you are interacting with WebRTC infrastructure, video processing pipelines, and deeply nested insight analytics.

If you decide to build a custom MCP server for Whereby, you own the entire API lifecycle. Here are the specific challenges you will face:

**Asynchronous Background Jobs for Media Processing**
Whereby does not return video summaries or transcriptions synchronously. Video and audio files are massive. When you request a transcription via the API, Whereby simply returns a `201 Created` or `204 No Content` indicating that a background job has been scheduled. If you build a custom MCP server, you have to explicitly teach the LLM that it will not get the transcription text back immediately. It has to trigger the job, wait, and then use a separate tool to poll for the result. Truto handles the schema translation so Claude understands exactly what inputs are required and what empty success responses mean.

**Transient Access Links**
Video recordings and transcriptions in Whereby are heavily protected. You cannot just retrieve a static URL to a video file. To give an LLM or an end-user access to a recording, you have to call specific endpoints to generate temporary `accessLink` URLs that expire (defaulting to 3,600 seconds). Managing the lifecycle of these links within a custom integration requires strict state tracking.

**Whereby Rate Limits and Backoff**
Whereby enforces API quotas to protect their infrastructure. If your AI agent loops excessively while trying to fetch paginated session insights for hundreds of participants, Whereby will reject the requests with an HTTP 429 status code. 

It is critical to note: **Truto does not retry, throttle, or apply automatic backoff on rate limit errors.** When the upstream Whereby API returns an HTTP 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. This means your MCP client or agent framework receives a predictable error format and is responsible for implementing its own intelligent retry and backoff logic.

Instead of building this infrastructure from scratch, you can use Truto. Truto derives tool definitions dynamically from the Whereby integration's resources and documentation, exposing them as ready-to-use MCP tools.

## How to Generate a Whereby MCP Server with Truto

Truto creates MCP servers scoped to a single integrated account. This means the server URL contains a cryptographically signed token that authenticates requests for that specific Whereby tenant. You do not need to configure API keys on the client side - the URL itself provides secure, scoped access.

There are two ways to generate this MCP server: via the Truto UI, or programmatically via the API.

### Method 1: Via the Truto UI

If you are an IT admin or developer setting up an agent manually, the UI is the fastest route:

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select the connected Whereby account you want to expose to Claude.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., give it a name, restrict it to `read` methods only, or set an expiration date).
6. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers for your users dynamically, you can use the Truto API. The API validates that the Whereby integration is AI-ready, hashes a secure token into distributed key-value storage, and returns a ready-to-use URL.

Make a `POST` request to `/integrated-account/:id/mcp`:

```bash
curl -X POST https://api.truto.one/integrated-account/<whereby_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Whereby AI Agent Server",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The response will contain the secure URL you need to pass to Claude:

```json
{
  "id": "mcp_8f7e6d5c4b3a",
  "name": "Whereby AI Agent Server",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, you need to connect it to your Claude environment. Because Truto's MCP servers communicate over HTTP using Server-Sent Events (SSE) for JSON-RPC 2.0 messages, connecting is incredibly straightforward.

### Method A: Via the Claude UI (Desktop or Web)

Anthropic natively supports adding remote MCP servers directly through the user interface.

1. Copy the MCP server URL you generated from Truto.
2. In Claude, navigate to **Settings -> Integrations -> Add MCP Server** (Note: Depending on your tier and interface, this may be under **Settings -> Connectors -> Add custom connector**).
3. Paste the Truto MCP URL and click **Add**.

Claude will immediately perform an initialization handshake, discovering all the available Whereby tools automatically.

### Method B: Via Manual Config File

If you are configuring Claude Desktop manually for local development, you can add the Truto MCP server to your `claude_desktop_config.json` file. You will use the standard `@modelcontextprotocol/server-sse` package to handle the transport.

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

Restart Claude Desktop. The application will connect to the Truto URL and populate the Whereby tools.

## Hero Tools for Whereby Automation

When Claude connects to the Truto MCP server, it dynamically loads the Whereby tools derived from the integration's schemas. Here are 6 high-leverage "hero tools" your AI agent can use to orchestrate video infrastructure.

### Create a Whereby Meeting

**Tool:** `create_a_whereby_meeting`

This tool allows Claude to spin up a new transient meeting room in Whereby. The API requires an `endDate` payload to define when the room expires. This is perfect for agents booking client calls or support sessions on the fly.

> "I need to schedule an urgent support call for a customer. Create a Whereby meeting that ends exactly two hours from now and give me the room URL."

### Generate a Meeting Summary

**Tool:** `create_a_whereby_summary`

Whereby's AI capabilities can generate summaries of transcriptions. This tool schedules an asynchronous background job to create a summary for a specific transcription ID. Because it triggers a background process, the agent receives a 201 response and must subsequently poll for the results.

> "Trigger a summary generation job for transcription ID tr_88721. Let me know when the request is successfully scheduled."

### Pull Room Session Insights

**Tool:** `list_all_whereby_insight_room_sessions`

This tool extracts session-level telemetry from Whereby's insights engine. It returns data points like `totalParticipantMinutes`, `totalUniqueParticipants`, and `rating` for a specific room name.

> "Pull the session insights for the room 'weekly-engineering-sync'. I need to know how many unique participants joined the last session and the total participant minutes."

### Retrieve Recording Access Links

**Tool:** `list_all_whereby_recording_access_links`

Because Whereby recordings are not public, this tool generates a temporary, secure `accessLink` for a specific `recordingId`. The link expires after a set period, making it safe for the agent to retrieve and pass to a user without permanently exposing the file.

> "Get me a temporary download link for recording ID rec_99812 so I can email it to the marketing team."

### Update Room Theme and Branding

**Tool:** `update_a_whereby_room_theme_token_by_id`

This tool allows Claude to dynamically alter the primary, secondary, and focus colors of a specific room. By supplying custom color values via `tokens.colors`, you can completely brand a room programmatically before a client joins.

> "Update the theme tokens for the room 'enterprise-demo-01'. Set the primary color to our brand hex #0055FF and ensure the tokens are applied immediately."

### Bulk Delete Old Recordings

**Tool:** `whereby_recordings_bulk_delete`

Video files consume massive amounts of storage. This tool accepts an array of `recordingIds` and schedules an asynchronous background job to permanently delete them. The endpoint is idempotent.

> "Schedule a bulk deletion job for the following three recording IDs: rec_111, rec_222, and rec_333. Confirm once the API returns a 204 success code."

To view the complete inventory of available Whereby tools, including transcription management, participant level metrics, and logo uploads, visit the [Whereby integration page](https://truto.one/integrations/detail/whereby).

## Workflows in Action

Exposing individual tools to Claude is useful, but the real power of MCP comes from [chaining these tools together](https://truto.one/handling-auth-tool-sharing-in-multi-agent-frameworks-via-mcp/) to execute complex, multi-step workflows. Because Claude receives all arguments as a single flat object, Truto's proxy routing translates these arguments into the exact query and body parameters Whereby expects.

Here are three real-world automation flows.

### Workflow 1: The Post-Meeting Automation Flow

After a major all-hands call, an operations manager wants to automatically transcribe the recording, summarize it, and distribute the notes. They prompt Claude:

> "Find the most recent recording for the room 'all-hands-q3'. Start a transcription job for it. Once that's done, create a summary, and retrieve the final summary text so I can review it."

**How Claude executes this:**

1. **`list_all_whereby_recordings`:** Claude queries the recordings, filtering by the room name to find the correct `recordingId`.
2. **`create_a_whereby_transcription`:** Claude passes the `recordingId` to trigger the transcription job.
3. **`get_single_whereby_transcription_by_id`:** Claude acts autonomously, polling this tool to check the `state` of the transcription until it shows as completed.
4. **`create_a_whereby_summary`:** Once transcribed, Claude passes the `transcriptionId` to trigger the summary generation job.
5. **`get_single_whereby_summary_by_id`:** Claude polls for the summary record, extracting the final text and presenting it to the operations manager.

```mermaid
flowchart TD
    A["Claude Agent<br>Receives Prompt"] --> B["Call: list_all_whereby_recordings"]
    B --> C["Call: create_a_whereby_transcription"]
    C --> D["Poll: get_single_whereby_transcription_by_id"]
    D --> E["Call: create_a_whereby_summary"]
    E --> F["Poll: get_single_whereby_summary_by_id"]
    F --> G["Return Summary<br>to User"]
```

### Workflow 2: Automated Room Provisioning and Branding

A sales representative is about to jump on a call with a high-value enterprise prospect and wants a custom-branded environment immediately.

> "Create a new meeting room for an enterprise pitch that ends in 3 hours. Then, update the room's theme so the primary color is #4A90E2 to match the prospect's brand."

**How Claude executes this:**

1. **`create_a_whereby_meeting`:** Claude calculates the ISO timestamp for 3 hours from the current time, passes it as the required `endDate` body parameter, and creates the room. It stores the resulting `roomName`.
2. **`update_a_whereby_room_theme_token_by_id`:** Claude takes the newly created `roomName` and passes it as a query parameter (or path identifier), while structuring the `tokens.colors` JSON payload in the body to apply the requested hex code.
3. **Result:** Claude provides the sales rep with the `roomUrl` of a fully branded, time-boxed meeting environment.

### Workflow 3: Storage Cleanup and Compliance

An IT administrator needs to enforce a strict data retention policy by purging old media files without navigating the Whereby dashboard.

> "Find all recordings in our account, identify any that were created before January 1st, and bulk delete them to comply with our retention policy."

**How Claude executes this:**

1. **`list_all_whereby_recordings`:** Claude fetches the list of recordings and examines the `startDate` metadata for each entry.
2. **Local Processing:** Claude's internal logic filters the array, isolating the `recordingIds` that fall outside the retention window.
3. **`whereby_recordings_bulk_delete`:** Claude constructs the array of `recordingIds` and sends them in the request body to the bulk delete endpoint.
4. **Result:** Claude confirms the background deletion job was successfully scheduled.

```mermaid
sequenceDiagram
    participant Agent as Claude
    participant MCP as Truto MCP
    participant API as Whereby API
    Agent->>MCP: whereby_recordings_bulk_delete(ids)
    MCP->>API: POST /recordings/bulk_delete
    API-->>MCP: 204 No Content (Job Scheduled)
    MCP-->>Agent: Success Response
```

## Security and Access Control

Giving an LLM access to your video conferencing infrastructure requires [strict governance](https://truto.one/how-to-safely-give-an-ai-agent-access-to-third-party-saas-data/). If an agent hallucinations, you do not want it bulk-deleting active meeting rooms or leaking transcriptions. Truto provides four distinct mechanisms to secure your Whereby MCP server:

*   **Method Filtering:** You can strictly limit the MCP server to specific operations. Setting `config.methods` to `["read"]` ensures the agent can only execute `get` and `list` operations (like fetching insights). It fundamentally blocks `create`, `update`, or `delete` requests at the protocol level.
*   **Tag Filtering:** Integration resources in Truto are tagged logically. By passing `config.tags = ["analytics"]` during server creation, you can expose only the insight and metric tools, completely hiding the recording and transcription tools from the LLM.
*   **Time-to-Live (TTL):** You can supply an `expires_at` ISO datetime when creating the server. Once that timestamp is reached, the distributed key-value store automatically purges the token and a background alarm cleans up the database record. The MCP server ceases to exist, making this perfect for temporary contractor access or ephemeral agent sessions.
*   **Required API Token Auth:** By default, the cryptographically signed MCP URL is all that is required to connect. For high-security environments, you can set `require_api_token_auth: true`. This adds a second middleware layer requiring the caller to pass a valid Truto API token in the Authorization header, ensuring that even if the URL leaks, it cannot be used without valid environment credentials.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} 
Ready to connect your AI agents to Whereby without wrestling with asynchronous jobs and temporary access links? Build your managed MCP server with Truto today.
:::

## Moving Beyond the Integration Bottleneck

Connecting Whereby to Claude shouldn't require weeks of engineering effort to handle media processing quirks, expiring tokens, and JSON Schema mappings. 

By leveraging a managed MCP server via Truto, you abstract away the API friction entirely. You get normalized rate limit headers, automatic schema extraction, and secure token management out of the box. This allows your engineering team to focus on what actually matters: designing intelligent AI workflows, agent prompts, and automated meeting analytics that drive real value for your users.