Forem: voipbin

Add Voice Calling to Claude Desktop in 5 Minutes with MCP

voipbin — Sat, 11 Apr 2026 17:01:48 +0000

You're already using Claude Desktop or Cursor to write code, answer questions, and automate workflows. But here's a capability most developers don't know exists: your AI assistant can make and receive real phone calls — right now, with five minutes of setup.

This isn't a gimmick. It's powered by VoIPBin's MCP server, and it opens up a surprisingly practical set of use cases once you see it in action.

Why Voice + AI in the Same Context?

The usual story is: you build an AI agent, then separately wire up telephony, then glue them together with webhooks and fragile state machines.

MCP flips that. Instead of your AI calling an external service, your AI assistant becomes the orchestrator. It can initiate a call, monitor it, branch on the result — all within the same reasoning loop where it already knows your context.

Practical examples:

Claude calls a customer to confirm an appointment it just scheduled
Your AI agent dials a support line on your behalf and navigates the IVR
You ask Cursor to make a test call to your new voice bot and report back what it heard
An automated flow places outbound calls when triggered by a database event

Step 1: Get a VoIPBin API Key

First, create an account. No OTP, no credit card required to start:

curl -s -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{
    "username": "your-username",
    "password": "your-password",
    "email": "you@example.com",
    "name": "Your Name"
  }'

The response includes accesskey.token — that's your API key. Copy it.

Step 2: Install the VoIPBin MCP Server

VoIPBin ships as a Python package you run with uvx (no install, just run):

uvx voipbin-mcp

That's it. No Docker, no daemon, no port forwarding.

Step 3: Connect It to Claude Desktop

Open your Claude Desktop config file:

# macOS
open ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Windows
notepad %APPDATA%\Claude\claude_desktop_config.json

Add the VoIPBin MCP server:

{
  "mcpServers": {
    "voipbin": {
      "command": "uvx",
      "args": ["voipbin-mcp"],
      "env": {
        "VOIPBIN_API_KEY": "your-api-key-here"
      }
    }
  }
}

Restart Claude Desktop. You'll see VoIPBin appear in the tools panel.

Step 4: Make a Call

Now just ask Claude:

"Call +1-555-0100 and play a message saying: Hello, this is a test call from my AI assistant."

Claude will use the MCP tool to initiate the call through VoIPBin's infrastructure. The call goes out over real PSTN. The recipient hears a real phone call.

Or try something more interesting:

"Call +1-555-0100, wait for the person to answer, read them the summary of today's tasks, and tell me what they said."

Because VoIPBin handles STT (speech-to-text) and TTS (text-to-speech) on its end, Claude never has to touch audio streams. It sends text in, gets text back. The entire voice pipeline is invisible to your AI logic.

What's Happening Under the Hood

Claude Desktop
     │
     │  MCP tool call: make_call(to="+1555...", message="Hello...")
     ▼
VoIPBin MCP Server
     │
     │  REST API → https://api.voipbin.net/v1.0
     ▼
VoIPBin Infrastructure
     │
     ├─ Allocates real phone number (or uses Direct Hash SIP URI)
     ├─ Initiates SIP/RTP call to destination
     ├─ Converts your text → TTS audio
     ├─ Plays to recipient
     ├─ Captures response via STT
     └─ Returns transcript back to Claude

Your AI sees: text in, text out.
VoIPBin handles: codecs, SIP, RTP, NAT traversal, carrier routing, audio processing.

Using It in Cursor (or Any MCP-Compatible IDE)

Cursor supports MCP too. Add the same config block to your Cursor settings and you can do things like:

You: "I just deployed the new onboarding flow. Can you call our test number
       +1-555-0199 and walk through the IVR to check if it's working?"

Cursor: [calls the number, navigates the prompts, reports back]
        "Step 1 asked for language selection — I pressed 1 for English.
         Step 2 played the welcome message correctly.
         Step 3 transferred to the queue as expected."

This is genuinely useful for testing voice bots during development — no need to manually call your own system every time you make a change.

What You Can Do With the MCP Tools

The VoIPBin MCP server exposes several tools:

Tool	What It Does
`make_call`	Initiate an outbound call to any PSTN number
`send_sms`	Send an SMS message
`get_call_status`	Check if a call is active, completed, or failed
`list_calls`	See recent call history
`get_recording`	Retrieve call recording or transcript

Claude can chain these together. For example: make a call, wait for it to complete, then retrieve the transcript and summarize it.

Real Use Case: AI-Assisted Outreach

Here's a pattern some teams are using:

Claude reads a CRM export (a CSV of leads)
For each lead, it composes a personalized intro message
It uses VoIPBin MCP to place calls and deliver the message
It collects responses and updates the CRM

All of this happens inside a single Claude conversation — no separate pipeline, no extra services, no code to deploy.

Limitations to Know

Free tier has call limits — check voipbin.net for current quotas
Outbound PSTN calls require a funded account for carrier costs
MCP tool availability depends on your Claude plan (Claude Pro and above support MCP)
Not all MCP clients support all tool types — test with your specific setup

Where to Go From Here

VoIPBin API Docs — full reference for calls, SMS, flows, and agents
Golang SDK: go get github.com/voipbin/voipbin-go — if you want to build custom integrations
Direct Hash SIP URI — run an AI voice bot without a phone number at all (no carrier required)

If you're already living in Claude or Cursor all day, adding voice is literally a config file change away. Five minutes, and your AI assistant has a phone.

Have a use case you've built with AI + voice? Drop it in the comments — always curious what people are doing with this.

Real-Time Voice Transcription for Your AI Agent — Without the Plumbing

voipbin — Fri, 10 Apr 2026 17:01:15 +0000

When you build an AI agent that handles voice calls, you quickly hit a wall: how do you get the spoken words into your AI's context in real time?

