---
title: "Connect Whereby to ChatGPT: Control Meetings, Analytics & Transcripts"
slug: connect-whereby-to-chatgpt-control-meetings-analytics-transcripts
date: 2026-07-08
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Whereby to ChatGPT using Truto's managed MCP server. Execute meeting generation, async media pipelines, and insight aggregation directly from your AI agent."
tldr: "Connect Whereby to ChatGPT using an MCP server to manage transient meeting rooms, extract real-time participant network diagnostics, and orchestrate asynchronous transcription and summary jobs."
canonical: https://truto.one/blog/connect-whereby-to-chatgpt-control-meetings-analytics-transcripts/
---

# Connect Whereby to ChatGPT: Control Meetings, Analytics & Transcripts


If you are trying to give an AI agent control over your video conferencing infrastructure, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). If your team uses Claude, check out our guide on [connecting Whereby to Claude](https://truto.one/connect-whereby-to-claude-automate-summaries-recordings-themes/), 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/). Here, we will break down exactly how to connect Whereby to ChatGPT.

Providing a Large Language Model (LLM) with read and write access to Whereby requires more than just mapping standard CRUD operations. Video infrastructure APIs are highly stateful, rely heavily on asynchronous background jobs, and expose complex, nested network diagnostics. You can either spend engineering cycles building, hosting, and maintaining a custom MCP server to handle this, or use a managed infrastructure layer to dynamically generate a secure, authenticated MCP server URL.

This guide outlines the engineering reality of the Whereby API and provides a step-by-step tutorial for using Truto to generate a secure, managed MCP server for Whereby, connect it natively to ChatGPT, and execute complex video workflows using natural language.

## The Engineering Reality of the Whereby API

A custom MCP server is a self-hosted integration layer that translates an LLM's [tool calls](https://truto.one/what-is-llm-function-calling-for-integrations-2026-guide/) into REST API requests. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Whereby is complex. If you build a custom MCP server for Whereby, your engineering team assumes ownership of the entire API lifecycle.

Here are the specific integration challenges you must solve when orchestrating Whereby from an AI agent:

### Transient Rooms and Endpoint Lifecycles
Unlike traditional entities in a CRM or ATS, video rooms in Whereby are predominantly transient. When you instruct an LLM to "create a meeting", the API requires an `endDate`. If your MCP tool schema does not strictly enforce this requirement, the LLM will hallucinate arguments and the API will reject the request. Furthermore, host and viewer URLs (`hostRoomUrl` and `viewerRoomUrl`) are not returned by default - your tool logic must explicitly request them via the `fields` parameter during room creation.

### Asynchronous Media Pipelines
Extracting insights from a meeting is not a simple synchronous GET request. The processes to generate recordings, transcriptions, and summaries are computationally heavy and execute asynchronously. When an agent calls the transcription endpoint, Whereby schedules a background job and returns a `201 Created` response. Your agent cannot immediately download the transcript. The LLM must be instructed to poll or subsequently call a list endpoint to verify the job status before calling a secondary endpoint to fetch a temporary access link. 

### Deeply Nested Network Diagnostics
Whereby provides highly granular room insights, but the data model is hierarchical: Rooms -> Sessions -> Participants. If an AI agent needs to diagnose why a user had a poor meeting experience, it cannot just query the user. It must list the sessions for a room, extract the session ID, query the participants for that session to find the specific user, and finally query the individual participant endpoint to extract packet loss and bandwidth metrics. 

### Strict Rate Limits and Pass-Through Errors
Whereby enforces strict rate limits on API consumption. If your agent enters an aggressive polling loop waiting for a transcription to finish, it will hit an HTTP 429 Too Many Requests error. 

It is critical to understand how Truto handles this: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream Whereby API returns a 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standard headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) according to the IETF specification. Your LLM orchestration framework is entirely responsible for reading these headers and executing a backoff strategy. 

## How to Create the Whereby MCP Server

Truto dynamically generates MCP tools based on the integration's documented resources and methods. Tools are never cached or pre-built. During tool execution, query and body parameters share a flat input namespace, and the MCP router automatically maps the LLM's arguments to the correct API payload based on the internal JSON schema.

You can generate an MCP server for Whereby using either the Truto UI or the API.

### Method 1: Via the Truto UI

For teams who want a visual configuration process:

1. Navigate to the integrated account page for your Whereby connection in the Truto dashboard.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (name, method filters, tag filters, and expiration).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the API

