---
title: "Connect Verbit to AI Agents: Scale Media Processing and Deliveries"
slug: connect-verbit-to-ai-agents-scale-media-processing-and-deliveries
date: 2026-07-19
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Verbit to ai agents using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows."
canonical: https://truto.one/blog/connect-verbit-to-ai-agents-scale-media-processing-and-deliveries/
---

# Connect Verbit to AI Agents: Scale Media Processing and Deliveries


You want to connect Verbit to an AI agent so your internal systems can independently ingest media, configure transcription profiles, generate AI insights, and orchestrate caption deliveries based on historical context. Here is exactly how to do it using Truto's `/tools` endpoint and SDK, bypassing the need to manually build custom connectors or maintain complex asynchronous polling wrappers. 

Giving a Large Language Model (LLM) read and write access to your Verbit instance is an engineering headache. You either spend weeks building, hosting, and maintaining a custom connector that understands the difference between post-production jobs and live session orders, or you use a managed infrastructure layer that handles the boilerplate for you. 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 if you are building on Anthropic's models, read our guide on [connecting Verbit to Claude](https://truto.one/connect-verbit-to-claude-manage-live-sessions-and-real-time-captions/). For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch [AI-ready tools for Verbit](https://truto.one/how-to-build-a-customer-facing-ai-agent-for-saas/), bind them natively to an LLM using LangChain (or any framework like LangGraph, CrewAI, or Vercel AI SDK), and execute complex [media processing workflows](https://truto.one/connect-vimeo-to-ai-agents-automate-video-management-and-metadata/). For a deeper look at the architecture behind this approach, refer to our research on [architecting AI agents and the SaaS integration bottleneck](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/).

## The Engineering Reality of Custom Verbit Connectors

Building AI agents is easy. Connecting them to external SaaS APIs is hard. Giving an LLM access to external data sounds simple in a prototype. You write a Node.js function that makes a fetch request and wrap it in an `@tool` decorator. In production, this approach collapses entirely, especially with an ecosystem as complex as Verbit.

If you decide to integrate Verbit yourself, you own the entire API lifecycle. Verbit's API introduces several highly specific integration challenges that break standard LLM assumptions.

### The Asynchronous State Machine Trap

Most LLMs assume API calls are synchronous - they ask for data, they get data. Verbit's media processing pipeline is inherently asynchronous and stateful. You cannot simply upload a video and receive a transcript in one HTTP request. An agent must understand that it has to create a job, attach media, explicitly trigger the transcription execution, and then monitor a state machine (moving from `created` to `pending_execution` to `draft_ready`). 

If you hand-code this integration, you have to write complex system prompts to teach the LLM this exact sequence of operations. When the LLM inevitably hallucinates and tries to download a caption file for a job that is still in the `created` state, the API throws an error, and the agent loop crashes.

### The "Jobs" vs "Orders" Domain Complexity

Verbit splits its universe into distinct domains that share similar language but require entirely different endpoints. Post-production transcriptions are managed as `jobs`, requiring a specific API version (`v`) and a transcription `profile`. Live captioning sessions and recurring events, however, are managed as `orders`. 

Exposing the raw REST endpoints directly to an LLM forces the model to memorize that `job_id` is required for fetching an offline widget, while `order_id` is required for fetching a live session transcript. This split taxonomy is a massive attack surface for hallucination.

### Rate Limits and Header Normalization

When your agent is orchestrating batch processing - perhaps analyzing dozens of past transcripts to generate a consolidated report - it will eventually hit a rate limit. 

It is critical to understand that Truto does not retry, throttle, or apply automatic backoff on rate limit errors. When the upstream Verbit API returns an HTTP 429 Too Many Requests error, 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. The caller - your agent framework - is entirely responsible for implementing the retry and backoff logic using these headers. This design ensures your agent maintains complete control over its execution loop and resource consumption, rather than hanging indefinitely on a hidden infrastructure retry queue.

## Why a Unified Tool Layer Matters for Agent Safety

Before writing a line of integration code, decide what layer your agent talks to. This choice determines how safe your production system will be.

Direct API tools (one tool per raw Verbit endpoint) look convenient, but they push provider quirks into the LLM's context window. The model has to remember that media URLs must be GET-accessible for 24 hours, that jobs require a profile name, and that canceling a recurrence uses a different payload than canceling a single order. Every one of those quirks is a hallucination waiting to happen.

A unified tool layer collapses these operational complexities behind strict schemas. Your agent sees `create_a_verbit_job`, `verbit_jobs_add_media`, and `verbit_jobs_get_draft`. That gives you three concrete safety wins:

1. **Smaller attack surface for hallucination.** The LLM only ever chooses from stable function names. It never invents endpoint paths or query parameter formats.
2. **Deterministic input validation.** Every tool has a strict JSON schema. If the agent forgets to include the required API version (`v`) when creating a job, the tool layer rejects the call before it ever hits Verbit, returning a fast, structured error that the agent can immediately correct.
3. **Separation of concerns.** Your agent focuses on reasoning about media operations. Truto handles the authentication, pagination processing, and standardized error mapping.

