TL;DR
Grok Voice 3.0 is xAI’s realtime spraak-naar-spraak-model, uitgebracht op 14 oktober 2026. De API-modelnaam is grok-voice-3.0; per 3 november 2026 verwijst grok-voice-latest naar deze versie. De lanceringsaankondiging vermeldt spraaksessies voor $0,08 per minuut ($4,80 per uur). Het combineert conversatie, onderbrekingsafhandeling en toolgebruik voor spraakassistenten en klantenondersteuning. Met basis-Python, een xAI API-sleutel en de websockets-bibliotheek kunt u een prompt verzenden en een gesproken antwoord opslaan. Begin met onderstaand voorbeeld en voeg vervolgens opgenomen audio, live microfoonstreaming en zakelijke tools toe naarmate uw toepassing groeit.
Key Takeaways
- Grok Voice 3.0 wisselt spraak en tekst in realtime uit. Uw toepassing verzendt en ontvangt tijdens het gesprek sessie-events via WebSocket.
- Uw eerste test kan één tekst-naar-audio-beurt zijn. Een afspeelbaar antwoord bevestigt dat authenticatie en audiogeneratie werken voordat u een microfoon toevoegt.
- Audio-invoer vereist een overeenkomend formaat en een duidelijke beurtgrens. Uw toepassing kan opgenomen PCM-audio indienen met handmatige beurtafsluiting of microfoonaudio streamen met serverzijdige spraakdetectie.
- Uw toepassing beheert zakelijke acties. Het valideert functieargumenten en gebruikersrechten, voert de goedgekeurde actie uit en geeft het resultaat terug zodat de spraakagent kan doorgaan.
- Browser- en mobiele clients gebruiken kortdurende referenties. Uw server bewaart de permanente API-sleutel en geeft tijdelijke tokens uit voor clientverbindingen.
What Is Grok Voice 3.0?
Grok Voice 3.0 is een realtime conversatie-spraakmodel ontwikkeld door xAI, onder de merknaam SpaceX Super Intelligence. Het accepteert gesproken of tekstinvoer en kan binnen een lopende sessie audio en tekst retourneren. Het model is geoptimaliseerd voor voice-agent use-cases en is geen directe vervanging voor algemene tekst-only Grok-modellen.
Traditionele spraakassistenten koppelen vaak spraakherkenning, een taalmodel en spraaksynthese. Grok Voice biedt in plaats daarvan een spraak-naar-spraak-sessie met geïntegreerd conversatiegedrag en toolondersteuning. Die architectuur kan de orkestratielaag voor ontwikkelaars vereenvoudigen, al hebben toepassingen nog steeds audio-opname, transport, autorisatie, zakelijke integraties en monitoring nodig.
De modeldefinitie van Grok Voice 3.0 identificeert tekst en audio als input- en outputmodaliteiten. In deze tutorial is het eerste nuttige controlemoment een afspeelbaar antwoord van een serverzijdig Python-script.
Key Features and Capabilities of Grok Voice 3.0
- Voer een live gesprek: wissel spraak en tekst uit via WebSocket gedurende een sessie.
- Ga om met onderbrekingen: gebruik serverzijdige spraakdetectie en stop de in de wachtrij geplaatste weergave zodra de beller begint te spreken.
- Gebruik zakelijke tools: koppel uw eigen functies voor taken zoals bestellingsopzoeking en agendering.
Grok Voice 3.0 Benchmark Performance
Het officiële lanceringsrapport vermeldt deze resultaten van Artificial Analysis, gedateerd 13 oktober 2026:
Dit zijn gepubliceerde benchmarkresultaten, geen garanties voor uw implementatie. Test uw eigen accenten, ruiscondities, tools en escalatiepaden voordat u de agent met klanten inzet.
What Do You Need Before Calling the Grok Voice 3.0 API?
Maak een account aan of meld u aan in de xAI Console, genereer een API-sleutel en controleer of uw account toegang en beschikbaar tegoed heeft. Gebruik een lokale terminal of een vertrouwde server voor het Python-voorbeeld.
- Python 3.11 of later en pip beschikbaar in dezelfde omgeving.
- Een geldige xAI API-sleutel opgeslagen als XAI_API_KEY.
- Een netwerkverbinding die uitgaande beveiligde WebSocket-verbindingen toestaat.
- Een mediaspeler om het gegenereerde WAV-bestand te openen.
Genereer een sleutel in de xAI Console. Sla deze op in een omgevingsvariabele in plaats van deze in de toepassing hard te coderen.
Stel de API-sleutel in voor de huidige Bash-terminal.
export XAI_API_KEY="your_xai_api_key"
Op Windows PowerShell:
Stel de API-sleutel in voor de huidige PowerShell-sessie.
$env:XAI_API_KEY="your_xai_api_key"
Installeer de WebSocket-client in uw Python-omgeving.
python -m pip install "websockets>=14,<18"
Voer de resterende opdrachten uit in dezelfde terminalsessie. Als u een virtuele omgeving gebruikt, activeer deze voordat u het pakket installeert.
How to Use the Grok Voice 3.0 API with Python
De native Realtime API maakt gebruik van een WebSocket-verbinding. In tegenstelling tot gewone tekstchat-completions wisselt deze doorlopend sessie-events uit en streamt audiodelen terwijl een gesprek gaande is.
Step 1: Select a fixed model and configure the session
De API accepteert een geverifieerde modelversienaam in de WebSocket-URL. Het voorbeeld gebruikt grok-voice-3.0 zodat de aangevraagde versie expliciet is. Een session.update-event stelt de stem, audio-indeling en handmatige beurtafhandeling in; wacht op session.updated voordat u de prompt indient.
Step 2: Send text and collect the spoken response
Sla het volgende script op als grok_voice_demo.py. Het dient één tekstprompt in, verzamelt base64-gecodeerde audiodelen en schrijft een mono, 24 kHz, 16-bit PCM WAV-bestand weg. Het stopt ook bij API-fouten, een onvoltooide afronding of een antwoord dat geen audio oplevert.
Maak één gesproken antwoord van een tekstprompt en sla dit op als een WAV-bestand.
import asyncio, base64, json, os, wave
import websockets
SAMPLE_RATE = 24000
async def receive_event(ws):
event = json.loads(await asyncio.wait_for(ws.recv(), 60))
if event.get("type") == "error":
raise RuntimeError(event)
return event
async def main():
url = "wss://api.x.ai/v1/realtime?model=grok-voice-3.0"
headers = {"Authorization": f"Bearer {os.environ['XAI_API_KEY']}"}
async with websockets.connect(url, additional_headers=headers) as ws:
await ws.send(json.dumps({"type": "session.update", "session": {
"voice": "eve", "turn_detection": {"type": None},
"audio": {
"input": {"format": {"type": "audio/pcm", "rate": SAMPLE_RATE}},
"output": {"format": {"type": "audio/pcm", "rate": SAMPLE_RATE},
"transport": "json"}}}}))
async with asyncio.timeout(30):
while (await receive_event(ws)).get("type") != "session.updated":
pass
await ws.send(json.dumps({"type": "conversation.item.create", "item": {
"type": "message", "role": "user",
"content": [{"type": "input_text", "text": "Explain Grok Voice 3.0 briefly."}]}}))
await ws.send(json.dumps({"type": "response.create"}))
chunks = []
async with asyncio.timeout(120):
while True:
event = await receive_event(ws)
if event["type"] in ("response.output_audio.delta", "response.audio.delta"):
chunks.append(base64.b64decode(event["delta"]))
elif event["type"] == "response.done":
if event.get("response", {}).get("status") != "completed":
raise RuntimeError(event)
break
if not chunks:
raise RuntimeError("The response contained no audio.")
with wave.open("grok_response.wav", "wb") as wav:
wav.setparams((1, 2, SAMPLE_RATE, 0, "NONE", "not compressed"))
wav.writeframes(b"".join(chunks))
print("Saved grok_response.wav")
asyncio.run(main())
Step 3: Run the script and check the result
Voer het Python-spraakvoorbeeld uit.
python grok_voice_demo.py
Na een succesvolle respons geeft de terminal Saved grok_response.wav weer. Open dat bestand in een mediaspeler en controleer of u een volledig antwoord op normale snelheid hoort. Een ontbrekend of niet-afspeelbaar bestand is een reden om de geretourneerde events en audio-configuratie te inspecteren voordat u meer functies toevoegt.
De referentie voor realtime events beschrijft de sessiebevestiging en het responslevenscyclus die hier worden gebruikt. Het script wacht op de hele beurt voordat het het bestand wegschrijft; een interactieve spraaktoepassing zou audiodelen moeten afspelen zodra ze binnenkomen.
How Do You Send Audio to Grok Voice 3.0?
Recorded audio with manual turn completion
Dit voorbeeld gebruikt een mono, 24 kHz, 16-bit PCM WAV-bestand. Grok Voice 3.0 ondersteunt ook andere PCM-samplerates, μ-law, A-law en Opus. Het werkelijke formaat moet overeenkomen met de configuratie in session.update. Vervang alleen het conversation.item.create-blok in het vorige script door het onderstaande fragment. Behoud de daaropvolgende response.create-aanroep en de bestaande ontvanglus.
Vervang het tekstberichtblok door een upload van opgenomen audio binnen main().
with wave.open("request.wav", "rb") as source:
if (
source.getnchannels() != 1
or source.getsampwidth() != 2
or source.getframerate() != SAMPLE_RATE
or source.getcomptype() != "NONE"
):
raise ValueError("Use mono, 24 kHz, 16-bit PCM WAV audio.")
pcm = source.readframes(source.getnframes())
if len(pcm) < SAMPLE_RATE * 2 // 10:
raise ValueError("Use a spoken recording longer than 100 ms.")
for offset in range(0, len(pcm), 4800):
await ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": base64.b64encode(pcm[offset:offset + 4800]).decode("ascii"),
}))
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
while (await receive_event(ws)).get("type") != "input_audio_buffer.committed":
pass
Spring deze vervanging in op hetzelfde niveau als het oorspronkelijke tekstberichtblok, binnen de WebSocket-context. Het verzendt ruwe PCM-samples uit het WAV-bestand, niet de WAV-containerheader. Het eerste script selecteert expliciet handmatige beurtbehandeling, dus het vastleggen van de buffer en vervolgens het aanvragen van een respons zijn afzonderlijke acties.
Live microphone capture and immediate playback
Voor een interactieve conversatie neemt u continu audio op, converteert u deze naar het geconfigureerde invoerformaat en verstuurt u korte delen terwijl een aparte ontvanglus de antwoorden afhandelt. Selecteer server_vad voor automatische beurtdetectie in plaats van de handmatige modus die in het voorbeeld met het opgenomen bestand wordt gebruikt. Vermijd het toevoegen van een tweede response.create wanneer de server het antwoord al aan het genereren is.
Stop bij een onderbreking snel met het afspelen van in de wachtrij staande assistentaudio. Alleen netwerkannulering verwijdert geen audio die al door uw toepassing is gebufferd. Houd de afspeelwachtrij klein en houd bij hoeveel audio de luisteraar daadwerkelijk heeft gehoord, zodat uw toepassing de conversatiestatus consistent kan houden.
How to Add Tools to a Grok Voice 3.0 Agent?
Toepassingen kunnen tools aanbieden zoals bestellingsopzoeking, planning of accountverificatie. De agent kan een complexe gesproken aanvraag interpreteren, een geautoriseerde functie aanroepen en het resultaat gebruiken om door te gaan. Dit is vooral nuttig wanneer een klant in één gesprek meerdere gerelateerde wijzigingen vraagt.
De API ondersteunt aangepaste functies en door de server beheerde tools. Voor een aangepaste functie implementeert uw toepassing de actie; het definiëren van een tool verbindt het model op zichzelf niet met uw database.
- Declareer de functienaam, beschrijving en JSON-argumentschema in session.tools.
- Handel response.function_call_arguments.done af, parse de argumenten en valideer de toestemming van de beller voordat u de functie uitvoert.
- Geef het resultaat terug als een conversation.item.create-event met item.type ingesteld op function_call_output en de overeenkomende call_id.
- Verstuur response.create nadat de vereiste functieresultaten zijn ingediend. Als meerdere aanroepen tegelijk binnenkomen, retourneer dan al hun resultaten voordat u het model vraagt door te gaan.
Begin met een alleen-lezen tool, zoals het controleren van de leveringsstatus van een bestelling. Voor acties die boekingen wijzigen, terugbetalingen uitvoeren of bestellingen plaatsen, dwingt u identiteitscontroles, bevestiging en bescherming tegen dubbele verzoeken af in de toepassing.
How to Use Grok Voice 3.0 in Browser and Mobile Apps
Gebruik kortdurende referenties voor client-side verbindingen. Uw server vraagt met zijn permanente API-sleutel een token met korte geldigheid aan en geeft het token door aan de client. Authenticeer verzoeken aan uw eigen token-endpoint en pas gebruikslimieten toe zodat het geen onbeperkte gateway wordt.
Houd microfoontoestemming, opnamebediening en verbindingsstatus zichtbaar in de interface. Ga expliciet om met verbindingsverlies: stop verouderde weergave, laat de gebruiker weten dat de verbinding wordt hersteld en voorkom het opnieuw afspelen van acties die mogelijk al zijn voltooid.
How to Troubleshoot Common Grok Voice 3.0 API Errors
- Authenticatiefout: controleer dat XAI_API_KEY is ingesteld in de terminal waarmee u het script uitvoert en dat de sleutel toebehoort aan een account met toegang. Plak de sleutel niet in logs of supportberichten.
- Onverwachte argumenten voor de clientbibliotheek: controleer dat pip de gevraagde websockets-versie heeft geïnstalleerd in de Python-omgeving die wordt gebruikt om het script te draaien.
- Geen audio-uitvoer: inspecteer fout-events en response.done, bevestig dat session.updated de configuratie heeft bevestigd en controleer dat een respons is aangevraagd voor de handmatige beurt.
- Vervormde weergave: vergelijk de werkelijke bytes met de geconfigureerde codec, samplerate, aantal kanalen en WAV-header. Een MP3-bestand hernoemen naar WAV converteert het niet.
- Timeout: controleer netwerktoegang en servicestatus, inspecteer vervolgens het laatste succesvolle event. Probeer een mislukte verbinding opnieuw, los van eventuele zakelijke acties die mogelijk al zijn uitgevoerd.
What Should You Budget for Grok Voice 3.0 API Calls?
Spraakgebruik en aangepaste integraties kunnen afzonderlijke kosten genereren. Voor deze tutorial zijn de relevante gepubliceerde tarieven de realtime sessie en tekstinvoer; zelfstandige transcriptie- en spraakgeneratiediensten zijn aparte services.
- Spraak-naar-spraak-sessie: $0,08 per minuut, gelijk aan $4,80 per uur.
- Tekstinvoer tijdens een spraaksessie: $0,004 per tekstinvoer.
Tarieven gecontroleerd op 29 oktober 2026. Zie de officiële prijspagina voor actuele tarieven.
Bijvoorbeeld, 500 factureerbare sessieminuten komen overeen met $40 aan basisspraakkosten. Die schatting is exclusief tekstinvoer, optionele tools, telefonie en uw eigen infrastructuur. Begin met korte testsessies en sluit inactieve verbindingen zodra het gesprek is beëindigd.
Conclusion
Begin met één complete Grok Voice 3.0 API-beurt: maak verbinding, configureer de sessie, dien een prompt in, ontvang audio en speel het resultaat af. Voeg, zodra dat pad werkt, opgenomen spraak toe en bouw vervolgens microfoonopname en streamingweergave eromheen. Introduceer zakelijke tools pas nadat de conversatie- en foutafhandelingspaden betrouwbaar zijn.