For automated deployments and programmatic agent orchestration, you can create the server via a POST request. The API validates the configuration, generates a secure token hashed via HMAC, stores it in Cloudflare KV, and returns the endpoint URL.

```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": "Whereby Audio Analytics Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["recordings", "transcriptions", "insights"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The response contains the secure URL the LLM client needs to connect:

```json
{
  "id": "mcp_8a9b0c1d",
  "name": "Whereby Audio Analytics Agent",
  "config": { "methods": ["read", "write"], "tags": ["recordings", "transcriptions", "insights"] },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you must register it with your ChatGPT environment. The MCP server is fully self-contained - the cryptographic token in the URL encodes the integrated account and configuration, meaning no additional authentication setup is required in the client unless explicitly configured.

### Method A: Via the ChatGPT UI

To connect the server directly to the ChatGPT desktop or web application:

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support requires this flag to be active).
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. **Name:** Enter a descriptive label (e.g., "Whereby Operations").
5. **Server URL:** Paste the Truto MCP URL obtained in the previous step.
6. Click **Save**.

ChatGPT will immediately ping the endpoint, execute the initialization handshake, and list the available Whereby tools.

### Method B: Via Manual Config File (Local Agents)

If you are using a custom desktop client, Cursor, or a local agent framework that utilizes JSON configuration files for MCP, you can wrap the Truto URL in a Server-Sent Events (SSE) transport adapter.

Add the following configuration to your MCP settings file (e.g., `mcp_config.json` or `claude_desktop_config.json`):

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

## Hero Tools for Whereby

Truto maps Whereby's API endpoints to highly descriptive, snake_case tools. Below are the highest-leverage tools available for AI agents operating on Whereby video infrastructure.

### 1. create_a_whereby_meeting

Creates a new transient meeting room. This tool is essential for on-demand scheduling. The agent must provide an `endDate`. It is recommended to instruct the LLM to request host and viewer URLs if it needs to distribute access links.

> "Schedule a new 45-minute Whereby meeting starting now. Make sure to generate and return both the host room URL and the viewer room URL so I can send them to the prospect."

### 2. list_all_whereby_insight_rooms

Retrieves high-level analytical summaries for Whereby rooms. This returns aggregated metrics including total participant minutes, total unique participants, and average room ratings. Useful for macro-level usage reporting.

> "Pull the insight summaries for all Whereby rooms used this week and list the top three rooms ordered by total participant minutes."

### 3. get_single_whereby_insight_participant_by_id

Fetches highly detailed, low-level network diagnostics for a specific participant within a specific session. This tool exposes user agent strings, connection timestamps, and time-series arrays for packet loss and bandwidth metrics.

> "Fetch the detailed network diagnostic data for participant ID 'pt-9012' in session 'sess-3456'. Analyze the samples array to see if they experienced packet loss greater than 5% during the call."

### 4. create_a_whereby_transcription

Initiates the asynchronous transcription pipeline for an existing recording. The operation is idempotent and returns a 201 status immediately while the background job executes.

> "Trigger a transcription job for recording ID 'rec-7788'. Confirm when the job has been successfully scheduled."

### 5. list_all_whereby_transcription_access_links

Generates a temporary, secure download link for a completed transcription. The link typically expires after one hour (3600 seconds) by default, though it can be configured for up to 43,200 seconds.

> "Get the secure access link for transcription ID 'tx-1122'. Return the raw URL so I can pass it to the document parser."

### 6. create_a_whereby_summary

Schedules a background job to generate an AI summary of a completed transcription. This relies on Whereby's internal models to process the text payload.

> "Now that transcription 'tx-1122' is complete, schedule a summary generation job for it. Let me know when the request succeeds."

### 7. update_a_whereby_room_theme_token_by_id

Sets the primary, secondary, and focus room theme colors for a specific room. The agent maps custom hexadecimal color values into the `tokens.colors` payload.

> "Update the room theme for 'sales-demo-alpha'. Set the primary brand color to '#FF5733' and the secondary color to '#1A1A1A'."

