DEV Community: voipbin

When AI Should Step Aside: Building Smart Human Handoff for Voice Bots

voipbin — Fri, 08 May 2026 17:04:53 +0000

Every AI voice bot eventually hits a wall.

A caller is frustrated. The issue is too complex. They ask for a manager. The AI stumbles.

At that moment, the worst thing your bot can do is keep trying. The best thing it can do is transfer the call gracefully to a human — with full context, zero hold-music dead air, and a warm intro.

This is called a warm handoff, and it separates a professional AI voice system from an annoying one. Today we build exactly that.

The Problem: AI Bots Don't Know When to Quit

Most developers focus on making their AI smarter. But there is an equally important skill: knowing when not to be smart, and routing to a human instead.

Common escalation triggers:

Caller explicitly asks for a human agent
AI fails to understand the same intent 2+ times
Sentiment turns angry or emotional
Topic falls outside AI scope (billing disputes, legal, account closures)
Call drags on without resolution

If your bot does not detect and handle these, callers hang up frustrated. That is worse than never having the bot at all.

The Architecture

Incoming Call
     |
     v
 VoIPBin receives + fires webhook
     |
     v
 AI Agent handles conversation
     |
     +-- Normal flow ---------> AI resolves, ends call
     |
     +-- Escalation trigger ---> Announce transfer
                                        |
                                        v
                                 VoIPBin bridges to
                                 human agent number
                                        |
                                        v
                                 Context whispered
                                 before bridge opens

VoIPBin handles the actual call bridging. Your code decides when and where to transfer. No SIP expertise required.

Step 1: Set Up Inbound Call Handling

A basic webhook server that receives calls and starts the AI conversation:

from flask import Flask, request, jsonify
import anthropic

app = Flask(__name__)

ANTHROPIC_CLIENT = anthropic.Anthropic()
HUMAN_AGENT_NUMBER = "+15551234567"
call_states = {}  # Use Redis in production

@app.route("/webhook/call", methods=["POST"])
def handle_call():
    data = request.json
    call_id = data["call_id"]
    event = data.get("event")

    if event == "call.started":
        call_states[call_id] = {"history": [], "failed_attempts": 0}
        return jsonify({
            "actions": [
                {
                    "type": "talk",
                    "text": "Hi! You have reached AI support. How can I help today?",
                    "voice": "en-US-Neural2-F"
                },
                {"type": "listen"}
            ]
        })

    if event == "call.speech":
        return handle_speech(call_id, data.get("transcript", ""))

    return jsonify({"status": "ok"})

Step 2: Detect Escalation Triggers

Three detection layers: keyword matching, failure counting, and AI sentiment analysis.

ESCALATION_PHRASES = [
    "talk to a human", "speak to a person", "real agent",
    "get a manager", "human please", "this is ridiculous",
    "this is useless", "forget it", "talk to someone"
]

def should_escalate(transcript, state):
    lower = transcript.lower()

    # Layer 1: explicit phrase match
    for phrase in ESCALATION_PHRASES:
        if phrase in lower:
            return True, "caller_requested"

    # Layer 2: repeated failure threshold
    if state["failed_attempts"] >= 2:
        return True, "repeated_failure"

    # Layer 3: AI sentiment detection (fast, cheap model)
    messages = state["history"] + [{"role": "user", "content": transcript}]
    check = ANTHROPIC_CLIENT.messages.create(
        model="claude-3-5-haiku-20241022",
        max_tokens=10,
        system=(
            "Evaluate if this support call should escalate to a human. "
            "Reply ONLY: ESCALATE or CONTINUE. "
            "Escalate if caller is angry, issue is sensitive, or AI cannot resolve."
        ),
        messages=messages
    )

    if check.content[0].text.strip() == "ESCALATE":
        return True, "ai_detected"

    return False, ""

Step 3: Execute the Warm Handoff

When escalation triggers, announce the transfer and bridge with context:

def handle_speech(call_id, transcript):
    state = call_states.get(call_id, {"history": [], "failed_attempts": 0})

    escalate, reason = should_escalate(transcript, state)
    if escalate:
        summary = summarize_call(state["history"], transcript)
        return execute_handoff(reason, summary)

    state["history"].append({"role": "user", "content": transcript})
    response = ANTHROPIC_CLIENT.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=200,
        system="You are a helpful support agent. Keep responses short for voice.",
        messages=state["history"]
    )
    ai_reply = response.content[0].text
    state["history"].append({"role": "assistant", "content": ai_reply})

    uncertainty_words = ["not sure", "cannot help", "unclear"]
    if any(w in ai_reply.lower() for w in uncertainty_words):
        state["failed_attempts"] += 1
    call_states[call_id] = state

    return jsonify({
        "actions": [
            {"type": "talk", "text": ai_reply, "voice": "en-US-Neural2-F"},
            {"type": "listen"}
        ]
    })


def summarize_call(history, last_transcript):
    if not history:
        return "Caller said: " + last_transcript
    result = ANTHROPIC_CLIENT.messages.create(
        model="claude-3-5-haiku-20241022",
        max_tokens=100,
        system="Summarize this support call in 1-2 sentences for the human agent taking over.",
        messages=history + [{"role": "user", "content": last_transcript}]
    )
    return result.content[0].text


def execute_handoff(reason, summary):
    announcements = {
        "caller_requested": "Of course. Let me connect you with a team member right away.",
        "repeated_failure": "I want to make sure you get the best help. Bringing in a specialist.",
        "ai_detected": "This sounds like something my colleague handles better. Transferring you now."
    }
    announce = announcements.get(reason, "Let me connect you with a team member.")

    return jsonify({
        "actions": [
            {"type": "talk", "text": announce, "voice": "en-US-Neural2-F"},
            {
                "type": "transfer",
                "destination": HUMAN_AGENT_NUMBER,
                "whisper": "AI transfer. Reason: " + reason + ". Context: " + summary
            }
        ]
    })

The whisper field is the critical detail. When the human agent answers, they hear the context summary before the bridge to the caller opens. No awkward silence. The agent starts informed.

Step 4: Register Your Webhook with VoIPBin

curl -X POST https://api.voipbin.net/v1.0/numbers/assign \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"number": "+15559998888", "webhook_url": "https://yourserver.com/webhook/call"}'

No VoIPBin account yet? Signup is instant — no email verification, no OTP:

curl -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"username": "you@example.com", "password": "yourpassword"}'
# Returns: { "accesskey": { "token": "eyJ..." } }

A Complete Call Flow With Escalation

AI:     "Hi! How can I help you today?"
Caller: "I need to dispute a $249 charge from April."
AI:     "I see the charge. It looks like an annual plan renewal."
Caller: "I cancelled that plan months ago. I want to talk to a manager."
AI:     "Absolutely. Connecting you with a team member right now."

[whisper to human agent — heard before caller bridge opens]:
  "AI transfer — caller_requested.
   John at john@example.com disputes a $249 annual renewal
   from April 3rd. Claims he cancelled. Tone: frustrated."

The human agent picks up already knowing who John is, why he is upset, and what the issue is. No "what is this call about?" No repeating the whole story.

Metrics to Watch

Once this is live, measure:

Escalation rate — what percent of calls transfer to humans? Aim for under 30%.
Escalation reason split — are callers requesting humans, or is your AI silently failing?
Post-transfer resolution rate — did the human actually solve it?
Repeat caller rate — same people calling back means root causes are not being fixed.

VoIPBin fires webhook events for every call state change, so you can log these into any analytics pipeline.

The Takeaway

A great AI voice bot is not one that never fails. It is one that fails gracefully.

Building smart escalation breaks down into five steps:

Detect triggers (explicit request, failure count, AI sentiment)
Summarize context for the human
Announce the transfer naturally
Whisper context before the bridge opens
Let VoIPBin bridge the call

Steps 3 through 5 are a single transfer action in your webhook response. The infrastructure does the heavy lifting. You focus on the logic.

Try it yourself at voipbin.net — get a token instantly and have a test call flowing in under 10 minutes.

Have you built human handoff in a voice bot before? What escalation triggers have you found most useful? Drop a comment below.

AI Call Screening: Let Your Bot Decide Which Calls Are Worth Your Time

voipbin — Thu, 07 May 2026 17:02:22 +0000

Most developers think of call screening as a phone carrier feature — press 1 to accept, or send to voicemail. But what if your AI could actually understand who is calling, why they are calling, and decide what to do next?

That is exactly what we will build today: an AI-powered call screening system that answers every incoming call, understands the intent, and routes accordingly — all without you ever picking up the phone.

The Problem with "Press 1"

Traditional IVR menus are friction machines. Callers hate them. Agents hate them. And they still do not solve the core problem: you do not know if a call is worth taking until you take it.

Here is a realistic scenario:

You run a consulting business or small SaaS
You get 30 calls a day
Maybe 5 are real leads
The rest are spam, vendors, or questions your docs already answer
You have no way to know which is which without answering

An AI screener changes this completely.

The Architecture

Incoming Call
     |
     v
 VoIPBin receives it
     |
     v
 Webhook -> Your Server
     |
     v
 AI greets caller, asks purpose
     |
     +-- Spam/vendor     --> Politely end call
     +-- Support question --> AI resolves it
     +-- Sales lead      --> Transfer to you
     +-- Urgent issue    --> SMS alert + transfer

Your AI handles the first 30 seconds of every call. You only get involved when it matters.

Setting Up VoIPBin

First, sign up and grab your API credentials:

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

This returns an accesskey.token immediately — no OTP, no waiting.

Next, rent a phone number and point it at your webhook URL, and you are ready.

Building the Screener

Here is the core screening bot in Python using FastAPI:

from fastapi import FastAPI, Request
from openai import OpenAI
import httpx, json

app = FastAPI()
client = OpenAI()

VOIPBIN_TOKEN = "YOUR_VOIPBIN_TOKEN"
MY_PHONE = "+14155551234"
BASE_URL = "https://api.voipbin.net/v1.0"

sessions = {}

SCREENER_PROMPT = """
You are an AI call screener. Your job:
1. Greet the caller and ask who they are and why they are calling
2. Classify the call as one of:
   - SPAM: robocalls, solicitations, irrelevant vendors
   - SUPPORT: tech questions, how-to, existing customers
   - SALES: potential new customers, partnership inquiries
   - URGENT: production issues, emergencies

Respond with JSON:
{"classification": "SALES", "summary": "Jane from Acme, wants enterprise pricing", "response": "What you said to the caller"}
"""