The naive path is painful. You stand up a WebSocket server, ingest raw RTP packets, decode the audio codec, buffer frames, feed them into a speech-to-text engine, manage partial vs. final transcripts, and somehow do all of this while also running your actual AI logic. Oh, and latency matters — callers don't wait 3 seconds between sentences.

This post shows how to skip all that plumbing and get real-time transcription piped directly into your AI agent using VoIPBin.

The Problem With DIY Transcription

Let's be concrete. Here's what a "simple" DIY voice pipeline looks like:

Caller → SIP → RTP stream → your server
                               ↓
                         decode opus/PCMU
                               ↓
                     buffer + VAD detection
                               ↓
                       STT API (Google/AWS/Deepgram)
                               ↓
                    handle partial transcripts
                               ↓
                         your AI logic
                               ↓
                    TTS → re-encode audio → RTP back

Each step is a failure point. Each step adds latency. And none of it is your actual product.

What VoIPBin Does Instead

VoIPBin handles the entire media pipeline. Your AI agent only ever sees text in, text out.

The architecture flips to:

Caller → SIP → VoIPBin
                  ↓
           STT (real-time)
                  ↓
        webhook → your AI agent (text)
                  ↓
        AI response (text)
                  ↓
           TTS + RTP back to caller

Your server doesn't touch audio at all. It receives a transcript, thinks, replies with text.

Hands-On: Getting Transcripts Into Your Agent

Step 1: Sign Up and Get Your Token

curl -s -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"username": "yourname", "password": "yourpass"}'

You get back an accesskey.token. No email confirmation, no waiting.

Step 2: Create a Flow That Transcribes and Calls Your Webhook

VoIPBin Flows define what happens during a call. Here's a minimal flow that:

Answers the call
Listens and transcribes
Sends the transcript to your agent via webhook
Speaks the agent's reply back

import httpx

TOKEN = "your-access-token"

flow = {
    "name": "AI Transcription Agent",
    "steps": [
        {
            "type": "answer"
        },
        {
            "type": "talk",
            "text": "Hello! How can I help you today?"
        },
        {
            "type": "listen",
            "timeout": 5000,
            "webhook": {
                "url": "https://your-server.com/transcript",
                "method": "POST"
            }
        }
    ]
}

res = httpx.post(
    "https://api.voipbin.net/v1.0/flows",
    headers={"Authorization": f"Bearer {TOKEN}"},
    json=flow
)
print(res.json())

When a caller speaks, VoIPBin transcribes it and POSTs the result to your webhook URL. You handle the text, return a response, and VoIPBin speaks it.

Step 3: Your AI Agent Receives the Transcript

Here's a minimal FastAPI handler that receives transcripts and responds with an AI reply:

from fastapi import FastAPI, Request
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI()

@app.post("/transcript")
async def handle_transcript(req: Request):
    body = await req.json()

    # VoIPBin sends the recognized text here
    user_text = body.get("transcript", "")
    call_id = body.get("call_id", "")

    print(f"[{call_id}] User said: {user_text}")

    if not user_text.strip():
        return {"action": "listen"}  # keep listening if empty

    # Run your AI
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are a helpful phone assistant. Keep responses brief."},
            {"role": "user", "content": user_text}
        ]
    )

    reply = response.choices[0].message.content

    # Return the reply — VoIPBin will speak it via TTS
    return {
        "action": "talk",
        "text": reply,
        "then": {"action": "listen"}  # loop: listen again after speaking
    }

That's the entire voice AI agent. No audio code. No codec handling. No streaming buffers.

Step 4: Attach a Phone Number (or Use SIP Without One)

If you want callers to reach you via a real phone number:

# Purchase a DID number
res = httpx.post(
    "https://api.voipbin.net/v1.0/numbers/purchase",
    headers={"Authorization": f"Bearer {TOKEN}"},
    json={"country": "US", "flow_id": "<your-flow-id>"}
)
number = res.json()["number"]
print(f"Your AI agent is reachable at: {number}")

Or skip the number entirely with a Direct Hash SIP URI — useful for testing or internal tools:

sip:<your-hash>@sip.voipbin.net

No number needed. Dial it from any SIP client.

What the Transcript Payload Looks Like

Here's a sample payload your webhook receives:

{
  "call_id": "a1b2c3d4-...",
  "transcript": "I need to cancel my subscription",
  "confidence": 0.97,
  "language": "en-US",
  "is_final": true,
  "duration_ms": 1840
}

is_final: true means VoIPBin has determined the speaker finished. You don't have to implement voice activity detection (VAD) yourself — it's already done.

Building a Conversation Loop

For a multi-turn conversation, keep a session store keyed by call_id:

from collections import defaultdict

conversation_history = defaultdict(list)

@app.post("/transcript")
async def handle_transcript(req: Request):
    body = await req.json()
    user_text = body.get("transcript", "")
    call_id = body.get("call_id", "")

    if not user_text.strip():
        return {"action": "listen"}

    # Append to conversation history
    history = conversation_history[call_id]
    history.append({"role": "user", "content": user_text})

    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are a helpful support agent."},
            *history
        ]
    )

    reply = response.choices[0].message.content
    history.append({"role": "assistant", "content": reply})

    return {
        "action": "talk",
        "text": reply,
        "then": {"action": "listen"}
    }

@app.post("/call-ended")
async def cleanup(req: Request):
    body = await req.json()
    call_id = body.get("call_id", "")
    # Log the full conversation, then clean up
    print(f"Call {call_id} ended. Turns: {len(conversation_history.get(call_id, []))}")
    conversation_history.pop(call_id, None)
    return {"ok": True}

Now your agent maintains context across the entire call without any extra infrastructure.

Using the MCP Server (Claude Desktop / Cursor)

