Realtime Voice API

Koppla AI till riktiga telefonsamtal

Få en ljudström via WebSocket från vilket samtal som helst — inkommande eller utgående — och koppla den till OpenAI, Claude, ElevenLabs, eller din egen modell.

Bygg din första agent Dokumentation

Hur funkar det?

  1. 1

    Telefon

    Skaffa ett nummer hos oss

  2. 2

    46elks

    Vi löser allt tekniska för att få ut samtalet som en WebSocket-ström

  3. 3

    Din app

    Du tar emot ljudströmmen och bestämmer själv vad du vill göra med den

  4. 4

    AI / Verktyg

    Välj vilken AI du vill. Bygg egna verktyg och använd dem i samtalet.

Prova det nu.

Prova ett av våra demos och se vad som är möjligt med AI i riktiga telefonsamtal.

Beställ pizza

Ring vår AI och beställ en pizza. Den tar din order, ställer frågor om topping och bekräftar leverans.

Pizza demo – ring och beställ pizza med AI

Prata med vår dokumentation

Ställ frågor om 46elks API direkt i telefon. Vår assistent har stenkoll.

076-686 29 49

Du äger hela kedjan

Ingen black box. Du får ljudströmmen och skickar tillbaka ljud. Däremellan gör du exakt vad du vill — transkribera, analysera, generera svar, anropa dina verktyg.

Funkar med vilken AI du vill

OpenAI Realtime, Claude, ElevenLabs, Whisper, en egen modell — spelar ingen roll. Det enda som krävs är att din app tar emot och skickar ljud.

Enkelt att bygga vidare på

En komplett AI-röstassistent i ~60 rader Python. Ingen SIP. Ingen Asterisk. Bara en WebSocket.

WebSocket-URL:
wss://min.server.io/audio
async def openai_bridge(elks_ws, openai_ws):
    # Get the call metadata from the hello message
    hello = json.loads(await elks_ws.recv())
    print(f"Received {hello['to']} <- {hello['from']} ({hello['callid']})")

    # Tell the API the format we want to receive audio in
    await elks_ws.send(json.dumps({
        "t": "listening",
        "format": "pcm_24000"
    }))

    # Tell the API the format we'll be sending audio in
    await elks_ws.send(json.dumps({
        "t": "sending",
        "format": "pcm_24000"
    }))
Visa mer... 
    elks_recv = asyncio.create_task(elks_ws.recv())
    openai_recv = asyncio.create_task(openai_ws.recv())

    while True:
        receivers = [elks_recv, openai_recv]
        done, _ = await asyncio.wait(receivers, return_when=asyncio.FIRST_COMPLETED)

        if elks_recv in done:
            raw = elks_recv.result()
            elks_recv = asyncio.create_task(elks_ws.recv())
            msg = json.loads(raw)

            if msg["t"] == "audio":
                # Forward the audio to OpenAI
                await openai_ws.send(json.dumps({
                    "type": "input_audio_buffer.append",
                    "audio": msg["data"],
                }))

            elif msg["t"] == "bye":
                # The call has ended
                await openai_ws.send(json.dumps({"type": "response.cancel"}))
                print("Call ended:", msg["message"])
                break

        if openai_recv in done:
            raw = openai_recv.result()
            openai_recv = asyncio.create_task(openai_ws.recv())
            msg = json.loads(raw)

            if msg["type"] == "input_audio_buffer.speech_started":
                # Cancel AI response and interrupt audio
                await openai_ws.send(json.dumps({"type": "response.cancel"}))
                await elks_ws.send(json.dumps({"t": "interrupt"}))

            elif msg["type"] == "response.audio.delta":
                # Forward the audio to 46elks
                await elks_ws.send(json.dumps({
                    "t": "audio",
                    "data": msg["delta"],
                }))

            elif msg["type"] in ("response.audio.done", "response.done", "response.cancelled"):
                # Stop ignoring audio
                await elks_ws.send(json.dumps({
                    "t": "sending",
                    "format": "pcm_24000"
                }))

Det här är en fungerande AI-röstassistent. ~60 rader. Byt ut OpenAI mot vilken modell du vill.

Se fullständigt exempel med tool-calling ->

Vad du kan bygga

AI-röstassistent

En AI som svarar i telefon, pratar naturligt och utför handlingar — bokar tider, kollar ordrar, svarar på frågor. Med tool-calling blir den en agent, inte bara en röst.

AI som ringer ut

Din app initierar ett samtal och kopplar in en AI-agent. Outbound sales, påminnelser, uppföljningar.

Realtidstranskribering

Transkribera live. Flagga nyckelord. Kör sentimentanalys medan samtalet pågår. Plocka fram relevant information i realtid.

Systemkoppling

CRM-uppdateringar, ärendehantering, loggning — automatiskt, i realtid. Telefonen blir ett gränssnitt till dina system.

Under huven

Protokoll

WebSocket (wss://) med full duplex.

Ljudformat

PCM 8/16/24 kHz, G.711, G.722, Opus, MP3, WAV.

Riktning

Inkommande och utgående samtal.

Streams

Separata streams för caller och agent, individuellt kontrollerbara.

Kontroll

bye avslutar samtalet graciöst. interrupt rensar bufferten direkt.

Integration

JSON-meddelanden, base64-kodat ljud.

Kom igång Dokumentation

Pris

Realtime Voice ingår i 46elks virtuella nummer

0,15 kr/min för att koppla ett samtal till WebSocket
3 samtidiga samtal per nummer Prata med oss om du behöver fler

Se fullständig prislista →

Kontakta oss

Frågor om hur du kan använda 46elks?
Vi hjälper dig gärna på traven.

076-686 10 04 help@46elks.com