@app.post("/webhook/call")
async def handle_call(request: Request):
    event = await request.json()
    call_id = event["call_id"]
    event_type = event["type"]

    if event_type == "call.started":
        sessions[call_id] = {"history": [], "turn": 0}
        await speak(call_id, "Hi, thanks for calling. Could you tell me your name and what you are calling about today?")

    elif event_type == "call.transcription":
        caller_text = event["text"]
        session = sessions.get(call_id, {"history": [], "turn": 0})
        session["history"].append({"role": "user", "content": caller_text})
        session["turn"] += 1

        result = await screen_call(session["history"])

        if "classification" in result:
            await handle_classification(call_id, result)
        else:
            response_text = result.get("response", "Could you tell me a bit more?")
            session["history"].append({"role": "assistant", "content": response_text})
            await speak(call_id, response_text)

        sessions[call_id] = session

    return {"status": "ok"}

async def screen_call(history: list) -> dict:
    messages = [{"role": "system", "content": SCREENER_PROMPT}] + history
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

async def handle_classification(call_id: str, result: dict):
    classification = result["classification"]
    summary = result["summary"]

    if classification == "SPAM":
        await speak(call_id, "Thanks for calling. We are not interested at this time. Have a great day!")
        await end_call(call_id)
    elif classification == "SUPPORT":
        await speak(call_id, "Let me help you with that directly.")
        # Add RAG over your docs here
    elif classification == "SALES":
        await speak(call_id, "This sounds like a great conversation. Let me connect you with our team.")
        await transfer_call(call_id, MY_PHONE)
    elif classification == "URGENT":
        await speak(call_id, "I understand this is urgent. Connecting you right away.")
        await send_sms_alert(summary)
        await transfer_call(call_id, MY_PHONE)

async def speak(call_id: str, text: str):
    async with httpx.AsyncClient() as http:
        await http.post(
            f"{BASE_URL}/calls/{call_id}/actions",
            headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"},
            json={"action": "speak", "text": text, "language": "en-US"}
        )

async def transfer_call(call_id: str, phone: str):
    async with httpx.AsyncClient() as http:
        await http.post(
            f"{BASE_URL}/calls/{call_id}/actions",
            headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"},
            json={"action": "transfer", "destination": phone}
        )

async def end_call(call_id: str):
    async with httpx.AsyncClient() as http:
        await http.delete(
            f"{BASE_URL}/calls/{call_id}",
            headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"}
        )

async def send_sms_alert(summary: str):
    async with httpx.AsyncClient() as http:
        await http.post(
            f"{BASE_URL}/messages",
            headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"},
            json={"to": MY_PHONE, "text": f"URGENT CALL: {summary}"}
        )

How It Flows in Practice

Let us trace a real call:

Spam call:

Bot: "Hi, thanks for calling. Could you tell me your name and why you are calling?"
Caller: "This is an automated message about your car extended warranty..."
AI classifies: SPAM
Bot: "Thanks for calling. We are not interested. Have a great day!"
Call ends. Total time: ~10 seconds.

Sales lead:

Bot: "Hi, thanks for calling. Could you tell me your name and why you are calling?"
Caller: "Hi, I am Sarah from TechCorp. We are evaluating voice APIs for our AI product."
AI classifies: SALES, summary: "Sarah from TechCorp, evaluating voice APIs"
Bot: "This sounds like a great conversation. Let me connect you with our team."
Transfer to your phone. You pick up knowing it is a qualified lead.

What You Do Not Have to Build

Notice what is missing from the code above:

No audio recording or playback code
No RTP/SIP handling
No STT pipeline
No TTS setup
No phone carrier integrations

VoIPBin handles all of that. Your webhook receives clean text (call.transcription events), and your actions send text back (speak). The voice layer is completely abstracted.

This is the real value: you write business logic, not telephony plumbing.

Extending the Screener

Caller ID enrichment:

async def enrich_caller(phone_number: str) -> dict:
    existing = await crm.lookup(phone_number)
    if existing:
        return {"known": True, "name": existing.name, "tier": existing.tier}
    return {"known": False}

Time-based rules:

import datetime

def is_after_hours():
    hour = datetime.datetime.now().hour
    return hour < 9 or hour > 18
# After hours: only URGENT gets through

Screening summary log:

async def log_screening(call_id, result):
    await db.insert("screened_calls", {
        "call_id": call_id,
        "classification": result["classification"],
        "summary": result["summary"],
        "timestamp": datetime.datetime.utcnow()
    })

After a week, you have a dataset showing exactly what kinds of calls you get, how often, and what the AI decided — without you having answered a single spam call.

The Real Win

This is not about productivity hacks. It is about attention economics.

Every time you pick up an unknown call, you are making a bet: is this worth interrupting what I am doing? Most of the time, the answer is no. An AI screener shifts that bet entirely — you only engage when the AI has already decided the call is worth your time.

For small teams and solo founders, this is transformative. Your phone becomes a high-signal channel instead of an interruption machine.

Get Started

VoIPBin signup: POST https://api.voipbin.net/v1.0/auth/signup — instant access, no OTP
MCP for Claude: uvx voipbin-mcp — test calls directly from Claude Desktop
Go SDK: go get github.com/voipbin/voipbin-go
Docs and API: voipbin.net

If you try this out, what classification categories do you end up using? Drop a comment below.

Replace 'Press 1 for Sales' with AI Intent Routing

voipbin — Wed, 06 May 2026 17:03:26 +0000

Every caller hears it: "Press 1 for Sales. Press 2 for Support. Press 3 for Billing."

And every caller hates it.

Numeric IVR menus were invented because computers could not understand speech. That limitation is gone. Your AI can now listen to what callers actually say and route them instantly — no dial-pad gymnastics required.

This post shows you how to build natural language call routing with a real phone number, in about 50 lines of Python.

The Problem with Traditional IVR

Classic IVR works like this:

Play a menu
Wait for a DTMF keypress
Branch on the digit

Simple code, terrible experience:

Callers forget which option they want by option 7
"Press 0 to hear these options again" is a UX failure
Callers say "representative" into the void and nothing happens
Any menu change requires re-recording audio

The fix is obvious: let the caller say what they want.

The Architecture

Caller dials your number
        |
        v
  VoIPBin answers
  STT converts speech to text
        |
        v
  Your webhook receives
  the transcript
        |
        v
  LLM classifies intent
  sales / support / billing / other
        |
        v
  VoIPBin transfers call
  to the right destination

Your server never touches audio. VoIPBin handles RTP, STT, and TTS. You write pure business logic.

Step 1: Sign Up and Get a Number

# Create an account
curl -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"username":"you","password":"pass","email":"you@example.com"}'
# Save the accesskey.token as TOKEN

# Buy a phone number
curl -X POST https://api.voipbin.net/v1.0/numbers \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"country_code":"US","area_code":"415"}'

The number is active immediately. Point it to your webhook in the VoIPBin dashboard.

Step 2: Answer the Call and Prompt the Caller

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/call", methods=["POST"])
def handle_call():
    return jsonify({
        "actions": [
            {
                "type": "talk",
                "text": "Hi! Who would you like to speak with? "
                        "You can say Sales, Support, Billing, or describe your issue."
            },
            {
                "type": "input",
                "speech": {"timeout": 5},
                "action_url": "https://yourserver.com/route"
            }
        ]
    })

The input action listens for speech, transcribes it, and POSTs the result to /route.

Step 3: Classify Intent and Transfer

import openai

ROUTING_TABLE = {
    "sales":   "+14155550100",
    "support": "+14155550101",
    "billing": "+14155550102",
}

def classify_intent(transcript: str) -> str:
    resp = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a call routing classifier. "
                    "Respond with exactly one word: sales, support, billing, or unknown."
                )
            },
            {"role": "user", "content": transcript}
        ],
        max_tokens=5,
    )
    return resp.choices[0].message.content.strip().lower()


@app.route("/route", methods=["POST"])
def route_call():
    data = request.json
    transcript = data.get("speech", {}).get("results", [{}])[0].get("text", "")
    intent = classify_intent(transcript)
    destination = ROUTING_TABLE.get(intent)

    if destination:
        return jsonify({
            "actions": [
                {"type": "talk", "text": f"Connecting you to {intent} now."},
                {"type": "transfer", "destination": destination}
            ]
        })

    # Fallback
    return jsonify({
        "actions": [
            {"type": "talk", "text": "Let me transfer you to our main desk."},
            {"type": "transfer", "destination": "+14155550199"}
        ]
    })


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

That is the complete router.

What Callers Experience

Caller says	Intent	Goes to
"I want to buy something"	sales	Sales team
"My account is broken"	support	Support team
"Question about my invoice"	billing	Billing team
"Can I speak to someone?"	unknown	Main desk
"Quiero hablar con soporte"	support	Support team

That last row matters. LLM-based routing handles multilingual callers with zero extra configuration.

Useful Extensions

Priority routing — detect urgent calls before classification runs:

PRIORITY_KEYWORDS = {"urgent", "outage", "down", "emergency"}

if any(kw in transcript.lower() for kw in PRIORITY_KEYWORDS):
    return jsonify({
        "actions": [
            {"type": "talk", "text": "This sounds urgent. Connecting you to on-call now."},
            {"type": "transfer", "destination": "+14155550911"}
        ]
    })

Multi-turn context — if intent is unclear, ask a follow-up and send the full exchange to the LLM:

def classify_with_context(turns: list[dict]) -> str:
    messages = [{"role": "system", "content": "Route to: sales, support, billing, or unknown."}]
    messages.extend(turns)
    resp = openai.chat.completions.create(
        model="gpt-4o-mini", messages=messages, max_tokens=5
    )
    return resp.choices[0].message.content.strip().lower()

Why This Scales

Your server is stateless. Every webhook hit is an independent HTTP request. Run it behind any load balancer with zero sticky-session config. Ten calls or ten thousand — same code, same latency.

VoIPBin owns the stateful parts: active call legs, audio streams, DTMF detection. Your code stays clean.

Run It Locally

pip install flask openai

# Tunnel for local testing
npx localtunnel --port 5000

# Set your VoIPBin webhook to <tunnel-url>/call
# Call your purchased number

For production, deploy to any Python host (Railway, Render, Fly.io) and update the webhook URL.

What You Built

A phone number that understands natural language
LLM-based intent classification — swap models any time
Automatic transfer to the right team
Multilingual support at zero extra cost
A stateless, horizontally scalable webhook server

No telephony SDK. No DTMF parsing. No recorded menus to maintain.

The days of Press 1 for Sales are over.

Resources:

