---
title: "Connect Verbit to ChatGPT: Manage Transcription Jobs and AI Insights"
slug: connect-verbit-to-chatgpt-manage-transcription-jobs-and-ai-insights
date: 2026-07-19
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Verbit to ChatGPT using a managed MCP server. Automate transcription workflows, extract AI insights, and manage live sessions."
tldr: "Connect Verbit to ChatGPT to automate complex transcription state machines and live caption sessions. This guide covers generating a Truto MCP server, tool configuration, and multi-step media processing workflows."
canonical: https://truto.one/blog/connect-verbit-to-chatgpt-manage-transcription-jobs-and-ai-insights/
---

# Connect Verbit to ChatGPT: Manage Transcription Jobs and AI Insights


You want to connect Verbit to ChatGPT so your AI agents can orchestrate transcription pipelines, manage live captioning sessions, and extract AI insights from recorded media. If your team uses Claude instead, check out our guide on [connecting Verbit to Claude](https://truto.one/connect-verbit-to-claude-manage-live-sessions-and-real-time-captions/), 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/). Here is exactly how to execute this using a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/).

Giving a Large Language Model (LLM) read and write access to a complex media processing platform like Verbit is an engineering challenge. You are not just dealing with standard REST operations; you are managing long-running state machines, strict job lifecycles, and large asset transfers. You either spend weeks building, hosting, and maintaining a custom MCP server, or you use a [managed infrastructure layer](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) that handles the boilerplate for you.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Verbit, [connect it natively to ChatGPT](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex media workflows using natural language.

## The Engineering Reality of the Verbit API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools, implementing it against vendor APIs requires navigating vendor-specific quirks.

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

### The Multi-Step Job State Machine
You cannot simply send a media file to Verbit and get a transcript back in a single request. The API requires a strict state machine orchestration. First, you must call the endpoint to create a job, specifying the API version and transcription profile. Next, you must make a separate call to link media (either via URL or by uploading an asset and passing the asset ID). Finally, you must make a third distinct request to explicitly instruct Verbit to perform the transcription. If an LLM skips one of these steps, the job will sit in a pending state forever. Your MCP tools must be carefully scoped and described so the LLM understands this strict sequence.

### Mutually Exclusive Parameters
Verbit enforces strict parameter isolation on several endpoints. For example, when adding existing transcription text to a job, you must provide either `transcription_text` or `transcription_url` - providing both results in a validation error. Similarly, when getting embeddable widget code, you must supply `player_id` or `media_url`, but never both. You have to write JSON schemas for your MCP tools that explicitly encode these rules using `oneOf` constraints, otherwise the LLM will hallucinate invalid payloads.

### Strict Live Session Status Constraints
Live session management (extending sessions, changing connection plans, or cancelling) relies on the session's current status. You cannot cancel an order unless it is in a `created`, `pending_approval`, `pending_execution`, `ready_to_connect`, or `execution_error` state. If the LLM attempts to modify an active or completed session, the API throws an error. Your integration must handle these state checks before allowing the LLM to commit changes.

### Transparent Rate Limit Handling
When an AI agent starts polling Verbit for job statuses or fetching insights across thousands of orders, it will hit rate limits. Truto passes upstream HTTP 429 errors directly to the caller, mapping the vendor's rate limit logic into standard `ratelimit-limit`, `ratelimit-remaining`, and `ratelimit-reset` headers per the IETF specification. Truto does not retry or absorb rate limit errors. It is up to your client or agent framework to read these headers and apply the appropriate exponential backoff.

Instead of forcing your engineering team to build state machine handlers and schema validation from scratch, Truto dynamically generates these tools from documented API definitions.

## How to Create a Managed MCP Server for Verbit

Truto derives MCP tools dynamically from an integration's resource definitions and schemas. This means a tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM only sees well-curated, structured endpoints.

Each MCP server is scoped to a single connected Verbit account. You can generate a server URL in two ways.

### Method 1: Via the Truto UI

For internal operations teams, the simplest path is using the dashboard.

1. Navigate to the integrated account page for your connected Verbit instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your configuration (name, method filters like `read` or `write`, tag filters, and optional expiry time).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

If you are provisioning AI agents programmatically, you can create the MCP server via a REST call. The API validates that the integration is AI-ready, generates a secure, hashed token in the key-value store, and returns a ready-to-use 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": "Verbit Transcription Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["jobs", "insights", "sessions"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The response includes the server ID and the authenticated URL:

```json
{
  "id": "mcp_srv_9x8y7z6",
  "name": "Verbit Transcription Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["jobs", "insights", "sessions"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/f7e6d5c4b3a2..."
}
```

This URL contains a cryptographic token that securely maps to the specific Verbit tenant. No additional OAuth negotiation is required by the client.

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can plug it directly into ChatGPT or any compatible MCP client framework.

### Method A: Via the ChatGPT UI

If you are using ChatGPT directly in the browser (requires a Pro, Plus, Enterprise, or Edu account):

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode**.
3. Under **MCP servers / Custom connectors**, click add a new server.
4. **Name**: `Verbit (Truto)`
5. **Server URL**: Paste the Truto MCP URL.
6. Save and exit. 

ChatGPT will immediately run an `initialize` handshake, call `tools/list`, and surface the Verbit operations to your agent.

*(Note: If you are connecting to Claude Desktop instead, go to Settings -> Integrations -> Add MCP Server, paste the URL, and click Add).* 

### Method B: Via Manual Config File (SSE Transport)

If you are running your own agent framework or a local development environment, you can configure the connection using the standard Server-Sent Events (SSE) transport wrapper provided by the MCP reference implementation.

Create a `verbit-mcp.json` configuration file:

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

When your framework boots, it executes the command, connects to Truto's JSON-RPC 2.0 endpoint, and dynamically fetches all available Verbit tools.

## Hero Tools for Verbit

Truto automatically derives tools based on Verbit's API documentation. Here are the highest-leverage tools available for your LLM.

### create_a_verbit_job

Creates a new transcription job in Verbit. This is the first step in processing media. The LLM must supply the API version (`v`) and a `profile` name (e.g., standard transcription, captioning, or translation).

**Usage note:** This tool only initializes the job. The LLM must extract the `job_id` from the 201 response and use it in subsequent calls to add media.

> "I need to start a new transcription request for our Q3 Earnings call. Create a Verbit job using API version 1.0 and the 'English-US-Standard' profile. Save the job ID for the next step."

### verbit_jobs_add_media

Attaches a media file to an initialized job via a direct URL. 

**Usage note:** The `media_url` provided by the LLM must be publicly accessible via a standard HTTP GET request for at least 24 hours so Verbit's ingestion engine can retrieve it.

> "Take the job ID we just created and add this media URL: https://storage.company.com/q3-earnings-audio.mp3. Make sure it attaches correctly before we execute the transcription."

### verbit_jobs_perform_transcription

Triggers the actual processing phase. After a job is created and media is attached, the LLM must invoke this tool to move the job from an initialized state into the processing queue.

**Usage note:** This is a zero-payload POST that requires only the `v` (API version) and `job_id`. 

> "We have created the job and attached the MP3 file. Now, trigger the transcription process for job ID 88392-12A."

### verbit_jobs_get_caption

Downloads the completed transcription or caption file for a specific job. 

**Usage note:** AI agents should only call this after verifying the job status is complete (using `verbit_jobs_get_info`). The return payload contains the raw caption text.

> "Check the status of job ID 88392-12A. If it is finished, download the caption file and summarize the three main themes discussed in the meeting."

### list_all_verbit_insights

Retrieves structured AI insights generated by Verbit for a specific job, including summaries, key entities, and topics. It supports both live sessions and post-production jobs.

**Usage note:** The LLM must provide one of `job_id`, `job_uuid`, or `order_id` to route the query correctly.

> "Fetch the AI insights for order ID 99201. Extract the key entities and action items, and format them into a markdown list for my weekly report."

### verbit_sessions_extend

Extends the duration of an active live realtime session. This is critical for events or webinars that run long.

**Usage note:** The LLM must provide the `order_id` (as a UUID) and the new `end_time` formatted strictly in ISO 8601 UTC.

> "The current live webinar is running 30 minutes over schedule. Extend the Verbit realtime session for order ID a1b2c3d4-e5f6 to end at 2026-10-15T15:30:00Z."

To view the full list of available tools, query parameters, and schema validations, visit the [Verbit integration page](https://truto.one/integrations/detail/verbit).

## Workflows in Action

By chaining these tools together, ChatGPT can automate complex Verbit operations that would normally require manual intervention in the UI.

### Scenario 1: End-to-End Media Processing and Extraction

An operations manager wants to process a raw recording, wait for completion, and generate a summary document.

> "Start a new transcription job for our compliance training video. Use API version 1.0 and the 'Compliance-Tier1' profile. Attach the media from https://assets.com/compliance-2026.mp4. Trigger the transcription. I know it will take time, so just confirm it started. I will ask you to fetch the captions later."

Here is how the AI agent maps this to the Verbit tools:

```mermaid
sequenceDiagram
    participant User as Operations Manager
    participant Agent as ChatGPT Agent
    participant MCP as Truto MCP Server
    participant Verbit as Verbit API

    User->>Agent: Start transcription job for compliance video
    Agent->>MCP: Call create_a_verbit_job (profile="Compliance-Tier1")
    MCP->>Verbit: POST /api/v1.0/jobs
    Verbit-->>MCP: 201 Created (job_id: "COMP-9901")
    MCP-->>Agent: Returns job_id
    
    Agent->>MCP: Call verbit_jobs_add_media (job_id="COMP-9901", url="...")
    MCP->>Verbit: POST /api/v1.0/jobs/COMP-9901/media
    Verbit-->>MCP: 200 OK
    MCP-->>Agent: Success confirmation
    
    Agent->>MCP: Call verbit_jobs_perform_transcription (job_id="COMP-9901")
    MCP->>Verbit: POST /api/v1.0/jobs/COMP-9901/perform
    Verbit-->>MCP: 200 OK
    MCP-->>Agent: Transcription started
    Agent-->>User: "The job has been created and the transcription is processing."
```

**What the user gets:** The LLM successfully navigates the strict three-step initialization process, capturing the state (`job_id`) at each stage, and confirms to the user that the pipeline is running.

### Scenario 2: Managing Live Session Anomalies

A support technician managing a live event notices the schedule has slipped and needs to adjust the transcription window.

> "Find the live session order for 'Keynote Address'. Check its maximum extend time, and then extend the session by an additional 45 minutes."

Here is the tool execution sequence:

1. **`list_all_verbit_orders`**: The agent searches for orders matching the text "Keynote Address" and extracts the specific `order_id` (e.g., `554a32-11x`).
2. **`verbit_sessions_get_max_extend_time`**: The agent checks the hard limits for this specific session type to ensure a 45-minute extension is allowed.
3. **`verbit_sessions_extend`**: The agent calculates the new UTC ISO 8601 timestamp and calls the extension tool with the `order_id` and new `end_time`.

**What the user gets:** The LLM reads the current state, validates constraints, mutates the session end time, and returns a confirmation that the live captions will not cut off prematurely.

## Security and Access Control

Exposing an LLM to an enterprise media processing platform requires strict boundaries. Truto provides several mechanisms to lock down your Verbit MCP server at generation time:

*   **Method Filtering:** Enforce read-only access by restricting `config.methods` to `["read"]`. This allows the LLM to fetch insights and captions but prevents it from creating jobs, cancelling orders, or modifying live sessions.
*   **Tag Filtering:** Limit the server to specific operational domains by passing `config.tags`. For example, setting tags to `["insights"]` ensures the LLM can only run analytical tools and cannot touch the raw job workflows.
*   **Require API Token Auth:** By default, anyone with the MCP URL can invoke tools. Setting `require_api_token_auth: true` forces the client to also pass a valid Truto API token in the Authorization header. This adds a secondary authentication layer for environments where URLs might be exposed in logs.
*   **Time-to-Live (TTL):** Set an `expires_at` timestamp for temporary access. Truto handles the automated cleanup in both the database and the edge key-value store, ensuring the server self-destructs exactly when intended.

> Want to generate MCP servers for your customers' tools without managing the underlying integration infrastructure? Truto handles the boilerplate, rate limits, and authentication.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)

## Final Thoughts on Verbit AI Integration

Automating Verbit with AI agents requires treating the platform like the complex state machine it is. You cannot rely on basic CRUD operations when managing transcription pipelines and live sessions. By using a documentation-driven MCP server, you offload the schema enforcement, parameter mapping, and tool derivation to the infrastructure layer. Your AI agents get structured, contextual access to Verbit, and your engineering team avoids building and maintaining a custom integration layer.