DEV Community: voipbin

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

GPT-4o Voice on a Real Phone Line: Connecting OpenAI Realtime API to Actual Calls

voipbin — Sun, 26 Apr 2026 17:04:20 +0000

You have probably seen OpenAI Realtime API demos — ultra-low-latency, natural voice conversations with GPT-4o. Impressive in the browser. But what about a real phone call?

Your users are not always at a computer. They call. Turning that browser demo into an actual phone number is where most developers get stuck.

This post walks through the architecture and code to put GPT-4o voice on a real phone line — without writing a single line of RTP or SIP code.

The Core Problem

OpenAI Realtime API speaks WebSocket. Phone networks speak RTP (Real-time Transport Protocol) — a completely different audio streaming format that requires:

SIP signaling to handle call setup and teardown
RTP stream processing for audio delivery
Audio codec transcoding (G.711 ↔ PCM16)
Network jitter buffering and packet loss handling

Most developers do not want to build this. They should not have to.

VoIPBin acts as the translation layer. When a call comes in, VoIPBin converts phone audio into a WebSocket stream your backend can consume — the same format OpenAI expects.

Phone Call
    │
    ▼
VoIPBin  ← handles SIP + RTP entirely
    │  WebSocket (PCM16 audio frames)
    ▼
Your Server (lightweight bridge)
    │  OpenAI Realtime API WebSocket
    ▼
GPT-4o  ← processes audio, generates voice response
    │
    ▼
VoIPBin  ← converts PCM16 back to RTP
    │
    ▼
Caller hears GPT-4o

Your server does one job: relay audio between two WebSocket connections.

Step 1 — Sign Up for VoIPBin

VoIPBin signup is a single API call. No email verification, no waiting.

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

Save the accesskey.token from the response — that is your API key. Then provision a phone number from the VoIPBin dashboard and point its inbound webhook at your server.

Step 2 — Build the Bridge Server

Install dependencies:

pip install fastapi uvicorn websockets openai python-dotenv

Create bridge.py:

import asyncio
import base64
import json
import os
import websockets
from fastapi import FastAPI, WebSocket, Request
from fastapi.responses import JSONResponse
from dotenv import load_dotenv

load_dotenv()
app = FastAPI()

OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
OPENAI_REALTIME_URL = (
    "wss://api.openai.com/v1/realtime"
    "?model=gpt-4o-realtime-preview-2024-12-17"
)

SYSTEM_PROMPT = (
    "You are a helpful phone assistant. "
    "Keep responses concise — callers are on a phone, not reading a document. "
    "One or two sentences per turn is ideal."
)


@app.post("/webhook/inbound")
async def handle_inbound_call(request: Request):
    data = await request.json()
    call_id = data.get("call_id", "unknown")
    print(f"Incoming call: {call_id}")

    # Tell VoIPBin to stream audio to our WebSocket bridge
    return JSONResponse({
        "actions": [
            {
                "type": "talk",
                "text": "Connecting you to the AI assistant."
            },
            {
                "type": "stream",
                "url": "wss://your-server.com/call",
                "audio_format": "pcm16",
                "sample_rate": 16000
            }
        ]
    })


@app.websocket("/call")
async def call_bridge(voipbin_ws: WebSocket):
    await voipbin_ws.accept()
    print("Call connected — opening OpenAI Realtime session")

    async with websockets.connect(
        OPENAI_REALTIME_URL,
        extra_headers={
            "Authorization": f"Bearer {OPENAI_API_KEY}",
            "OpenAI-Beta": "realtime=v1"
        }
    ) as openai_ws:

        # Configure the session
        await openai_ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "modalities": ["text", "audio"],
                "instructions": SYSTEM_PROMPT,
                "voice": "alloy",
                "input_audio_format": "pcm16",
                "output_audio_format": "pcm16",
                "input_audio_transcription": {"model": "whisper-1"},
                "turn_detection": {
                    "type": "server_vad",
                    "threshold": 0.5,
                    "silence_duration_ms": 700
                }
            }
        }))

        async def phone_to_ai():
            # Forward caller audio to OpenAI
            try:
                async for audio_bytes in voipbin_ws.iter_bytes():
                    await openai_ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": base64.b64encode(audio_bytes).decode()
                    }))
            except Exception as exc:
                print(f"phone_to_ai closed: {exc}")

        async def ai_to_phone():
            # Forward GPT-4o audio back to caller
            try:
                async for raw in openai_ws:
                    event = json.loads(raw)

                    if event["type"] == "response.audio.delta":
                        audio = base64.b64decode(event["delta"])
                        await voipbin_ws.send_bytes(audio)

                    elif event["type"] == (
                        "conversation.item.input_audio_transcription.completed"
                    ):
                        print(f"Caller: {event.get('transcript', '')}")

            except Exception as exc:
                print(f"ai_to_phone closed: {exc}")

        await asyncio.gather(phone_to_ai(), ai_to_phone())

    print("Call ended")

Step 3 — Run and Test

uvicorn bridge:app --host 0.0.0.0 --port 8000

For local development, expose it with ngrok:

ngrok http 8000

Update your VoIPBin number's webhook to https://your-ngrok-url/webhook/inbound. Call the number. You are talking to GPT-4o.

What VoIPBin Is Handling (That You Are Not)

Here is everything happening behind the scenes that your code does not touch:

Concern	Handled by
SIP INVITE / 200 OK / BYE	VoIPBin
RTP packet assembly	VoIPBin
G.711 ↔ PCM16 transcoding	VoIPBin
DTMF detection	VoIPBin
Network jitter compensation	VoIPBin
Call recording (optional)	VoIPBin
Your AI logic	You

Your server handles two async loops and some JSON. That is the entire diff.

Scaling This

Because VoIPBin handles all media processing, your bridge server is CPU-light. Each call is two WebSocket connections and async I/O. A single server can comfortably handle dozens of concurrent calls. When you outgrow one, add more — each is stateless.

VoIPBin scales its media infrastructure independently. You scale your AI logic independently. Clean separation of concerns.

Extending the Bot

With this foundation, common additions are straightforward:

Call recording: VoIPBin can record audio server-side — just add a flag in your webhook response.

Post-call transcripts: OpenAI Realtime API streams transcripts via the conversation.item.input_audio_transcription.completed event. Collect them and send a summary after hangup.

Human escalation: If GPT-4o cannot help, add a transfer action to your VoIPBin webhook response to forward the call to a human agent.

Outbound calls: Flip the model — use VoIPBin to dial out, then connect the answered call to the same bridge. Same architecture, opposite direction.

Getting Started

VoIPBin API docs and dashboard: voipbin.net
Golang SDK: go get github.com/voipbin/voipbin-go
MCP server (use from Claude Code or Cursor): uvx voipbin-mcp

The signup endpoint returns your token immediately — no waiting, no onboarding call required.

The gap between "cool browser demo" and "real phone call" turns out to be about 60 lines of Python and one API account.

Why Your AI Voice Bot Is Actually Just an HTTP Server (And Why That Scales Beautifully)

voipbin — Sat, 25 Apr 2026 17:03:14 +0000

You built an AI voice bot that handles one call perfectly. Then you run a real campaign — 50 calls come in simultaneously. Contexts bleed between sessions. Your server buckles. The architecture that was fine for demos breaks in production.

Here's the counterintuitive insight that fixes this: a voice bot is just an HTTP server. Once you see it that way, scaling becomes trivial.

Why Concurrent Voice Calls Seem Hard

Each live phone call requires:

A persistent RTP media stream carrying audio
Real-time speech-to-text per call
Text-to-speech generation and delivery per response
Session state (conversation history, caller context)
Proper teardown when the call ends

At 100 concurrent calls, you're managing 100 simultaneous audio streams plus 100 STT engines running in parallel. At 1,000, the infrastructure problem completely dominates the AI problem. Most developers trying to build this from scratch end up deep in SIP registrars, RTP proxies, codec negotiation, and NAT traversal — none of which has anything to do with the AI they actually wanted to build.

The Media Offloading Model

VoIPBin separates concerns cleanly:

[Caller] <── SIP/RTP ──> [VoIPBin] <── HTTP webhooks ──> [Your AI Backend]

VoIPBin owns the hard telephony layer:

All RTP streams (regardless of concurrency)
STT per call in real time
TTS synthesis and audio delivery
SIP session lifecycle
Codec negotiation (G.711, G.722, Opus)
NAT traversal and media relay

Your AI backend sees none of that. It receives HTTP POST requests with transcribed text. It returns JSON with a response string. That's the entire interface.

This means your "voice bot" is a plain HTTP server. Concurrency is handled by goroutines, async Python, or the Node.js event loop — tools you already know how to scale.

A Concurrent Call Handler in Go

Here's a minimal but production-shaped handler that manages thousands of simultaneous calls:

package main

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

// CallSession holds per-call conversation context
type CallSession struct {
    CallID    string
    CallerNum string
    StartedAt time.Time
    Messages  []Message
    mu        sync.Mutex
}

type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

// WebhookEvent is what VoIPBin sends your server
type WebhookEvent struct {
    Type       string `json:"type"`
    CallID     string `json:"call_id"`
    CallerNum  string `json:"caller_num"`
    Transcript string `json:"transcript"`
}

// In-memory store — swap for Redis in production
var sessions sync.Map

func getOrCreate(callID, callerNum string) *CallSession {
    actual, _ := sessions.LoadOrStore(callID, &CallSession{
        CallID:    callID,
        CallerNum: callerNum,
        StartedAt: time.Now(),
        Messages: []Message{
            {
                Role:    "system",
                Content: "You are a helpful support agent. Keep responses brief — under 2 sentences — for voice delivery.",
            },
        },
    })
    return actual.(*CallSession)
}

