InstantVid
All AI news
Creator guides

Grok Voice 3.0: How to Use It, API Tutorial, Pricing & Alternatives

Explore Grok Voice 3.0 with a step-by-step API tutorial, a Python audio-file example, browser token authentication, pricing and comparisons with GPT-Live and Gemini Live.

InstantVid · EditorialPublished

Grok Voice 3.0 launched on October 14, 2026, bringing a new speech-to-speech model to the Voice Agent API without changing the preceding version's API or base pricing. Sessions using grok-voice-latest now run on 3.0. The official announcement and developer release notes confirm the transition.

This guide was checked on October 16, 2026. It covers how to try the model, an API example that saves a playable audio file, browser authentication, pricing and alternatives. We reviewed documentation and checked the example offline; we have not performed paid model calls or hands-on voice-quality, latency or task-success benchmarks.

What is Grok Voice 3.0?

Grok Voice 3.0 is a real-time speech-to-speech model. An application streams a person's audio, receives spoken replies and can connect tools to help the assistant complete tasks. Transcribing a recording, narrating a fixed script and holding an interactive conversation are different workflows.

Consider a customer asking which video package to buy, then adding that they mainly make product demonstrations. A useful assistant needs to incorporate the interruption, retrieve the actual plans and explain a suitable choice. It does not automatically know your prices, customer records or business rules.

For creators, worthwhile experiments include rehearsing an ad conversation, revising a voiceover script aloud and adding a spoken interface to an existing tool. For a finished narration from fixed text, compare the separate Grok Text to Speech API before building a conversational agent.

What changed from Grok Voice 2.0?

Item Current position Practical consequence
Pinned model grok-voice-3.0 Use it when you want an explicit version
Latest alias grok-voice-latest currently resolves to 3.0 Convenient upgrades, with the possibility of future alias changes
Earlier model grok-voice-2.0 is deprecated Migrate applications that explicitly select the old ID
API and base price Unchanged from 2.0, according to the release notes This release does not require a complete protocol rewrite

The migration notice establishes compatibility, not identical behavior in every application. Recheck interruptions, domain terminology and business-tool results after changing versions.

The launch article cites an 86.9 Speech-to-Speech Index result from Artificial Analysis's October 13 evaluation, alongside improved support-task results and subsecond latency. Treat those as dated announcement/evaluation results, not a latency promise on your own network or proof that one model wins every language and task. We have not independently reproduced them.

How to try Grok Voice without writing code

  1. Follow the official announcement's trial link to console.x.ai. Sign in and look for the available Voice or Speech to Speech playground. Availability and visible model controls depend on the account.
  2. Review the credit, billing and microphone prompts before starting. A trial entry point does not establish unlimited free usage for every account.
  3. Choose grok-voice-3.0 if the interface exposes a model selector and reproducibility matters. The latest alias means whichever model it resolves to at that time.
  4. Start with three short turns: an ordinary question, an interrupted request and a question containing a product name or number. Evaluate whether the answer stays correct, rather than only whether the voice sounds pleasant.
  5. For everyday mobile use, follow grok.com to its official app-store links and check the voice feature offered to your account. Consumer subscriptions and API access are separate interfaces; do not assume the app exposes a pinned API version or includes developer credits.

An original prompt to try: “You are a short-video script coach. Ask what my product is, then who it is for, one question at a time. Finish with a three-sentence voiceover draft. Do not invent product benefits.”

Prepare for the Grok Voice 3.0 API tutorial

You need an API-enabled account, a trusted server environment and an XAI_API_KEY. Create the key in the console, set a spending boundary and keep it out of browser code, public repositories and screenshots. Check developer billing separately from consumer-plan billing.

The first example uses Python 3.11+ and a text question to test authentication, session events and audio output before introducing microphone permissions or business tools. Set the real key only in your own trusted environment; the value below is a placeholder.

python3 -m venv .venv
source .venv/bin/activate
python -m pip install "websockets>=14,<16"
export XAI_API_KEY='YOUR_XAI_API_KEY'

On Windows, use the corresponding virtual-environment activation command and environment-variable syntax.

API tutorial: save your first spoken response

