Forem: voipbin

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

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

Every AI voice tutorial on the internet starts with Python.

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

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

The Problem with AI Voice Today (for Go Developers)

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

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

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

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

What You Will Build

A simple AI voice receptionist that:

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

All in Go. Under 100 lines of application logic.

Prerequisites

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

Step 1: Sign Up and Get Your Token

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

You get back:

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

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

Step 2: Install the SDK

go get github.com/voipbin/voipbin-go

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

Step 3: Write Your Webhook Handler

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

Create main.go:

package main

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

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

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

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

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

    var actions []Action

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

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

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

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

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

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

Run it:

go run main.go

In another terminal, expose it:

ngrok http 8080

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

Step 4: Register Your Webhook and Make a Call

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

package main

import (
    "context"
    "fmt"
    "log"

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

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

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

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

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

Step 5: Wire In a Real LLM

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

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

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

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

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

Two things to keep in mind for voice LLM responses:

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

What VoIPBin Is Handling For You

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

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

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

Going to Production

A few things to harden before you ship:

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

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

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

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

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

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

What You Get

By the end of this tutorial you have:

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

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

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

Resources

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

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

Make Your First AI Phone Call in 10 Minutes

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

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

This isn't that tutorial.

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

What You're Building

A simple flow:

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

Your code never touches audio. It just speaks HTTP.

Prerequisites

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

Step 1: Sign Up and Get Your API Key

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

Response:

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

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

Step 2: Write Your Webhook Handler

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

from flask import Flask, request, jsonify

app = Flask(__name__)

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

    call_type = data.get("type")

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

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

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

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

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

Run it:

pip install flask
python app.py

Expose it with ngrok:

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

Step 3: Make the Call

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

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

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

That's it.

What Just Happened (Under the Hood)

Here's why this was so simple:

You wrote zero audio code. VoIPBin handled:

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

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

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

Swap in Real AI Logic

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

import openai

client = openai.OpenAI()

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

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

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

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

What's Next

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

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

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

Resources

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

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

Your AI Voice Bot Doesn't Need a Phone Number

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

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

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

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

The Problem With Phone Numbers for AI Bots

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

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

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

What Is a Direct Hash SIP URI?

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

It looks like this:

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

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

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

Setting It Up: 10 Lines of Config

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

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

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

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

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

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

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

Dial it from any SIP client and your webhook fires.

The Webhook: Same as Always

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

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

Your server responds with a call flow:

from flask import Flask, request, jsonify

app = Flask(__name__)

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

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

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

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

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

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

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

Calling the Bot from a Softphone

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

Linphone (desktop/mobile):

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

Zoiper:

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

From another VoIPBin call flow:

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

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

Real Use Cases

1. Internal On-Call AI Assistant

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

2. B2B Integration Testing

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

3. Browser-to-AI Calls

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

4. Multi-Bot Architectures

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

What You're Actually Saving

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

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

One More Thing: MCP Integration

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

uvx voipbin-mcp

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

Getting Started

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

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

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

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

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

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

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

This post is about how to escape that trap.

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

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

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

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

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

The Alternative: Media Offloading

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

Your AI agent should only ever see:

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

And it should only ever produce:

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

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

What This Looks Like in Practice

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

from flask import Flask, request, jsonify
import openai

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

conversation_history = {}

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

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

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

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

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

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

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

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

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

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

Getting Started

First, sign up and get your API token:

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

Then create a flow that points to your webhook:

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

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

The Golang SDK Version

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

package main

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

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

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

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

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

    var actions []Action

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

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

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

Install the SDK:

go get github.com/voipbin/voipbin-go

What You Get

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

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

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

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

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

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

The Mental Model Shift

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

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

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

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

Try It

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

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

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

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

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

It does not have to be that way.

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

The Problem: Two UIs, Two Codebases

When users contact your AI assistant, they might:

Open a chat widget on your website
Call a phone number

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

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

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

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

The Solution: Abstract the Transport

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

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

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

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

Building the Unified AI Core

Here is a complete FastAPI service that handles both channels:

from fastapi import FastAPI, Request
from openai import OpenAI

app = FastAPI()
client = OpenAI()

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

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

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

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

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

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

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

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

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

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

    return {"response": ai_reply}

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

Setting Up the Voice Channel with VoIPBin

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

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

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

import httpx

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

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

The Web Chat Side

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

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

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

Same backend. Same AI. Different wire format.

What You Actually Maintain

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

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

Adding a Third Channel Later

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

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

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

    return {"reply": ai_reply}

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

What You Get From This Architecture

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

Try It

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

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

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

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.