VoIPBin: https://voipbin.net
Sign up: POST https://api.voipbin.net/v1.0/auth/signup
MCP Server: uvx voipbin-mcp (works in Claude Code and Cursor)
Go SDK: go get github.com/voipbin/voipbin-go

Build an AI IVR in an Afternoon — No Telephony Expertise Needed

voipbin — Tue, 05 May 2026 17:03:10 +0000

Phone trees. We all hate them.

"Press 1 for sales. Press 2 for support. Press 3 for billing. Press 9 to repeat this menu."

Even the companies running them hate them. They are expensive to build, painful to maintain, and callers abandon them in frustration. But the alternative — routing every call to a human — does not scale.

For years, the only way to build a smarter IVR was to hire a telephony specialist, negotiate a contract with an enterprise platform like Avaya or Genesys, and spend months in integration hell.

That is no longer true.

What Changed: AI Understands Intent

The old IVR model was brittle because it depended on exact inputs: press a number, say a keyword, follow a script. One mismatch and the caller was lost.

Modern LLMs understand intent. A caller can say "I got double-charged last month" and an AI agent knows that means billing. It does not need a menu. It does not need a keyword. It listens, understands, and routes — or resolves the issue entirely.

The remaining challenge is the plumbing: how do you connect an LLM to an actual phone call?

The Traditional IVR Stack (Why It Is Hard)

If you tried to build this from scratch, here is what you would need:

SIP trunk — a carrier connection to receive phone calls
Media server — to handle the RTP audio stream
ASR/STT pipeline — to convert speech to text in real time
NLU layer — to extract intent from the transcript
TTS engine — to synthesize the AI response back to speech
Call routing logic — to transfer, queue, or hang up
Monitoring and failover — because calls cannot go down at 2AM

Each of these is a non-trivial system. Telephony engineers spend careers specializing in just the media layer. Most backend developers have never touched SIP or RTP.

The result: AI IVR projects get stuck in the plumbing phase and never ship.

A Different Model: Offload the Telephony

VoIPBin handles the entire telephony stack — SIP, RTP, STT, TTS, DTMF — and exposes it through a simple REST API.

Your AI agent only ever sees text. It receives a caller's transcribed message via webhook, responds with text, and VoIPBin handles everything else: synthesizing the voice, playing it on the call, listening for the next utterance, and looping back.

Here is how the architecture looks:

Caller ──► VoIPBin (SIP/RTP/STT) ──► Webhook (your server)
                                          │
                                    LLM (GPT, Claude...)
                                          │
                              Text response back to VoIPBin
                                          │
                              VoIPBin (TTS) ──► Caller hears voice

Your server is just an HTTP endpoint. No telephony knowledge required.

Building the AI IVR: Step by Step

Step 1: Get Your API Key

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

The response includes accesskey.token — that is your API key for all subsequent requests.

Step 2: Get a Phone Number

curl -X POST https://api.voipbin.net/v1.0/numbers \
  -H "Authorization: Bearer <your-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "country_code": "US",
    "number_type": "local"
  }'

Save the number — callers will dial this to reach your AI IVR.

Step 3: Build the Webhook Handler

When a call comes in, VoIPBin sends your server a webhook with the caller's speech transcribed to text. Your job is to:

Run the text through your LLM
Return a response with the next action

Here is a minimal Python example using FastAPI and OpenAI:

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from openai import OpenAI

app = FastAPI()
client = OpenAI()

SYSTEM_PROMPT = """
You are an AI receptionist for Acme Corp.

When a caller describes their issue, classify it into one of:
- BILLING: payment issues, invoices, refunds
- SUPPORT: technical problems, bugs, how-to questions
- SALES: pricing, demos, new accounts
- OTHER: anything else

If you can resolve the issue directly with a short answer, do so.
Otherwise, tell the caller you are connecting them to the right team
and include the routing tag at the end of your message like [ROUTE:BILLING].
"""

@app.post("/ivr/webhook")
async def handle_call(request: Request):
    body = await request.json()
    caller_speech = body.get("speech_result", "")
    call_id = body.get("call_id", "")

    if not caller_speech:
        # First turn: greet the caller
        return JSONResponse({
            "action": "talk",
            "text": "Hello, thank you for calling Acme Corp. How can I help you today?",
            "webhook_url": "https://yourserver.com/ivr/webhook"
        })

    # Process with LLM
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": caller_speech}
        ]
    )

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

    # Check if routing is needed
    if "[ROUTE:BILLING]" in ai_text:
        clean_text = ai_text.replace("[ROUTE:BILLING]", "").strip()
        return JSONResponse({
            "action": "transfer",
            "text": clean_text,
            "destination": "+18005550100"  # billing team
        })
    elif "[ROUTE:SUPPORT]" in ai_text:
        clean_text = ai_text.replace("[ROUTE:SUPPORT]", "").strip()
        return JSONResponse({
            "action": "transfer",
            "text": clean_text,
            "destination": "+18005550200"  # support team
        })
    elif "[ROUTE:SALES]" in ai_text:
        clean_text = ai_text.replace("[ROUTE:SALES]", "").strip()
        return JSONResponse({
            "action": "transfer",
            "text": clean_text,
            "destination": "+18005550300"  # sales team
        })
    else:
        # AI resolved it — continue the conversation
        return JSONResponse({
            "action": "talk",
            "text": ai_text + " Is there anything else I can help you with?",
            "webhook_url": "https://yourserver.com/ivr/webhook"
        })

Step 4: Link the Number to Your Webhook

curl -X POST https://api.voipbin.net/v1.0/flows \
  -H "Authorization: Bearer <your-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AI IVR Flow",
    "actions": [
      {
        "type": "webhook",
        "url": "https://yourserver.com/ivr/webhook",
        "method": "POST"
      }
    ]
  }'

Assign this flow to your phone number, and every incoming call is routed through your AI agent.

The Conversation Loop

What makes this more powerful than a traditional IVR is that the conversation is stateful. The caller does not have to start over. They can say:

"I was double-charged in April"

And if the AI asks a follow-up:

"Which card ending in which digits was charged?"

The caller answers, the AI gathers the information, and when it transfers to billing, it can pass along a structured summary of what was discussed.

You can maintain conversation history keyed to call_id:

# Simple in-memory store (use Redis in production)
call_history = {}

@app.post("/ivr/webhook")
async def handle_call(request: Request):
    body = await request.json()
    call_id = body.get("call_id")
    caller_speech = body.get("speech_result", "")

    # Retrieve or initialize conversation history
    history = call_history.get(call_id, [])

    if caller_speech:
        history.append({"role": "user", "content": caller_speech})

    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + history

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )

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

    # ... routing logic as before

What You Did Not Have to Do

Look at what is missing from this code:

No SIP stack
No RTP handling
No audio codec configuration
No jitter buffer tuning
No STT streaming pipeline
No TTS voice synthesis
No telephony carrier negotiation

You wrote an HTTP server that talks to an LLM. VoIPBin handled everything else.

Going Further

Once the basic IVR is working, a few extensions that are straightforward to add:

Post-call summary: When the call ends, VoIPBin sends a final webhook. Log the full transcript, run it through your LLM to generate a structured summary, and store it in your CRM.

Business hours logic: Check the current time in your webhook handler. Outside business hours, tell the caller and offer a callback option instead.

Voicemail fallback: If no agents are available, switch the action from transfer to record to capture a voicemail.

Sentiment escalation: If the caller seems frustrated (detectable via LLM prompt), skip the routing step and connect directly to a senior agent.

All of these are just logic in your webhook handler — no telephony config changes needed.

The Bottom Line

Traditional IVR systems are expensive and inflexible because they were built in an era when telephony was the hard part. Today, the hard part is building good AI — and the telephony layer can be abstracted away entirely.

Your IVR is now just a Python function. Update the system prompt and the routing changes. Add a new route and it takes a few lines. The entire system can be deployed and iterated on like any other web service.

If you want to try it:

Sign up: https://voipbin.net
API docs: https://api.voipbin.net/v1.0
MCP server: uvx voipbin-mcp — works in Claude Code and Cursor
Go SDK: go get github.com/voipbin/voipbin-go

The phone tree that took six months to build can now be replaced in an afternoon. And when your requirements change next week, you update a prompt — not a call flow diagram.

Real-Time Voice Transcription for Your AI Agent — Without Writing a Single Line of Audio Code

voipbin — Mon, 04 May 2026 17:02:07 +0000

Speech-to-text sounds simple until you actually build it.

You need to handle RTP packet assembly, choose the right audio codec (G.711? G.722? Opus?), manage jitter buffers, stream audio chunks to a transcription API with low enough latency that the conversation doesn't feel broken, and then pipe that text into your AI agent — all in real time, while keeping the call alive.

Most developers who try this spend weeks on audio infrastructure before writing a single line of AI logic.

There's a better path.

The Real Problem: Audio Is Hostile Territory for Most Developers

Voice calls operate at the network layer — RTP streams, SIP signaling, DTMF tones. These are protocols that telecom engineers have spent decades specializing in. Most AI developers have never touched them.

So when you want an AI agent that can listen to a caller and respond intelligently, you're suddenly responsible for:

Capturing audio in real-time from a phone network
Transcribing it with low latency (>500ms feels broken)
Feeding transcription chunks into your LLM
Generating a response and synthesizing speech
Playing audio back without interrupting the conversation flow

Each of these steps is solvable. But doing all of them together, reliably, at scale, is a significant engineering investment.

What Media Offloading Actually Means

The key insight behind VoIPBin's architecture is this: your AI agent should never touch audio.

Instead of your agent receiving raw RTP streams, VoIPBin sits in the middle and handles:

STT (Speech-to-Text): Audio from the caller is transcribed in real-time
Text delivery: Your agent receives clean text via webhook
TTS (Text-to-Speech): Your agent replies with text, VoIPBin speaks it
RTP lifecycle: Stream setup, teardown, codec negotiation — all handled

Your AI agent becomes a pure text processor. It reads, thinks, and writes. No audio code required.

Caller → [RTP Audio] → VoIPBin → [STT] → [Webhook: text] → Your AI Agent
Caller ← [RTP Audio] ← VoIPBin ← [TTS] ← [Response: text] ← Your AI Agent

Building a Real-Time Transcription Handler

Let's build a simple AI agent that receives transcriptions and responds. We'll use Python with FastAPI.

Step 1: Sign Up and Get Your Access Token

curl -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"
  }'

You'll get an accesskey.token back immediately — no OTP, no waiting.

Step 2: Configure Your Webhook Handler

VoIPBin sends call events to your server. The key event type for transcription is transcript.