func handleTranscript(w http.ResponseWriter, r *http.Request) {
    var event WebhookEvent
    if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
        http.Error(w, "invalid payload", http.StatusBadRequest)
        return
    }

    if event.Type == "call.ended" {
        sessions.Delete(event.CallID)
        w.WriteHeader(http.StatusOK)
        return
    }

    session := getOrCreate(event.CallID, event.CallerNum)
    session.mu.Lock()
    defer session.mu.Unlock()

    // Append caller speech to this call's history
    session.Messages = append(session.Messages, Message{
        Role:    "user",
        Content: event.Transcript,
    })

    // Call your LLM (each call is a fully isolated context)
    aiResponse := callLLM(session.Messages)

    session.Messages = append(session.Messages, Message{
        Role:    "assistant",
        Content: aiResponse,
    })

    // VoIPBin reads this, synthesizes speech, and plays it to the caller
    json.NewEncoder(w).Encode(map[string]string{
        "response": aiResponse,
    })
}

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

    getOrCreate(event.CallID, event.CallerNum)

    json.NewEncoder(w).Encode(map[string]string{
        "greeting": fmt.Sprintf("Hello! How can I help you today?"),
    })
}

func callLLM(messages []Message) string {
    // Replace with your OpenAI / Anthropic / Gemini call
    // Each invocation is scoped to one call's message history
    return "I can help with that. Could you give me a bit more detail?"
}

func main() {
    http.HandleFunc("/webhook/call-started", handleCallStarted)
    http.HandleFunc("/webhook/transcript", handleTranscript)

    log.Println("AI voice backend running on :8080")
    log.Println("Each call is an isolated HTTP session — scale horizontally")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Session Isolation: The Actual Scaling Strategy

The key is the sync.Map (or Redis in production): every call gets its own entry, keyed by call_id. When VoIPBin sends a webhook for call abc-123, you load that call's history. When it sends one for def-456, you load a completely different history. Calls never touch each other.

This is just standard HTTP request isolation — the same principle that lets a web server handle thousands of users simultaneously. That's how you've solved concurrent AI voice calls.

Upgrading to Redis for Multi-Instance Deployments

For serious production load, swap the in-memory map for Redis:

import (
    "context"
    "time"
    "github.com/redis/go-redis/v9"
)

var rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379"})

func loadSession(ctx context.Context, callID string) (*CallSession, error) {
    data, err := rdb.Get(ctx, "call:"+callID).Bytes()
    if err == redis.Nil {
        return &CallSession{CallID: callID}, nil
    }
    if err != nil {
        return nil, err
    }
    var s CallSession
    return &s, json.Unmarshal(data, &s)
}

func saveSession(ctx context.Context, s *CallSession) error {
    data, _ := json.Marshal(s)
    // Sessions expire after 30 min of inactivity
    return rdb.Set(ctx, "call:"+s.CallID, data, 30*time.Minute).Err()
}

Now you can run 10 instances of your AI backend behind a load balancer. Each instance handles a slice of traffic. All instances share the same Redis call store. Horizontal scaling becomes docker scale.

What VoIPBin Absorbs So You Never Have To

Problem	Handled by VoIPBin
1,000 simultaneous RTP streams	✅
STT for each stream, in parallel	✅
TTS generation and audio playback	✅
SIP registration and routing	✅
Codec negotiation (G.711, G.722, Opus)	✅
NAT traversal and media relay	✅
Call recording	✅
DTMF detection	✅

Your backend only sees HTTP. No audio bytes, no SIP headers, no RTP.

Try It Yourself

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

Or use the Go SDK:

go get github.com/voipbin/voipbin-go

Deploy your HTTP handler to Railway, Fly.io, or any cloud. Point your VoIPBin inbound number's webhook URL at it. You're live.

The Takeaway

Scaling AI voice bots is an infrastructure problem disguised as an AI problem. The AI side — stateless HTTP handlers, LLM calls, session maps — is something every web developer already knows how to scale. The telephony side is genuinely complex, but you don't have to own it.

Your 1-call demo and your 1,000-call production deployment can run the same code. The only difference is whether your session store is an in-process map or a Redis cluster.

Build once. Scale horizontally. No SIP expertise required.

VoIPBin gives AI agents real phone numbers and voice infrastructure. Start building →

Build a Multilingual AI Voice Bot: Auto-Detect and Respond in the Caller's Language

voipbin — Fri, 24 Apr 2026 17:03:20 +0000

Your AI voice bot is live. It's handling calls. Then someone calls and speaks Spanish.

Your bot replies in English. The caller repeats themselves, louder. The bot still replies in English. The caller hangs up.

You just lost a customer because of a solvable engineering problem.

This post walks through how to build an AI voice bot that automatically detects the caller's language from their first utterance — and continues the entire conversation in that language. No upfront language selection menus. No "Press 1 for English, oprima 2 para español." Just a natural conversation.

What Makes This Hard

Language detection in voice bots isn't just about speech-to-text. There are three layers:

STT (Speech-to-Text): The transcription engine must support the language
LLM prompt: The model must be instructed to respond in the detected language
TTS (Text-to-Speech): The voice synthesis must produce natural-sounding audio in that language

If any layer breaks, the experience degrades. If your TTS can only do English but your LLM responds in Spanish, callers hear phonetically mangled output. If your STT doesn't detect the language, you get garbled transcriptions.

VoIPBin handles the STT → TTS pipeline entirely — and returns the detected language alongside each transcript — which makes building this significantly simpler. Your server never touches audio.

The Architecture

Inbound call
    │
    ▼
VoIPBin receives audio
    │
    ▼
STT transcription + language detection
    │
    ▼
Webhook → your server (transcript + detected_language)
    │
    ▼
Language-specific LLM prompt
    │
    ▼
VoIPBin TTS in detected language
    │
    ▼
Caller hears response in their own language

Step 1: Get a VoIPBin Token

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

Set your inbound number's webhook to your server. VoIPBin will POST a JSON payload on every caller utterance.

Step 2: Handle the Webhook and Detect Language

When VoIPBin sends a speech event, the payload includes the detected language code:

{
  "call_id": "abc-123",
  "transcript": "Hola, necesito ayuda con mi pedido",
  "language": "es",
  "confidence": 0.97,
  "caller": "+15551234567"
}

Use that language field to select the right LLM system prompt:

from flask import Flask, request, jsonify
import httpx, os

app = Flask(__name__)

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

SYSTEM_PROMPTS = {
    "en": "You are a helpful customer support agent. Respond in English. Be concise.",
    "es": "Eres un agente de soporte al cliente. Responde en español. Sé conciso.",
    "fr": "Vous êtes un agent de support client. Répondez en français. Soyez concis.",
    "ja": "あなたはカスタマーサポートエージェントです。日本語で回答してください。簡潔に。",
    "de": "Sie sind ein Kundensupport-Agent. Antworten Sie auf Deutsch. Seien Sie präzise.",
    "pt": "Você é um agente de suporte. Responda em português. Seja conciso.",
}

# In-memory store — use Redis in production
conversations = {}

@app.route("/webhook/speech", methods=["POST"])
def handle_speech():
    data = request.json
    call_id = data["call_id"]
    transcript = data["transcript"]
    detected_language = data.get("language", "en")

    # Lock language on first utterance
    if call_id not in conversations:
        conversations[call_id] = {"language": detected_language, "history": []}

    language = conversations[call_id]["language"]
    history = conversations[call_id]["history"]

    ai_response = get_ai_response(transcript, language, history)

    history.append({"role": "user", "content": transcript})
    history.append({"role": "assistant", "content": ai_response})

    speak_response(call_id, ai_response, language)
    return jsonify({"status": "ok"})

def get_ai_response(transcript: str, language: str, history: list) -> str:
    system_prompt = SYSTEM_PROMPTS.get(language, SYSTEM_PROMPTS["en"])
    if language != "en":
        system_prompt += f"\n\nIMPORTANT: Always respond in {language} only."

    messages = [{"role": "system", "content": system_prompt}]
    messages.extend(history)
    messages.append({"role": "user", "content": transcript})

    resp = httpx.post(
        "https://api.openai.com/v1/chat/completions",
        headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
        json={"model": "gpt-4o", "messages": messages, "max_tokens": 150}
    )
    return resp.json()["choices"][0]["message"]["content"]

def speak_response(call_id: str, text: str, language: str):
    httpx.post(
        f"{VOIPBIN_API}/calls/{call_id}/actions",
        headers={
            "Authorization": f"Bearer {VOIPBIN_TOKEN}",
            "Content-Type": "application/json"
        },
        json={"type": "speak", "text": text, "language": language, "voice": "neural"}
    )

Step 3: Why You Lock Language on the First Utterance

Do not re-detect language on every turn. Mid-call language flips happen because:

The caller quotes something in English while speaking French
Background noise causes a brief misdetection
A proper noun triggers a false positive

Lock it once, hold it for the whole call:

# WRONG: Re-detecting every turn
language = data.get("language", "en")  # Unstable

# RIGHT: Lock on first utterance
if call_id not in conversations:
    conversations[call_id] = {"language": detected_language, ...}
language = conversations[call_id]["language"]  # Stable

Step 4: Remember Returning Callers

For callers who call back, skip detection entirely — you already know their language:

import redis

redis_client = redis.Redis()

def get_caller_language(phone: str, detected: str) -> str:
    saved = redis_client.get(f"lang:{phone}")
    if saved:
        return saved.decode()
    # First call — use detected, then save
    redis_client.setex(f"lang:{phone}", 86400 * 30, detected)
    return detected

Now returning callers get their preferred language before they even speak — the first TTS greeting can be in their language too.

Step 5: Graceful Fallback for Unsupported Languages

def get_language_prompt(language: str) -> str:
    if language in SYSTEM_PROMPTS:
        return SYSTEM_PROMPTS[language]
    # Unknown language — ask LLM to try, but offer fallback
    return (
        f"The caller is speaking {language}. "
        "If you know this language, respond in it. "
        "Otherwise, politely explain in English that you currently support "
        "English, Spanish, French, German, Portuguese, and Japanese."
    )

What the Caller Experiences

Without this system:

🤖 Bot: "Hello! How can I help you today?"
👤 Caller: "Necesito ayuda con mi pedido número 4521"
🤖 Bot: "I'm sorry, could you repeat that in English?"
👤 Caller: [hangs up]

With this system:

🤖 Bot: "Hello! How can I help you today?"
👤 Caller: "Necesito ayuda con mi pedido número 4521"
🤖 Bot: "Claro, déjame revisar el pedido 4521. ¿Puede confirmar su nombre?"
👤 Caller: [stays on the line, gets helped]

The switch is invisible. No menu. No friction. Just a bot that listens.

Run It Locally

pip install flask httpx redis
gunicorn -w 4 app:app

# For local testing with ngrok:
ngrok http 8080
# Set VoIPBin webhook → https://your-ngrok-url/webhook/speech

What You Get

Zero menu friction — no language selection prompts
Stable conversations — language locked on first utterance
Returning caller memory — preferred language saved in Redis
No audio code — your server handles text only; VoIPBin owns the audio
Global reach — any language your STT and LLM support

The infrastructure complexity (codecs, RTP, STT, TTS) lives inside VoIPBin. Your server implements the logic. That's the clean separation that makes this build under 100 lines of Python.

Try free at voipbin.net — token returned on signup, no verification step.

MCP server for Claude / Cursor: uvx voipbin-mcp

Golang SDK: go get github.com/voipbin/voipbin-go

Build AI Voice Bots That Remember: Persistent Context Across Multiple Calls

voipbin — Thu, 23 Apr 2026 17:03:12 +0000

Your AI voice bot picks up the phone. The caller says:

"Hey, I was calling back about my order from last week."

And your bot responds:

"Hello! How can I help you today?"

The caller sighs. Explains everything again. Gets frustrated. Hangs up.

This is the dirty secret of most AI voice bots: every call starts from zero. No memory. No context. No recognition of returning callers. It does not matter how smart your LLM is — if the bot has no memory of past interactions, it will always feel robotic.

The solution is not complicated. This post shows you exactly how to build persistent caller context that survives across sessions.

Why Voice Bots Forget

Most voice bot architectures look like this:

Inbound call → Speech-to-Text → LLM prompt → Text-to-Speech → Response

Each call initializes a fresh LLM context. The phone number that called you? Ignored. The fact that this same number called three times this week? Unknown. The issue they reported on Monday? Gone.

The fix requires two things:

A caller identity anchor — the phone number from the inbound call
A persistent store — a database or cache keyed to that number

VoIPBin gives you the caller ID on every webhook event. You supply the memory layer. Together, they make a bot that actually knows who it is talking to.

Architecture Overview

Inbound call (with caller ID)
        ↓
   VoIPBin Webhook
        ↓
  Look up caller in Redis
        ↓
  Build LLM prompt with history
        ↓
  AI responds (via VoIPBin TTS)
        ↓
  Append exchange to Redis
        ↓
  Call ends → persist to DB

The caller ID acts as the session key. Redis holds short-term conversation memory. A database (Postgres, Mongo — your choice) holds long-term history.

Setup

Install dependencies:

pip install flask redis openai requests

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

Set your environment variables:

export VOIPBIN_TOKEN="<your-access-token>"
export OPENAI_API_KEY="<your-openai-key>"
export REDIS_URL="redis://localhost:6379"

Building the Memory Layer

import redis
import json
import os
from datetime import datetime

r = redis.from_url(os.environ["REDIS_URL"])

CALLER_HISTORY_PREFIX = "caller:"
MAX_HISTORY_TURNS = 10  # Keep last 10 exchanges per caller
HISTORY_TTL = 86400 * 30  # 30 days

def get_caller_history(phone_number: str) -> list:
    key = f"{CALLER_HISTORY_PREFIX}{phone_number}"
    raw = r.get(key)
    if raw:
        return json.loads(raw)
    return []

def save_caller_history(phone_number: str, history: list):
    key = f"{CALLER_HISTORY_PREFIX}{phone_number}"
    trimmed = history[-MAX_HISTORY_TURNS:]
    r.setex(key, HISTORY_TTL, json.dumps(trimmed))

def append_exchange(phone_number: str, user_msg: str, bot_msg: str):
    history = get_caller_history(phone_number)
    history.append({
        "role": "user",
        "content": user_msg,
        "timestamp": datetime.utcnow().isoformat()
    })
    history.append({
        "role": "assistant",
        "content": bot_msg,
        "timestamp": datetime.utcnow().isoformat()
    })
    save_caller_history(phone_number, history)

The Webhook Handler

VoIPBin sends a webhook when a call comes in and when speech is recognized. Here is the core handler:

from flask import Flask, request, jsonify
import openai
import os

app = Flask(__name__)
client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

SYSTEM_PROMPT = """
You are a helpful customer support voice assistant.
You will be given the caller's phone number and their conversation history.
Use this context to provide personalized, continuous support.
Keep responses concise (under 40 words) - this is a phone call, not a chat.
If you recognize a returning caller, acknowledge it naturally.
"""

@app.route("/webhook/call", methods=["POST"])
def handle_call_event():
    data = request.json
    event_type = data.get("type")
    caller_number = data.get("from")  # e.g. "+14155551234"
    call_id = data.get("call_id")

    if event_type == "call.ringing":
        history = get_caller_history(caller_number)
        is_returning = len(history) > 0

        # Store call session state
        r.setex(f"call:{call_id}:caller", 3600, caller_number)
        r.setex(f"call:{call_id}:returning", 3600, "1" if is_returning else "0")

        greeting = build_greeting(caller_number, is_returning, history)
        return jsonify({
            "actions": [
                {"type": "talk", "text": greeting},
                {"type": "listen"}
            ]
        })

    elif event_type == "call.speech_recognized":
        user_speech = data.get("speech", "")
        caller_number = r.get(f"call:{call_id}:caller").decode()
        history = get_caller_history(caller_number)

        # Build LLM messages with full history
        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
        messages.append({
            "role": "system",
            "content": f"Caller phone number: {caller_number}. Prior conversation history follows."
        })
        for turn in history[-6:]:  # Last 3 exchanges
            messages.append({"role": turn["role"], "content": turn["content"]})
        messages.append({"role": "user", "content": user_speech})

        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            max_tokens=100
        )
        bot_reply = response.choices[0].message.content

        append_exchange(caller_number, user_speech, bot_reply)

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

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