## Hero Tools for Verbit AI Agents

Truto provides a comprehensive set of Proxy APIs for Verbit, mapping all underlying resources to executable methods. We expose these methods dynamically as tools via the `/tools` endpoint. 

Here are the highest-leverage tools available for automating Verbit workflows.

### Create a Transcription Job

This tool (`create_a_verbit_job`) is the starting point for post-production workflows. It creates the initial job record in Verbit. The agent must specify the API version and the desired transcription profile (e.g., ASR-only vs Human-reviewed).

**Contextual usage notes:** This tool only creates the empty job container. The agent must subsequently use media addition tools to attach the actual payload. 

> "I need to transcribe the latest all-hands meeting. Create a new Verbit job named 'Q3 All Hands' using the standard automated transcription profile. Give me the job ID when you're done."

### Add Media via Direct URL

This tool (`verbit_jobs_add_media`) attaches a media file to an existing job using a direct, accessible URL. 

**Contextual usage notes:** Agents are terrible at handling binary file uploads via multipart/form-data. This tool is vastly superior for agentic workflows because it allows the agent to simply pass a string (the URL from your cloud storage) rather than attempting to stream bytes. The URL must be accessible via GET request for at least 24 hours.

> "Take this presigned S3 URL for the all-hands video and add it as the media source for job ID 49201. Once attached, confirm the upload."

### Execute Transcription Processing

This tool (`verbit_jobs_perform_transcription`) commands Verbit to begin processing the job.

**Contextual usage notes:** Because Verbit separates job creation, media attachment, and execution, an agent must call this tool to actually start the ASR or human review process. Calling this on a job with no media will result in a structured error.

> "The media has been attached to job ID 49201. Start the transcription process now and let me know the initial status."

### Retrieve Transcription Drafts

This tool (`verbit_jobs_get_draft`) allows the agent to download the draft transcription file in a specified format (such as `.srt`, `.web_vtt`, or `.txt`).

**Contextual usage notes:** This is typically used in a polling loop or triggered via a webhook event. Agents can use this tool to pull the raw text into their context window for summarization or insight generation before the final human review is completed.

> "Check if the draft for job ID 49201 is ready. If it is, download the text version so we can generate a meeting summary."

### Generate AI Insights

This tool (`verbit_insights_generate`) triggers Verbit's native AI insight generation engine on a specific job or order, processing the transcript for key themes, summaries, and action items.

**Contextual usage notes:** This allows your agent to offload heavy transcript analysis to Verbit's specialized models rather than burning your own token limits. The agent simply requests the insights and can later retrieve them using the list insights tool.

> "The transcription for order 99281 is complete. Trigger the AI insights generation for this order so we have the automated summary ready for the marketing team."

### Orchestrate Caption Deliveries

This tool (`create_a_verbit_delivery`) creates a downloadable package of caption and transcription files across multiple formats.

**Contextual usage notes:** Ideal for final asset distribution. The agent can take completed order IDs and request a bundle (e.g., both VTT and SRT formats) that will be zipped and provided via a download URL.

> "Take completed orders 88102 and 88103, and create a delivery package containing both SRT and WebVTT formats. Return the download URL when the package is pending."