from fastapi import FastAPI, Request
from openai import OpenAI
import httpx
import os

app = FastAPI()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

VOIPBIN_TOKEN = os.environ["VOIPBIN_TOKEN"]
VOIPBIN_BASE = "https://api.voipbin.net/v1.0"

# In-memory conversation context (use Redis in production)
conversation_history = {}

@app.post("/webhook")
async def handle_event(request: Request):
    event = await request.json()
    event_type = event.get("type")
    call_id = event.get("call_id")

    if event_type == "call.initiated":
        # Initialize conversation context for this call
        conversation_history[call_id] = [
            {
                "role": "system",
                "content": "You are a helpful voice assistant. Keep responses concise — under 30 words. The caller will hear your response spoken aloud."
            }
        ]
        # Greet the caller
        await speak(call_id, "Hello! How can I help you today?")

    elif event_type == "transcript":
        # This is where the magic happens
        transcript_text = event.get("transcript", "")
        if not transcript_text.strip():
            return {"status": "ok"}

        print(f"[{call_id}] Caller said: {transcript_text}")

        # Add caller's words to conversation history
        history = conversation_history.get(call_id, [])
        history.append({"role": "user", "content": transcript_text})

        # Get AI response
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=history,
            max_tokens=100
        )
        ai_reply = response.choices[0].message.content

        # Add AI reply to history
        history.append({"role": "assistant", "content": ai_reply})
        conversation_history[call_id] = history

        print(f"[{call_id}] AI replies: {ai_reply}")

        # Speak the response back to the caller
        await speak(call_id, ai_reply)

    elif event_type == "call.ended":
        # Clean up
        conversation_history.pop(call_id, None)
        print(f"[{call_id}] Call ended")

    return {"status": "ok"}


async def speak(call_id: str, text: str):
    """Send TTS response back through the call."""
    async with httpx.AsyncClient() as http:
        await http.post(
            f"{VOIPBIN_BASE}/calls/{call_id}/actions",
            headers={
                "Authorization": f"Bearer {VOIPBIN_TOKEN}",
                "Content-Type": "application/json"
            },
            json={
                "action": "talk",
                "text": text,
                "voice": "en-US-Neural2-F"
            }
        )

Step 3: Register Your Webhook with VoIPBin

curl -X POST https://api.voipbin.net/v1.0/webhooks \
  -H "Authorization: Bearer $VOIPBIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.example.com/webhook",
    "events": ["call.initiated", "transcript", "call.ended"]
  }'

Step 4: Create an Inbound Flow

curl -X POST https://api.voipbin.net/v1.0/flows \
  -H "Authorization: Bearer $VOIPBIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AI Transcription Agent",
    "webhook_url": "https://your-server.example.com/webhook",
    "transcription": {
      "enabled": true,
      "language": "en-US",
      "interim_results": false
    }
  }'

Assign a number to this flow and you're live. Every call becomes a real-time transcription → AI → voice loop.

What You Can Build With Real-Time Transcription

Once your agent is receiving clean text from every call, the use cases multiply fast:

Live sentiment monitoring
Detect frustration or urgency in caller language and escalate to a human agent automatically.

def check_urgency(text: str) -> bool:
    urgent_keywords = ["cancel", "lawsuit", "refund", "urgent", "immediately", "supervisor"]
    return any(kw in text.lower() for kw in urgent_keywords)

# In your transcript handler:
if check_urgency(transcript_text):
    await transfer_to_human(call_id)
    return

Keyword-triggered actions
Play a specific audio clip, send an SMS, or trigger a webhook when the caller mentions specific topics.

Post-call summaries
Every transcript event is a conversation turn. After the call ends, you have the full dialogue. Run it through GPT-4 for a structured summary, action items, or CRM update.

elif event_type == "call.ended":
    history = conversation_history.get(call_id, [])

    # Generate call summary
    summary_response = client.chat.completions.create(
        model="gpt-4o",
        messages=history + [{
            "role": "user",
            "content": "Summarize this call in 3 bullet points. What did the caller want? Was it resolved?"
        }]
    )
    summary = summary_response.choices[0].message.content
    print(f"Call {call_id} summary:\n{summary}")

    # Save to your CRM or database
    await save_call_record(call_id, history, summary)

Compliance recording
Every word is captured as structured text. Search it, audit it, analyze it — no manual review of audio files.

The Latency Question

Real-time voice AI lives and dies by latency. If the gap between the caller finishing a sentence and hearing a response exceeds ~1.5 seconds, the conversation feels wrong.

The main latency components:

Component	Typical Range
STT (end-of-speech detection)	200–400ms
LLM inference (short responses)	300–800ms
TTS synthesis	100–300ms
Network/RTP delivery	50–150ms

Total: 650ms–1.65 seconds for a complete turn.

VoIPBin handles the STT and TTS ends of this pipeline. Your job is to keep the LLM call fast — use smaller models for simple responses, stream output where possible, and cache common replies.

Running It Locally

pip install fastapi uvicorn openai httpx

# Expose locally with ngrok for testing
ngrok http 8000

# Set your env vars
export VOIPBIN_TOKEN="your-token-here"
export OPENAI_API_KEY="sk-..."

# Start the server
uvicorn main:app --reload

Update your VoIPBin webhook URL to point at your ngrok URL and you can test with a real phone call immediately.

What You're Not Building

This is worth pausing on. By using VoIPBin's media offloading for transcription, you've skipped:

RTP server implementation
Codec handling (G.711 μ-law, a-law, G.722, Opus)
Jitter buffer management
Audio chunking and streaming to STT APIs
VAD (Voice Activity Detection) for end-of-speech detection
TTS audio streaming back into RTP

That's typically 4–8 weeks of specialized work for an experienced VoIP engineer. You built the same capability in an afternoon.

Try It

Sign up: voipbin.net — free trial, no credit card
API docs: https://api.voipbin.net/v1.0
MCP Server: uvx voipbin-mcp — use VoIPBin directly from Claude Code or Cursor
Go SDK: go get github.com/voipbin/voipbin-go

If you're building AI agents that need to handle real phone conversations, the audio layer shouldn't be the hard part. Let the infrastructure handle the RTP. You handle the intelligence.

Have questions about integrating real-time transcription into your AI agent? Drop them in the comments.

Run AI Outbound Call Campaigns Without Managing Dialer Infrastructure

voipbin — Sun, 03 May 2026 17:02:22 +0000

You have a list of phone numbers. You want an AI agent to call each one, carry a real conversation, and log the outcome.

Maybe it's appointment reminders. Maybe it's post-purchase follow-ups. Maybe it's a survey. The use case doesn't matter — the infrastructure problem is always the same.

To run outbound calls at any real scale, you traditionally need:

A SIP trunk with outbound routing
A predictive dialer or campaign manager
RTP media handling and codec negotiation
DTMF detection and TTS/STT pipelines
Retry logic, concurrency limits, and DNC compliance
A team who knows what all of the above means

That's months of engineering before your AI makes its first call.

This post shows a different approach: your app triggers calls via a simple HTTP API, and VoIPBin handles everything beneath the AI — the SIP stack, the audio, the real-time transcription, and the TTS responses.

How the Architecture Works

The key idea behind VoIPBin's Media Offloading model is a clean separation of concerns:

Your AI handles conversation logic — it reads transcripts, generates responses
VoIPBin handles telephony — it dials the number, streams audio, runs STT/TTS, manages call state

Your AI agent never touches RTP. It never talks to a SIP server. It just receives text and returns text. VoIPBin is the bridge between your AI and the actual phone network.

This means you can scale outbound campaigns by scaling your API calls — not by provisioning telephony infrastructure.

Step 1: Get Your API Key

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

Response:

{
  "token": "your-access-token-here"
}

Save that token. Every API call from here uses it as a Bearer token.

Step 2: Trigger a Single Outbound Call

Before building a campaign loop, verify a single call works:

import requests

VOIPBIN_TOKEN = "your-access-token-here"
BASE_URL = "https://api.voipbin.net/v1.0"

def make_outbound_call(destination_number: str, ai_webhook_url: str) -> dict:
    """
    Trigger a single outbound call.
    VoIPBin dials the number; when answered, it posts transcripts to your webhook.
    """
    payload = {
        "source": "+15550001234",           # Your VoIPBin number
        "destinations": [
            {
                "type": "tel",
                "target": destination_number
            }
        ],
        "flow_id": "your-ai-flow-id",       # Pre-configured conversation flow
        "webhook": ai_webhook_url
    }

    resp = requests.post(
        f"{BASE_URL}/calls",
        json=payload,
        headers={
            "Authorization": f"Bearer {VOPBIN_TOKEN}",
            "Content-Type": "application/json"
        }
    )
    resp.raise_for_status()
    return resp.json()

# Test it
call = make_outbound_call("+14155550100", "https://yourapp.com/ai-webhook")
print(f"Call initiated: {call['id']}")

When the callee picks up, VoIPBin starts the conversation flow, runs STT on their speech, and sends transcripts to your webhook in real time.

Step 3: Build the Campaign Loop

A campaign is just a controlled loop over your contact list:

import time
import requests
from typing import Optional

VOIPBIN_TOKEN = "your-access-token-here"
BASE_URL = "https://api.voipbin.net/v1.0"
SOURCE_NUMBER = "+15550001234"
FLOW_ID = "your-ai-flow-id"
WEBHOOK_URL = "https://yourapp.com/ai-webhook"

# Rate limit: how many concurrent calls you want to run
MAX_CONCURRENT = 5
CALL_DELAY_SECONDS = 2  # Pause between each dial

def run_campaign(contacts: list[dict]) -> None:
    """
    contacts = [
        {"phone": "+14155550100", "name": "Alice", "context": "appointment_tuesday"},
        {"phone": "+14155550101", "name": "Bob",   "context": "appointment_thursday"},
        ...
    ]
    """
    active_calls: dict[str, dict] = {}

    for contact in contacts:
        # Check active call count, throttle if needed
        while len(active_calls) >= MAX_CONCURRENT:
            active_calls = prune_completed_calls(active_calls)
            time.sleep(1)

        call = initiate_call(
            destination=contact["phone"],
            webhook=f"{WEBHOOK_URL}?context={contact['context']}"
        )
        active_calls[call["id"]] = contact
        print(f"[{contact['name']}] Call started: {call['id']}")
        time.sleep(CALL_DELAY_SECONDS)

    # Wait for stragglers
    while active_calls:
        active_calls = prune_completed_calls(active_calls)
        time.sleep(2)

    print("Campaign complete.")