Save this original example as grok_voice_demo.py and run python grok_voice_demo.py. It selects the version explicitly, waits for the configuration acknowledgment, collects PCM audio deltas and writes a playable grok-voice-demo.wav file.

import asyncio
import base64
import json
import os
import wave

import websockets


async def main():
    key = os.environ["XAI_API_KEY"]
    url = "wss://api.x.ai/v1/realtime?model=grok-voice-3.0"
    frames = bytearray()
    sent = False
    completed = False

    async with asyncio.timeout(45):
        async with websockets.connect(
            url,
            additional_headers={"Authorization": f"Bearer {key}"},
            open_timeout=15,
        ) as ws:
            await ws.send(json.dumps({
                "type": "session.update",
                "session": {
                    "voice": "eve",
                    "instructions": "Reply briefly in English.",
                    "turn_detection": {"type": None},
                    "audio": {"output": {
                        "format": {"type": "audio/pcm", "rate": 24000}
                    }}
                }
            }))
            async for raw in ws:
                event = json.loads(raw)
                kind = event.get("type")
                if kind == "error":
                    code = event.get("error", {}).get("code", "unknown")
                    raise RuntimeError(f"Voice API error: {code}")
                if kind == "session.updated" and not sent:
                    sent = True
                    await ws.send(json.dumps({
                        "type": "conversation.item.create",
                        "item": {"type": "message", "role": "user",
                                 "content": [{"type": "input_text",
                                              "text": "Welcome an AI video creator in one short sentence."}]}
                    }))
                    await ws.send(json.dumps({"type": "response.create"}))
                elif kind in ("response.output_audio.delta", "response.audio.delta"):
                    frames.extend(base64.b64decode(event["delta"], validate=True))
                elif kind == "response.done":
                    completed = event.get("response", {}).get("status") == "completed"
                    break

    if not completed or not frames or len(frames) % 2:
        raise RuntimeError("No complete PCM16 audio response was received")
    with wave.open("grok-voice-demo.wav", "wb") as output:
        output.setnchannels(1)
        output.setsampwidth(2)
        output.setframerate(24000)
        output.writeframes(frames)
    print("Saved grok-voice-demo.wav")


asyncio.run(main())

Check the event names against the official Voice API reference. Running this example makes a billable request. It is a connectivity example, not a complete microphone application, playback queue, reconnect strategy or monitoring service. Our offline checks do not establish that a live API request succeeded.

Extend the example into a microphone conversation

Follow the Speech to Speech guide, then add the audio path in stages:

  1. Set turn_detection.type to server_vad. Configure input as 24 kHz mono PCM16 and ensure the microphone bytes actually match.
  2. Base64-encode small chunks and send input_audio_buffer.append. A 20 ms chunk in that format contains 960 bytes; this is an implementation choice, not a required fixed packet size.
  3. With server VAD, let the service manage speech turns. Do not manually commit every tiny chunk. In manual mode, commit at the end of an utterance and request a response.
  4. Queue incoming response.output_audio.delta chunks in order and play them promptly. When the user interrupts, stop playback and discard queued old audio so the speaker does not keep talking after the server has moved on.
  5. Browser MediaRecorder output may use a WebM container. Do not label those bytes as raw PCM. Decode and resample appropriately, or implement a documented matching format.

The documentation links to maintained tester applications, including a web agent. Review their dependencies, audio handling and credential setup before deployment. A sample client is not a finished business-support system.

Browser authentication with ephemeral tokens

Your server can obtain a short-lived token from the official endpoint:

curl https://api.x.ai/v1/realtime/client_secrets \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{"expires_after":{"seconds":300}}'

Only issue client tokens through your own authenticated, rate-limited backend. Do not expose an unrestricted public token dispenser, return the long-lived key or treat token expiry as a substitute for application permissions.

Native browser WebSockets cannot attach an arbitrary Authorization header like the server example. The ephemeral-token documentation shows authentication through a WebSocket subprotocol:

const ws = new WebSocket(
  "wss://api.x.ai/v1/realtime?model=grok-voice-3.0",
  [`xai-client-secret.${token}`]
);

