---
title: "Connect Verbit to Claude: Manage Live Sessions & Real-time Captions via MCP"
slug: connect-verbit-to-claude-manage-live-sessions-and-real-time-captions
date: 2026-07-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Verbit to Claude using a managed MCP server. This guide covers API rate limits, dynamic tool generation, and real-world media workflows."
tldr: "Connect Verbit to Claude using a managed MCP server via Truto. Automate transcription jobs, manage live captioning sessions, and enforce strict access controls without writing custom API integrations."
canonical: https://truto.one/blog/connect-verbit-to-claude-manage-live-sessions-and-real-time-captions/
---

# Connect Verbit to Claude: Manage Live Sessions & Real-time Captions via MCP


If you need to connect Verbit to Claude to automate transcription pipelines, manage live captioning sessions, or extract AI insights from media, 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 Verbit's REST APIs. 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. 

If your team uses ChatGPT, check out our guide on [connecting Verbit to ChatGPT](https://truto.one/connect-verbit-to-chatgpt-manage-transcription-jobs-and-ai-insights/) or explore our broader architectural overview on [connecting Verbit to AI Agents](https://truto.one/connect-verbit-to-ai-agents-scale-media-processing-and-deliveries/).

Giving a Large Language Model (LLM) read and write access to a sprawling media processing ecosystem like Verbit is an engineering challenge. You have to handle API key lifecycles, map complex asynchronous job schemas to MCP tool definitions, and deal with Verbit's specific file handling requirements. Every time Verbit 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) for Verbit, connect it natively to Claude, and execute complex media processing workflows using natural language.

## The Engineering Reality of the Verbit 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, the reality of implementing it against vendor APIs is painful. If you decide to build a custom MCP server for Verbit, you own the entire API lifecycle. Here are the specific challenges you will face:

**Asynchronous Media Workflows and Job States**
Transcription in Verbit is not a synchronous request-response loop. Creating a job is a multi-step orchestration. You must first create the job shell, then upload or link media assets, optionally attach backup records or notes, and finally trigger the `perform_transcription` endpoint. If you expose raw endpoints to Claude without proper contextual boundaries, the model will frequently attempt to download transcripts for jobs that are still processing, resulting in errors. Your integration must handle state polling seamlessly.

**Strict Media Accessibility Requirements**
When passing media URLs to Verbit via the API (such as adding media to a job), Verbit requires those URLs to be accessible via a standard HTTP GET request for at least 24 hours. LLMs are notoriously bad at validating URL accessibility before passing them as arguments. A robust MCP implementation needs to understand when to instruct the LLM to generate presigned URLs versus passing direct links, mitigating failed ingestion tasks.

**Live Session Mutability**
Managing live captioning sessions (Orders) requires precise timestamp handling. Extending a live session requires passing an exact ISO 8601 UTC timestamp for the new end time. Canceling a recurrence or updating an order status is highly state-dependent - you can only cancel orders in `created`, `pending_approval`, or `ready_to_connect` states. Exposing these mutations to an LLM requires strict schema validation to prevent destructive actions on active live events.

**Rate Limits and Standardized Backoff**
Verbit enforces [rate limits](https://truto.one/how-to-handle-third-party-api-rate-limits-when-an-ai-agent-is-scraping-data/) on API requests to protect their infrastructure. If you build your own MCP server, you must write the logic to catch HTTP 429 Too Many Requests errors and implement exponential backoff. Truto takes a standardized approach: it normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. **Truto does not retry, throttle, or apply backoff on rate limit errors.** When Verbit returns a 429, Truto passes that error and the corresponding headers directly back to Claude. The caller (the AI agent) is fully responsible for reading the reset window and managing its own retry logic.

Instead of building this infrastructure from scratch, you can use Truto to dynamically generate an MCP server that handles authentication, schema mapping, and flat input namespaces out of the box.

## How to Generate a Verbit MCP Server

Truto's MCP servers feature turns any connected Verbit account into an MCP-compatible tool server. Tool generation is dynamic and documentation-driven - derived directly from the integration's resource definitions. 

You can generate an MCP server URL for Verbit using either the Truto UI or the Truto REST API.

### Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the MCP server in a few clicks:

1. Log in to your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Verbit integration.
3. Click on the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., filtering for specific methods like "read" or "write", assigning tags, or setting an expiration date).
6. Click **Create** and immediately copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For platform engineers building automated provisioning flows, you can generate the MCP server programmatically. Truto validates the request, generates a cryptographically secure token hashed in 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/<verbit_account_id>/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Verbit Live Ops MCP",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The API returns the database record along with the secure token URL:

```json
{
  "id": "mcp-789-xyz",
  "name": "Verbit Live Ops MCP",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

Keep this URL secure. It contains the token required to authenticate requests to the server.

## How to Connect the MCP Server to Claude

Once you have your Truto MCP server URL, connecting it to Claude requires zero additional code. You simply register the endpoint. You can do this visually through the application settings or manually via configuration files.

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

If you are using Claude Desktop or an enterprise workspace that supports UI-based connector management:

1. Open Claude and navigate to **Settings**.
2. Click on **Integrations** (or **Connectors** depending on your tier).
3. Select **Add MCP Server** or **Add custom connector**.
4. Give the server a descriptive name (e.g., "Verbit Media Ops").
5. Paste the Truto MCP server URL generated in the previous step.
6. Click **Add**. Claude will immediately perform a handshake with the `/mcp/:token` endpoint and ingest the available Verbit tools.

### Method B: Via Manual Configuration File (Claude Desktop)

For developers managing local environments, you can define the MCP server using Claude Desktop's configuration file. Because Truto serves the tools over Server-Sent Events (SSE) via an HTTP endpoint, you use the `@modelcontextprotocol/server-sse` transport.

Open your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add the following:

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

Restart Claude Desktop. The application will initialize the connection, read the generated JSON schemas for Verbit, and expose them as callable tools.

## Verbit MCP Hero Tools

Truto dynamically translates Verbit's API resources into highly descriptive tools. When Claude calls a tool, the arguments arrive as a flat JSON object. Truto seamlessly splits these into the correct query parameters and request body schemas before proxying the call to Verbit.

Here are 6 high-leverage tools available on the Verbit MCP server.

### 1. `create_a_verbit_job`

This tool creates the initial shell for a new transcription job in Verbit. It requires an API version (`v`) and a transcription `profile`. It returns a 201 success response, signaling that the job is ready to receive media assets.

**Contextual Usage Notes:** This is always the first step in a post-production transcription workflow. The LLM must capture the `job_id` from the response to use in subsequent asset additions.

> "Create a new Verbit transcription job using the standard English profile. Name the job 'Q3 Earnings Call'."

### 2. `verbit_jobs_add_media`

Once a job is created, this tool links media to the job via a direct URL. The media URL must be accessible via GET request for at least 24 hours.

**Contextual Usage Notes:** If the media is private, the agent should first generate a presigned URL using `verbit_uploads_get_presigned_url` before calling this tool.

> "Add the audio file from https://example.com/audio/q3-call.mp3 to the Verbit job I just created."

### 3. `verbit_jobs_get_caption`

Downloads the final transcription or caption file for a specific Verbit job. 

**Contextual Usage Notes:** The agent should check the job status using `verbit_jobs_get_info` to ensure the job is complete before attempting to download the caption, avoiding empty or error responses.

> "Fetch the final transcription file for job ID 98765 and summarize the key action items discussed by the speakers."

### 4. `verbit_sessions_extend`

Extends a Verbit real-time live session's duration to a specified end time. This is critical for live events that run over their scheduled slot.

**Contextual Usage Notes:** The `end_time` parameter must be formatted strictly as an ISO 8601 UTC timestamp. The agent handles the time conversion automatically.

> "The live captioning session for order ID 4567 is going to run long. Extend the session end time by 45 minutes."

### 5. `list_all_verbit_insights`

Lists Verbit AI insights for a specific job, supporting both live sessions and post-production jobs. It requires one of `job_id`, `job_uuid`, or `order_id`.

**Contextual Usage Notes:** Use this tool to extract structured data like summaries, topic modeling, and speaker analytics generated by Verbit's native AI engine.

> "Retrieve the Verbit insights for job ID 98765 and list out the primary topics discussed during the session."

### 6. `create_a_verbit_order`

Creates a new live order (real-time captioning session) in Verbit. It requires an order name, client transaction ID, and input/output configuration details. The start time must be in the future.

**Contextual Usage Notes:** This tool is used for scheduling human or automated live captioners for upcoming webinars, classes, or broadcasts.

> "Schedule a new live Verbit order for tomorrow at 2 PM EST for the 'All Hands Company Meeting'. Set the input language to English."

For a complete list of all available Verbit tools, schema definitions, and parameters, visit the [Verbit integration page](https://truto.one/integrations/detail/verbit).

## Workflows in Action

MCP servers transform Claude from a passive chatbot into an active orchestrator. By chaining Verbit tools together, you can automate complex media pipelines using conversational prompts.

### Workflow 1: End-to-End Transcription Automation

**The Prompt:**
> "I have a recorded Zoom meeting at https://storage.company.com/meeting.mp4. Create a new Verbit job for this recording, add the media, start the transcription process, and let me know when it's done so we can review the transcript."

**Step-by-Step Execution:**
1. Claude calls `create_a_verbit_job`, passing a standard profile and generating a descriptive name based on the prompt. Verbit returns a `job_id`.
2. Claude extracts the `job_id` and calls `verbit_jobs_add_media`, mapping the provided MP4 URL to the `media_url` parameter.
3. Claude calls `verbit_jobs_perform_transcription`, initiating the actual ASR and human review pipeline.
4. Claude calls `verbit_jobs_get_info` to check the status. Recognizing that transcription takes time, Claude informs the user that the job is processing and it will wait before retrieving the final file.

**The Output:**
Claude successfully orchestrates the entire job setup phase without the user having to write a single script. It provides the user with the job ID and confirms the pipeline has started.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude
    participant MCP as Truto MCP
    participant Verbit as Verbit API
    
    User->>Claude: "Create job for this MP4 and start transcription"
    Claude->>MCP: call tool: create_a_verbit_job
    MCP->>Verbit: POST /jobs
    Verbit-->>MCP: { job_id: "10293" }
    MCP-->>Claude: { job_id: "10293" }
    
    Claude->>MCP: call tool: verbit_jobs_add_media(10293, URL)
    MCP->>Verbit: POST /jobs/10293/media
    Verbit-->>MCP: 200 OK
    MCP-->>Claude: Success
    
    Claude->>MCP: call tool: verbit_jobs_perform_transcription(10293)
    MCP->>Verbit: POST /jobs/10293/perform
    Verbit-->>MCP: 200 OK
    MCP-->>Claude: Success
```

### Workflow 2: Live Event Crisis Management

**The Prompt:**
> "The keynote live session (order ID 55432) is running 30 minutes over schedule. Extend the session so the captions don't cut off, then check the status to confirm it's still active."

**Step-by-Step Execution:**
1. Claude calculates the new UTC timestamp by adding 30 minutes to the current scheduled end time (or asks the user for the exact new time if ambiguous).
2. Claude calls `verbit_sessions_extend`, passing the `order_id` and the formatted `end_time`.
3. Claude calls `get_single_verbit_session_by_id` to retrieve the updated order object and verifies that the `status` is still active and the new end time is reflected.

**The Output:**
Claude mutates the live event state in real-time, preventing a loss of accessibility for viewers, and returns a confirmation to the event coordinator with the updated session details.

## Security and Access Control

When exposing an enterprise media platform like Verbit to an AI model, strict access controls are non-negotiable. Truto provides several mechanisms to scope down what an MCP server can actually do:

*   **Method Filtering:** Limit the server to specific HTTP verbs. By passing `methods: ["read"]` during creation, you generate a server that can fetch transcripts and check job statuses, but completely blocks the model from creating jobs, extending live sessions, or canceling orders.
*   **Tag Filtering:** Group tools by functional area. You can restrict an MCP server to only expose tools tagged with "live_sessions" or "insights", ensuring the agent doesn't hallucinate API calls outside its designated domain.
*   **Extra Authentication (`require_api_token_auth`):** By default, possessing the MCP URL is enough to invoke tools. Setting this flag to `true` forces the client to also pass a valid Truto API token in the `Authorization` header, adding a secondary layer of security for shared workspaces.
*   **Temporary Access (`expires_at`):** You can generate ephemeral MCP servers by providing a future ISO datetime. Truto automatically schedules a cleanup alarm. Once the TTL expires, the server is securely deleted from the key-value store, making it perfect for temporary contractor access or single-run CI/CD agents.

## Moving Beyond Hardcoded Automations

Connecting Verbit to Claude via a managed MCP server eliminates the brittle scripts and Zapier workflows that traditionally dominate media operations. Instead of writing custom polling logic to check transcription statuses or building UI dashboards for event producers to extend live sessions, you give the LLM the tools to orchestrate the API directly.

Truto handles the heavy lifting of dynamic tool generation, flat input namespace mapping, and strict schema validation. It passes rate limit realities through transparently, empowering your agents to act intelligently. The result is a media pipeline that responds to natural language, scales infinitely, and requires zero maintenance when Verbit ships API updates.

> Want to generate managed MCP servers for Verbit and 100+ other enterprise SaaS APIs? See how Truto can connect your AI agents to production data in minutes.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)