WhatsApp calls do not work like standard phone calls or basic HTTP webhooks:

• When someone calls your number, Meta sends a WebRTC session request (SDP offer) over HTTPS.
• Audio is streamed back and forth via encrypted SRTP packets over UDP.
• Meta often sends duplicate webhooks at the same time, which can trigger multiple bot instances for the same call.

WhatsApp Caller (Mobile App)
             │
             ▼ WebRTC (SDP offer / SRTP audio)
    Meta Graph API Webhook
             │
             ▼ Public Tunnel / Ingress
          WAVoice
   ┌─────────┴─────────────────────────────────────────┐
   │ • Decodes WebRTC audio stream                     │
   │ • Prevents duplicate call triggers                │
   │ • Negotiates codecs & manages call state          │
   └─────────┬─────────────────────────────────────────┘
             │
             ▼
  Your AI Platform (Retell / LiveKit / Gemini / Custom Python)

What WAVoice automates:

1. Auto-Discovery: Pulls your WABA ID and Phone Number ID directly from your token via the Graph API.
2. Calling Activation: Automatically sets calling.status = "ENABLED" on your phone number so the Call button appears in WhatsApp.
3. 3-Tier Webhook Sync: Registers Phone overrides, WABA subscriptions, and App subscriptions to ensure calls never get dropped.
4. WebRTC Media Plumbing: Handles STUN/TURN traversal, SRTP decryption, and connects audio streams to your chosen provider.
5. Call Claim Locks: Uses atomic in-memory claiming per call_id so calls are answered exactly once.

If you are a Python developer building a custom pipeline with your own Speech-to-Text, LLM, and Text-to-Speech models, you can use WAVoice with Pipecat:

import os
from wavoice import WhatsAppVoiceApp
from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineParams, PipelineTask
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import (
    LLMContextAggregatorPair,
    LLMUserAggregatorParams,
)
from pipecat.services.deepgram import DeepgramSTTService
from pipecat.services.openai import OpenAILLMService
from pipecat.services.cartesia import CartesiaTTSService

app = WhatsAppVoiceApp()

@app.on_call
async def handle_incoming_call(transport, call_info):
    caller = getattr(call_info, "from_", "caller")
    print(f"Incoming call from {caller}")

    # Set up your models
    stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
    llm = OpenAILLMService(api_key=os.environ["OPENAI_API_KEY"], model="gpt-4o-mini")
    tts = CartesiaTTSService(api_key=os.environ["CARTESIA_API_KEY"], voice_id="...")

    # Set up conversation context
    context = LLMContext([{"role": "system", "content": "You are a concise voice assistant."}])
    user_agg, assistant_agg = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(vad_analyzer=SileroVADAnalyzer()),
    )

    # Wire the audio from WhatsApp into your pipeline
    pipeline = Pipeline([
        transport.input(),    # WebRTC Audio In from WhatsApp
        stt,                  # Speech-to-Text
        user_agg,             # Turn Aggregator
        llm,                  # Large Language Model
        tts,                  # Text-to-Speech
        transport.output(),   # WebRTC Audio Out to WhatsApp
        assistant_agg,
    ])

    task = PipelineTask(pipeline=pipeline, params=PipelineParams(allow_interruptions=True))
    runner = PipelineRunner()
    await runner.run(task)

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

(See examples/custom_stt_llm_tts.py for the complete file).

• Local testing: By default, WAVoice uses a temporary Cloudflare tunnel (trycloudflare.com). This is meant for quick local testing and development.
• Production (24/7): For live production traffic, host WAVoice on your server with a permanent domain (or behind Nginx / Caddy / Cloudflare) and pass your URL:

  wavoice start --public-url https://voice.yourdomain.com
  # or
  wavoice livekit dev --public-url https://voice.yourdomain.com
  

• Dograh Cloud: If you use wavoice dograh setup, calls route directly to Dograh's cloud infrastructure—no local process or tunnel is needed.

WAVoice collects anonymous usage statistics (command runs, answered call count, coarse country/timezone) to help improve the project. It never collects personal information, phone numbers, tokens, or audio data.

To disable telemetry, you can:

• Add --no-telemetry to any command (e.g., wavoice start --no-telemetry)
• Set WAVOICE_TELEMETRY=false in your .env file
• Set DO_NOT_TRACK=1 in your system environment