Bygg med CometAPITrenger du ett API for flere modeller?Test arbeidsflyten i Playground, og opprett deretter en API-nøkkel når modellen og kostnaden passer bruksområdet ditt.
Grok Voice 3.0 er xAIs sanntids tale-til-tale-modell, utgitt 14. oktober 2026. API-modellnavnet er grok-voice-3.0; per 3. november 2026, grok-voice-latest points to this version. Lanseringskunngjøringen oppgir stemmeøkter til $0.08 per minutt ($4.80 per time). Den kombinerer samtale, avbruddshåndtering og verktøybruk for stemmeassistenter og kundestøtte. Med grunnleggende Python, en xAI API-nøkkel og websockets-biblioteket kan du sende en prompt og lagre et opplest svar. Start med eksempelet nedenfor, og legg deretter til opptatt lyd, direkte mikrofonstrømming og forretningsverktøy etter hvert som applikasjonen vokser.
Gjennomgått for klarhet, kildeangivelse og gjeldende API-terminologi.
Nøkkelpunkter
Grok Voice 3.0 utveksler tale og tekst i sanntid. Applikasjonen din sender og mottar økthendelser over WebSocket gjennom hele samtalen.
Din første test kan være én tekst-til-lyd-omgang. En avspillbar respons bekrefter at autentisering og lydgenerering fungerer før du kobler til en mikrofon.
Lydinput krever et matchende format og et tydelig turskille. Applikasjonen kan sende innspilt PCM-lyd med manuell avslutning av turen, eller strømme mikrofonlyd med serverstyrt stemmedeteksjon.
Applikasjonen din styrer forretningshandlingene. Den validerer funksjonsargumenter og brukertillatelser, utfører godkjent handling og returnerer resultatet slik at stemmeagenten kan fortsette.
Nettleser- og mobilklienter bruker kortlivede legitimasjoner. Serveren din beholder den permanente API-nøkkelen og utsteder midlertidige token for klienttilkoblinger.
Hva er Grok Voice 3.0?
Grok Voice 3.0 er en sanntids, konversasjonell stemmemodell utviklet av xAI, under SpaceX Super Intelligence-merkevaren. Den tar imot tale- eller tekstinput og kan returnere lyd og tekst innenfor en pågående økt. Modellen er optimalisert for stemmeagent-bruksområder, ikke som en direkte erstatning for generelle tekst-only Grok-modeller.
Tradisjonelle stemmeassistenter lenker ofte talegjenkjenning, en språkmodell og talesyntese. Grok Voice eksponerer i stedet en tale-til-tale-økt med integrert konversasjonsatferd og verktøystøtte. Den arkitekturen kan forenkle utviklerens orkestreringslag, selv om applikasjoner fortsatt trenger lydopptak, transport, autorisasjon, forretningsintegrasjoner og monitorering.
Grok Voice 3.0-modelldefinisjonen identifiserer tekst og lyd som inn- og utgangsmodaliteter. For denne veiledningen er den første nyttige sjekkpunktet et avspillbart svar fra et serverdrevet Python-skript.
Nøkkelfunksjoner og -kapabiliteter i Grok Voice 3.0
Hold en direkte samtale: utveksle tale og tekst over WebSocket gjennom en økt.
Håndter avbrudd: bruk serverstyrt stemmedeteksjon og stopp køet avspilling når innringeren begynner å snakke.
Bruk forretningsverktøy: koble til egne funksjoner for oppgaver som ordreoppslag og planlegging.
Dette er publiserte benchmark-resultater, ikke garantier for din utrulling. Test egne aksenter, støynivå, verktøy og eskaleringsbaner før du bruker agenten med kunder.
Hva trenger du før du kaller Grok Voice 3.0 API-et?
Opprett eller logg inn på en konto i xAI Console, generer en API-nøkkel, og sjekk at kontoen din har tilgang og tilgjengelig brukskreditt. Bruk et lokalt terminalvindu eller en betrodd server for Python-eksempelet.
Python 3.11 eller nyere og pip tilgjengelig i samme miljø.
En gyldig xAI API-nøkkel lagret som XAI_API_KEY.
En nettverkstilkobling som tillater utgående sikre WebSocket-tilkoblinger.
En mediespiller for å åpne den genererte WAV-filen.
Generer en nøkkel i xAI Console. Lagre den i en miljøvariabel i stedet for å hardkode den i applikasjonen.
Sett API-nøkkelen for gjeldende Bash-terminal.
export XAI_API_KEY="your_xai_api_key"
På Windows PowerShell:
Sett API-nøkkelen for gjeldende PowerShell-økt.
$env:XAI_API_KEY="your_xai_api_key"
Installer WebSocket-klienten i Python-miljøet ditt.
python -m pip install "websockets>=14,<18"
Kjør de resterende kommandoene i samme terminaløkt. Hvis du bruker et virtuelt miljø, aktiver det før du installerer pakken.
Hvordan bruke Grok Voice 3.0 API med Python
Det native Realtime API-et bruker en WebSocket-tilkobling. I motsetning til vanlige tekstchat-fullføringer utveksler det pågående økthendelser og strømmer lydfragmenter mens en samtale pågår.
Trinn 1: Velg en fast modell og konfigurer økten
API-et aksepterer et versjonert modellenavn i WebSocket-URL-en. Eksempelet bruker grok-voice-3.0 slik at den forespurte versjonen er eksplisitt. En session.update-hendelse angir stemmen, lydformatet og manuell turhåndtering; vent på session.updated før du sender prompten.
Trinn 2: Send tekst og samle det oppleste svaret
Lagre følgende skript som grok_voice_demo.py. Det sender inn én tekstprompt, samler base64-kodede lydfragmenter og skriver en mono, 24 kHz, 16-bit PCM WAV-fil. Det stopper også ved API-feil, manglende fullføring eller et svar som ikke produserer lyd.
Opprett ett opplest svar fra en tekstprompt og lagre det som en WAV-fil.
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": "Forklar kort hva Grok Voice 3.0 er."}]}}))
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("Svaret inneholdt ingen lyd.")
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("Lagret grok_response.wav")
asyncio.run(main())
Trinn 3: Kjør skriptet og sjekk resultatet
Kjør Python-stemmeeksempelet.
python grok_voice_demo.py
Etter en vellykket respons skriver terminalen Lagret grok_response.wav. Åpne filen i en mediespiller og sjekk at du hører et komplett svar i normal hastighet. En manglende eller uavspillbar fil er en grunn til å inspisere returnerte hendelser og lydkonfigurasjon før du legger til flere funksjoner.
Referansen for sanntidshendelser beskriver øktbekreftelsen og responsens livssyklus som brukes her. Skriptet venter på hele turen før det skriver filen; en interaktiv stemmeapplikasjon bør spille av lydfragmenter etter hvert som de ankommer.
Hvordan sender du lyd til Grok Voice 3.0?
Opptak med manuell turavslutning
Dette eksempelet bruker en mono, 24 kHz, 16-bit PCM WAV-fil. Grok Voice 3.0 støtter også andre PCM-samplerater, μ-law, A-law og Opus. Det faktiske formatet må matche session.update-konfigurasjonen. Bytt bare ut conversation.item.create-blokken i forrige skript med kodesnutten nedenfor. Behold den påfølgende response.create-kallet og den eksisterende mottakssløyfen.
Erstatt tekstmeldingsblokken med en opplasting av innspilt lyd inne i 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("Bruk mono, 24 kHz, 16-bit PCM WAV-lyd.")
pcm = source.readframes(source.getnframes())
if len(pcm) < SAMPLE_RATE * 2 // 10:
raise ValueError("Bruk et taleopptak som er lengre enn 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
Rykk inn denne erstatningen på samme nivå som den opprinnelige tekstmeldingsblokken, inne i WebSocket-konteksten. Den sender rå PCM-prøver fra WAV-filen, ikke WAV-konteinerheaderen. Det første skriptet velger eksplisitt manuell turhåndtering, så å commite bufferet og deretter be om et svar er separate handlinger.
Direkte mikrofonopptak og umiddelbar avspilling
For en interaktiv samtale, fang lyd kontinuerlig, konverter den til det konfigurerte inputformatet, og send korte fragmenter mens en separat mottakssløyfe håndterer responser. Velg server_vad for automatisk turdeteksjon i stedet for den manuelle modusen som ble brukt i eksemplet med innspilt fil. Unngå å legge til et nytt response.create når serveren allerede genererer svaret.
Ved avbrudd, stopp avspillingen av køet assistentlyd umiddelbart. Nettverkskansellering alene fjerner ikke lyd som allerede er bufret av applikasjonen din. Hold avspillingskøen liten og spor hvor mye lyd lytteren faktisk hørte, slik at applikasjonen din kan holde samtaletilstanden konsistent.
Hvordan legge til verktøy i en Grok Voice 3.0-agent?
Applikasjoner kan eksponere verktøy som ordreoppslag, planlegging eller kontoverifisering. Agenten kan tolke en kompleks muntlig forespørsel, kalle en autorisert funksjon og bruke resultatet til å fortsette. Dette er særlig nyttig når en kunde ber om flere relaterte endringer i én samtale.
API-et støtter egendefinerte funksjoner og serverstyrte verktøy. For en egendefinert funksjon implementerer applikasjonen handlingen; det å definere et verktøy kobler ikke modellen til databasen din i seg selv.
Deklarer funksjonsnavn, beskrivelse og JSON-argumentskjema i session.tools.
Håndter response.function_call_arguments.done, parse argumentene, og valider innringerens tillatelser før du utfører funksjonen.
Returner resultatet som en conversation.item.create-hendelse med item.type satt til function_call_output og matchende call_id.
Send response.create etter at nødvendige funksjonsresultater er sendt inn. Hvis flere kall kommer samtidig, returner alle resultatene før du ber modellen fortsette.
Start med et skrivebeskyttet verktøy, som å sjekke leveringsstatus for en ordre. For handlinger som endrer bookinger, utsteder refusjoner eller legger inn ordre, håndhev identitetssjekker, bekreftelse og beskyttelse mot dupliserte forespørsler i applikasjonen.
Hvordan bruke Grok Voice 3.0 i nettleser- og mobilapper
Bruk kortlivede legitimasjoner for klienttilkoblinger. Serveren din ber om et kortvarig token med sin permanente API-nøkkel og gir tokenet videre til klienten. Autentiser forespørsler til din egen token-endepunkt og bruk begrensninger slik at det ikke blir en ubegrenset gateway.
Hold mikrofontillatelse, opptakskontroller og tilkoblingsstatus synlig i grensesnittet. Håndter tilkoblingstap eksplisitt: stopp utdatert avspilling, fortell brukeren at tilkoblingen gjenopprettes, og unngå å spille av handlinger på nytt som kanskje allerede er fullført.
Hvordan feilsøke vanlige Grok Voice 3.0 API-feil
Autentiseringsfeil: bekreft at XAI_API_KEY er satt i terminalen som kjører skriptet og at nøkkelen tilhører en konto med tilgang. Ikke lim inn nøkkelen i logger eller supportmeldinger.
Uventede argumenter til klientbiblioteket: verifiser at pip installerte ønsket websockets-versjon i Python-miljøet som brukes til å kjøre skriptet.
Ingen lydutgang: inspiser feilhendelser og response.done, bekreft at session.updated bekreftet konfigurasjonen, og sjekk at et svar ble forespurt for den manuelle turen.
Forvrengt avspilling: sammenlign de faktiske bytene med konfigurert kodek, samplerate, antall kanaler og WAV-header. Å gi en MP3-fil nytt navn til WAV konverterer den ikke.
Timeout: sjekk nettverkstilgang og tjenestestatus, og inspiser deretter siste vellykkede hendelse. Forsøk en mislykket tilkobling på nytt separat fra enhver forretninghandling som allerede kan ha kjørt.
Hva bør du budsjettere for Grok Voice 3.0 API-kall?
Stemmebruk og egendefinerte integrasjoner kan generere separate kostnader. For denne veiledningen er de relevante publiserte satsene sanntidsøkten og tekstinput; frittstående transkripsjon og stemmegenerering er separate tjenester.
Tale-til-tale-økt: $0.08 per minutt, tilsvarer $4.80 per time.
Tekstinput under en stemmeøkt: $0.004 per tekstinput.
For eksempel tilsvarer 500 fakturerbare øktminutter $40 i grunnleggende stemmekostnader. Det estimatet ekskluderer tekstinput, valgfrie verktøy, telefoni og din egen infrastruktur. Start med korte testøkter og lukk inaktive tilkoblinger når samtalen er over.
Konklusjon
Start med én komplett Grok Voice 3.0 API-omgang: koble til, konfigurer økten, send en prompt, motta lyd og spill av resultatet. Når den banen fungerer, legg til innspilt tale, og bygg deretter mikrofonopptak og strømmende avspilling rundt dette. Introduser forretningsverktøy først etter at samtale- og feilhåndteringsbanene er robuste.