If you want to wire this up from Claude Desktop or Cursor without writing any boilerplate:

uvx voipbin-mcp

This launches the VoIPBin MCP server. Configure it in your Claude Desktop config.json and you can tell Claude to "make a call", "check transcripts", or "set up a flow" directly from the chat.

What You Get (and What You Don't Have to Build)

What VoIPBin handles	What you own
RTP / audio streaming	Business logic
Speech-to-text	AI model choice
Voice activity detection	Conversation state
Text-to-speech	Webhook endpoint
SIP signaling	Deployment
Multi-language STT	Nothing else

Your codebase stays small. Your team doesn't need telephony expertise.

Try It

Website: voipbin.net
MCP Server: uvx voipbin-mcp
Go SDK: go get github.com/voipbin/voipbin-go
Signup: POST https://api.voipbin.net/v1.0/auth/signup — token returned immediately

If you're building any kind of voice AI — customer support bots, appointment scheduling, survey calls — the transcription pipeline is the part that will eat your sprint. Offload it.

Questions? Drop them in the comments.

VoIPBin Quickstart: Make Your First AI Phone Call in 10 Minutes

voipbin — Fri, 10 Apr 2026 13:41:32 +0000

VoIPBin Quickstart: Make Your First AI Phone Call in 10 Minutes

Who is this for: Developers building AI agents, voice bots, or anything that needs to make/receive phone calls.
Goal: From signup to your first outbound call in under 10 minutes.
Prerequisites: curl, internet connection, a valid email address.

Overview

Step 1: Sign up & get your accesskey     (~1 min)
Step 2: Create an extension              (~1 min)
Step 3: Register a virtual number        (~2 min)
Step 4: Make your first call with TTS    (~2 min)
[Optional] Add an AI voice agent         (~5 min)

URL rules:

Signup only: https://api.voipbin.net/auth/signup (no version prefix)
All other APIs: https://api.voipbin.net/v1.0/...
Auth: append ?accesskey=<token> to every /v1.0/ request

Step 1: Sign Up & Get Your accesskey (~1 min)

1-1. Create your account

curl -X POST "https://api.voipbin.net/auth/signup" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Company",
    "email": "you@example.com",
    "accepted_tos": true
  }'

Required fields:

email — must be unique
accepted_tos — must be true (HTTP 400 if missing or false)
name — display name (optional but recommended)

Success response (HTTP 200):

{
  "customer": {
    "id": "8ecaddc4-132b-442c-b298-50eb5f999ef4",
    "name": "My Company",
    "email": "you@example.com",
    "status": "initial"
  },
  "accesskey": {
    "token": "vb_hTKRAgGglhaw8na3zpuHEx8JQs5dPJgd",
    "tm_expire": "2027-04-10T02:35:36Z"
  }
}

⚠️ Save your token now. It is only returned once at signup. Subsequent calls to GET /v1.0/accesskeys only return a token_prefix.

Got an empty {} response? The email is already registered. Use a different email (VoIPBin does not confirm duplicates for security reasons).

1-2. Save your key

export VOIPBIN_KEY="vb_hTKRAgGglhaw8na3zpuHEx8JQs5dPJgd"  # replace with your token

1-3. Verify your account

curl "https://api.voipbin.net/v1.0/customer?accesskey=$VOIPBIN_KEY"

Check these fields:

status: "initial" — email not yet verified, but virtual number tests work fine
balance_token: 100 — free credits for new accounts

To call real PSTN numbers (like +1-555-xxx), you will need email verification + identity verification. For now, virtual numbers work without any verification.

Step 2: Create an Extension (~1 min)

An extension is a virtual phone endpoint — think of it as an internal SIP address. You can receive calls on it using a SIP softphone (e.g., Linphone), or use it as a destination for your AI agent to call.

Note on uniqueness: The extension value must be globally unique across the entire VoIPBin platform. Use a timestamp or UUID to avoid conflicts.

EXT_ID="qs-$(date +%s)"

curl -X POST "https://api.voipbin.net/v1.0/extensions?accesskey=$VOIPBIN_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"extension\": \"$EXT_ID\",
    \"name\": \"quickstart-phone\",
    \"detail\": \"My quickstart extension\",
    \"password\": \"SecurePass123!\"
  }"

Success response:

{
  "id": "5c48c33d-5a0d-4c66-a858-d93baf692352",
  "name": "quickstart-phone",
  "extension": "qs-1775789155",
  "direct_hash": "direct.5411df2cf9c6"
}

Important: When making calls to this extension, use the name value ("quickstart-phone") as target_name.

Optional — connect a SIP softphone to actually hear the call:

SIP server: sip.voipbin.net
Username: the extension field value
Domain: the domain_name field value
Password: what you set above

Step 3: Register a Virtual Number (~2 min)

Virtual numbers (+899 range) let you test voice flows without buying a real phone number. No email verification needed.

3-1. Find an available virtual number

curl "https://api.voipbin.net/v1.0/available_numbers?accesskey=$VOIPBIN_KEY&type=virtual"

Response:

{
  "result": [
    { "number": "+899617591104", "country": "899", "features": ["voice"] },
    { "number": "+899469526280", "country": "899", "features": ["voice"] }
  ]
}

3-2. Register the number

curl -X POST "https://api.voipbin.net/v1.0/numbers?accesskey=$VOIPBIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "number": "+899617591104",
    "type": "virtual",
    "call_flow_id": "00000000-0000-0000-0000-000000000000",
    "message_flow_id": "00000000-0000-0000-0000-000000000000",
    "name": "quickstart-virtual",
    "detail": "My quickstart number"
  }'

call_flow_id and message_flow_id define what happens when someone calls this number. For outbound-only testing, use the nil UUID "00000000-0000-0000-0000-000000000000".

export VOIPBIN_NUMBER="+899617591104"  # replace with your number