def build_greeting(phone_number: str, is_returning: bool, history: list) -> str:
    if not is_returning:
        return "Hello! How can I help you today?"

    last_user_msg = next(
        (h["content"] for h in reversed(history) if h["role"] == "user"),
        None
    )
    if last_user_msg:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": "Generate a brief, warm phone greeting (under 20 words) for a returning caller. Mention their last topic naturally."},
                {"role": "user", "content": f"Last topic: {last_user_msg}"}
            ],
            max_tokens=50
        )
        return response.choices[0].message.content

    return "Welcome back! Great to hear from you again. How can I help?"


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

Register Your Webhook with VoIPBin

Point VoIPBin to your server:

curl -X POST https://api.voipbin.net/v1.0/numbers/<your-number-id>/webhook \
  -H "Authorization: Bearer $VOIPBIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"webhook_url": "https://your-server.com/webhook/call"}'

Now every inbound call to your VoIPBin number triggers the webhook with the caller's phone number included.

What This Unlocks

Once your bot has memory, the interaction quality jumps immediately:

First call:

Caller: "I need help resetting my password."
Bot: "Of course! I've sent a reset link to your email."

Second call (3 days later):

Bot: "Welcome back! Did the password reset work out for you?"
Caller: "Actually no, I never got that email."
Bot: "Got it — let me resend that to a different address."

The caller did not explain the context again. The bot already knew.

Production Considerations

Caller privacy: Phone numbers are PII. Consider hashing them before using as Redis keys (sha256(phone_number)). Store only what you need.

History size: Limit turns per caller. Unbounded history means unbounded token costs. MAX_HISTORY_TURNS = 10 is a reasonable default for most support bots.

Redis vs database: Redis for hot, active sessions. Move to Postgres or MongoDB for long-term storage after the call ends.

Multi-number bots: If you run bots on multiple VoIPBin numbers, namespace your keys: caller:{bot_number}:{caller_number} to avoid cross-bot memory bleed.

The Result

With fewer than 100 lines of Python, your AI voice bot now:

Recognizes returning callers by phone number
Loads prior conversation context before responding
Generates personalized greetings based on the last interaction
Appends each exchange to persistent memory automatically

This is not a complex feature. It is missing from most voice bots because the infrastructure was hard. VoIPBin handles the telephony — RTP, STT, TTS, and caller ID delivery. You handle the logic. The phone call becomes just another API call.

Try VoIPBin: https://voipbin.net — signup is instant, no OTP.

MCP Server (use directly from Claude Desktop or Cursor): uvx voipbin-mcp

Go SDK: go get github.com/voipbin/voipbin-go

Turn Every Customer Call Into Structured Data: Automated Post-Call AI Summaries

voipbin — Wed, 22 Apr 2026 17:03:08 +0000

Your sales team makes 50 calls a day. Each call is 8–15 minutes of negotiation, objection handling, and valuable customer insight. At the end of the day, your CRM has entries like:

"Called John. Interested. Follow up next week."

That's it. The actual conversation — the customer's pain points, the objections they raised, the specific numbers they mentioned — is gone. Lost to memory decay and rushed note-taking.

This isn't a laziness problem. It's a physics problem. You can't be fully present in a conversation and take detailed notes at the same time.

What We're Building

A post-call intelligence pipeline that:

Captures every inbound/outbound call through VoIPBin
Fires a webhook when the call ends (with the recording URL)
Transcribes the audio using OpenAI Whisper
Extracts structured data with GPT-4o: summary, sentiment, action items, deal signals
Pushes a clean, structured record to your CRM or Notion