For the complete list of available operations, schema definitions, and authentication requirements, review the [Verbit integration page](https://truto.one/integrations/detail/verbit).

## Workflows in Action

When you combine these tools within an agentic loop, you move beyond simple API wrappers into [autonomous media operations](https://truto.one/connect-deepgram-to-ai-agents-automate-voice-transcription-and-analytics/). Here is what that looks like in practice.

### Scenario 1: The Autonomous Podcast Pipeline

Media companies process hundreds of podcast episodes a week. Instead of a human manually uploading files and configuring profiles, an agent can orchestrate the entire ingestion pipeline based on a simple command.

> "Grab the raw audio file from this Google Drive link, create a Verbit transcription job using our standard 'asr-only' profile, attach the media, start the processing, and confirm when the job is officially in the execution queue."

**Execution Steps:**
1. The agent calls `create_a_verbit_job`, passing `v` and `profile`. It extracts the resulting `job_id`.
2. The agent calls `verbit_jobs_add_media`, passing the `job_id` and the `media_url` from the prompt.
3. The agent calls `verbit_jobs_perform_transcription` using the same `job_id`.
4. The agent calls `verbit_jobs_get_info` to verify the status has moved to `pending_execution`.

**Result:** The user receives a confirmation message with the active Job ID and current status, turning a multi-click, five-minute manual process into a single autonomous command.

### Scenario 2: Post-Production Insights and Distribution

After a live session or event concludes, production teams need transcripts, summaries, and formatted caption files distributed immediately.

> "Find live session order ID 10492. If it's complete, generate Verbit AI insights for it. Then, create a delivery package containing the SRT files and give me the download URL."

**Execution Steps:**
1. The agent calls `get_single_verbit_order_by_id` to verify the order status.
2. The agent calls `verbit_insights_generate`, passing the `order_id` to trigger the automated summary.
3. The agent calls `create_a_verbit_delivery`, requesting the `srt` format for the specified `order_id`.

**Result:** The agent orchestrates a hand-off between live captioning and post-production asset generation, providing the user with a direct link to the finalized delivery package.

## Building Multi-Step Workflows

To build these workflows, you need to connect Truto's dynamically generated tools to your agent framework. Truto is framework-agnostic. We expose a standard REST endpoint (`/integrated-account/<id>/tools`) that returns all Proxy API methods as formatted JSON schemas. 

Whether you are using LangChain, Vercel AI SDK, or CrewAI, the binding process follows the same architectural pattern.

### Fetching and Binding Tools

First, you retrieve the tool definitions for the specific integrated account. You can optionally filter this using query parameters. For example, `?methods [0]=create&methods [1]=custom` will return only the tools needed for writing data and executing custom operations.

```typescript
import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
import { ChatPromptTemplate } from "@langchain/core/prompts";
// Truto SDK provides the tool manager utility
import { TrutoToolManager } from "truto-langchainjs-toolset";

async function runVerbitAgent(prompt: string, integratedAccountId: string) {
  // 1. Initialize the Truto Tool Manager with your API key
  const toolManager = new TrutoToolManager({
    apiKey: process.env.TRUTO_API_KEY,
  });

  // 2. Fetch the dynamically generated tools for Verbit
  // This hits GET /integrated-account/<id>/tools
  const tools = await toolManager.getTools(integratedAccountId);

  // 3. Initialize your preferred LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
  });

  // 4. Bind the strict JSON schemas to the LLM
  const llmWithTools = llm.bindTools(tools);

  // 5. Setup the agent prompt and executor
  const promptTemplate = ChatPromptTemplate.fromMessages([
    ["system", "You are a media operations assistant. Use the provided tools to manage Verbit jobs and deliveries."],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
  ]);

  const agent = createToolCallingAgent({
    llm: llmWithTools,
    tools,
    prompt: promptTemplate,
  });

  const agentExecutor = new AgentExecutor({
    agent,
    tools,
  });

  // 6. Execute the workflow
  const result = await agentExecutor.invoke({
    input: prompt,
  });

  return result.output;
}
```

### Handling Rate Limits in the Agent Loop

When an agent chains multiple tools rapidly - such as looping through 50 historical orders to generate insights - it will eventually hit upstream rate limits. 

Because Truto passes 429 errors directly back to the caller with normalized IETF headers, your infrastructure must intercept these errors and instruct the agent to wait. 

```mermaid
sequenceDiagram
    participant Agent as Agent Framework
    participant Truto as Truto API Proxy
    participant Upstream as Upstream API (Verbit)

    Agent->>Truto: Call verbit_jobs_perform_transcription
    Truto->>Upstream: POST /api/v1/jobs/{id}/transcribe
    Upstream-->>Truto: 429 Too Many Requests
    Truto-->>Agent: 429 Error (ratelimit-reset: 60)
    
    rect rgb(235, 232, 226)
    Note over Agent: Parse ratelimit-reset header<br>Apply backoff delay (60s)
    Agent->>Agent: Wait for reset window
    end

    Agent->>Truto: Retry verbit_jobs_perform_transcription
    Truto->>Upstream: POST /api/v1/jobs/{id}/transcribe
    Upstream-->>Truto: 200 OK
    Truto-->>Agent: Tool execution successful```

To implement this safely, you wrap your tool execution layer or agent executor in a retry interceptor that reads `ratelimit-reset`. If a 429 occurs, the interceptor pauses the agent loop for the specified duration before re-invoking the failed tool call. This guarantees that your system respects Verbit's capacity without crashing the active agent session or relying on opaque middle-tier queues.

## Moving Toward Autonomous Media Operations

Connecting Verbit to an AI agent is fundamentally different from building a traditional point-to-point integration. You aren't just syncing a database row; you are giving a reasoning engine the ability to orchestrate complex, asynchronous media processing pipelines.

By leveraging Truto's `/tools` endpoint, you abstract away the authentication boilerplate and schema enforcement, providing your LLM with a safe, deterministic interface. You avoid the hallucination risks of raw REST APIs while retaining complete architectural control over rate limiting and backoff strategies.

The result is a system that can independently ingest media, configure profiles, generate insights, and package deliverables - scaling your operations without scaling your engineering headcount.

> Stop burning engineering cycles on custom SaaS wrappers. Let Truto generate AI-ready tools for Verbit and 150+ other APIs dynamically.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)