Step 4: Make Your First Call — TTS Voice Message (~2 min)

This is the part where your AI agent actually speaks. You do not need to handle any audio, codecs, or media servers — VoIPBin takes care of all of that.

curl -X POST "https://api.voipbin.net/v1.0/calls?accesskey=$VOIPBIN_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"source\": {
      \"type\": \"tel\",
      \"target\": \"$VOIPBIN_NUMBER\"
    },
    \"destinations\": [
      {
        \"type\": \"extension\",
        \"target_name\": \"quickstart-phone\"
      }
    ],
    \"actions\": [
      {
        \"type\": \"talk\",
        \"option\": {
          \"text\": \"Hello! This is a VoIPBin test call. Your AI voice agent is working!\",
          \"language\": \"en-US\"
        }
      },
      {
        \"type\": \"hangup\"
      }
    ]
  }"

Supported languages for talk:

English: "en-US"
Korean: "ko-KR"
Japanese: "ja-JP"

Success response:

{
  "groupcalls": [
    {
      "id": "fc2b8e74-cdab-435c-827b-cc3c6e59ffc1",
      "status": "progressing"
    }
  ]
}

status: "progressing" means the call connected and TTS is playing. That is it — your AI agent just made a phone call.

Check call status

GROUPCALL_ID="fc2b8e74-cdab-435c-827b-cc3c6e59ffc1"
curl "https://api.voipbin.net/v1.0/groupcalls/$GROUPCALL_ID?accesskey=$VOIPBIN_KEY"

Call states: dialing → ringing → progressing → hangup

Step 5 (Optional): Add an AI Voice Agent

Want two-way conversation instead of one-way TTS? You can attach a GPT or Gemini model to handle the dialogue.

Create an AI configuration

curl -X POST "https://api.voipbin.net/v1.0/ais?accesskey=$VOIPBIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "quickstart-ai",
    "detail": "My AI voice agent",
    "engine_model": "openai.gpt-4o-mini",
    "engine_key": "<YOUR_OPENAI_API_KEY>",
    "init_prompt": "You are a helpful voice assistant. Keep responses short and clear.",
    "tts_type": "openai",
    "stt_type": "openai",
    "stt_language": "en-US"
  }'

Supported models: openai.gpt-4o-mini, openai.gpt-4o, gemini.gemini-2.0-flash, gemini.gemini-2.5-flash, grok.grok-3-mini

Make a call with the AI agent

curl -X POST "https://api.voipbin.net/v1.0/calls?accesskey=$VOIPBIN_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"source\": { \"type\": \"tel\", \"target\": \"$VOIPBIN_NUMBER\" },
    \"destinations\": [{ \"type\": \"extension\", \"target_name\": \"quickstart-phone\" }],
    \"actions\": [
      {
        \"type\": \"ai_talk\",
        \"option\": {
          \"assistance_type\": \"ai\",
          \"assistance_id\": \"<YOUR_AI_ID>\",
          \"duration\": 300
        }
      }
    ]
  }"

Common Errors

Status	Cause	Fix
`401` on signup	Using `/v1.0/auth/signup`	Use `https://api.voipbin.net/auth/signup` (no version prefix)
`400` on signup	Missing `accepted_tos` or `email`	Add `"accepted_tos": true` and a valid email
`400` on extension	`extension` value already taken	Use a timestamp: `"qs-$(date +%s)"`
`200 {}` on signup	Email already registered	Use a different email
`401` on API calls	Wrong accesskey	Check your `$VOIPBIN_KEY` value

What's Next

Feature	Endpoint	What it gives you
Reusable flows	`POST /v1.0/flows`	Save and reuse call logic
Call recording	`POST /v1.0/calls/{id}/recording_start`	Record ongoing calls
Real-time transcription	`transcribe_start` action + WebSocket	Live speech-to-text
Inject TTS mid-call	`POST /v1.0/speakings/{id}/say`	Speak into an active call
Buy a real number	`GET /v1.0/available_numbers?country_code=US`	PSTN numbers
Outbound campaigns	`POST /v1.0/campaigns`	Bulk automated calling

Receive events (webhook or WebSocket):

# Set a webhook
curl -X PUT "https://api.voipbin.net/v1.0/customer?accesskey=$VOIPBIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"webhook_method": "POST", "webhook_uri": "https://your-server.com/events"}'

# Or connect via WebSocket
# wss://api.voipbin.net/v1.0/ws?accesskey=<VOIPBIN_KEY>

Resources


API Docs	https://api.voipbin.net/redoc/
OpenAPI spec	https://api.voipbin.net/openapi.json
Detailed docs	https://api.voipbin.net/docs/
Admin console	https://admin.voipbin.net
Go SDK	https://github.com/voipbin/voipbin-go
MCP server	`uvx voipbin-mcp`
Website	https://voipbin.net

Building an AI-Powered IVR with VoIPBin Flows

voipbin — Thu, 09 Apr 2026 17:01:24 +0000

Traditional IVR (Interactive Voice Response) systems are famously terrible. Press 1 for billing. Press 2 for support. Press 0 to repeat the menu. They're rigid, frustrating, and haven't fundamentally changed in decades.

With VoIPBin Flows, you can replace the entire DTMF press-tree with a natural language AI that understands intent, handles multi-turn conversations, and takes real actions — all without managing audio infrastructure.

This post walks through designing and deploying an AI-powered IVR using VoIPBin's Flows API.

What Is a VoIPBin Flow?

A Flow is a reusable call behavior definition — a sequence of actions that VoIPBin executes when a call is answered. Actions can:

Speak text (TTS)
Collect speech input (STT + transcription)
Branch on conditions
Hand off to an AI agent
Transfer to a human agent
Play audio files
Hang up