Obtain token from your trusted backend rather than hardcoding it. Your browser client also needs HTTPS or localhost, microphone permission and user-initiated audio playback.

Connect business tools without inventing results

Begin with one authenticated, read-only function such as looking up an order. On response.function_call_arguments.done, validate the function and arguments, verify the caller's access, run the real lookup and return a function_call_output. Then send response.create to continue the conversation.

An assistant saying “refunded” is not proof of a completed refund. Keep authorization, confirmation and idempotency in the business backend for refunds, address changes and subscription cancellation. Do not execute arbitrary model-generated code, URLs or SQL. These are our engineering recommendations, not additional model capability claims.

Grok Voice 3.0 pricing: calculate the complete bill

The official price table lists $0.08 per minute ($4.80 per hour), plus $0.004 per text input. Include the additional line item when estimating costs.

For example, assume your usage records contain 10 billable minutes and five billable text inputs. Those items total 10 × $0.08 + 5 × $0.004 = $0.82. This is arithmetic for specified usage, not a quoted ten-minute call package. Account for telephony, tools, storage and other applicable charges separately.

Set a session-duration limit, close unused connections and compare the bill against completed user tasks. A low headline rate is not useful if the system repeatedly fails to finish the job.

Grok Voice vs GPT-Live vs Gemini Live

This comparison concerns developer APIs, not Grok, ChatGPT or Gemini consumer subscriptions. Rates were checked on October 16, 2026. Their billing units differ, so the numbers are not an apples-to-apples total-cost ranking.

Option Architecture and purpose Published billing points What we suggest testing first
Grok Voice 3.0 Real-time speech conversations with tools available in the session $0.08/min plus text inputs and applicable additional charges Teams extending an existing Grok application with a conversational business workflow
OpenAI GPT-Live 1 Full-duplex conversation, with reasoning and tasks delegated to a backend Voice is $0.05/min, billed per second; backend models and tools are separate Teams wanting to manage the conversational layer and task agent independently
Gemini 3.8 Live Real-time audio and multimodal interaction through Live API Paid audio input is $3/1M tokens and output $12/1M tokens; text, context and tools follow their own billing rules Applications combining live visual input with audio and explicit token/context management

Sources: GPT-Live 1 model documentation, Gemini Live overview and Gemini API pricing. OpenAI separates voice duration from backend usage; Google's Live API best practices explains persistent-session context billing. Neither headline voice rate nor a single second of input establishes a completed task's final bill.

Our recommendation is to compare the same business scenarios: task completion, interruption recovery, specialist vocabulary, failure handling and total cost. A benchmark with another prompt, reasoning configuration or network is not a replacement for that evaluation.

Troubleshooting and an original evaluation checklist

Symptom or check Start here
Authentication fails or the connection is rejected Key, account credit, model access and the selected model ID
Events arrive but there is no sound Whether audio is decoded and played instead of only logging event names
Speech is too fast, too slow or noisy Codec, sample rate, channel count and playback configuration
Old speech continues after an interruption Playback cancellation, queued audio and duplicate response requests
A migrated application breaks Deprecated model IDs and mixed authentication/event conventions from different providers

Run a recorded evaluation using ordinary speech, a number spoken with background noise, a changed requirement mid-answer, multilingual product names, a nonexistent order and an action that requires confirmation. Change one variable at a time and record real outcomes. This is an original evaluation plan, not a table of results we claim to have measured.

How video creators can use a voice workflow

Rehearse a 15-second product voiceover aloud, then turn the approved scene, action and camera direction into a video prompt. Continue in the video studio or product ad workspace to create visuals. Separately recorded or synthesized speech may still need editing; do not assume an arbitrary audio file will automatically produce accurate lip sync.

This InstantVid page is editorial coverage and a tutorial, not an announcement that Grok Voice 3.0 is integrated here. Check the studio for actual video models, audio capabilities and credit quotes. See models and pricing.

The cover is an original AI-assisted editorial illustration of a microphone and sound waves, not an official screenshot or endorsement. Follow the official links for subsequent changes to model aliases, availability and pricing.

Sources & further reading

Sources reviewed Oct 16, 2026