def initiate_call(destination: str, webhook: str) -> dict:
    payload = {
        "source": SOURCE_NUMBER,
        "destinations": [{"type": "tel", "target": destination}],
        "flow_id": FLOW_ID,
        "webhook": webhook
    }
    resp = requests.post(
        f"{BASE_URL}/calls",
        json=payload,
        headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"}
    )
    resp.raise_for_status()
    return resp.json()


def prune_completed_calls(active: dict[str, dict]) -> dict[str, dict]:
    still_active = {}
    for call_id, contact in active.items():
        status = get_call_status(call_id)
        if status in ("active", "ringing"):
            still_active[call_id] = contact
        else:
            print(f"[{contact['name']}] Call ended ({status})")
    return still_active


def get_call_status(call_id: str) -> str:
    resp = requests.get(
        f"{BASE_URL}/calls/{call_id}",
        headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"}
    )
    return resp.json().get("status", "unknown")


# Run it
contacts = [
    {"phone": "+14155550100", "name": "Alice", "context": "reminder_may5"},
    {"phone": "+14155550101", "name": "Bob",   "context": "reminder_may6"},
    {"phone": "+14155550102", "name": "Carol",  "context": "reminder_may5"},
]
run_campaign(contacts)

Step 4: Handle Conversation Outcomes at Your Webhook

Every time the callee speaks, VoIPBin posts a transcript event to your webhook. Your AI reads it and returns the next response:

from flask import Flask, request, jsonify
import openai

app = Flask(__name__)
client = openai.OpenAI()

@app.route("/ai-webhook", methods=["POST"])
def handle_call_event():
    event = request.json
    context = request.args.get("context", "")

    if event["type"] == "transcript":
        caller_said = event["transcript"]
        call_id = event["call_id"]

        # Your AI generates the next line
        ai_reply = generate_response(caller_said, context)

        # Log outcome keywords
        log_outcome(call_id, caller_said, context)

        return jsonify({"speak": ai_reply})

    elif event["type"] == "call_ended":
        # Final summary hook
        save_call_summary(event)
        return jsonify({"status": "ok"})

    return jsonify({})


def generate_response(transcript: str, context: str) -> str:
    system_prompt = (
        "You are a friendly scheduling assistant calling to confirm an appointment. "
        f"Context: {context}. "
        "Be concise. If they confirm, say thank you and end the call. "
        "If they want to reschedule, note the request."
    )
    resp = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user",   "content": transcript}
        ]
    )
    return resp.choices[0].message.content


def log_outcome(call_id: str, transcript: str, context: str) -> None:
    # Save to your DB, Notion, Airtable, wherever
    print(f"[{call_id}] [{context}] Caller said: {transcript}")


def save_call_summary(event: dict) -> None:
    print(f"Call {event['call_id']} ended. Duration: {event.get('duration')}s")

Your webhook decides what the AI says next. VoIPBin handles converting that text into actual speech on the call.

What You Get Without Building

Here's what VoIPBin handles on your behalf:

Concern	Without VoIPBin	With VoIPBin
SIP stack	Build and maintain	Fully managed
RTP audio	Handle codecs, jitter	Offloaded
Speech-to-text	Choose, integrate, scale STT	Built-in
Text-to-speech	Choose voice, manage SSML	Built-in
Call state machine	Implement from scratch	API
Retry on no-answer	Custom logic	Configurable
Concurrency scaling	Provision trunk channels	API throttle

Your code handles one thing: conversation logic. The loop above is the entire campaign runner. The webhook is the entire AI layer.

Practical Limits and Considerations

Rate limiting: VoIPBin will cap concurrent outbound calls based on your plan. The MAX_CONCURRENT variable in the loop above should match your limit.

DNC compliance: Do-not-call regulations vary by country. VoIPBin doesn't manage your DNC list — that's your application's responsibility before you pass numbers to the API.

Voicemail detection: If a call goes to voicemail, VoIPBin will still trigger your webhook with transcript events. You can detect common voicemail patterns ("Please leave a message") and hang up gracefully, or leave a prerecorded message.

Timezone-aware scheduling: For campaigns that need to respect local business hours, wrap the run_campaign call with timezone logic before triggering — VoIPBin dials immediately when you POST.

What's Next

Once your basic campaign loop is running, common next steps:

Outcome tagging: Parse transcripts for confirmed/declined/rescheduled and update your CRM
A/B testing prompts: Run two webhook variants on split contact lists, compare outcomes
Escalation paths: If AI can't resolve, transfer to a live agent via VoIPBin's transfer API
Webhook retries: Add a retry queue for webhook failures so no call result is lost

Start Here

If you want to try it:

# Install the MCP server for interactive testing
uvx voipbin-mcp

# Or use the Golang SDK
go get github.com/voipbin/voipbin-go

Full API docs and signup at voipbin.net.

The campaign loop above is maybe 80 lines of Python. The AI webhook is another 40. The telephony layer — SIP, RTP, STT, TTS, codec negotiation — is zero lines, because it's not yours to write.

That's the trade worth making.

Give Claude a Phone: Add Real Voice Calls via MCP in 5 Minutes

voipbin — Sat, 02 May 2026 17:02:16 +0000

You have Claude in your terminal. It answers questions, writes code, summarizes documents.

But it cannot call a phone number.

Not because it is incapable — but because it has no connection to the actual telephone network. It lives in text. The moment a task needs a real human on the other end of a phone line, your AI workflow hits a wall.

This post shows you how to remove that wall in about five minutes, using the VoIPBin MCP server.

The Gap Between AI and the Phone Network

Model Context Protocol (MCP) is how AI assistants like Claude get access to external tools. Instead of hardcoding integrations, you plug in an MCP server and suddenly your AI can search the web, query databases, run code.

But the phone network? PSTN, SIP, RTP, codecs — none of that is accessible to an MCP server out of the box. Building it yourself means:

Registering a SIP account and handling registration
Negotiating RTP streams for audio
Running STT (speech-to-text) and TTS (text-to-speech) pipelines
Managing call state machines

That is a telephony engineering project, not an AI project.

VoIPBin wraps all of that into a single MCP server. Your Claude instance calls a tool. A real phone rings.

Setup: Three Steps

Step 1: Get a VoIPBin API Key

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 is your API key. Copy it.

Step 2: Add VoIPBin to Claude Desktop

Open your Claude Desktop config file:

# macOS
nano ~/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. Done.

Step 3: Verify It Works

In Claude Desktop, type:

"List the phone numbers available on my VoIPBin account."

Claude will call the VoIPBin MCP tool and return your account details. If you see a response with account info, you are connected.

What You Can Now Ask Claude to Do

With VoIPBin MCP active, Claude has access to real telephony tools. Here are prompts that actually work:

Make an outbound call

"Call +12025550100 and when they answer, say: Hello, this is an automated reminder that your appointment is tomorrow at 2pm. Press 1 to confirm or 2 to reschedule."

Claude translates that into a VoIPBin API call. The phone rings. The TTS message plays. Digit input is captured and returned to Claude.

Check call history

"Show me all calls from the last 24 hours and tell me which ones were not answered."

Claude queries the call log via MCP and summarizes it in plain English.

Build a quick notification flow

"I need to call these three numbers one after another with this message: [your message]. Start now."

Claude queues and executes the calls sequentially.

Using VoIPBin MCP in Cursor (or Any MCP Client)

The same setup works in Cursor IDE and any other MCP-compatible client.

For Cursor, edit .cursor/mcp.json in your project root:

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

Now your Cursor AI agent can make calls as part of a coding session. Useful for testing voice webhook flows without leaving the IDE.

A Real Use Case: Automated Deployment Notification

Here is a workflow that combines Cursor + VoIPBin MCP:

You deploy a critical service
Ask Cursor: "Call the on-call engineer at +1-xxx-xxx-xxxx and tell them the deployment to production just completed. Ask them to confirm receipt by pressing 1."
VoIPBin makes the call, plays the TTS, waits for DTMF input
Cursor receives the confirmation and logs it

No custom script. No Twilio account setup. No webhook server. Claude orchestrated it via MCP.

Under the Hood: What MCP Tools Are Exposed

The voipbin-mcp package exposes the core VoIPBin API surface as MCP tools:

Tool	What It Does
`call_create`	Initiate an outbound call with a flow
`call_list`	Retrieve recent call records
`call_get`	Get details for a specific call
`flow_create`	Define a call flow (TTS, DTMF, transfer)
`number_list`	List phone numbers on your account
`recording_get`	Retrieve a call recording

Claude decides which tool to invoke based on your natural language request. You do not need to know the API shape — that is the whole point of MCP.

Why This Pattern Matters for AI Agents

The trend in AI agent development is shifting from "write a Python script that calls an API" toward "describe what you want and let the agent figure out the tool calls."

For most domains — web search, code execution, databases — that pattern already works well.

For telephony, it has been blocked by infrastructure complexity. STT, TTS, RTP, SIP registration — these are not things you configure in a JSON file.

VoIPBin's approach is to absorb all of that complexity server-side. Your MCP config stays at five lines. Claude gets a call_create tool. The rest is invisible.

The result: an AI agent that can reach a human by phone as naturally as it can search the web.

Get Started

Website: https://voipbin.net
MCP install: uvx voipbin-mcp
Go SDK: go get github.com/voipbin/voipbin-go
Signup endpoint: POST https://api.voipbin.net/v1.0/auth/signup

No credit card required to explore. The signup API returns a working token immediately.

If you build something with this, drop a comment below. Particularly curious what workflows people are automating with Claude + voice.

Build an AI Voice Agent in Go: Complete Tutorial with VoIPBin SDK

voipbin — Fri, 01 May 2026 17:02:18 +0000

Every AI voice tutorial on the internet starts with Python.

Python is great. But Go powers a huge chunk of production infrastructure — microservices, APIs, cloud-native backends. If your team writes Go, you should not have to context-switch into Python just to add voice calling to your AI agent.

This tutorial shows you how to build a working AI voice bot in Go, end to end, using the VoIPBin Go SDK.

The Problem with AI Voice Today (for Go Developers)

Here is what most Go developers face when they want to add voice to their AI agent:

Find a VoIP provider → SIP credentials, codec negotiation, RTP handling
Set up an audio pipeline → STT, buffering, VAD (voice activity detection)
Wire in TTS → audio encoding, streaming to the caller
Keep latency low enough to feel like a real conversation

None of this is your application logic. It is infrastructure. And it is the reason most Go developers give up and reach for a managed service that only has a Python SDK.