You compose these actions into a call flow that runs server-side. Your application code stays clean and stateless — VoIPBin tracks the in-progress call state.

The Problem With Classic IVR

A typical press-to-navigate IVR looks like this:

"Press 1 for Sales"
"Press 2 for Support"
"Press 3 for Billing"
"Press 0 to speak with an agent"

Users get lost, press wrong numbers, and abandon calls. Developers maintain brittle decision trees that grow one branch at a time.

An AI-powered IVR replaces the menu with a simple open question:

"Hi! How can I help you today?"

The AI routes the call based on what the caller says, not which button they press.

Step 0: Get Your Access Key

curl -s -X POST "https://api.voipbin.net/v1.0/auth/signup" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-ivr-project",
    "email": "you@example.com",
    "password": "secure-password"
  }'
# Returns: { "accesskey": { "token": "your-access-key" } }

Use the returned token as ?accesskey=<token> on all subsequent requests.

Step 1: Create a Routing AI Agent

First, create an AI agent whose job is to understand the caller's intent and return a routing decision:

curl -s -X POST "https://api.voipbin.net/v1.0/agents?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ivr-router",
    "detail": "You are a voice IVR router. When the caller says what they need, classify it into one of: SALES, SUPPORT, BILLING, or GENERAL. Respond with only the category name. If unclear, say GENERAL.",
    "engine_type": "openai",
    "engine_model": "gpt-4o"
  }'

Note the returned id — you'll reference it in the flow.

Step 2: Create Specialized Agents

For each department, create a specialized agent:

# Sales agent
curl -s -X POST "https://api.voipbin.net/v1.0/agents?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "sales-agent",
    "detail": "You are a helpful sales representative. Assist callers with product information, pricing, and demos. Be friendly and concise.",
    "engine_type": "openai",
    "engine_model": "gpt-4o"
  }'

# Support agent
curl -s -X POST "https://api.voipbin.net/v1.0/agents?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "support-agent",
    "detail": "You are a technical support specialist. Help callers troubleshoot issues with their account or product. Ask clarifying questions when needed.",
    "engine_type": "openai",
    "engine_model": "gpt-4o"
  }'

# Billing agent
curl -s -X POST "https://api.voipbin.net/v1.0/agents?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "billing-agent",
    "detail": "You are a billing specialist. Help callers with invoices, payments, refunds, and subscription changes.",
    "engine_type": "openai",
    "engine_model": "gpt-4o"
  }'

Step 3: Create the IVR Flow

Now assemble the flow. The structure is:

Greet the caller
Collect their intent via speech
Route to the appropriate AI agent

curl -s -X POST "https://api.voipbin.net/v1.0/flows?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "smart-ivr-flow",
    "actions": [
      {
        "type": "talk",
        "text": "Hello! Thanks for calling. How can I help you today?"
      },
      {
        "type": "transcribe",
        "end_silence_timeout": 2,
        "max_duration": 15
      },
      {
        "type": "ai_route",
        "agent_id": "<ivr-router-agent-id>",
        "routes": {
          "SALES": {
            "type": "ai_talk",
            "agent_id": "<sales-agent-id>",
            "welcome_message": "Connecting you to our sales team. One moment."
          },
          "SUPPORT": {
            "type": "ai_talk",
            "agent_id": "<support-agent-id>",
            "welcome_message": "I will help you with that support issue."
          },
          "BILLING": {
            "type": "ai_talk",
            "agent_id": "<billing-agent-id>",
            "welcome_message": "Let me look into your billing question."
          },
          "GENERAL": {
            "type": "ai_talk",
            "agent_id": "<sales-agent-id>",
            "welcome_message": "Let me connect you with someone who can help."
          }
        }
      }
    ]
  }'

Step 4: Attach a Phone Number to the Flow

Purchase or assign a number to your flow:

# List available numbers
curl -s "https://api.voipbin.net/v1.0/numbers/available?accesskey=YOUR_KEY&country_code=US"

# Purchase a number and link it to your flow
curl -s -X POST "https://api.voipbin.net/v1.0/numbers?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "number": "+12025550100",
    "flow_id": "<your-flow-id>"
  }'

Now any call to that number runs your smart IVR flow automatically.

Python Example: Dynamically Creating Flows

For production systems, you might want to generate flows programmatically:

import httpx

BASE_URL = "https://api.voipbin.net/v1.0"
ACCESS_KEY = "your-access-key"

def create_ivr_flow(name: str, agent_ids: dict) -> dict:
    """Create a smart IVR flow with AI routing."""
    actions = [
        {
            "type": "talk",
            "text": "Hello! Thanks for calling. How can I help you today?"
        },
        {
            "type": "transcribe",
            "end_silence_timeout": 2,
            "max_duration": 15
        },
        {
            "type": "ai_route",
            "agent_id": agent_ids["router"],
            "routes": {
                dept: {
                    "type": "ai_talk",
                    "agent_id": agent_id,
                    "welcome_message": f"Routing to {dept.lower()} now."
                }
                for dept, agent_id in agent_ids.items()
                if dept != "router"
            }
        }
    ]

    response = httpx.post(
        f"{BASE_URL}/flows",
        params={"accesskey": ACCESS_KEY},
        json={"name": name, "actions": actions}
    )
    response.raise_for_status()
    return response.json()

# Usage
flow = create_ivr_flow(
    name="smart-ivr",
    agent_ids={
        "router": "<router-agent-id>",
        "SALES": "<sales-agent-id>",
        "SUPPORT": "<support-agent-id>",
        "BILLING": "<billing-agent-id>",
    }
)
print(f"Flow created: {flow['id']}")

Bonus: Webhook for Post-Call Analytics

You can receive a webhook after each call with the full transcript, routing path, and duration:

from flask import Flask, request

app = Flask(__name__)

