DEV Community: Mark Turner

Botverse officially launches tomorrow - 6/9/26!

Mark Turner — Mon, 08 Jun 2026 20:35:13 +0000

Mark Turner

Jun 8

Add video transcoding to your Claude agent in 5 minutes (MCP)

#ai #mcp #tutorial #video

3 min read

Add video transcoding to your Claude agent in 5 minutes (MCP)

Mark Turner — Mon, 08 Jun 2026 19:40:57 +0000

Teach your Claude Agent to process Zoom recordings and extract audio in 5 minutes (MCP)

As IT developers, we are constantly tasked with building internal tools to automate messy, repetitive workflows. With the rise of AI agents, it’s now incredibly easy to build a Claude-powered bot that manages tickets, audits logs, or summarizes text.

But things fall apart the moment a user drops a massive 2GB raw Zoom recording, a Microsoft Teams .webm export, or a screen-share video into the chat and asks the agent to "compress this for the wiki" or "extract the audio so we can transcribe it."

Suddenly, your lightweight AI agent needs to be a media engineering wizard. Your options? Either force a local installation of FFmpeg (and deal with cross-platform binary dependencies breaking in production) or spend days configuring AWS MediaConvert pipelines, S3 buckets, IAM roles, and webhooks.

Spoiler alert: You shouldn't have to build cloud infrastructure just to downsample a corporate meeting recording.

Thanks to Anthropic’s Model Context Protocol (MCP) and a developer-friendly platform called Botverse, you can give your Claude Agent full video-transcoding and audio-extraction superpowers in exactly 5 minutes—without writing a single line of infrastructure code.

🛠️ The 5-Minute Setup

To give your local Claude Desktop agent video-processing capabilities, you just need to connect the Botverse remote MCP server to your client.

Sign up at botverse.cloud and copy your API token from the dashboard.
Open your Claude Desktop configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Add the botverse configuration block under the mcpServers object:

{
  "mcpServers": {
    "botverse": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://botverse.cloud/mcp?token=YOUR_BOTVERSE_TOKEN"
      ],
      "env": {}
    }
  }
}

Replace YOUR_BOTVERSE_TOKEN with your actual token, save the file, and restart Claude Desktop. That’s it. Claude now inherently understands how to manipulate video and audio files.

🔄 The IT Developer Workflow Under the Hood

Once connected, Claude automatically discovers the new media tools. When you ask Claude to handle a video file, it autonomously orchestrates a clean, 3-step asynchronous workflow:

1. `transcode_from_url`

Claude kicks off the process by sending the raw video URL (like a direct link to a cloud-stored meeting recording) straight to Botverse. You don't have to upload massive files into your LLM prompt context.

For video compression: You can tell Claude to convert a massive raw file to a web-friendly 720p MP4.
For data/text extraction: You can instruct Claude to strip the video entirely and extract just the MP3 or WAV audio—perfect for feeding into a transcription API like Whisper to generate meeting notes.

2. `get_job_status`

Media processing takes time. Instead of blocking the LLM or hitting a network timeout, Claude will intelligently poll this tool in the background to check on the job's progress while it cooks.

3. `get_download_url`

As soon as the job status marks itself complete, Claude calls this final tool to retrieve a secure, signed download URL for the newly generated asset.

📸 See It In Action

Imagine an internal Slack or desktop bot where a developer or project manager needs to extract audio from a town hall meeting. You can type a natural language command:

"Extract the audio from this raw recorded meeting link as an MP3 so I can run a transcript on it: https://storage.company.internal/meeting_10823.webm"

Claude handles the tool coordination automatically:

[Claude Desktop UI]
🤖 Calling tool: botverse.transcode_from_url... 
   ↳ Parameters: { url: "...", outputs: [{ format: "mp3" }] }
   ↳ Status: Job created (ID: job_dev_7812)

🤖 Calling tool: botverse.get_job_status (job_dev_7812)... 
   ↳ Status: Processing (Audio extraction in progress...)

🤖 Calling tool: botverse.get_job_status (job_dev_7812)... 
   ↳ Status: Completed

🤖 Calling tool: botverse.get_download_url (job_dev_7812)...
   ↳ Signed URL retrieved!

"I have successfully extracted the audio from your meeting recording. You can download the MP3 file here to pass to your transcription pipeline: [Download Meeting Audio](https://botverse.cloud/d/xyz123...)"