VoIPBin handles all of the above. Your Go code just handles webhooks and returns JSON.

What You Will Build

A simple AI voice receptionist that:

Receives an inbound call
Greets the caller with TTS
Listens for their question
Responds with a smart answer
Ends the call cleanly

All in Go. Under 100 lines of application logic.

Prerequisites

Go 1.21+
A public webhook URL (use ngrok for local dev)
A VoIPBin account (sign up via API — no OTP, instant token)

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 '{
    "name": "your-name",
    "email": "you@example.com",
    "password": "yourpassword"
  }'

You get back:

{
  "accesskey": {
    "token": "YOUR_API_TOKEN"
  }
}

Save that token. That is your auth header going forward.

Step 2: Install the SDK

go get github.com/voipbin/voipbin-go

This gives you a fully typed client for the VoIPBin API — calls, flows, agents, numbers.

Step 3: Write Your Webhook Handler

When VoIPBin receives a call, it sends a POST request to your webhook. Your webhook returns a list of actions — speak, listen, transfer, hang up. VoIPBin executes them.

Create main.go:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

// VoIPBin sends this when a call event occurs
type CallEvent struct {
    CallID    string `json:"call_id"`
    Type      string `json:"type"`
    Transcript string `json:"transcript,omitempty"`
}

// We return a list of actions
type Action struct {
    Type string `json:"type"`
    Text string `json:"text,omitempty"`
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    var event CallEvent
    if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
        http.Error(w, "bad request", http.StatusBadRequest)
        return
    }

    log.Printf("event: type=%s call_id=%s transcript=%q",
        event.Type, event.CallID, event.Transcript)

    var actions []Action

    switch event.Type {
    case "call.started":
        // Greet the caller
        actions = []Action{
            {Type: "talk", Text: "Hello! You have reached our AI assistant. How can I help you today?"},
            {Type: "listen"},
        }

    case "call.input":
        // Caller said something — respond based on transcript
        reply := getAIReply(event.Transcript)
        actions = []Action{
            {Type: "talk", Text: reply},
            {Type: "listen"},
        }

    default:
        // End anything we do not handle
        actions = []Action{
            {Type: "hangup"},
        }
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(actions)
}

func getAIReply(input string) string {
    // Plug in your LLM here — OpenAI, Anthropic, Gemini, local model
    // For this tutorial, we use a simple static response
    if input == "" {
        return "Sorry, I did not catch that. Could you repeat?"
    }
    return fmt.Sprintf("You said: %s. Let me look that up for you — our team will follow up shortly!", input)
}

func main() {
    http.HandleFunc("/webhook", webhookHandler)
    log.Println("Webhook listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Run it:

go run main.go

In another terminal, expose it:

ngrok http 8080

Copy the ngrok URL — you will use it in the next step.

Step 4: Register Your Webhook and Make a Call

With the VoIPBin Go SDK, create a helper script to place a test call:

package main

import (
    "context"
    "fmt"
    "log"

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

func main() {
    client := voipbin.NewClient("YOUR_API_TOKEN")

    // Place an outbound call to your own number to test
    call, err := client.Calls.Create(context.Background(), voipbin.CreateCallRequest{
        Source: "voipbin",
        Destinations: []voipbin.Destination{
            {Type: "tel", Target: "+1234567890"}, // your number
        },
        WebhookURL: "https://your-ngrok-id.ngrok.io/webhook",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Call started: %s\n", call.ID)
}

Your phone rings. You answer. Your Go webhook handles the conversation.

Step 5: Wire In a Real LLM

Replace the getAIReply stub with an actual LLM call. Here is the OpenAI pattern:

import (
    "context"
    "github.com/sashabaranov/go-openai"
)

func getAIReply(input string) string {
    client := openai.NewClient("OPENAI_API_KEY")

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: openai.GPT4oMini,
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleSystem,
                    Content: "You are a friendly customer support agent. Keep responses under 30 words for voice.",
                },
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: input,
                },
            },
        },
    )
    if err != nil {
        return "I am having trouble right now. Please try again."
    }

    return resp.Choices[0].Message.Content
}

Two things to keep in mind for voice LLM responses:

Keep it short. Nobody wants to listen to a paragraph read aloud. Aim for 1-2 sentences.
Avoid markdown. TTS engines will literally say "asterisk asterisk bold asterisk asterisk". Write plain prose.

What VoIPBin Is Handling For You

While your Go code is happily processing HTTP requests, VoIPBin is doing the heavy lifting:

Task	VoIPBin handles it
SIP signaling	✅
RTP media stream	✅
Speech-to-Text (STT)	✅
Text-to-Speech (TTS)	✅
DTMF detection	✅
Call recording	✅
Number provisioning	✅

Your code is just an HTTP server. Which means everything you already know about Go servers applies: middleware, structured logging, graceful shutdown, horizontal scaling. No new mental model required.

Going to Production

A few things to harden before you ship:

Verify webhook authenticity:
VoIPBin signs webhook payloads. Validate the signature so random clients cannot trigger your bot.

Keep conversation state:
The webhook is stateless by default. For multi-turn conversations, store state in Redis or a DB keyed by call_id.

var sessions = sync.Map{} // call_id -> []Message

func getHistory(callID string) []Message {
    if v, ok := sessions.Load(callID); ok {
        return v.([]Message)
    }
    return nil
}

Handle timeouts:
LLM calls can be slow. If your webhook takes too long, VoIPBin plays a hold message. Add a context deadline:

ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
defer cancel()

What You Get

By the end of this tutorial you have:

A production-ready webhook pattern for Go AI voice bots
STT, TTS, and RTP off your plate entirely
A codebase that is just HTTP handlers — testable, deployable, scalable
A starting point you can extend with any LLM, any business logic

Go is an excellent language for this. The concurrency model handles parallel calls cleanly. The binary deployment is simple. The type system keeps webhook parsing honest.

The only missing piece was a VoIP layer that speaks Go. Now you have one.

Resources

VoIPBin Go SDK: go get github.com/voipbin/voipbin-go
VoIPBin API Docs
Sign up — instant API token, no credit card required to test

If you build something with this, drop a comment below. Always curious what people are actually shipping.

Make Your First AI Phone Call in 10 Minutes

voipbin — Thu, 30 Apr 2026 17:01:59 +0000

Most tutorials about AI voice calling assume you already know telephony. They throw terms like SIP trunking, RTP streams, codec negotiation, and DTMF detection at you before you've even written a line of code.

This isn't that tutorial.

In 10 minutes, you'll have a real AI voice call running — a bot that picks up, talks back with synthesized speech, and hangs up cleanly. No telephony background required.

What You're Building

A simple flow:

You trigger an outbound call via a REST API
VoIPBin connects the call and hits your webhook
Your webhook returns instructions: "speak this text, then wait for input"
VoIPBin handles all the audio — STT, TTS, RTP — and sends transcriptions back to you
You respond with the next action

Your code never touches audio. It just speaks HTTP.

Prerequisites

Any language that can run an HTTP server (examples below use Python)
A publicly reachable URL for your webhook (use ngrok if you're local)
10 minutes

Step 1: Sign Up and Get Your API Key

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

Response:

{
  "accesskey": {
    "token": "YOUR_API_TOKEN_HERE"
  }
}

No email confirmation. No OTP. Just a token. Keep it.

Step 2: Write Your Webhook Handler

This is the core of your AI bot. VoIPBin calls this URL when the call connects, and whenever speech is transcribed.

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/call-webhook", methods=["POST"])
def handle_call():
    data = request.json
    print("Incoming event:", data)

    call_type = data.get("type")

    if call_type == "call.answered":
        # Call just connected — greet the user
        return jsonify({
            "actions": [
                {
                    "type": "talk",
                    "text": "Hello! This is your AI assistant. How can I help you today?",
                    "language": "en-US",
                    "gender": "female"
                },
                {
                    "type": "listen",
                    "timeout": 5000
                }
            ]
        })

    elif call_type == "call.speech":
        transcript = data.get("transcript", "")
        print(f"User said: {transcript}")

        # Simple echo response — replace with your AI logic
        return jsonify({
            "actions": [
                {
                    "type": "talk",
                    "text": f"You said: {transcript}. Thanks for calling. Goodbye!",
                    "language": "en-US",
                    "gender": "female"
                },
                {
                    "type": "hangup"
                }
            ]
        })

    # Default: hang up
    return jsonify({"actions": [{"type": "hangup"}]})

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

Run it:

pip install flask
python app.py

Expose it with ngrok:

ngrok http 5000
# Copy the https URL, e.g. https://abc123.ngrok.io

Step 3: Make the Call

Now trigger an outbound call. Replace the values with your token, webhook URL, and a real destination number:

curl -s -X POST "https://api.voipbin.net/v1.0/calls" \
  -H "Authorization: Bearer YOUR_API_TOKEN_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "flow_id": null,
    "source": {
      "type": "sip",
      "target": "sip:bot@voipbin.net"
    },
    "destination": {
      "type": "tel",
      "target": "+15551234567"
    },
    "webhook_url": "https://abc123.ngrok.io/call-webhook"
  }'

VoIPBin dials the number. When it answers, your webhook gets called. The bot speaks, listens, echoes back what was said, and hangs up.

That's it.

What Just Happened (Under the Hood)

Here's why this was so simple:

You wrote zero audio code. VoIPBin handled:

Dialing via PSTN
Encoding and streaming RTP audio
Speech-to-text (STT) on the caller's voice
Text-to-speech (TTS) for your bot's responses
Session state and timing

Your server only processed JSON and returned JSON. This is VoIPBin's Media Offloading model — your AI logic runs as a stateless HTTP service, and the telephony infrastructure handles everything media-related.

This matters a lot when you scale. Your webhook can be a serverless function, a container, or any backend. No persistent connections. No WebSocket management. No codec knowledge needed.

Swap in Real AI Logic

The echo response is a placeholder. Replacing it with GPT-4o, Claude, or any LLM is straightforward:

import openai

client = openai.OpenAI()

def ai_response(transcript: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a helpful phone assistant. Keep responses short and clear."},
            {"role": "user", "content": transcript}
        ]
    )
    return response.choices[0].message.content

# In your webhook:
elif call_type == "call.speech":
    transcript = data.get("transcript", "")
    reply = ai_response(transcript)

    return jsonify({
        "actions": [
            {"type": "talk", "text": reply, "language": "en-US", "gender": "female"},
            {"type": "listen", "timeout": 5000}
        ]
    })

Now you have a real AI phone assistant — no telephony expertise required, no audio handling, no infrastructure to manage.