@app.route("/call-events", methods=["POST"])
def handle_call_event():
    event = request.json
    event_type = event.get("type")

    if event_type == "call.ended":
        call_id = event["call_id"]
        transcript = event.get("transcript", [])
        routed_to = event.get("routed_agent")
        duration = event.get("duration_seconds")

        print(f"Call {call_id}: routed to {routed_to}, {duration}s")
        print(f"Transcript: {transcript}")

        # Log to your analytics pipeline
        log_call_data(call_id, routed_to, transcript, duration)

    return "", 204

if __name__ == "__main__":
    app.run(port=8080)

This gives you real routing data — which intents are most common, where callers get stuck, which agents handle calls fastest.

Classic IVR vs. AI IVR: Quick Comparison

Dimension	Classic IVR	AI-Powered IVR
Navigation	DTMF button presses	Natural language
Routing logic	Hardcoded decision tree	LLM intent classification
Maintenance	Add branches manually	Update agent prompt
Caller experience	Frustrating menus	Conversational
Misrouting	Common on complex trees	Handled by "GENERAL" fallback
Time to deploy	Hours of flow design	Minutes

MCP Shortcut

If you prefer to stay in your editor, the VoIPBin MCP server makes flow creation conversational:

uvx voipbin-mcp

Then in Claude Code or Cursor:

"Create an AI IVR flow for a SaaS company with routing to sales, support, and billing agents"

The MCP server handles all the API calls — you describe the behavior, it builds the flow.

Summary

VoIPBin Flows let you replace rigid DTMF menus with a clean action-based pipeline:

Greet — TTS welcome message
Listen — STT captures caller intent
Route — AI agent classifies and routes
Handle — Specialized AI agent manages the conversation
Analyze — Webhook delivers call data post-hang-up

No audio pipeline to manage. No codec configuration. Just flow logic and LLM prompts.

Resources

Direct Hash SIP URI: Run an AI Voice Bot Without a Phone Number

voipbin — Wed, 08 Apr 2026 17:02:21 +0000

Most people assume that to build a voice bot you need a phone number. Buy a DID, wire it to your IVR, handle the calls. That's the traditional path.

But what if you don't need a phone number at all?

VoIPBin supports Direct Hash SIP URIs — a way to connect callers directly to an AI voice agent using a SIP address instead of a phone number. No number purchase, no DID provisioning, no carrier dependency.

What Is a Direct Hash SIP URI?

A Direct Hash SIP URI looks like this:

sip:direct.<12-hex-chars>@sip.voipbin.net

For example:

sip:direct.a3f9c12b4e87@sip.voipbin.net

The 12-character hex string is derived from your agent's ID. Anyone with a SIP-capable client — softphone, WebRTC gateway, another SIP server — can call this URI and reach your AI agent directly.

No phone number. No carrier. Just SIP.

Why This Matters

Traditional approach:

Buy a phone number ($1–5/month per number)
Associate it with your app
Wait for provisioning
Handle PSTN ingress costs

Direct Hash SIP approach:

Create an agent
Derive the SIP URI from the agent ID
Share it with callers — done

This is especially useful for:

Internal tools — employee-facing voice bots that don't need a public number
B2B integrations — connect two SIP systems directly without PSTN
Dev/test environments — avoid burning real numbers during development
WebRTC apps — connect browser-based callers through a SIP gateway

Step 1: Sign Up and Get an Access Key

curl -s -X POST "https://api.voipbin.net/v1.0/auth/signup" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Agent",
    "email": "you@example.com",
    "password": "secure-password"
  }'
# Returns: { "accesskey": { "token": "your-access-key" } }

The token value is your accesskey — append it as ?accesskey=<token> to all API calls.

Step 2: Create an AI Agent

curl -s -X POST "https://api.voipbin.net/v1.0/agents?accesskey=<your-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "voice-assistant",
    "detail": "You are a helpful voice assistant. Answer questions concisely.",
    "engine_type": "openai",
    "engine_model": "gpt-4o"
  }'

Response:

{
  "id": "a3f9c12b-4e87-4a2c-9f31-d0e1b8c72a5f",
  "name": "voice-assistant",
  "detail": "You are a helpful voice assistant..."
}

Hold on to that id — you'll derive the SIP URI from it.

Step 3: Derive the Direct Hash SIP URI

The Direct Hash is the first 12 hex characters of the agent's UUID (dashes removed):

def get_direct_hash_uri(agent_id: str) -> str:
    hex_id = agent_id.replace("-", "")[:12]
    return f"sip:direct.{hex_id}@sip.voipbin.net"

# Example
agent_id = "a3f9c12b-4e87-4a2c-9f31-d0e1b8c72a5f"
print(get_direct_hash_uri(agent_id))
# sip:direct.a3f9c12b4e87@sip.voipbin.net

Same logic in Go — using the VoIPBin Go SDK:

package main

import (
    "fmt"
    "strings"
)

func getDirectHashURI(agentID string) string {
    hexID := strings.ReplaceAll(agentID, "-", "")
    if len(hexID) > 12 {
        hexID = hexID[:12]
    }
    return fmt.Sprintf("sip:direct.%s@sip.voipbin.net", hexID)
}

func main() {
    agentID := "a3f9c12b-4e87-4a2c-9f31-d0e1b8c72a5f"
    fmt.Println(getDirectHashURI(agentID))
    // sip:direct.a3f9c12b4e87@sip.voipbin.net
}

Step 4: Call the URI

Dial the SIP URI from any SIP-capable client (Linphone, Zoiper, Bria, etc.):

sip:direct.a3f9c12b4e87@sip.voipbin.net

VoIPBin routes the inbound call to your AI agent. The agent handles STT, LLM inference, and TTS — your code never sees raw audio.

You can also trigger a programmatic two-leg call using the Calls API:

