Transmissão de Áudio Bidirecional
Nesta página
Atualizado em 2 de novembro de 2026 — Modelos de áudio. Vários modelos neste curso estão obsoletos:
tts-1,tts-1-hdegpt-4o-mini-ttsdeixarão de funcionar a 6 de janeiro de 2027 (a substituição indicada égpt-realtime-2.1-mini, que o guia TTS da OpenAI afirma não ser suportada por/v1/audio/speech: a migração da síntese de fala passa para a Realtime API);gpt-realtime,gpt-4o-realtimee modelos de áudio legados a 20 de janeiro de 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribee/v1/audio/translationsa 26 de fevereiro de 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Para voz em full-duplex, o GPT-Live 1 está disponível na API desde 10 de setembro de 2026.
Transmissão de Áudio Bidirecional
A transmissão de áudio bidirecional é o núcleo da Realtime API. O seu sistema envia continuamente fragmentos de áudio do microfone e o modelo devolve continuamente fragmentos de áudio de resposta. Estes dois fluxos são independentes e podem operar simultaneamente — é isto que torna a conversa natural.
Formato de Áudio PCM16
A Realtime API utiliza o formato PCM de 16 bits, mono, a 24 kHz. Trata-se de um formato bruto e não comprimido: cada amostra é um inteiro com sinal de 16 bits. Esta escolha privilegia a baixa latência em detrimento da eficiência da largura de banda.
Os fragmentos de áudio são enviados codificados em Base64 dentro de eventos JSON. Cada fragmento representa tipicamente entre 20 a 100 ms de áudio.
Envio de Áudio: Captura do Microfone
Eis como capturar o microfone e transmitir o áudio:
import asyncio
import sounddevice as sd
import numpy as np
import base64
import json
SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)
async def stream_microphone(ws):
"""Capture o microfone e envie fragmentos para a Realtime API."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Aviso de áudio: {status}")
# Converter para int16 e colocar na fila
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Iniciar captura
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Microfone ativo — fale agora...")
while True:
pcm_data = await audio_queue.get()
audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")
await ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": audio_b64
}))
O Buffer de Áudio no Servidor
Os fragmentos enviados através de input_audio_buffer.append acumulam-se num buffer no servidor. Este buffer é processado de duas formas:
- Modo VAD automático (
server_vad): O servidor deteta quando deixa de falar e confirma automaticamente o buffer. - Modo manual: Envia explicitamente
input_audio_buffer.commitpara acionar o processamento.
# Confirmar manualmente o buffer de áudio
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Ou limpar o buffer sem o processar
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Receção de Áudio de Resposta
As respostas de áudio chegam em fragmentos através de eventos response.output_audio.delta. Deve descodificá-los e reproduzi-los continuamente:
import pyaudio
async def play_response_audio(ws):
"""Receber e reproduzir áudio de resposta."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=SAMPLE_RATE,
output=True,
frames_per_buffer=CHUNK_SIZE
)
try:
async for raw_message in ws:
event = json.loads(raw_message)
if event["type"] == "response.output_audio.delta":
# Descodificar o fragmento de áudio Base64
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Resposta de áudio terminada")
elif event["type"] == "response.output_audio_transcript.delta":
# Transcrição de texto da resposta
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Aplicação Completa: Conversa por Voz
Eis como montar a captura e a reprodução para uma conversa completa:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Aguardar session.created
await ws.recv()
# Configurar a sessão
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "You are a voice assistant. Respond in English.",
"audio": {
"input": {
"format": {"type": "audio/pcm", "rate": 24000},
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"silence_duration_ms": 700
}
},
"output": {
"format": {"type": "audio/pcm", "rate": 24000},
"voice": "marin"
}
}
}
}))
await ws.recv() # session.updated
# Lançar captura e reprodução em paralelo
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Gestão de Fluxos Concorrentes
O desafio da transmissão bidirecional reside no facto de estar a enviar e a receber simultaneamente no mesmo WebSocket. O asyncio.gather lança ambas as corrotinas em paralelo, mas estas partilham o mesmo objeto WebSocket. A biblioteca websockets gere esta concorrência corretamente.
Pontos-chave
- O áudio é transmitido como PCM mono de 16 bits a 24 kHz, codificado em Base64 em eventos JSON
- Os fragmentos têm tipicamente entre 20 a 100 ms de áudio para um bom equilíbrio entre latência e sobrecarga
- O buffer de áudio no servidor acumula fragmentos até à confirmação (automática no modo VAD)
- A reprodução da resposta ocorre fragmento a fragmento através de
response.output_audio.delta - O
asyncio.gatherpermite a captura e reprodução simultâneas no mesmo WebSocket