What's Next

From here, you can extend this pattern in many directions:

Multi-turn conversations — maintain chat history between turns using a session store
Inbound calls — assign a phone number (or use a Direct Hash SIP URI for no-number setups) and handle incoming calls the same way
Structured data extraction — after each call, log the transcript and run a summarization pass
Outbound campaigns — loop over a list of numbers and trigger calls programmatically

The core loop stays the same: webhook in, JSON out.

Resources

VoIPBin API docs
MCP Server (for Claude Desktop / Cursor): uvx voipbin-mcp
Golang SDK: go get github.com/voipbin/voipbin-go
Sign up: POST https://api.voipbin.net/v1.0/auth/signup

If you build something with this, drop a comment — always curious what people connect AI phone calls to first.

Your AI Voice Bot Doesn't Need a Phone Number

voipbin — Wed, 29 Apr 2026 17:02:17 +0000

Most developers building AI voice bots start by thinking they need a phone number. Get a number, attach a webhook, receive calls. It makes sense — that's how traditional telephony works.

But phone numbers come with friction. You need to provision them (which takes time), pay monthly per number, and deal with geographic restrictions. For internal tools, testing environments, B2B integrations, or AI agent demos, this overhead is completely unnecessary.

Here's what most people don't know: you can run a fully functional AI voice bot with zero phone numbers.

The Problem With Phone Numbers for AI Bots

Phone numbers are great when your users are consumers dialing from a mobile phone. But a lot of AI voice bot use cases aren't consumer-facing:

B2B voice integrations between two services that both speak SIP
Internal tools — an AI bot your team calls for on-call triage
Testing and staging environments — you don't want to burn real numbers
SIP-to-SIP calling from softphones, desk phones, or other services
Browser-to-bot calling using WebRTC bridges

For all of these, requiring a phone number adds unnecessary cost and complexity. What you actually need is an addressable SIP endpoint — and that's exactly what VoIPBin's Direct Hash SIP URI gives you.

What Is a Direct Hash SIP URI?

A Direct Hash SIP URI is a stable, unique SIP address that points directly to your AI bot — no phone number required.

It looks like this:

sip:your-bot-name@sip.voipbin.net

Anyone with a SIP client, softphone, or SIP-capable service can call this URI directly. VoIPBin routes the incoming call to your webhook, and your AI handles it — exactly like it would handle a regular phone call.

From your AI's perspective, there's no difference. The same POST comes to your endpoint with the same call metadata.

Setting It Up: 10 Lines of Config

First, sign up and get your access token. No OTP, no waiting:

curl -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"
  }'

The response gives you accesskey.token immediately. Use it for all subsequent requests.

Next, create a SIP trunk that points to your AI webhook:

curl -X POST https://api.voipbin.net/v1.0/trunks \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-ai-bot",
    "detail": "AI voice bot — no phone number needed",
    "domain_name": "my-ai-bot",
    "auth_types": ["ip"],
    "webhook": "https://your-server.com/voice",
    "webhook_method": "POST"
  }'

That's it. Your bot is now reachable at:

sip:my-ai-bot@sip.voipbin.net

Dial it from any SIP client and your webhook fires.

The Webhook: Same as Always

Your voice webhook doesn't change at all. VoIPBin sends the same call event structure whether the call came from a phone number or a Direct Hash SIP URI:

{
  "call_id": "uuid-here",
  "from": "sip:caller@their-domain.com",
  "to": "sip:my-ai-bot@sip.voipbin.net",
  "direction": "inbound",
  "status": "ringing"
}

Your server responds with a call flow:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/voice", methods=["POST"])
def handle_call():
    data = request.json
    call_id = data["call_id"]

    # Answer and greet
    return jsonify([
        {
            "type": "talk",
            "text": "Hello! You've reached the AI assistant. How can I help you today?",
            "language": "en-US"
        },
        {
            "type": "gather",
            "action": f"https://your-server.com/ai-response?call_id={call_id}",
            "timeout": 10
        }
    ])

@app.route("/ai-response", methods=["POST"])
def ai_response():
    call_id = request.args.get("call_id")
    transcript = request.json.get("transcript", "")

    # Send transcript to your LLM
    ai_reply = call_your_llm(transcript)

    return jsonify([
        {
            "type": "talk",
            "text": ai_reply,
            "language": "en-US"
        },
        {
            "type": "gather",
            "action": f"https://your-server.com/ai-response?call_id={call_id}",
            "timeout": 10
        }
    ])

def call_your_llm(text):
    # Replace with your actual LLM call
    import openai
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": text}]
    )
    return response.choices[0].message.content

No RTP. No SIP stack. No audio encoding. VoIPBin handles all of that — your bot is just an HTTP server.

Calling the Bot from a Softphone

Anyone with a SIP-capable client can call your bot directly. Here's how to set it up in a few common tools:

Linphone (desktop/mobile):

Add account → SIP address: sip:my-ai-bot@sip.voipbin.net
No registration required — just dial directly

Zoiper:

Add a SIP contact: my-ai-bot@sip.voipbin.net
Dial it like any other contact

From another VoIPBin call flow:

{
  "type": "dial",
  "to": "sip:my-ai-bot@sip.voipbin.net"
}

This makes it trivially easy to chain AI bots together or build fallback flows.

Real Use Cases

1. Internal On-Call AI Assistant

Your engineers dial a SIP URI from their desk phones. The AI reads from your runbook, queries your alerting system, and either resolves the issue or escalates to a human. No phone number needed — it's internal infrastructure.

2. B2B Integration Testing

You're building a voice integration for a client who has a SIP-capable PBX. Instead of provisioning test numbers, you give them your SIP URI. They call it, the AI validates their flow, and logs everything. When you're ready for production, you can optionally attach a real number — but you might not need to.

3. Browser-to-AI Calls

Using a WebRTC-to-SIP gateway (or VoIPBin's own bridge), users on your website can click a button and be connected to your AI bot via SIP URI — no phone number involved anywhere in the chain.

4. Multi-Bot Architectures

You have a routing bot that handles the first touch, and specialized bots for billing, support, and sales. Each bot gets its own SIP URI. Your routing logic dials the right one based on intent — clean, composable, and easy to test.

What You're Actually Saving

Approach	Monthly Cost	Setup Time	Geographic Limits
Phone number per bot	$1–5/number	Minutes to hours	Yes
Direct Hash SIP URI	$0	~5 minutes	None

For teams running multiple bots or environments (dev, staging, prod), the savings add up fast. More importantly, you remove a dependency that slows iteration.

One More Thing: MCP Integration

If you're building AI agents with Claude Code or Cursor, VoIPBin has an MCP server that makes all of this scriptable:

uvx voipbin-mcp

Your AI agent can provision SIP endpoints, manage call flows, and query call logs — all from natural language. No more copy-pasting API calls.

Getting Started

Sign up: POST https://api.voipbin.net/v1.0/auth/signup → get your token instantly
Create a trunk with your webhook URL
Dial sip:your-bot-name@sip.voipbin.net from any SIP client
Iterate — no number provisioning delays

Full docs and the Go SDK (go get github.com/voipbin/voipbin-go) are at voipbin.net.

Phone numbers are a UX concept for humans. Your AI bots don't need them. Give them a SIP URI and get out of your own way.

Stop Handling RTP in Your AI Agent — Let the Infrastructure Do It

voipbin — Tue, 28 Apr 2026 17:02:51 +0000

If you have ever tried to build a real AI voice agent — not a demo, but something that actually picks up phone calls — you know the moment everything stops being fun.

It is not the AI logic. That part is usually clean. It is everything underneath: RTP streams, jitter buffers, DTMF detection, SRTP negotiation, codec transcoding, VAD (voice activity detection), SIP signaling. Suddenly your elegant AI agent is buried under thousands of lines of audio plumbing that have nothing to do with the problem you set out to solve.

This post is about how to escape that trap.

The Real Problem: Audio Infrastructure Is a Full-Time Job

Let me show you what typical DIY voice-AI stacks look like under the hood:

Phone Call
  → SIP INVITE (handle SIP stack)
  → RTP stream (decode G.711 / G.729 / Opus)
  → Jitter buffer management
  → VAD (detect speech vs silence)
  → Chunked audio → STT API
  → AI inference (finally, the fun part)
  → TTS API → audio bytes
  → Encode audio back to RTP
  → Send RTP packets with correct timestamps
  → Handle DTMF events in parallel
  → Deal with packet loss, reordering, clock drift

Every one of those steps is an opportunity to introduce bugs, latency spikes, or dropped audio. And none of it is your core product.

Worse, scaling it is a nightmare. RTP is stateful and UDP-based. You cannot just throw it behind a load balancer and call it a day.

The Alternative: Media Offloading

The idea is simple: let AI handle text, let infrastructure handle audio.

Your AI agent should only ever see:

Transcribed text ("I want to check my account balance")
Structured events (call started, DTMF pressed, call ended)

And it should only ever produce:

Text responses that get synthesized into speech
High-level commands ("transfer to billing", "play hold music", "hang up")

This is what VoIPBin calls Media Offloading. VoIPBin sits between the phone network and your AI, handling 100% of the audio layer. Your code speaks clean HTTP and JSON.

What This Looks Like in Practice

Here is a complete AI voice agent in Python. Notice what is not in this code:

from flask import Flask, request, jsonify
import openai

app = Flask(__name__)
client = openai.OpenAI()

conversation_history = {}

@app.route("/voice-agent", methods=["POST"])
def voice_agent():
    event = request.json
    call_id = event.get("call_id")
    event_type = event.get("type")

    # Call started — greet the caller
    if event_type == "call.started":
        conversation_history[call_id] = [
            {"role": "system", "content": "You are a helpful support agent. Be concise."}
        ]
        return jsonify({
            "actions": [
                {"type": "talk", "text": "Hello! How can I help you today?"}
            ]
        })

    # Caller spoke — run AI inference on the transcript
    if event_type == "speech.recognized":
        transcript = event.get("transcript", "")
        history = conversation_history.get(call_id, [])
        history.append({"role": "user", "content": transcript})

        response = client.chat.completions.create(
            model="gpt-4o",
            messages=history
        )
        reply = response.choices[0].message.content
        history.append({"role": "assistant", "content": reply})
        conversation_history[call_id] = history

        return jsonify({
            "actions": [
                {"type": "talk", "text": reply}
            ]
        })

    # Call ended — clean up
    if event_type == "call.ended":
        conversation_history.pop(call_id, None)
        return jsonify({"actions": []})

    return jsonify({"actions": []})

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

That is the entire voice agent. No RTP. No SIP. No audio codecs. No jitter buffer. Just HTTP in, HTTP out.

VoIPBin takes the raw phone call, transcribes speech in real time, sends your webhook the transcript, receives your text response, and synthesizes it into speech — all before the caller notices any delay.

Getting Started

First, sign up and get your API token:

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"
  }'