curl -s -X POST "https://api.voipbin.net/v1.0/calls?accesskey=<your-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "source": "sip:caller@yourdomain.com",
    "destinations": [
      {
        "type": "sip",
        "target": "sip:direct.a3f9c12b4e87@sip.voipbin.net"
      }
    ]
  }'

This lets you bridge an external SIP endpoint into your AI agent on demand.

Bonus: Use the VoIPBin MCP Server

If you work with Claude Code or Cursor, the fastest way to experiment is the VoIPBin MCP server:

uvx voipbin-mcp

Then prompt Claude:

"Create a VoIPBin agent and give me its Direct Hash SIP URI"

The MCP server exposes the full VoIPBin API surface, so you can create agents, make calls, and manage flows entirely through natural language — no curl required.

Phone Number vs. Direct Hash: When to Use Which

	Direct Hash SIP URI	Phone Number (DID)
Cost	Free	~$1-5/month
Caller type	SIP / WebRTC clients	Any phone (PSTN)
Setup time	Instant	Minutes to hours
Best for	Internal, B2B, dev/test	Consumer-facing
PSTN access	No	Yes

Use Direct Hash when your callers are already SIP-capable. Use a real number when you need to reach regular phones or mobile.

Wrapping Up

Direct Hash SIP URIs are a simple but underappreciated feature:

No phone number purchase required
URI derived instantly from the agent ID
Works with any SIP client or WebRTC gateway
Zero carrier cost, zero provisioning delay

For internal tooling, developer environments, or B2B voice integrations, this is the cleanest way to deploy an AI voice bot without the overhead of phone number management.

Resources

Media Offloading: Why Your AI Agent Should Never Touch an Audio Stream

voipbin — Tue, 07 Apr 2026 17:01:22 +0000

Building a voice-capable AI agent sounds hard. You imagine it: raw RTP packets, G.711 codecs, jitter buffers, WebRTC negotiation, VAD (voice activity detection), and somehow, on top of all that, you need to run your LLM inference in real-time. It's a lot.

But here's the thing — your AI doesn't need to touch audio at all.

This is the core idea behind Media Offloading, the architectural pattern VoIPBin is built around. Let's break it down.

The Problem: AI + Audio Is a Bad Combination

Large language models are exceptionally good at understanding and generating text. They are not designed to:

Process raw audio bytes in real-time
Manage RTP session state
Handle codec negotiation (G.711 µ-law vs. A-law, Opus, G.729…)
Deal with packet loss, jitter, and network instability
Coordinate echo cancellation

Forcing your AI agent to own the audio pipeline is like hiring a brilliant engineer and making them manage server rack cabling. Technically possible, practically wasteful.

The Solution: Let the Telecom Layer Own the Media

Media offloading means the communication infrastructure handles everything audio-related, while your AI only ever sees clean, structured text.

Here's what the flow looks like:

Caller → [VoIPBin]
           ├── RTP handling
           ├── STT (Speech-to-Text)
           └── Text → [Your AI Agent]
                        └── Text response
           ├── TTS (Text-to-Speech)
           └── RTP back to caller

Your AI agent receives a webhook with the transcribed text, decides what to say, and returns a plain text response. VoIPBin handles everything else — codec negotiation, STT, TTS, and delivering audio back to the caller.

What This Looks Like in Practice

Let's say a user calls your AI-powered support line. Here's what each layer does:

VoIPBin (telecom layer):

Accepts the SIP INVITE
Establishes RTP media stream
Converts speech → text via STT
Sends a webhook to your AI

Your AI agent (text layer):

Receives: { "text": "I need to reset my password" }
Responds: { "text": "Sure! I'll send a reset link to your registered email." }

VoIPBin again:

Converts your text response → speech via TTS
Streams audio back to the caller

Your AI never saw a single audio byte. It just processed text, like it always does.

Building This With VoIPBin

Let's walk through a minimal implementation. First, sign up and get your access key:

curl -s -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"name": "my-agent", "password": "yourpassword"}'

# Returns:
# { "accesskey": { "token": "abc123..." } }

Step 1: Create an AI Agent

curl -s -X POST "https://api.voipbin.net/v1.0/agents?accesskey=abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "support-agent",
    "detail": "AI-powered customer support agent",
    "webhook": "https://your-server.com/ai-webhook"
  }'

Step 2: Handle the Webhook

Your server receives a POST request each time the caller speaks:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/ai-webhook", methods=["POST"])
def handle_call():
    data = request.json
    user_speech = data.get("text", "")
    call_id = data.get("call_id")

    print(f"[{call_id}] User said: {user_speech}")

    # Your AI logic here — call OpenAI, Anthropic, local model, etc.
    ai_response = generate_ai_response(user_speech)

    return jsonify({
        "text": ai_response
    })

def generate_ai_response(user_input: str) -> str:
    # Plug in any LLM here
    # Example: simple rule-based for illustration
    if "password" in user_input.lower():
        return "I can help with that. Can you confirm your email address?"
    elif "hours" in user_input.lower():
        return "We're open Monday through Friday, 9am to 6pm."
    else:
        return "I understand. Let me look into that for you."

if __name__ == "__main__":
    app.run(port=8080)

Step 3: Create a Flow That Uses the Agent

curl -s -X POST "https://api.voipbin.net/v1.0/flows?accesskey=abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "support-flow",
    "actions": [
      {
        "type": "ai_talk",
        "agent_id": "<your-agent-id>",
        "welcome_message": "Hello! How can I help you today?"
      }
    ]
  }'

That's it. Calls routed to this flow will automatically use STT → your AI → TTS, with VoIPBin managing all the media.

Golang SDK Example

If you prefer Go:

package main

import (
    "context"
    "fmt"
    "log"

    voipbin "github.com/voipbin/voipbin-go"
)

