AudioCodes (LiveHub) and Deepgram Voice Agent API

AudioCodes VoiceAI Connect is a powerful platform that enables the integration of telephony and contact center platforms with the cloud, thus facilitating the use of Deepgram in your customer journey.

It offers a simple user interface for standing up connections and developer-friendly APIs for advanced integrations.

Note, AudioCodes offers two versions of this platform - LiveHub, which is the self serve version, as well as VoiceAI Connect Enterprise, which is the managed services version.

This guide will focus on LiveHub, as it is accessible to all users. However, if you are using VoiceAI Connect Enterprise, the steps and instructions laid out here will be very similar. In addition, you will have the help of the AudioCodes Professional Services team to help you with the configuration. Refer to this doc for guidance, but note that the exact steps may vary slightly depending on how your specific version of VoiceAI Connect Enterprise is built.

Before you Begin

The Problem This SDK Solves

Most enterprise call centers ultimately rely on SIP for call signaling and RTP for media transport — the core VoIP protocols that have underpinned telephony since the late 1990s. Deepgram’s Voice Agent API speaks WebSocket. These worlds don’t connect natively.

AudioCodes VoiceAI Connect already bridges that gap for thousands of enterprises — it accepts calls from any number of call center platforms or telephony systems and exposes them as WebSocket connections that AI systems can connect to.

But there is still a missing piece. Someone has to take that WebSocket audio stream, forward it to Deepgram’s Voice Agent API in real time, route the agent’s synthesized speech back to the caller, and handle everything that can go wrong in between. Rather than have every customer write that plumbing from scratch, Deepgram maintains an open-source SDK — deepgram-audiocodes-bridge — that solves it once.

AudioCodes VoiceAI Connect 
(Bot API - websocket mode)
            ↕
deepgram-audiocodes-bridge
            ↕
Deepgram Voice Agent API

What the SDK Does

The bridge runs a WebSocket server that speaks the AudioCodes Bot API, manages a Deepgram Voice Agent connection per call, routes audio bidirectionally in real time, and emits typed events your application code hooks into. Audio frame parsing, protocol handshaking, barge-in handling, TTS streaming, and session teardown all live inside the SDK — your code stays focused on business logic.

For installation, the full event and method reference, authentication walkthroughs, and runnable examples, see the deepgram-audiocodes-bridge README. The rest of this page covers the AudioCodes-specific context that’s most useful to know before you start.

A minimal bridge looks like this:

1
# Configure the bridge: Deepgram credentials + your Voice Agent settings.
2
bridge = DeepgramBridge(BridgeConfig(
3
    deepgram_api_key="your-deepgram-api-key",
4
    deepgram_config={
5
        "agent": {
6
            "listen": {
7
                "provider": {
8
                    "type": "deepgram", 
9
                    "model": "flux-general-en"
10
                    }
11
                },
12
            "think": {
13
                "provider": {
14
                    "type": "open_ai",  
15
                    "model": "gpt-5.4-mini"
16
                    },
17
                "prompt":   "You are a helpful assistant."},
18
            "speak": {
19
                "provider": {
20
                    "type": "deepgram", 
21
                    "model": "aura-2-helena-en"
22
                    }
23
                },
24
            "greeting": "Hi! How can I help today?",
25
        },
26
    },
27
    port=8000,
28
))
29
30
# Hook into typed events — your business logic lives here.
31
@bridge.on("session_start")
32
async def on_start(session, event):
33
    print(f"Call started: conversation_id={session.conversation_id}")
34
35
@bridge.on("conversation_text")
36
async def on_text(session, event):
37
    print(f"{event.role}: {event.content}")
38
39
# Start the WebSocket server — now accepting connections at ws://localhost:8000
40
asyncio.run(bridge.run())

That’s the whole shape of an integration: configure once, register handlers for the events you care about, and run. Everything else — audio routing, barge-in, session teardown — is handled inside the SDK.

Tying Calls Back to Your CCaaS: conversation_id

Every session_start event includes a conversation_id — the AudioCodes conversation identifier surfaced from the session.initiate handshake.

This is the foreign key that ties the Deepgram session to the upstream CCaaS call record. Use it to associate transcript writes, screen pops, disposition codes, and compliance logs with the correct call in Genesys, Amazon Connect, Salesforce, or wherever your call data ultimately lives. Without it, you have a transcript with no way to reconcile it back to the call it came from.

1
@bridge.on("session_end")
2
async def on_end(session, event):
3
    transcript = session.get_transcript()
4
    await write_to_crm(session.conversation_id, transcript)

Configuring AudioCodes LiveHub

Once your bridge is running and reachable from the public internet (via your own hosting, or a tunnel like ngrok for testing), point an AudioCodes LiveHub Bot Connection at it.

Follow the LiveHub Bot Connection setup guide, following the “Add new voice bot connection” instructions:

• Bot connection API type - select Websocket mode
• Bot URL — the WebSocket URL of your running bridge (for example, wss://your-host.example.com/).
• Authentication — LiveHub supports No Auth, Permanent Token (shared secret), and OAuth 2.0. Pick one and match it on the bridge side via BridgeConfig. See the SDK’s auth example for copy-pasteable walkthroughs of all three modes.
• Barge-in — toggle on if you want callers to interrupt the agent. The Voice Agent API supports barge-in natively and the bridge handles it for you, but VAIC’s own barge-in setting can override it. This defaults to off when you create a new Bot Connection. See Edit your Bot Connection for the toggle.