💰 Predictable Pricing, Zero Idle Server Costs

We all hate surprise cloud bills from idle infrastructure. Botverse uses a transparent, pay-as-you-go model that keeps costs entirely predictable:

$0.25 per job (for standard source video files under 5 minutes).
+$0.08 per minute for overage on longer files (like 30-minute standups or hour-long webinars).
$2.50 minimum top-up to fund your developer wallet and get started.

There are no fixed monthly subscriptions, no base fees, and your credits never expire. You only pay when your agent is actively processing media.

🚀 Next Steps

Stop wasting time writing boilerplate infrastructure code, debugging FFmpeg layers in Docker containers, or over-engineering cloud pipelines for simple internal tools. Let MCP do the heavy lifting.

🌐 Get Started: Head over to botverse.cloud to grab your API token.
📚 Read the Docs: Check out the Botverse Documentation for more advanced parameters, document conversions, and agent automation blueprints.

I gave my AI agent a 2MB PDF. Here's what happened to my token count.

Mark Turner — Thu, 28 May 2026 21:42:35 +0000

Every token your agent spends on file I/O is wasted reasoning capacity.

I was building a document processing agent — the kind that reads incoming research reports, extracts key findings, and produces executive briefings. Nothing exotic. The kind of workflow thousands of teams are automating right now.

The PDF I was testing with was 2MB. Dense text. A typical industry research report.

When I measured the token cost of processing it inline, the number was 97,354 input tokens — just to get the text into Claude's context. At claude-sonnet-4-6 pricing, that's $0.29 per document. For a pipeline that processes 500 reports a month, you're looking at $150/month before your agent writes a single word of output.

That's the problem nobody talks about in the AI agent space. Everyone optimises prompt engineering and output tokens. The silent cost is input: the files, the content, the raw data you're shoving into context before the agent can do anything useful.

How the token count explodes

When you pass a document to an agent inline, one of two things happens:

Option A — Base64 encoding. You read the binary file, encode it, embed it in the prompt. A 2MB PDF in base64 is ~2.7MB of text. At roughly 3.5 characters per token, that's ~770,000 tokens before your agent has read a single word. This is catastrophic. Don't do this.

Option B — Text extraction. You extract the raw text content first (via pdftotext, PyMuPDF, or equivalent), then pass the text to the agent. Better — but a 2MB PDF with dense content still yields ~97,000 tokens of extracted text. You've paid for every word, every header, every footnote.

Either way, the document content dominates your context window, crowds out your system prompt, and you're burning money on file I/O instead of reasoning.

The alternative: specialist services via MCP

Model Context Protocol (MCP) is Anthropic's open standard for connecting AI agents to external tools and services. The key insight is simple: your agent doesn't need to contain the computation — it needs to orchestrate it.

File conversion is a perfect example. Converting a PDF to clean markdown is deterministic, CPU-bound work. It doesn't require LLM reasoning. Running it inside your agent's context window is like using a screwdriver to hammer a nail — you can, sort of, but why would you?

Here's what the same 2MB PDF workflow looks like when the agent delegates to a specialist service:

Agent token cost to process the 2MB PDF:
  ├── convert_from_url call:    ~300 tokens
  ├── get_job_status poll:      ~200 tokens  
  ├── get_download_url call:    ~200 tokens
  └── Total MCP overhead:    ~8,000 tokens

8,000 tokens vs 97,354 tokens. A 12× reduction.

The converted markdown (clean, structured, without PDF encoding artifacts) is stored externally. The agent gets back a URL. For many workflows — convert, store, route, email — the agent never needs to read the full content at all. For workflows that do need to reason over the content, the clean markdown is 40-50% smaller than the raw extracted text.

The cost difference: $0.029 vs $0.29. Ten times cheaper per document.

A concrete example

Say your agent handles incoming vendor contracts. The workflow: receive a PDF, convert to a canonical format, extract key dates and obligations, store the result, notify procurement.

Inline approach:

import anthropic, base64

client = anthropic.Anthropic()

with open("vendor_contract.pdf", "rb") as f:
    pdf_b64 = base64.b64encode(f.read()).decode()

# This burns ~770,000 tokens just loading the file
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Extract key dates, parties, and obligations from this contract."},
            {
                "type": "document",
                "source": {
                    "type": "base64",
                    "media_type": "application/pdf",
                    "data": pdf_b64
                }
            }
        ]
    }]
)