func main() {
    client := voipbin.NewClient("your-access-key")

    agent, err := client.Agents.Create(context.Background(), voipbin.CreateAgentParams{
        Name:    "support-agent",
        Detail:  "Handles customer support calls",
        Webhook: "https://your-server.com/ai-webhook",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Agent created: %s\n", agent.ID)
}

Install with:

go get github.com/voipbin/voipbin-go

Using VoIPBin MCP with Claude Code

If you use Claude Code or Cursor, you can set up VoIPBin's MCP server and control everything from your editor:

uvx voipbin-mcp

Then ask Claude to:

"Create an AI agent that handles inbound calls"
"Make an outbound call to +1-555-0100 and play a message"
"List all active calls right now"

The MCP server translates natural language instructions into VoIPBin API calls. Your AI development environment becomes a telecom control plane.

Why Media Offloading Matters for AI Agents

The shift from chatbots to voice agents is happening fast. But the infrastructure complexity of real-time audio has been a genuine barrier. Media offloading removes that barrier by:

Letting AI stay in its lane — LLMs are text-in, text-out. Keep it that way.
Reducing latency variance — Telecom infrastructure is optimized for low-latency audio. Your app server doesn't need to be.
Simplifying scaling — Scale your AI and your media handling independently.
Improving reliability — A bug in your AI logic doesn't crash the audio session.

Try It

🌐 Website: https://voipbin.net
📖 API Docs: https://api.voipbin.net/redoc/
📦 MCP on PyPI: voipbin-mcp
🐙 GitHub: github.com/voipbin

If you're building an AI agent that needs to talk to the real world, you probably want to stop thinking about audio pipelines and start thinking about what your AI actually does. Media offloading is how you make that separation clean.

Have questions or want to see a specific integration example? Drop a comment below.

One AI Flow, Two Channels: Voice and Web Chat from the Same Logic

voipbin — Tue, 07 Apr 2026 02:47:49 +0000

Most voice bot architectures and web chatbot architectures are built separately. Different codebases, different state management, duplicated logic.

VoIPBin just shipped a prototype that eliminates that separation.

The Insight: Direct Hash Works for Web Too

VoIPBin's Direct Hash was originally designed for voice: instead of provisioning a phone number, you generate a unique hash that maps directly to an AI flow.

sip:direct.<12-hex-chars>@sip.voipbin.net

The same mechanism now works for web clients. A web chatbot widget connects to the same hash, routes to the same AI flow. No separate endpoint. No separate logic.

Build Once, Deploy Everywhere

You design your AI interaction flow once in VoIPBin. That flow can now handle:

SIP voice calls
Web chatbot widget sessions

Same flow definition. Same conversation logic. Zero duplication.

The aicall Architecture

The underlying engine is aicall — originally built to manage async real-time voice. It tracks conversation state, manages the lifecycle, handles turn-taking.

Turns out the same lifecycle management works for web chat. A web conversation has the same fundamental pattern: async messages, stateful context, turn-taking. The voice infrastructure just works.

Current Status

This is a prototype. The architecture is validated, the servers are live, and you can test it at voipbin.net right now.

voipbin.net
API Reference
MCP: uvx voipbin-mcp
GitHub

Your AI Agent Can Make Real Phone Calls — Without Touching RTP or SIP

voipbin — Tue, 07 Apr 2026 02:11:15 +0000

If you're building AI agents that need to communicate with humans, you've probably hit the same wall: voice is hard.

Not the AI part. The telephony part.

RTP, SIP, DTMF, codecs, NAT traversal — this is a 40-year-old stack that was not designed for agents. Most developers end up either avoiding voice entirely, or spending weeks fighting infrastructure before writing a single line of agent logic.

There's a better path.

The Core Problem: Agents Shouldn't Handle Audio

A typical DIY voice bot pipeline:

Receive raw RTP audio from the caller
Run STT to get a transcript
Send the transcript to your LLM
Run TTS on the response
Stream audio back over RTP

Every step has latency, codec issues, and infrastructure concerns. And none of it is your actual product.

Media Offloading: Let VoIPBin Handle Audio

VoIPBin uses Media Offloading. Your AI agent only ever sees text. VoIPBin handles RTP, STT, and TTS.

Caller → VoIPBin (RTP/STT) → Your Agent (text only) → VoIPBin (TTS/RTP) → Caller

Getting Started

1. Sign Up

curl -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"username": "myagent", "password": "mypassword"}'

You get an accesskey.token immediately — no email verification needed.

2. Create a Call Flow

curl -X POST "https://api.voipbin.net/v1.0/flows?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Support Bot",
    "actions": [
      {"type": "talk", "text": "Hello! How can I help you today?"},
      {"type": "transcribe", "end_silence_timeout": 2}
    ]
  }'

3. Make a Call

curl -X POST "https://api.voipbin.net/v1.0/calls?accesskey=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "flow_id": "<flow-id>",
    "destination": "+15551234567"
  }'

VoIPBin dials out, handles the audio, and your agent logic runs on transcripts.

No Phone Number? No Problem

VoIPBin supports Direct Hash SIP URIs — no number provisioning needed:

sip:direct.<12-hex-chars>@sip.voipbin.net

Great for internal tools, dev testing, or agent-to-agent communication.

Use It From Claude Code (MCP)

VoIPBin ships an MCP server. Add to your settings:

{
  "mcpServers": {
    "voipbin": {
      "command": "uvx",
      "args": ["voipbin-mcp"],
      "env": { "VOIPBIN_API_KEY": "your-access-key" }
    }
  }
}

Then just tell Claude Code: "make a test call to this number" — no curl needed.

What You Skip

No RTP stack to manage
No codec negotiation
No STT/TTS infrastructure to deploy
No SIP registration

You keep: your agent logic and LLM calls.