Resumo: A xAI acabou de lançar o Grok Voice Think Fast 2.0, liderando o benchmark Tau Voice com latência de primeiro áudio de 0,70s a $0,08/min. Este guia percorre toda a xAI Voice API em três blocos de código — TTS, clonagem de voz e um assistente de fala para fala em tempo real via WebSocket — tudo executável hoje mesmo.
Por Que Merece Atenção
Em 30 de julho, a xAI lançou oficialmente o Grok Voice Think Fast 2.0, um dos modelos speech-to-speech mais rápidos disponíveis:
-
Primeiro lugar no benchmark Tau Voice (56,5%), à frente da OpenAI, Google e Alibaba Qwen.
-
Latência de primeiro áudio de 0,70s — o único modelo entre os cinco primeiros abaixo de um segundo.
-
Preço de $0,08/min, cerca da metade do OpenAI GPT-Realtime-2.1.
-
Streaming bidirecional via WebSocket, compatível com o protocolo da OpenAI Realtime API.
-
26 vozes de ponta além de clonagem de voz personalizada, em mais de 25 idiomas.
Esta não é uma daquelas versões para assistir ao keynote — a xAI Voice API está totalmente aberta, e tudo abaixo funciona no momento em que você tiver uma chave de API.
Os Três Níveis de Capacidade
-
TTS (text-to-speech) — uma linha de curl transforma texto em áudio, com 26 vozes além de controle de velocidade e tom.
-
Voz Personalizada (clonagem) — envie 120 segundos de áudio de referência para criar sua própria voz.
-
Speech-to-Speech (conversa em tempo real) — um stream bidirecional via WebSocket com detecção de turnos por VAD, tool calling e retomada de sessão.
Um exemplo de código executável por nível, começando agora.
Passo 1: TTS — Áudio com um Único curl
A chamada mais simples, e uma verificação de cinco segundos de que sua chave de API funciona:
# Generate speech and save straight to an MP3 file
curl -X POST https://api.x.ai/v1/tts \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"text": "Hello, and welcome to Grok Voice text to speech. This is a test.",
"voice_id": "eve",
"language": "en"
}' \
--output hello.mp3A versão em Python é igualmente curta:
import os, requests
resp = requests.post(
"https://api.x.ai/v1/tts",
headers={
"Authorization": f"Bearer {os.environ['XAI_API_KEY']}",
"Content-Type": "application/json",
},
json={
"text": "Hello, and welcome to Grok Voice text to speech.",
"voice_id": "eve",
"language": "en",
},
)
resp.raise_for_status()
with open("hello.mp3", "wb") as f:
f.write(resp.content)
print(f"Saved {len(resp.content):,} bytes -> hello.mp3")Parâmetros opcionais de relance:
-
speed: 0,7–1,5, multiplicador de velocidade da fala. -
output_format: taxa de amostragem (8kHz–44,1kHz) e bitrate; suporta MP3/PCM/μ-law. -
with_timestamps: timestamps em nível de caractere para legendas ou lip sync. -
text_normalization: converte números e símbolos em formas faladas automaticamente. -
optimize_streaming_latency: 0–2, knob de prioridade para a latência de streaming do primeiro frame.
Passo 2: Voz Personalizada — Crie Sua Própria Voz
Sem necessidade de fine-tuning — envie um clipe de referência (WAV/MP3, até 120 segundos):
# Create a custom voice
curl -X POST https://api.x.ai/v1/custom-voices \
-H "Authorization: Bearer $XAI_API_KEY" \
-F "name=My Voice" \
-F "language=en" \
-F "[email protected];type=audio/wav"
# Returns: {"voice_id": "nlbqfwie", "name": "My Voice", "language": "en", ...}Depois, use o voice_id retornado em qualquer chamada de TTS:
curl -X POST https://api.x.ai/v1/tts \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"text": "This is my custom voice. Not bad, right?",
"voice_id": "nlbqfwie",
"language": "en"
}' \
--output custom_voice_demo.mp3Dica: use vocais limpos, com pouco ruído de fundo e ritmo natural no clipe de referência. Um voice_id é reutilizável, mas não suporta atualizações incrementais — se não gostar do resultado, crie uma nova voz a partir de uma gravação melhor.
Passo 3: Speech-to-Speech — um Assistente de Voz em Tempo Real
A peça central: um stream de voz bidirecional via WebSocket com detecção automática de turnos por VAD, tool calling (busca/MCP) e retomada de sessão. Código completo e executável:
import asyncio, json, os, websockets
async def voice_agent():
"""Connect to Grok Voice over WebSocket for realtime conversation"""
url = "wss://api.x.ai/v1/realtime?model=grok-voice-latest"
headers = {"Authorization": f"Bearer {os.environ['XAI_API_KEY']}"}
async with websockets.connect(url, additional_headers=headers) as ws:
# 1. Configure the session: voice, system instructions, VAD
await ws.send(json.dumps({
"type": "session.update",
"session": {
"voice": "eve",
"instructions": "You are a warm, helpful voice assistant. Keep answers short.",
"turn_detection": {
"type": "server_vad", # automatic speech detection
"threshold": 0.85, # activation threshold
"silence_duration_ms": 800, # silence that counts as "done"
},
"tools": [{ # mount a search capability
"type": "web_search",
"name": "web_search"
}],
}
}))
print("[session ready] voice: eve | VAD: on")
# 2. Send a text message to start the interaction
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [{
"type": "input_text",
"text": "What's the big AI news today?"
}]
}
}))
await ws.send(json.dumps({"type": "response.create"}))
# 3. Listen to the server's event stream
async for raw in ws:
event = json.loads(raw)
t = event["type"]
if t == "response.audio.delta": # audio chunk received
pass # audio_data = event["delta"] -> play it
elif t == "response.text.delta": # synced text (for captions)
print(event["delta"], end="", flush=True)
elif t == "response.done": # turn finished
print("\n[response complete]")
elif t == "error":
print(f"[error] {event}")
break
asyncio.run(voice_agent())Parâmetros-chave explicados:
-
turn_detection.type: "server_vad"— o servidor decide quando o usuário terminou de falar; sem necessidade de push-to-talk manual. -
silence_duration_ms— quanto silêncio conta como “fim de fala”; valores mais altos evitam que pausas no meio da frase interrompam o usuário. -
prefix_padding_ms— áudio gravado antes do disparo do VAD (padrão de 333ms) para que o início das frases não seja cortado. -
idle_timeout_ms— se definido, o assistente proativamente dá continuidade quando o usuário fica em silêncio por muito tempo. -
resumption.enabled: true— a retomada de sessão restaura o contexto automaticamente após uma reconexão.
Dicas Práticas
-
Aprenda o fluxo começando pelo TTS: primeiro o curl, depois um wrapper em Python, depois a semântica dos parâmetros — cinco minutos, e está pronto.
-
Trate a clonagem de voz como demo, não como produto: 120 segundos de áudio de referência bastam para protótipos, mas ficam aquém do nível de produção. Grave várias tomadas e compare.
-
Os parâmetros de VAD são onde vive a qualidade do tempo real: o ritmo de fala varia por idioma — experimente
silence_duration_msentre 800–1000ms para estilos de conversa mais pausados e 600–800ms para os mais rápidos. -
Use Ephemeral Tokens no navegador: nunca envie sua chave de API ao frontend. Gere tokens de curta duração no servidor (com o prefixo
xai-client-secret.) e passe-os ao WebSocket. -
Comece pelo xAI Cookbook: o repositório no GitHub traz quatro apps de exemplo completos — iOS, Web (WebSocket/WebRTC) e Telefonia (Twilio) — prontos para fazer fork.