Cost: ~$2.31 in input tokens for a 2MB contract, before any output.

MCP approach (with Botverse):

Set up the MCP server once in your Claude Desktop config or agent runtime:

{
  "mcpServers": {
    "botverse": {
      "url": "https://botverse.cloud/mcp?token=YOUR_TOKEN"
    }
  }
}

Then your agent prompt becomes:

You have access to the Botverse MCP tools.

A new vendor contract has arrived at:
https://contracts.yourcompany.com/incoming/vendor_contract_2026.pdf

1. Convert it to markdown using convert_from_url
2. Once converted, retrieve the content and extract:
   - Contract parties (names and roles)
   - Effective date and term
   - Payment obligations with amounts and dates
   - Key termination conditions
3. Format the output as structured JSON

What happens:

Tool call: convert_from_url(url, "md")
  → job_id: "job_abc123", estimated_cost: $0.05

Tool call: get_job_status("job_abc123")  
  → status: "complete"

Tool call: get_download_url("job_abc123")
  → download_url: "https://cdn.botverse.cloud/..."

The agent fetches the clean markdown (~35,000 tokens for the same contract), extracts the structured data, and produces the output. Total input tokens: ~37,000. Total cost including the $0.05 Botverse job: ~$0.16 vs $2.31.

For a pipeline processing 500 contracts a month: $80 vs $1,155.

When the agent doesn't need to read the file at all

The pattern gets even more powerful when the agent's job is transformation, not comprehension.

Consider: "Convert all this week's board meeting notes from DOCX to PDF and upload them to the board portal."

The agent doesn't need to read the content. It needs to:

Get a list of DOCX files (from Drive, S3, wherever)
For each: call convert_from_url(url, "pdf"), get the output URL
Upload each PDF to the board portal

Total agent token cost per document: ~1,500 tokens (three MCP calls). The files can be arbitrarily large — 100MB, 1GB — the token cost doesn't change.

This is the correct architecture for file-processing agents. The agent reasons. Specialist services compute.

The underlying principle

There's an argument that LLM context windows are getting so large that this doesn't matter anymore. Gemini 2.0 Pro has 2M tokens. Claude has 200K. Just throw everything in.

This argument has two problems.

Cost. Large context windows are expensive. 97,354 input tokens at claude-sonnet-4-6 is $0.29. At claude-opus-4-7 it's over $1.00. If your agent processes high volumes, you're paying a huge premium for compute you don't need.

Performance. LLMs degrade at extracting specific information from large, noisy contexts. The "lost in the middle" problem is well-documented — models struggle to attend to relevant content buried in long inputs. A clean, well-structured markdown document is easier for a model to reason about than raw extracted PDF text with page numbers, headers, and encoding artifacts embedded throughout.

The right mental model: every token your agent spends on file I/O is reasoning capacity it can't spend on your actual problem.

Getting started

Botverse is an MCP-native cloud API for file processing — video transcoding and document conversion, built for AI agents.

Sign up at botverse.cloud — $2.50 minimum top-up, no monthly fees
Document conversion: $0.05/job (md, html, docx, pdf, rst, txt, xlsx)
Video transcoding: $0.25/job base (mp4, webm, ProRes, mp3, gif)
Add the MCP server in Claude Desktop in 30 seconds: Smithery search "Botverse"

The benchmark numbers in this article came from processing a 2MB research PDF in both modes using claude-sonnet-4-6. https://botverse.cloud/benchmark

Have a different approach to token-efficient file processing? I'd love to hear it in the comments.

DEV Community: Mark Turner

Botverse officially launches tomorrow - 6/9/26!

Add video transcoding to your Claude agent in 5 minutes (MCP)

Add video transcoding to your Claude agent in 5 minutes (MCP)

Teach your Claude Agent to process Zoom recordings and extract audio in 5 minutes (MCP)

🛠️ The 5-Minute Setup

🔄 The IT Developer Workflow Under the Hood

1. transcode_from_url

2. get_job_status

3. get_download_url

📸 See It In Action

💰 Predictable Pricing, Zero Idle Server Costs

🚀 Next Steps

I gave my AI agent a 2MB PDF. Here's what happened to my token count.

How the token count explodes

The alternative: specialist services via MCP

A concrete example

When the agent doesn't need to read the file at all

The underlying principle

Getting started

1. `transcode_from_url`

2. `get_job_status`

3. `get_download_url`