# Returns: { "token": "..." }  ← your access token, no OTP needed

Then create a flow that points to your webhook:

curl -s -X POST https://api.voipbin.net/v1.0/flows \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AI Voice Agent",
    "actions": [
      {
        "type": "webhook",
        "url": "https://your-server.com/voice-agent"
      }
    ]
  }'

Assign a phone number to the flow, and every incoming call now drives your webhook. That is it. Your Flask app above is a fully functional phone AI agent.

The Golang SDK Version

If you prefer Go, the SDK makes it equally clean:

package main

import (
    "encoding/json"
    "net/http"
    "log"
)

type Event struct {
    CallID     string `json:"call_id"`
    Type       string `json:"type"`
    Transcript string `json:"transcript"`
}

type Action struct {
    Type string `json:"type"`
    Text string `json:"text,omitempty"`
}

type Response struct {
    Actions []Action `json:"actions"`
}

func voiceHandler(w http.ResponseWriter, r *http.Request) {
    var event Event
    json.NewDecoder(r.Body).Decode(&event)

    var actions []Action

    switch event.Type {
    case "call.started":
        actions = []Action{{Type: "talk", Text: "Hello! How can I help you?"}}
    case "speech.recognized":
        // Call your AI model here
        reply := callAI(event.Transcript)
        actions = []Action{{Type: "talk", Text: reply}}
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(Response{Actions: actions})
}

func main() {
    http.HandleFunc("/voice-agent", voiceHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Install the SDK:

go get github.com/voipbin/voipbin-go

What You Get

When you offload audio to infrastructure instead of handling it yourself:

Simpler codebase. Your AI logic stays focused on AI logic. No audio thread pools, no RTP socket management, no codec libraries to vendor.

Better latency. VoIPBin runs purpose-built media servers geographically close to carriers. Your webhook only adds the inference time — not the full audio round-trip overhead of a DIY stack.

Free horizontal scaling. Your webhook is stateless HTTP. Scale it like any API. VoIPBin handles the stateful media sessions.

Automatic codec handling. Callers dial in from SIP phones, mobile networks, WebRTC clients — each with different codecs. VoIPBin normalizes everything before your code ever sees it.

STT/TTS without wiring. Built-in speech recognition and synthesis. Swap languages or voices through config, not code.

The Mental Model Shift

The key insight is this: audio infrastructure is not your product, it is a dependency.

You would not write your own TCP stack to build an API. You would not implement your own TLS to serve HTTPS. The same logic applies to RTP and SIP.

Let the infrastructure layer handle packets, timing, and codec negotiation. Keep your application layer focused on the thing that actually creates value — the AI behavior.

Your AI voice agent should look like a webhook handler. If it looks like a media server, something has gone wrong.

Try It

Website: voipbin.net
MCP Server: uvx voipbin-mcp (works with Claude Code, Cursor)
Golang SDK: go get github.com/voipbin/voipbin-go
API Base: https://api.voipbin.net/v1.0

If you are building AI voice agents and want to talk through the architecture, drop a comment below. Happy to go deeper on any part of this.

One Codebase, Two Channels: Handle Voice Calls and Web Chat with the Same AI Logic

voipbin — Mon, 27 Apr 2026 17:03:23 +0000

Many teams build an AI chatbot first, then realize they also need voice support. So they build a second system — separate logic, separate prompts, separate maintenance burden.

It does not have to be that way.

This post walks through an architecture where the same AI business logic handles both incoming voice calls and web chat sessions. You write the intelligence once. The transport layer handles the rest.

The Problem: Two UIs, Two Codebases

When users contact your AI assistant, they might:

Open a chat widget on your website
Call a phone number

Both are valid. Both need responses. But they feel like completely different engineering problems:

Web chat: HTTP requests, JSON payloads, WebSocket for streaming
Voice call: SIP signaling, RTP audio, STT/TTS, codec negotiation

The typical response is to build them separately. Two prompt engineering efforts. Two conversation state machines. Two sets of edge cases to handle.

This is expensive — and it creates drift. The phone bot knows things the chat bot does not, and vice versa. Users get inconsistent answers depending on which channel they used.

The Solution: Abstract the Transport

The key insight is that your AI does not care how input arrives. It processes text and returns text. Everything else — audio encoding, channel management, delivery — is a transport-layer concern.

Voice Call ──→ VoIPBin (STT) ──→ text ──→ Your AI Core ──→ text ──→ VoIPBin (TTS) ──→ voice
Web Chat   ──→ Your API       ──→ text ──→ Your AI Core ──→ text ──→ Your API       ──→ text

Your AI Core only sees text in, text out. The channel-specific plumbing lives outside it.

VoIPBin handles the entire telephony stack — SIP signaling, RTP streams, STT, TTS, codec transcoding. Your server never touches raw audio. It just receives transcribed text and replies with text.

Building the Unified AI Core

Here is a complete FastAPI service that handles both channels:

from fastapi import FastAPI, Request
from openai import OpenAI

app = FastAPI()
client = OpenAI()

# ── Shared in-memory history (use Redis in production) ────────
_history: dict[str, list] = {}

def get_history(session_id: str) -> list:
    return _history.get(session_id, [])

def save_history(session_id: str, user_msg: str, ai_msg: str):
    h = _history.get(session_id, [])
    h.append({"role": "user", "content": user_msg})
    h.append({"role": "assistant", "content": ai_msg})
    _history[session_id] = h[-20:]  # keep last 10 turns

# ── Core AI logic — channel-agnostic ─────────────────────────
async def get_ai_response(
    user_message: str,
    history: list,
    channel: str = "text"
) -> str:
    system = "You are a helpful customer support assistant."
    if channel == "voice":
        system += " Keep answers under two sentences. The user is listening, not reading."
    else:
        system += " You can be detailed. Use markdown when helpful."

    messages = [
        {"role": "system", "content": system},
        *history,
        {"role": "user", "content": user_message}
    ]
    resp = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        max_tokens=300
    )
    return resp.choices[0].message.content

# ── Voice channel (VoIPBin webhook) ──────────────────────────
@app.post("/webhook/voice")
async def voice_webhook(request: Request):
    data = await request.json()
    call_id    = data.get("call_id", "")
    transcript = data.get("transcript", "")

    if not transcript:
        ai_reply = "Hello! How can I help you today?"
    else:
        history  = get_history(call_id)
        ai_reply = await get_ai_response(transcript, history, channel="voice")
        save_history(call_id, transcript, ai_reply)

    # VoIPBin reads these actions and handles TTS + next listen turn
    return {
        "actions": [
            {"type": "talk",   "text": ai_reply},
            {"type": "listen", "webhook_url": "https://yourdomain.com/webhook/voice"}
        ]
    }

# ── Web chat channel ──────────────────────────────────────────
@app.post("/chat")
async def chat_endpoint(request: Request):
    data       = await request.json()
    session_id = data.get("session_id", "")
    message    = data.get("message", "")

    history  = get_history(session_id)
    ai_reply = await get_ai_response(message, history, channel="text")
    save_history(session_id, message, ai_reply)

    return {"response": ai_reply}

Both channels call the same get_ai_response() function. Same model. Same business logic. The only difference is a channel flag that adjusts response length.

Setting Up the Voice Channel with VoIPBin

Get your API key — signup returns a token immediately, no OTP:

curl -s -X POST "https://api.voipbin.net/v1.0/auth/signup" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "yourname",
    "password": "yourpassword",
    "email": "you@example.com"
  }'
# → { "token": "<your-access-token>" }

Then create a flow that points inbound calls at your webhook:

import httpx

async def create_voice_flow(token: str, webhook_url: str) -> dict:
    async with httpx.AsyncClient() as c:
        resp = await c.post(
            "https://api.voipbin.net/v1.0/flows",
            headers={
                "Authorization": f"Bearer {token}",
                "Content-Type": "application/json"
            },
            json={
                "name": "AI Support Flow",
                "actions": [
                    {
                        "type": "webhook",
                        "url": webhook_url,
                        "method": "POST"
                    }
                ]
            }
        )
        return resp.json()

VoIPBin runs STT on incoming audio, sends the transcript to your webhook, receives your text response, and converts it to speech before the caller hears anything. Your server is a pure text API.

The Web Chat Side

For the browser, a single fetch call is all you need:

async function sendMessage(sessionId, message) {
  const res = await fetch("/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ session_id: sessionId, message })
  });
  const { response } = await res.json();
  return response;
}

// Usage
const reply = await sendMessage("user-42", "What are your business hours?");
console.log(reply);

Same backend. Same AI. Different wire format.

What You Actually Maintain

Concern	Voice	Web Chat
Audio encoding	VoIPBin	n/a
STT	VoIPBin	n/a
TTS	VoIPBin	n/a
SIP / RTP	VoIPBin	n/a
AI logic	Your code	Your code
Conversation state	Your code	Your code

You own the intelligence. VoIPBin owns the telephony. Neither side needs to know about the other.

Adding a Third Channel Later

Because your AI core is isolated, adding SMS or a Slack bot later is additive — not a rewrite:

# SMS channel — exact same core function
@app.post("/sms")
async def sms_endpoint(request: Request):
    data    = await request.json()
    from_   = data["from"]
    message = data["body"]

    history  = get_history(from_)
    ai_reply = await get_ai_response(message, history, channel="text")
    save_history(from_, message, ai_reply)

    return {"reply": ai_reply}

New channel, same get_ai_response(). Zero changes to your prompt or business logic.

What You Get From This Architecture

Half the AI logic to write and maintain — one prompt engineering effort covers all channels
Consistent answers — voice and chat users get the same information from the same model
Zero telephony expertise needed — VoIPBin handles everything below the text layer
Easy to extend — new channels are thin adapters, not separate systems
Faster iteration — improve your prompt once and both channels benefit immediately

Try It

If you already have a chatbot and want to add a phone number — or are starting fresh and want both from day one — this architecture keeps your codebase small and your channels consistent.

VoIPBin signup is instant (token returned in the response, no email verification flow), and you can test inbound calls with a real number in minutes.

→ voipbin.net
→ MCP for Claude/Cursor: uvx voipbin-mcp
→ Go SDK: go get github.com/voipbin/voipbin-go