The output looks like this:

{
  "caller": "+1-555-0123",
  "duration": 847,
  "summary": "John from Acme Corp wants to expand their license from 50 to 200 seats. Main blocker is Q3 budget freeze. He asked for a written proposal by Friday and mentioned a competitor (Twilio) is also in evaluation.",
  "sentiment": "positive",
  "action_items": [
    "Send written proposal by Friday",
    "Include volume discount for 200-seat tier",
    "Schedule follow-up for Q4 budget cycle"
  ],
  "next_follow_up": "2026-05-01",
  "deal_signals": {
    "competitor_mentioned": "Twilio",
    "deal_size": "200 seats",
    "blocker": "Q3 budget freeze"
  }
}

No manual notes. No forgotten details. Every call, automatically.

Setting Up VoIPBin

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

You'll immediately receive an accesskey.token. No email verification, no OTP.

Next, configure a webhook that fires when a call recording is ready:

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

The Post-Call Pipeline

Here's the complete Python implementation:

import os
import json
import httpx
import openai
from fastapi import FastAPI, Request
from datetime import datetime

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

VOIPBIN_TOKEN = os.environ["VOIPBIN_TOKEN"]


@app.post("/webhooks/call-ended")
async def handle_call_ended(request: Request):
    payload = await request.json()

    recording_url = payload["recording_url"]
    caller_number = payload.get("caller", "unknown")
    duration = payload.get("duration_seconds", 0)
    call_id = payload["call_id"]

    # Step 1: Download the recording
    async with httpx.AsyncClient() as http_client:
        response = await http_client.get(
            recording_url,
            headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"}
        )
        audio_bytes = response.content

    audio_path = f"/tmp/{call_id}.mp3"
    with open(audio_path, "wb") as f:
        f.write(audio_bytes)

    # Step 2: Transcribe with Whisper
    with open(audio_path, "rb") as audio_file:
        transcription = client.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file,
            response_format="text"
        )

    # Step 3: Extract structured intelligence with GPT-4o
    intelligence = await extract_call_intelligence(
        transcription, caller_number, duration
    )

    # Step 4: Push to CRM
    await push_to_crm(intelligence)

    return {"status": "processed", "call_id": call_id}


async def extract_call_intelligence(
    transcript: str,
    caller: str,
    duration: int
) -> dict:

    prompt = f"""Analyze this sales call transcript and extract structured data.

Caller: {caller}
Duration: {duration} seconds
Transcript:
{transcript}

Return a JSON object with these fields:
- summary: 2-3 sentence summary of the conversation
- sentiment: positive, neutral, or negative
- action_items: list of specific next steps mentioned
- next_follow_up: suggested follow-up date (YYYY-MM-DD) if mentioned, else null
- deal_signals: object with any of: competitor_mentioned, deal_size, budget, timeline, blocker
- topics: list of main topics discussed

Return only valid JSON, no markdown."""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

    data = json.loads(response.choices[0].message.content)
    data["caller"] = caller
    data["duration"] = duration
    data["processed_at"] = datetime.utcnow().isoformat()

    return data


async def push_to_crm(intelligence: dict):
    notion_token = os.environ.get("NOTION_TOKEN")
    notion_db_id = os.environ.get("NOTION_DB_ID")

    if not notion_token:
        print(json.dumps(intelligence, indent=2))
        return

    async with httpx.AsyncClient() as http_client:
        await http_client.post(
            "https://api.notion.com/v1/pages",
            headers={
                "Authorization": f"Bearer {notion_token}",
                "Notion-Version": "2022-06-28",
                "Content-Type": "application/json"
            },
            json={
                "parent": {"database_id": notion_db_id},
                "properties": {
                    "Caller": {
                        "title": [{"text": {"content": intelligence["caller"]}}]
                    },
                    "Summary": {
                        "rich_text": [{"text": {"content": intelligence["summary"]}}]
                    },
                    "Sentiment": {
                        "select": {"name": intelligence["sentiment"]}
                    }
                }
            }
        )

Running the Server

pip install fastapi uvicorn httpx openai

export VOIPBIN_TOKEN=your_token_here
export OPENAI_API_KEY=your_openai_key

uvicorn main:app --host 0.0.0.0 --port 8080

For local development, expose it with ngrok:

ngrok http 8080
# Copy the HTTPS URL and set it as your VoIPBin webhook

What You Actually Get

Every call automatically produces structured data your team can act on.

For sales teams: Full conversation context in the CRM before the follow-up call. Your rep knows the competitor was mentioned, the deal size, the budget cycle — without bullet-point notes.

For support teams: Every resolution is documented. If a customer calls back, the previous issue is already in context.

For founders: Aggregate call data across all reps. Which objections come up most? Which topics are trending? Which deals stall at the same stage? You have the data now.

The Pattern, Not Just the Feature

This webhook-to-intelligence pipeline generalizes well:

Candidate interviews: Extract skills mentioned, red flags, questions asked
Partner calls: Track commitments made, follow-ups promised, relationship health
Board calls: Auto-generate meeting minutes and decision logs
Support escalations: Document resolution steps for future agent training data

VoIPBin handles the telephony layer — recording, storage, delivery via webhook — so your code is pure business logic. The ~80 lines above are doing the actual work; the infrastructure is invisible.

The insight has always been in those calls. Now you can actually capture it.

Try it: Sign up at voipbin.net — API token in 30 seconds, no credit card required for the trial.

Never Miss an Urgent Call Again: Build an AI Voicemail Handler

voipbin — Tue, 21 Apr 2026 17:02:17 +0000

You're in a meeting. Your phone rings. You ignore it. Fifteen minutes later, you check voicemail — "Hi, this is Dave from Acme Corp, we need to talk about our $200k contract, please call back—"

That was 20 minutes ago. Dave called your competitor while he waited.

This happens dozens of times a day in any business. The fix isn't hiring someone to monitor phones. It's building a voicemail handler that transcribes every missed call, classifies its urgency, and routes it to the right person in real time.

Here's how to build one in Python with about 80 lines of code.

The Architecture

When a caller leaves a voicemail:

VoIPBin records the audio
Fires a webhook to your server with the recording URL
Your server downloads the audio and sends it to OpenAI Whisper for transcription
GPT-4o classifies the urgency and extracts key info
Your system routes it: Slack for urgent, email digest for routine

No telephony expertise required. No SIP configuration. No audio codec negotiation.

Setting Up VoIPBin

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

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

Then configure a Flow on your inbound number to record calls and fire a webhook when callers leave a message:

curl -X POST https://api.voipbin.net/v1.0/flows \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "voicemail-handler",
    "actions": [
      {
        "type": "talk",
        "text": "You have reached our office. Please leave a message after the beep."
      },
      {
        "type": "record",
        "max_duration": 120,
        "on_complete": {
          "type": "webhook",
          "url": "https://yourserver.com/voicemail"
        }
      }
    ]
  }'

That's the entire telephony setup. Everything else is Python.

Building the Webhook Handler

from flask import Flask, request, jsonify
import requests
import openai
import os
import json

app = Flask(__name__)
openai.api_key = os.environ["OPENAI_API_KEY"]
VOIPBIN_TOKEN = os.environ["VOIPBIN_TOKEN"]

@app.route("/voicemail", methods=["POST"])
def handle_voicemail():
    data = request.json
    recording_url = data.get("recording_url")
    caller = data.get("from", "Unknown")
    timestamp = data.get("timestamp", "")

    if not recording_url:
        return jsonify({"error": "No recording URL"}), 400

    # Download the audio
    audio_response = requests.get(recording_url)
    audio_path = f"/tmp/voicemail_{caller}.wav"
    with open(audio_path, "wb") as f:
        f.write(audio_response.content)

    # Transcribe with Whisper
    transcript = transcribe_audio(audio_path)

    # Classify and extract info
    analysis = analyze_voicemail(transcript, caller)

    # Route based on urgency
    route_voicemail(analysis, caller, timestamp)

    return jsonify({"status": "processed", "urgency": analysis["urgency"]})


def transcribe_audio(audio_path: str) -> str:
    with open(audio_path, "rb") as f:
        result = openai.audio.transcriptions.create(
            model="whisper-1",
            file=f
        )
    return result.text


def analyze_voicemail(transcript: str, caller: str) -> dict:
    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": """Analyze this voicemail and return JSON with:
- urgency: \"critical\", \"high\", \"normal\", or \"low\"
- summary: one sentence summary
- action_required: what needs to happen next
- callback_needed: true/false
- sentiment: \"positive\", \"neutral\", \"frustrated\", or \"angry\"

Urgency guide:
- critical: contract, legal, emergency, immediate action
- high: decision needed soon, time-sensitive request
- normal: general inquiry or follow-up
- low: spam, unsolicited sales pitch"""
            },
            {
                "role": "user",
                "content": f"Caller: {caller}\nTranscript: {transcript}"
            }
        ],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)


def route_voicemail(analysis: dict, caller: str, timestamp: str):
    urgency = analysis["urgency"]
    summary = analysis["summary"]
    action = analysis["action_required"]

    message = f"""