For the complete list of Whereby tools and comprehensive JSON schema definitions, visit the [Whereby integration page](https://truto.one/integrations/detail/whereby).

## Workflows in Action

An MCP server turns individual tool executions into orchestrated workflows. Here is how different personas leverage an AI agent connected to Whereby.

### Sales Engineering: Automated Demo Provisioning

Sales engineers often need isolated, branded demo environments for high-value prospects. Instead of manually configuring rooms, they can ask the agent to provision everything.

> "Spin up a new Whereby demo room for the Acme Corp presentation tomorrow at 2 PM EST. Set the room expiration for 4 PM EST. Once created, update the room theme tokens to use Acme's brand colors: primary #0052CC and secondary #172B4D. Return the host link for me and the viewer link to send to the client."

**Execution flow:**
1. `create_a_whereby_meeting` (Creates the transient room and extracts the `roomName`).
2. `update_a_whereby_room_theme_token_by_id` (Injects the hex codes into the newly created room).
3. Agent returns the formatted host and viewer URLs to the user.

### IT Operations: Network Diagnostic Triage

When executives complain about lag during an all-hands call, IT support needs to isolate the root cause immediately without logging into multiple dashboards.

> "The CEO reported severe audio lag during the all-hands meeting in the 'leadership-sync' room this morning. Pull the session logs for that room, find the CEO's participant record, and check their detailed network diagnostics for high packet loss."

**Execution flow:**
1. `list_all_whereby_insight_room_sessions` (Finds the latest session ID for 'leadership-sync').
2. `list_all_whereby_insight_participants` (Filters participants by the CEO's external ID or display name to extract the `participantId`).
3. `get_single_whereby_insight_participant_by_id` (Retrieves the time-series samples and analyzes the packet loss percentage).
4. Agent generates a natural language summary of the network degradation timeline.

### Revenue Operations: Post-Call Intelligence Extraction

To ensure CRM hygiene, RevOps relies on meeting transcriptions. Because processing is asynchronous, the agent must orchestrate a multi-step background process.

```mermaid
sequenceDiagram
    participant Agent as ChatGPT Agent
    participant Truto as Truto MCP Router
    participant Whereby as Whereby API

    Agent->>Truto: call create_a_whereby_transcription
    Truto->>Whereby: POST /recordings/{id}/transcriptions
    Whereby-->>Truto: 201 Created
    Truto-->>Agent: Job scheduled successfully
    Note over Agent, Whereby: Agent waits or polls status
    Agent->>Truto: call list_all_whereby_transcriptions
    Truto->>Whereby: GET /transcriptions
    Whereby-->>Truto: List of transcript metadata
    Truto-->>Agent: Status: "completed"
    Agent->>Truto: call list_all_whereby_transcription_access_links
    Truto->>Whereby: GET /transcriptions/{id}/access_link
    Whereby-->>Truto: { "accessLink": "https://..." }
    Truto-->>Agent: Returns temporary secure link
```

> "Start a transcription job for yesterday's recording 'rec-9944'. Wait for it to finish, then generate the access link so I can push the text to Salesforce."

**Execution flow:**
1. `create_a_whereby_transcription` (Schedules the job).
2. `list_all_whereby_transcriptions` (Called iteratively to check if the job state has moved to completed).
3. `list_all_whereby_transcription_access_links` (Fetches the secure URL for ingestion).

## Security and Access Control

Exposing your communication infrastructure to an LLM requires strict boundary controls. Truto enforces security at the MCP token level:

* **Method Filtering**: You can restrict an MCP token to only allow read operations by passing `methods: ["read"]` during creation. This prevents the LLM from accidentally deleting recordings or mutating room themes.
* **Tag Filtering**: Isolate tools by domain. Pass `tags: ["insights"]` to generate a server that can only access analytical metrics, completely blinding the LLM to meeting creation or recording management.
* **Expiration (`expires_at`)**: Tokens can be issued with a strict time-to-live. This is ideal for short-lived agents running automated batch jobs. Once the timestamp passes, Cloudflare KV drops the token and the Durable Object alarm tears down the database record.
* **Extra Authentication (`require_api_token_auth`)**: By default, possession of the tokenized URL grants access. By setting this flag to true, the client must also append a valid Truto API token in the Authorization header, preventing lateral movement if the URL leaks in client logs.

## Orchestrating Video APIs Requires Precision

Whereby is an incredibly powerful platform for building custom video experiences, but its API expects stateful orchestration, precise network diagnostics extraction, and asynchronous pipeline management. 

Building a custom MCP server to translate LLM intent into Whereby's specific schemas demands heavy engineering effort. You are forced to write backoff logic for rate limits, polling structures for transcripts, and pagination cursors for large participant lists. Using Truto's managed MCP server infrastructure allows you to bypass the boilerplate. The integration handles token lifecycle management, schema mapping, and secure tool generation dynamically, allowing your team to focus exclusively on designing complex agentic workflows.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} 
Ready to connect your AI agents to Whereby? Book a technical deep dive with our engineering team.
:::