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. 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 URL. If your team uses OpenAI, check out our guide on connecting Whereby to ChatGPT or explore our broader architectural overview on connecting Whereby to AI Agents.

Giving a Large Language Model (LLM) read and write access 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:

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:

{
  "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.

{
  "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.

Workflows in Action

Exposing individual tools to Claude is useful, but the real power of MCP comes from chaining these tools together 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.

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.

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. 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.

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.