📞 *New Voicemail from {caller}*
🕐 {timestamp}
⚡ Urgency: {urgency.upper()}
📝 {summary}
✅ Action: {action}
    """.strip()

    if urgency in ["critical", "high"]:
        send_slack_alert(message)
    else:
        queue_for_digest(message)

    # Auto-acknowledge if callback was explicitly requested
    if analysis.get("callback_needed"):
        send_callback_sms(caller)


def send_slack_alert(message: str):
    webhook_url = os.environ["SLACK_WEBHOOK_URL"]
    requests.post(webhook_url, json={"text": message})


def queue_for_digest(message: str):
    # Append to DB or message queue for daily digest
    print(f"[DIGEST QUEUE] {message}")


def send_callback_sms(phone_number: str):
    """Acknowledge the caller automatically via SMS."""
    requests.post(
        "https://api.voipbin.net/v1.0/messages",
        headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"},
        json={
            "to": phone_number,
            "message": "Thanks for calling. We received your voicemail and will call you back within the hour."
        }
    )


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

What Happens in Practice

Here's a real-world example of what the analysis output looks like for a contract renewal call:

{
  "urgency": "critical",
  "summary": "Existing customer calling about contract renewal deadline today at 5pm.",
  "action_required": "Call back immediately before 5pm to confirm renewal terms.",
  "callback_needed": true,
  "sentiment": "frustrated"
}

That message hits Slack within 10 seconds of the call ending. The caller also gets an SMS acknowledgment automatically. You call back with full context before they've had time to dial a competitor.

Extending This for Production

CRM enrichment before classification

Cross-reference the caller's phone number with your CRM before the AI sees it. A missed call from your largest account should always be marked critical, regardless of what they said.

def enrich_caller(phone_number: str) -> dict:
    response = requests.get(
        f"https://your-crm.com/api/contacts?phone={phone_number}",
        headers={"Authorization": f"Bearer {CRM_TOKEN}"}
    )
    return response.json() if response.ok else {}

# Then pass enrichment context into analyze_voicemail

Trend analytics

Store every transcript and classification in a database. After a month, you'll know:

Which hours generate the most missed calls (staff scheduling)
What percentage of voicemails are actually urgent (team triage calibration)
Whether caller sentiment is trending up or down (product/support signal)

Escalation chains

For critical calls, don't just Slack one person — escalate progressively if no one acknowledges:

import time
import threading

def escalate_if_unacknowledged(message: str, call_id: str):
    def check_and_escalate():
        time.sleep(300)  # Wait 5 minutes
        if not is_acknowledged(call_id):
            notify_manager(message)  # Escalate to manager
            time.sleep(300)
            if not is_acknowledged(call_id):
                notify_on_call(message)  # Page the on-call person

    threading.Thread(target=check_and_escalate, daemon=True).start()

Why This Works Without Telephony Expertise

The full stack here is:

VoIPBin: handles inbound call routing, recording, codec negotiation, and webhook delivery
OpenAI Whisper: transcription
GPT-4o mini: classification and extraction
Flask: webhook receiver
Slack/SMS: delivery

The pieces you write are the webhook handler and the AI prompts. The pieces you don't write are everything telephony — SIP signaling, RTP streams, audio encoding, call state machines.

This is the Media Offloading model: AI agents handle intelligence, VoIPBin handles communication infrastructure.

Getting Started

Sign up at voipbin.net — instant, no credit card required
Get a phone number from the dashboard
Deploy the Flask app above (any cloud instance works)
Configure the flow to point to your webhook
Call your number, don't answer, leave a message

Your Slack channel should ping within 10 seconds.

The missed $200k renewal call? That's now a Slack alert. Dave gets an SMS saying you'll call him back. You call back with the full transcript in front of you.

Dave stays your customer.

Build a Voice Survey Bot: Automate Customer Feedback Calls with AI

voipbin — Mon, 20 Apr 2026 17:04:21 +0000

You just shipped a new feature. Your product manager wants feedback. Your marketing team schedules a survey email. Three days later: 2% open rate, 0.3% completion.

Email surveys are dead. But what if instead of hoping customers find your survey, your survey called them?

In this post, we'll build a voice survey bot that calls customers, reads questions aloud, captures their spoken answers, and stores structured responses — all with about 100 lines of Python and no telephony expertise required.

Why Voice Surveys Work

Response rates for voice surveys hover around 30-50% compared to <5% for email. The reason is simple: a ringing phone demands attention in a way an email never will.

And with AI-powered speech recognition, you don't have to force users into clunky keypad menus ("Press 1 for satisfied..."). You can ask open-ended questions and let them answer naturally — then analyze the transcripts programmatically.

The catch: building this traditionally means wrangling SIP trunks, RTP streams, DTMF signaling, and TTS pipelines. That's weeks of work before you write your first survey question.

We'll skip all of that.

What We're Building

A Python service that:

Initiates outbound calls to a list of phone numbers
Plays a TTS greeting and survey questions
Records and transcribes spoken answers in real time
Stores structured survey responses

The telephony infrastructure — RTP handling, STT/TTS, codec negotiation — is handled by VoIPBin. Your code never touches audio.

Prerequisites

Python 3.9+
A VoIPBin account (free tier available)
pip install requests flask

Get your API token by signing up:

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

The response includes accesskey.token — copy it. No email verification, no waiting.

Step 1: Design Your Survey Flow

VoIPBin uses a Flow — a JSON-defined sequence of actions. For a survey, we want:

Greet the caller
Ask a question
Listen for a spoken response (and transcribe it)
Repeat for each question
Thank and hang up

Here's a minimal three-question survey flow:

import requests

VOIPBIN_TOKEN = "your_api_token"
WEBHOOK_URL = "https://your-server.com/survey-webhook"

headers = {
    "Authorization": f"Bearer {VOIPBIN_TOKEN}",
    "Content-Type": "application/json"
}

survey_flow = {
    "name": "customer-survey-v1",
    "actions": [
        {"type": "talk", "text": "Hi! This is a quick 3-question survey. Let's begin."},
        {"type": "talk", "text": "Q1: On a scale of 1-10, how satisfied are you with our service?"},
        {"type": "listen", "timeout": 5, "webhook": f"{WEBHOOK_URL}?question=1"},
        {"type": "talk", "text": "Q2: What is one thing we could do better?"},
        {"type": "listen", "timeout": 15, "webhook": f"{WEBHOOK_URL}?question=2"},
        {"type": "talk", "text": "Q3: Would you recommend us to a friend? Say yes or no."},
        {"type": "listen", "timeout": 5, "webhook": f"{WEBHOOK_URL}?question=3"},
        {"type": "talk", "text": "Thank you for your feedback. Have a great day!"},
        {"type": "hangup"}
    ]
}

response = requests.post(
    "https://api.voipbin.net/v1.0/flows",
    headers=headers,
    json=survey_flow
)
flow_id = response.json()["id"]
print(f"Survey flow created: {flow_id}")

The listen action is the key here. VoIPBin records the caller's speech, runs STT, and POSTs the transcript to your webhook. Your server receives clean text — zero audio processing on your end.

Step 2: Receive Transcripts via Webhook

Set up a Flask endpoint to receive transcribed answers:

from flask import Flask, request, jsonify
from datetime import datetime

app = Flask(__name__)
survey_responses = {}  # use a real DB in production

@app.route("/survey-webhook", methods=["POST"])
def handle_transcript():
    question_num = request.args.get("question")
    payload = request.json

    call_id = payload.get("call_id")
    transcript = payload.get("transcript", "").strip()
    timestamp = datetime.utcnow().isoformat()

    if call_id not in survey_responses:
        survey_responses[call_id] = {"started_at": timestamp, "answers": {}}

    survey_responses[call_id]["answers"][f"q{question_num}"] = {
        "transcript": transcript,
        "recorded_at": timestamp
    }

    print(f"[Call {call_id}] Q{question_num}: {transcript}")
    return jsonify({"status": "ok"})

@app.route("/responses", methods=["GET"])
def get_responses():
    return jsonify(survey_responses)

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

Step 3: Launch the Survey Campaign

Trigger outbound calls to your customer list:

import time

def call_customer(phone_number, flow_id):
    payload = {
        "flow_id": flow_id,
        "source": "+12025550100",  # Your VoIPBin number
        "destination": phone_number
    }
    response = requests.post(
        "https://api.voipbin.net/v1.0/calls",
        headers=headers,
        json=payload
    )
    if response.status_code == 200:
        data = response.json()
        print(f"Called {phone_number} — ID: {data['id']}")
        return data["id"]
    print(f"Failed: {response.text}")
    return None

customers = ["+14155550101", "+14155550102", "+14155550103"]

for number in customers:
    call_customer(number, flow_id)
    time.sleep(2)  # pace your calls

For production, replace time.sleep with a proper queue (Celery, Redis) and add retry logic for unanswered calls.

Step 4: Analyze the Results

Once calls complete, your /responses endpoint returns structured data:

{
  "call_abc123": {
    "started_at": "2026-04-21T10:00:00",
    "answers": {
      "q1": { "transcript": "eight", "recorded_at": "2026-04-21T10:00:15" },
      "q2": { "transcript": "I wish the checkout was faster", "recorded_at": "2026-04-21T10:00:40" },
      "q3": { "transcript": "yes definitely", "recorded_at": "2026-04-21T10:01:00" }
    }
  }
}

From here, pipe the transcripts into an LLM for instant sentiment analysis:

import openai, json

def analyze_response(answers):
    transcript = "\n".join(
        [f"Q{k[1:]}: {v['transcript']}" for k, v in answers.items()]
    )
    result = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": (
                "Analyze this customer survey and return JSON with: "
                "satisfaction_score (1-10), sentiment (positive/neutral/negative), "
                f"key_feedback (one sentence).\n\n{transcript}"
            )
        }]
    )
    return json.loads(result.choices[0].message.content)

What You Get

With this setup, each survey call:

Takes ~2 minutes end-to-end
Costs a fraction of a call center
Returns structured, searchable transcripts
Scales to hundreds of calls per hour — no infrastructure changes needed

And critically — you wrote zero telephony code. No SIP, no RTP, no audio codecs. VoIPBin handles all of that. Your code is just Python sending HTTP requests and receiving webhooks.

Going Further

A few ways to extend this:

Conditional branching: If Q1 score < 5, route to a human agent for service recovery
Retry logic: If no answer, call again in 4 hours (once)
Multilingual surveys: Pass language in the talk action for automatic localization
DTMF fallback: If STT confidence is low, fall back to keypad input

The Bigger Picture

Voice feedback is one of the richest signals you can collect from customers. People speak more naturally than they type — you get tone, hesitation, and nuance that multiple-choice forms will never capture.

The only reason most products don't collect voice feedback is that it's been hard. That excuse is gone.

VoIPBin is an AI-native CPaaS that lets developers add voice and telephony to their applications without managing telecom infrastructure. Get started at voipbin.net — API access is instant, no verification required.

Why Email Alerts Fail at 3AM — Build a Voice Alert System with AI

voipbin — Sun, 19 Apr 2026 17:02:22 +0000

You have Prometheus running. You have Grafana dashboards. You have Slack alerts configured. And yet, somehow, your on-call engineer still sleeps through a critical outage at 3AM.

Here's the uncomfortable truth: humans ignore notifications. Push alerts get swiped away. Slack messages get buried under 200 others. Emails sit unread until morning standup, when the damage is already done.

But a phone call? That's impossible to ignore.

In this post, I'll show you how to build a production-ready AI voice alert system that calls your on-call engineer when production goes down — using VoIPBin's REST API and about 80 lines of Python.

The Problem with Silent Monitoring

Modern observability stacks are brilliant at generating alerts. They're terrible at making humans pay attention.

Alert fatigue is real. When everything is tagged critical, nothing feels critical. Engineers develop a Pavlovian response to notification sounds: dismiss, snooze, ignore.

The solution isn't more alerts — it's the right kind of alert at the right moment. A phone call interrupts whatever you're doing. It demands a response. And when production is on fire, that friction is exactly what you need.

What We're Building

A webhook handler that:

Receives an alert from your monitoring system (Prometheus Alertmanager, Grafana, CloudWatch, Datadog — anything with webhook support)
Calls your on-call engineer via an AI voice agent
Reads out the alert details in plain English using text-to-speech
Escalates through the on-call chain if the first engineer doesn't pick up

Prerequisites

Python 3.8+
A VoIPBin account — signup is API-first, no forms or email verification
A phone number provisioned from VoIPBin

Step 1: Get Your API Token

VoIPBin signup takes one API call:

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

You'll get back:

{
  "accesskey": {
    "token": "your-api-token-here"
  }
}

Store that token. Every API call uses it as a Bearer token.

Step 2: The Alert Webhook Handler

Install dependencies:

pip install flask requests

Now the handler:

from flask import Flask, request, jsonify
import requests
from threading import Thread
import time

app = Flask(__name__)

VOIPBIN_TOKEN = "your-api-token-here"
VOIPBIN_BASE = "https://api.voipbin.net/v1.0"
FROM_NUMBER = "+19876543210"  # Your VoIPBin number

# Escalation chain — calls in order until someone answers
ECALATION_CHAIN = [
    "+1234567890",  # Primary on-call
    "+1987654321",  # Secondary on-call
    "+1555000111",  # Engineering manager
]


def make_voice_alert(alert_message: str, to_number: str) -> dict:
    """Trigger an AI voice call with the alert details."""
    payload = {
        "from": FROM_NUMBER,
        "to": to_number,
        "actions": [
            {
                "type": "talk",
                "text": (
                    f"Attention. This is a production alert. "
                    f"{alert_message}. "
                    "Press 1 to acknowledge and stop escalation."
                )
            },
            {
                "type": "gather",
                "timeout": 15,
                "num_digits": 1
            }
        ]
    }

    response = requests.post(
        f"{VOIPBIN_BASE}/calls",
        headers={
            "Authorization": f"Bearer {VOIPBIN_TOKEN}",
            "Content-Type": "application/json"
        },
        json=payload
    )
    return response.json()


def escalate_alert(message: str, wait_seconds: int = 90):
    """Walk the escalation chain until someone picks up."""
    for number in ESCALATION_CHAIN:
        print(f"[ALERT] Calling {number}...")
        result = make_voice_alert(message, number)
        call_id = result.get("id")

        if not call_id:
            print(f"[ERROR] Failed to create call: {result}")
            continue

        # Wait for the call to complete, then check status
        time.sleep(wait_seconds)

        status_resp = requests.get(
            f"{VOIPBIN_BASE}/calls/{call_id}",
            headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"}
        )
        call_status = status_resp.json().get("status", "unknown")

        if call_status in ("answered", "completed"):
            print(f"[OK] Alert acknowledged by {number}")
            return

        print(f"[ESCALATE] No answer from {number}, trying next...")

    print("[CRITICAL] Escalation chain exhausted. Alert unacknowledged.")


@app.route("/webhook/alerts", methods=["POST"])
def handle_alert():
    """Receive Prometheus Alertmanager (or similar) webhooks."""
    data = request.json
    alerts = data.get("alerts", [])
    firing_alerts = [a for a in alerts if a.get("status") == "firing"]

    if not firing_alerts:
        return jsonify({"status": "no firing alerts"}), 200

    for alert in firing_alerts:
        alert_name = alert.get("labels", {}).get("alertname", "Unknown Alert")
        severity = alert.get("labels", {}).get("severity", "unknown")
        summary = alert.get("annotations", {}).get(
            "summary", "Check your systems immediately."
        )

        message = f"Severity {severity}. Alert name: {alert_name}. {summary}"

        # Escalate in background so we can return 200 immediately
        Thread(
            target=escalate_alert,
            args=(message,),
            daemon=True
        ).start()

    return jsonify({"status": "escalation started", "alerts": len(firing_alerts)}), 200


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

Step 3: Wire Up Prometheus Alertmanager

Add a receiver in your alertmanager.yml:

receivers:
  - name: voice-alerts
    webhook_configs:
      - url: "https://your-server.com/webhook/alerts"
        send_resolved: false

route:
  group_wait: 30s
  repeat_interval: 4h
  routes:
    - match:
        severity: critical
      receiver: voice-alerts

For Grafana, go to Alerting → Contact points → Add contact point → Webhook, and point it at the same URL.

For CloudWatch or Datadog, add an SNS topic or webhook integration that POSTs to your endpoint.

What VoIPBin Handles for You

If you've built alert systems before, you know the usual pain:

Standing up a SIP server or navigating a CPaaS console
Parsing DTMF input from raw audio streams
Managing call state across retries
Implementing TTS yourself or paying for a separate service
Dealing with RTP when you want real-time speech

VoIPBin's Media Offloading model eliminates all of this. Your application sends a plain REST API call with an action list. VoIPBin converts your text to speech, makes the call, collects the DTMF keypress, and delivers events back to your webhook. Your Python code never touches audio — not a single byte of RTP.

This is the core principle: your AI agent or alert system handles logic, VoIPBin handles the telephony.

Step 4: Harden for Production

A few things you'll want before going live:

Add webhook authentication — verify that the request actually came from your alerting system:

import hmac, hashlib

SECRET = "your-shared-webhook-secret"

def verify_signature(payload: bytes, sig_header: str) -> bool:
    expected = hmac.new(SECRET.encode(), payload, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, sig_header)

@app.before_request
def check_signature():
    sig = request.headers.get("X-Webhook-Signature", "")
    if not verify_signature(request.data, sig):
        return jsonify({"error": "unauthorized"}), 401

Track acknowledged alerts — use Redis or a simple database to mark alerts as acknowledged so the escalation loop stops:

import redis

r = redis.Redis()

@app.route("/webhook/acknowledged", methods=["POST"])
def mark_acknowledged():
    call_id = request.json.get("call_id")
    r.set(f"ack:{call_id}", "1", ex=3600)  # expires in 1 hour
    return jsonify({"status": "acknowledged"})

# In escalate_alert, check before calling the next person:
if r.get(f"ack:{call_id}"):
    print("Alert acknowledged via keypress. Stopping escalation.")
    return

Run with gunicorn in production:

pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:5000 app:app

Result

You now have a voice alert system that:

✅ Works with any monitoring tool that supports webhooks
✅ Reads alert details in plain English — no cryptic codes
✅ Escalates through your entire on-call chain automatically
✅ Requires no SIP knowledge, no audio handling, no RTP
✅ Can be deployed in an afternoon on any cloud platform

The on-call engineer gets a real phone call. Not a notification they can swipe away. A call.

Get Started

VoIPBin signup is one API call:

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

Documentation, SDKs, and pricing at voipbin.net.

If you're using the Golang SDK instead:

go get github.com/voipbin/voipbin-go

Have you built a voice alerting system or tried a different approach to on-call notifications? I'd love to hear what worked — and what didn't — in the comments.

Build a Voice OTP System: Phone-Based Two-Factor Authentication in 10 Minutes

voipbin — Sat, 18 Apr 2026 17:02:38 +0000

SMS-based OTP is everywhere. It is also increasingly broken.

SIM-swapping attacks let bad actors hijack someone's phone number and intercept every text message. SS7 vulnerabilities have allowed nation-state-level interception of SMS OTPs for years. And delivery rates vary wildly depending on carrier relationships, country regulations, and anti-spam filters.

Voice OTP is a credible alternative — and for certain user segments (elderly users, regions with poor SMS delivery, high-security flows) it's already preferred. Let's build one.

How Voice OTP Works

Instead of sending a text, your backend places an outbound call to the user's number. An AI voice reads the code aloud. The user hears it and types it into your app.

That's it. No SMS gateway contract. No carrier filtering. Just a phone call.

The flow looks like this:

User requests OTP
       │
       ▼
Your Backend generates code → stores in cache → calls VoIPBin API
       │
       ▼
VoIPBin places outbound call → reads OTP via TTS
       │
       ▼
User hears code → enters it in your app
       │
       ▼
Your Backend validates → grants access

No special telephony knowledge required. No SIP trunk to configure. Just an API call.

Getting Started with VoIPBin

First, grab an API key. It's a single POST request — no email confirmation, no OTP to get through (the irony).

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

Response:

{
  "accesskey": {
    "token": "your-api-token-here"
  }
}

Save that token. You'll use it in every subsequent request.

The Backend: Generate and Deliver OTP via Voice

Here's a minimal Python backend using FastAPI that:

Generates a 6-digit OTP
Stores it in memory (use Redis in production)
Places an outbound call via VoIPBin that reads the code aloud

import random
import httpx
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

VOIPBIN_TOKEN = "your-api-token-here"
VOIPBIN_BASE = "https://api.voipbin.net/v1.0"
CALLER_NUMBER = "+12025551234"  # your VoIPBin number

# In-memory OTP store — use Redis in production
otp_store: dict[str, str] = {}


class OTPRequest(BaseModel):
    phone: str  # E.164 format, e.g. "+14155551234"
    user_id: str


class OTPVerify(BaseModel):
    user_id: str
    code: str


@app.post("/otp/request")
async def request_otp(req: OTPRequest):
    code = str(random.randint(100000, 999999))
    otp_store[req.user_id] = code

    # Speak the digits with pauses for clarity
    spoken = ". ".join(list(code))
    message = (
        f"Your verification code is: {spoken}. "
        f"I repeat: {spoken}. "
        "Do not share this code with anyone."
    )

    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{VOIPBIN_BASE}/calls",
            headers={
                "Authorization": f"Bearer {VOIPBIN_TOKEN}",
                "Content-Type": "application/json",
            },
            json={
                "source": {"type": "tel", "target": CALLER_NUMBER},
                "destination": {"type": "tel", "target": req.phone},
                "actions": [
                    {
                        "type": "talk",
                        "text": message,
                        "language": "en-US",
                        "gender": "female",
                    }
                ],
            },
        )

    if resp.status_code not in (200, 201):
        raise HTTPException(status_code=502, detail="Failed to place call")

    return {"status": "call_initiated", "user_id": req.user_id}


@app.post("/otp/verify")
async def verify_otp(req: OTPVerify):
    stored = otp_store.get(req.user_id)
    if not stored or stored != req.code:
        raise HTTPException(status_code=401, detail="Invalid or expired OTP")

    del otp_store[req.user_id]
    return {"status": "verified", "user_id": req.user_id}

Install dependencies:

pip install fastapi uvicorn httpx
uvicorn main:app --reload

Test the flow:

# Step 1: request OTP
curl -X POST http://localhost:8000/otp/request \
  -H "Content-Type: application/json" \
  -d '{ "phone": "+14155551234", "user_id": "user_42" }'

# Step 2: verify (after user enters code)
curl -X POST http://localhost:8000/otp/verify \
  -H "Content-Type: application/json" \
  -d '{ "user_id": "user_42", "code": "391847" }'

The call is placed immediately. The user's phone rings, they hear the code read aloud twice, and your /otp/verify endpoint handles the rest.

Making the Voice Clearer

OTP readability matters. A voice that runs "three nine one eight four seven" together is hard to follow. A few techniques help:

Pace the digits. The ". ".join(list(code)) trick in the example above inserts a short pause between each digit. VoIPBin's TTS engine respects punctuation pauses.

Repeat the code. Always say it twice. Users are often distracted when they pick up an unexpected call.

Keep it short. The full message should be under 15 seconds. Don't add marketing copy — this is a security interaction.

Use a consistent caller ID. Register a number with VoIPBin and use it exclusively for OTP calls. This lets users recognize the call and builds trust over time.

Handling Call Failures

What if the call doesn't connect? Real-world handling means:

@app.post("/otp/request")
async def request_otp(req: OTPRequest):
    code = str(random.randint(100000, 999999))
    otp_store[req.user_id] = {"code": code, "attempts": 0}

    # ... place call ...

    # Return call ID so frontend can poll status
    call_id = resp.json().get("id")
    return {
        "status": "call_initiated",
        "call_id": call_id,
        "fallback_available": True,  # offer SMS fallback in UI
    }

On the frontend, show a "Didn't receive the call?" button after 20 seconds. That button can either retry the voice call or fall back to SMS — your choice.

Multilingual Support

VoIPBin's TTS supports multiple languages. If you know the user's locale, pass it directly:

language_map = {
    "ko": "ko-KR",
    "ja": "ja-JP",
    "es": "es-ES",
    "fr": "fr-FR",
    "de": "de-DE",
    "en": "en-US",
}

lang = language_map.get(user_locale, "en-US")

actions = [
    {
        "type": "talk",
        "text": message,
        "language": lang,
        "gender": "female",
    }
]

For a global user base, this is the kind of UX detail that actually matters. A Japanese user hearing their OTP in Japanese is a meaningfully better experience.

Why Not Just Use an SMS Gateway?

Fair question. SMS OTP is well-understood and cheap for most use cases. Voice OTP makes more sense when:

Your users are at elevated risk of SIM-swapping (crypto, fintech, high-value accounts)
SMS delivery is unreliable in your target market
Your users are less mobile-native and find a phone call more natural
You're building a voice-first product anyway and want consistent UX
Regulatory requirements in your industry recommend or require voice-based verification

You can also offer both and let the user choose. Many security-conscious apps show: "Send code via SMS" / "Call me instead."

What You've Built

With about 60 lines of Python and one API endpoint, you have:

Outbound voice calls that speak a dynamically generated OTP
OTP validation with a clean POST endpoint
Language-aware TTS for international users
A foundation to add DTMF collection, retry logic, and SMS fallback

No SIP configuration. No audio encoding. No carrier contract. VoIPBin handles the call placement, number management, and TTS — you just send JSON.

Want to go further? Try collecting the OTP during the call via DTMF — the user presses their keypad instead of typing into your app, and VoIPBin returns the digits via webhook. It's a tighter UX for certain flows.

Check the VoIPBin docs or explore the MCP integration: uvx voipbin-mcp to test calls directly from Claude Code or Cursor.

Build a Voice Appointment Reminder Bot: AI Calls That Confirm, Reschedule, or Cancel

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

No-shows are expensive. Whether you're running a clinic, a salon, a law office, or a SaaS demo pipeline — every missed appointment is lost revenue. The traditional fix is a human calling each person the day before. That doesn't scale.

The modern fix is an AI voice bot that calls, holds a real conversation, and updates your system based on what the customer says.

Let's build one.

The Problem with Most Reminder Systems

Most automated reminder systems are one-way: "Your appointment is tomorrow at 2pm. Reply STOP to opt out." That's not a conversation — it's spam with a disclaimer.

What customers actually want is to be able to say: "Can we do 3pm instead?" or "Actually, I need to cancel." And what you want is to capture that intent and act on it immediately — without a human in the loop.

This requires:

Outbound call initiation
Natural language understanding mid-call
A webhook to update your backend

All three are straightforward with VoIPBin + your AI of choice.

Architecture Overview

Your Backend
    │
    ├── POST /calls (initiate outbound call)
    │       │
    │       ▼
    │   VoIPBin ──── calls patient's phone
    │       │
    │       ├── STT: patient speech → text
    │       ├── sends text to your AI
    │       ├── TTS: AI response → audio
    │       │
    │       └── POST /webhook (call events)
    │               │
    └───────────────┘
                    ▼
              Update your DB

Your server never touches audio. VoIPBin handles the RTP stream, STT, and TTS. You write business logic — not telephony code.

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 '{"username": "yourname", "password": "yourpass"}'

Response includes accesskey.token — use that as your Bearer token for all subsequent requests.

Step 2: Define the AI Conversation

Here's a minimal Python handler for the AI side. This runs on your server and receives text from VoIPBin:

from flask import Flask, request, jsonify
import openai

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

sessions = {}  # conversation_id -> history

@app.route("/ai", methods=["POST"])
def handle_voice_turn():
    data = request.json
    call_id = data.get("call_id")
    user_text = data.get("text", "")

    if call_id not in sessions:
        sessions[call_id] = [
            {
                "role": "system",
                "content": (
                    "You are a scheduling assistant for Maple Dental Clinic. "
                    "You're calling to confirm tomorrow's appointment. "
                    "Be concise — this is a phone call. "
                    "Ask if they can confirm, reschedule, or if they need to cancel. "
                    "When they decide, say: 'Great, I've noted that. Have a good day!' "
                    "and end the call."
                )
            }
        ]

    sessions[call_id].append({"role": "user", "content": user_text})

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

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

    # Signal call end when AI wraps up
    should_end = "have a good day" in reply.lower()

    return jsonify({
        "text": reply,
        "end_call": should_end
    })

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

Simple, stateful, and easy to extend.

Step 3: Handle VoIPBin Webhooks

VoIPBin posts call events to your webhook endpoint. Here's how to capture the outcome:

@app.route("/webhook", methods=["POST"])
def call_webhook():
    event = request.json
    call_id = event.get("call_id")
    event_type = event.get("type")

    if event_type == "call.ended":
        # Extract last user intent from session history
        history = sessions.get(call_id, [])
        last_user_msg = next(
            (m["content"] for m in reversed(history) if m["role"] == "user"),
            ""
        ).lower()

        if "cancel" in last_user_msg:
            update_appointment(call_id, status="cancelled")
        elif "reschedule" in last_user_msg or "change" in last_user_msg:
            update_appointment(call_id, status="reschedule_requested")
        else:
            update_appointment(call_id, status="confirmed")

        # Clean up session
        sessions.pop(call_id, None)

    return jsonify({"ok": True})

def update_appointment(call_id, status):
    # Your DB update logic here
    print(f"[{call_id}] Appointment status: {status}")

Step 4: Initiate the Outbound Call

Now the part that kicks everything off — your backend triggers the call:

import httpx

VOIPBIN_TOKEN = "your-access-token"

def call_patient(patient_phone: str, call_id: str):
    payload = {
        "source": "+15551234567",   # your VoIPBin number
        "destination": patient_phone,
        "ai_url": "https://yourserver.com/ai",
        "webhook_url": "https://yourserver.com/webhook",
        "metadata": {"call_id": call_id}
    }

    res = httpx.post(
        "https://api.voipbin.net/v1.0/calls",
        json=payload,
        headers={
            "Authorization": f"Bearer {VOIPBIN_TOKEN}",
            "Content-Type": "application/json"
        }
    )
    return res.json()

# Example: trigger reminder for tomorrow's appointments
for appt in get_tomorrows_appointments():
    call_patient(appt["phone"], appt["id"])

VoIPBin places the call, pipes audio to/from your AI endpoint, and fires the webhook when it ends.

Step 5: Schedule It

For a daily reminder run, a simple cron job does the trick:

# crontab -e
0 10 * * * /usr/bin/python3 /app/trigger_reminders.py >> /var/log/reminders.log 2>&1

Or use your scheduler of choice (Celery, APScheduler, AWS EventBridge, etc.).

What You Get

With this setup:

Confirmed → appointment stays, no staff effort needed
Reschedule requested → flag in your system, staff follows up or routes to another AI flow
Cancelled → slot freed immediately, you can offer it to someone on a waitlist

The whole loop — call placed, conversation completed, DB updated — takes under 2 minutes per patient, fully automated.

Extending the Flow

A few things you can layer in:

Voicemail fallback: If no one answers, leave a message and send an SMS link.

if event_type == "call.no_answer":
    send_sms(patient_phone, f"Missed your call! Confirm your appt here: {confirm_link}")

Reschedule automation: Instead of flagging for human follow-up, connect to your calendar API and offer alternative slots during the call:

# In your system prompt:
"Available slots tomorrow: 9am, 11am, 3pm. Offer these if they want to reschedule."

Multilingual support: Swap the system prompt language based on the patient's stored preference. Same VoIPBin setup, different AI instruction.

Why Not Just Use a DTMF Menu?

You could. "Press 1 to confirm, press 2 to cancel" has worked for 30 years.

But patients hang up on DTMF menus. They talk. An AI that can handle "I need to push it back a bit, maybe Thursday?" has a dramatically higher completion rate — and that means fewer no-shows.

Try It

VoIPBin signup is instant — no OTP, no lengthy onboarding:

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

You'll have an access token in seconds and can place your first AI outbound call in minutes.

→ voipbin.net

Building something with VoIPBin? Drop a comment — always curious what people are shipping.

From AI to Human: Building a Seamless Warm Transfer in AI Voice Calls

voipbin — Thu, 16 Apr 2026 17:02:49 +0000

Every AI voice bot eventually hits its limit.

A customer gets frustrated. A question falls outside the script. An edge case triggers a loop. When that happens, the worst thing you can do is let the AI keep stumbling — you need a graceful handoff to a real human agent.

This is called a warm transfer: the AI stays on the line long enough to brief the human, then steps aside. Done well, the customer barely notices the transition. Done poorly, they hear silence, get disconnected, or have to repeat everything from scratch.

This post walks through building warm transfer with VoIPBin. Your AI handles the first leg, detects when it needs help, and passes the call — with context — to a human.

The Problem With "Just Transfer the Call"

A blind transfer drops the caller into a queue with zero context. The human agent picks up cold. The customer repeats their name, their account number, their problem — everything they already told the bot.

This destroys the value of having an AI in the first place.

A warm transfer means:

AI detects it cannot resolve the issue
AI places the human agent into the call as a conference participant
AI briefs the agent ("Customer is asking about a billing dispute from March — account #48291")
AI exits the call, leaving customer and human agent connected

The customer hears: "Let me connect you with a specialist who can help. One moment."

The agent hears: a whisper from the AI with the full context, then the customer.

Architecture Overview

[Customer calls in]
        ↓
[VoIPBin receives call → sends webhook to your server]
        ↓
[AI agent handles conversation via STT/TTS webhooks]
        ↓
[AI detects escalation trigger]
        ↓
[Your server calls VoIPBin: add human agent to call as conference leg]
        ↓
[VoIPBin calls human agent (SIP or PSTN)]
        ↓
[Both are bridged → AI plays whisper message to agent only]
        ↓
[AI leaves the call]
        ↓
[Customer ↔ Human Agent continue]

Your server handles intent detection and escalation logic. VoIPBin handles all the telephony: forking the call, bridging legs, managing audio routing.

Step 1: Set Up Your Account

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

You get back an accesskey.token immediately — no OTP, no verification delay. Use that token in all subsequent requests.

Step 2: Handle the Inbound Call

When VoIPBin receives a call, it sends a webhook to your server. Respond with a flow that starts the AI conversation:

from flask import Flask, request, jsonify

app = Flask(__name__)

ACCESS_TOKEN = "your-access-token"
HUMAN_AGENT_NUMBER = "+15551234567"  # or a SIP URI

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

    # Start the AI conversation
    return jsonify({
        "actions": [
            {
                "type": "talk",
                "text": "Hi! I am an AI assistant. How can I help you today?",
                "voice": "en-US-Neural2-F"
            },
            {
                "type": "listen",
                "webhook": f"https://yourserver.com/webhook/speech?call_id={call_id}",
                "timeout": 10
            }
        ]
    })

Step 3: Detect the Escalation Trigger

In your speech webhook, process what the customer said. If your AI logic determines it cannot help, trigger the warm transfer:

import requests

@app.route("/webhook/speech", methods=["POST"])
def handle_speech():
    data = request.json
    call_id = request.args.get("call_id")
    transcript = data.get("transcript", "")

    # Your AI logic here
    intent = classify_intent(transcript)
    response_text, needs_human = get_ai_response(intent, transcript)

    if needs_human:
        summary = summarize_conversation(transcript)
        return trigger_warm_transfer(call_id, summary)

    # Continue the conversation normally
    return jsonify({
        "actions": [
            {
                "type": "talk",
                "text": response_text,
                "voice": "en-US-Neural2-F"
            },
            {
                "type": "listen",
                "webhook": f"https://yourserver.com/webhook/speech?call_id={call_id}",
                "timeout": 10
            }
        ]
    })

Step 4: Execute the Warm Transfer

This is where the magic happens. You add the human agent as a new call leg, bridge them into the conversation, deliver a whisper, then remove the AI:

def trigger_warm_transfer(call_id: str, context_summary: str):
    headers = {
        "Authorization": f"Bearer {ACCESS_TOKEN}",
        "Content-Type": "application/json"
    }

    # Step 4a: Inform the customer while dialing the agent
    requests.post(
        f"https://api.voipbin.net/v1.0/calls/{call_id}/actions",
        headers=headers,
        json={
            "actions": [
                {
                    "type": "talk",
                    "text": "Let me connect you with a specialist. Please hold for just a moment.",
                    "voice": "en-US-Neural2-F"
                }
            ]
        }
    )

    # Step 4b: Dial the human agent and bridge into the call
    requests.post(
        f"https://api.voipbin.net/v1.0/calls/{call_id}/bridge",
        headers=headers,
        json={
            "destination": HUMAN_AGENT_NUMBER,
            "whisper": f"Connecting you now. Customer context: {context_summary}",
            "whisper_voice": "en-US-Neural2-D"
        }
    )

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

The whisper field is played only to the agent when they pick up — the customer hears hold music. Once the agent is live, VoIPBin bridges both legs and removes the AI from the audio path.

Step 5: Attach Call Context as Metadata

Passing a summary via whisper is good. Attaching the full conversation log as call metadata is better — so the agent's CRM screen can pull it up:

def attach_context(call_id: str, conversation_history: list):
    requests.patch(
        f"https://api.voipbin.net/v1.0/calls/{call_id}",
        headers={
            "Authorization": f"Bearer {ACCESS_TOKEN}",
            "Content-Type": "application/json"
        },
        json={
            "metadata": {
                "ai_transcript": conversation_history,
                "escalation_reason": "Customer requested billing support",
                "ai_handled_turns": len(conversation_history)
            }
        }
    )

This metadata travels with the call and is available in your call-complete webhook for CRM sync, quality review, or training data collection.

What Makes This Pattern Powerful

You never lose context. The entire conversation up to escalation is attached to the call. The agent does not start cold.

The customer hears continuity. They hear a brief hold message, then a human who already knows their issue. No re-explanation.

The AI only handles what it can. Common queries are resolved instantly. Edge cases and frustrated customers reach humans — with full context.

Fallback is safe. If the agent does not pick up, you can re-route to another number, play a voicemail prompt, or schedule a callback. VoIPBin handles the retry logic.

Escalation Triggers to Implement

Beyond explicit user requests, consider triggering warm transfer when:

Sentiment turns negative — detect frustration or anger keywords
Repeated clarification loops — user rephrased the same question three or more times
High-stakes phrases — "cancel my account", "talk to a manager", "legal action"
Confidence threshold — AI confidence drops below a set threshold for two consecutive turns
Time limit — call exceeds N minutes without resolution

def needs_escalation(transcript: str, turn_count: int, ai_confidence: float) -> bool:
    escalation_phrases = [
        "speak to a human", "talk to a person", "get a manager",
        "cancel my account", "this is ridiculous", "i want a refund"
    ]
    phrase_triggered = any(p in transcript.lower() for p in escalation_phrases)
    low_confidence = ai_confidence < 0.55 and turn_count > 2
    call_timeout = turn_count > 10

    return phrase_triggered or low_confidence or call_timeout

What You Get at the End

With roughly 100 lines of Python:

An AI agent handles tier-1 calls automatically, 24/7
Escalation is detected via intent, sentiment, or explicit request
Warm transfer bridges customer and human agent with full context
The agent hears a whisper brief before greeting the customer
Call metadata is preserved for CRM sync and quality review

You handle none of the telephony plumbing. VoIPBin manages the SIP legs, audio bridging, codec negotiation, and retry logic.

Try It

If you use the MCP server (uvx voipbin-mcp), you can prototype this entire flow directly from Claude Desktop or Cursor without leaving your editor.

Have you built something similar? What triggers do you use for escalation? Leave a comment below.