O que é GPT-Realtime-2 e como usar a API GPT-Realtime-2

A OpenAI lançou uma nova geração de modelos de voz em 6 de novembro de 2026. O principal lançamento é o GPT-Realtime-2: um modelo fala-para-fala com raciocínio de classe GPT-5, janela de contexto de 128.000 tokens e esforço de raciocínio configurável para equilibrar latência e qualidade. Se você já usa gpt-realtime, a migração começa trocando a string do modelo para gpt-realtime-2 e revisando os novos campos de sessão e ferramentas.

Experimente o Apidog hoje

Este guia mostra o que mudou, como configurar uma sessão Realtime, como chamar o modelo via WebSocket e SIP, como usar vozes, imagem, ferramentas e MCP, além de como testar o fluxo no Apidog sem regravar áudio a cada execução.

Para contexto sobre a linha de modelos mais ampla da OpenAI para 2026, consulte O que é GPT-5.5. Para o modelo irmão multimodal, consulte Como usar a API GPT-Image-2.

TL;DR

• gpt-realtime-2 é o principal modelo fala-para-fala da OpenAI, com raciocínio de classe GPT-5, contexto de 128k e até 32k tokens de saída.
• O preço de áudio é de $32 por 1M de tokens de entrada e $64 por 1M de tokens de saída. Entrada em cache custa $0.40/1M.
• As novas vozes Cedar e Marin são exclusivas da API Realtime. As oito vozes existentes receberam atualização de qualidade.
• Há cinco níveis de raciocínio: minimal, low, medium, high, xhigh. O padrão é low.
• Conexão principal via WebSocket: wss://api.openai.com/v1/realtime?model=gpt-realtime-2.
• SIP permite receber chamadas telefônicas reais via call_id.
• Modelos complementares:
  • GPT-Realtime-Translate: tradução ao vivo, 70 idiomas de entrada, $0.034/min.
  • GPT-Realtime-Whisper: STT em streaming, $0.017/min.
• Use o Apidog para salvar a conexão WebSocket, reproduzir eventos e comparar execuções.

O que é GPT-Realtime-2?

GPT-Realtime-2 é um modelo fala-para-fala. Você envia áudio de entrada, recebe áudio de saída, e o modelo lida com transcrição, raciocínio, seleção de ferramentas e geração de voz em uma única passagem.

Na prática, você não precisa montar um pipeline separado:

STT -> LLM -> TTS

Em vez disso, a sessão Realtime fica assim:

áudio/texto/imagem -> gpt-realtime-2 -> áudio/texto

O modelo aceita texto, áudio e imagem como entrada, e retorna texto e áudio como saída. A entrada de imagem é a nova modalidade importante: você pode enviar uma captura de tela durante uma conversa de voz e pedir para o agente explicar o erro, orientar o usuário ou continuar o atendimento em voz alta.

Especificações principais

O que mudou em relação ao gpt-realtime

Comparado ao gpt-realtime-1.5, o gpt-realtime-2 melhora principalmente em inteligência de áudio e seguimento de instruções:

• Big Bench Audio: 81,4% → 96,6%.
• Audio MultiChallenge: 34,7% → 48,5%.

Esses resultados foram obtidos com raciocínio high e xhigh. Em produção, o padrão é low, priorizando latência.

As mudanças mais relevantes para implementação são:

• Preâmbulos: o modelo pode falar algo como “deixe-me verificar isso” antes da resposta final, reduzindo a percepção de latência.
• Chamadas de ferramentas paralelas: o modelo pode disparar várias funções ao mesmo tempo e narrar o progresso.
• Recuperação melhor: turnos ambíguos ou parcialmente falhos não precisam reiniciar a conversa.
• Controle de tom: o modelo mantém terminologia especializada e pode ajustar estilo de fala durante a sessão.

A janela de contexto também aumentou de 32k para 128k tokens. Isso é relevante para agentes de voz em suporte, bancos, tutoria, triagem e call centers, onde uma única sessão pode durar vários minutos.

Preços

O GPT-Realtime-2 é cobrado por token, com preços separados para texto, áudio e imagem.

A entrada em cache reduz bastante o custo quando você reutiliza contexto, como:

• prompt de sistema fixo;
• políticas internas;
• documentação do produto;
• instruções de atendimento;
• catálogo de ferramentas.

Para comparação com outros modelos da linha OpenAI, consulte preços do GPT-5.5.

Modelos complementares:

• GPT-Realtime-Translate: $0,034 por minuto. Suporta 70 idiomas de entrada e 13 idiomas de saída.
• GPT-Realtime-Whisper: $0,017 por minuto. Fala-para-texto em streaming para legendas ao vivo e transcrição contínua.

Use:

• gpt-realtime-2 quando precisar de raciocínio + voz.
• GPT-Realtime-Translate para interpretação multilíngue ao vivo.
• GPT-Realtime-Whisper quando você só precisa de transcrição.

Endpoints e autenticação

Endpoints relevantes:

POST https://api.openai.com/v1/chat/completions
POST https://api.openai.com/v1/responses
WSS  wss://api.openai.com/v1/realtime?model=gpt-realtime-2
WSS  wss://api.openai.com/v1/realtime?call_id={call_id}
POST https://api.openai.com/v1/realtime/translations
POST https://api.openai.com/v1/realtime/transcription_sessions

Para agentes de voz, use o WebSocket:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2

Cabeçalhos:

Authorization: Bearer $OPENAI_API_KEY
OpenAI-Beta: realtime=v1

Defina a chave uma vez no ambiente:

export OPENAI_API_KEY="sk-proj-..."

Conectando via WebSocket

Um cliente Node.js mínimo:

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime?model=gpt-realtime-2",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Beta": "realtime=v1",
    },
  }
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      voice: "cedar",
      instructions: "You are a friendly support agent for a fintech app.",
      input_audio_format: "pcm16",
      output_audio_format: "pcm16",
      turn_detection: { type: "server_vad" },
      reasoning: { effort: "low" },
    },
  }));
});

ws.on("message", (raw) => {
  const event = JSON.parse(raw.toString());

  if (event.type === "response.audio.delta") {
    // Chunk de áudio PCM16 em base64.
    // Envie para o player, speaker ou pipeline de áudio do cliente.
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }

  if (event.type === "response.done") {
    console.log("Resposta concluída");
  }
});

A sessão é orientada por eventos:

1. Abra o WebSocket.
2. Envie session.update.
3. Enquanto o usuário fala, envie eventos input_audio_buffer.append.
4. Quando o turno terminar, crie uma resposta com response.create.
5. Consuma eventos como response.audio.delta.

Exemplo de envio de áudio:

ws.send(JSON.stringify({
  type: "input_audio_buffer.append",
  audio: audioChunkBase64
}));

ws.send(JSON.stringify({
  type: "input_audio_buffer.commit"
}));

ws.send(JSON.stringify({
  type: "response.create"
}));

PCM16 a 24 kHz é uma escolha segura. G.711 mu-law e A-law também são suportados, úteis para telefonia.

Para comparar a superfície Realtime com a API Responses, consulte Como usar a API GPT-5.5.

Vozes

Novas vozes:

• Cedar: voz masculina quente e de médio alcance. Boa opção padrão para agentes gerais.
• Marin: voz feminina clara e brilhante. Boa para tradução e anúncios.

Também continuam disponíveis:

alloy
ash
ballad
coral
echo
sage
shimmer
verse

Para trocar a voz durante a sessão, envie outro session.update:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    voice: "marin"
  }
}));

Entrada de imagem

Você pode anexar uma imagem a um turno do usuário. Isso permite construir agentes que escutam, falam e também analisam uma tela, foto ou captura.

Exemplo:

ws.send(JSON.stringify({
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_image",
        image_url: "https://example.com/screenshot.png"
      },
      {
        type: "input_text",
        text: "What does this error mean?"
      }
    ],
  },
}));

ws.send(JSON.stringify({ type: "response.create" }));

Casos comuns:

• QA por voz: o testador mostra uma tela quebrada e dita o bug.
• Suporte em campo: o técnico envia foto de um painel e recebe diagnóstico guiado.
• Acessibilidade: o agente descreve a tela em voz alta durante o atendimento.

Para detalhes sobre a pilha de imagens da OpenAI, consulte Como usar a API GPT-Image-2.

Chamada de função e MCP

O GPT-Realtime-2 suporta:

• ferramentas de função padrão;
• servidores MCP remotos;
• chamadas paralelas;
• narração durante execução de ferramentas.

Funções padrão

O fluxo é parecido com Chat Completions:

1. Declare as ferramentas na sessão.
2. O modelo emite argumentos da função.
3. Seu backend executa a função.
4. Você responde com function_call_output.
5. O modelo continua a conversa.

Exemplo conceitual:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [
      {
        type: "function",
        name: "lookup_account",
        description: "Busca dados da conta de um usuário",
        parameters: {
          type: "object",
          properties: {
            user_id: { type: "string" }
          },
          required: ["user_id"]
        }
      }
    ]
  }
}));

Servidores MCP remotos

Com MCP remoto, você configura um servidor e uma lista de ferramentas permitidas. A própria API Realtime executa as chamadas.

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [
      {
        type: "mcp",
        server_url: "https://mcp.example.com/sse",
        allowed_tools: [
          "lookup_account",
          "list_transactions"
        ],
      }
    ],
  },
}));

Isso reduz a necessidade de round-trips manuais no seu loop de eventos e ajuda agentes de voz que precisam consultar muitas ferramentas.

Se você estiver testando servidores MCP antes de conectá-los ao agente, veja o guia testando servidores MCP no Apidog.

Chamada telefônica SIP

O GPT-Realtime-2 também pode receber chamadas telefônicas reais via SIP.

Fluxo:

1. Aponte seu tronco SIP para o gateway SIP da OpenAI.
2. Uma chamada de entrada cria uma sessão associada a um call_id.
3. Seu cliente conecta no WebSocket:

wss://api.openai.com/v1/realtime?call_id={call_id}

O modelo aceita G.711 mu-law e A-law diretamente, então você não precisa transcodificar áudio na ponte.

Esse modo é importante para call centers porque combina:

• voz em tempo real;
• interrupção por VAD;
• ferramentas paralelas;
• MCP;
• integração com sistemas internos.

Níveis de raciocínio

O campo reasoning.effort controla o equilíbrio entre qualidade e latência.

Configuração recomendada para começar:

reasoning: {
  effort: "low"
}

Aumente para medium, high ou xhigh apenas se você medir perda de qualidade em low. Em chamadas de voz, latência alta é perceptível rapidamente.

Testando a API Realtime no Apidog

APIs WebSocket são difíceis de depurar no terminal porque a conversa tem estado. No Apidog, você pode salvar e reproduzir a sessão.

Fluxo prático:

1. Crie uma nova requisição WebSocket.
2. Use a URL:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2

1. Configure os headers:

Authorization: Bearer {{OPENAI_API_KEY}}
OpenAI-Beta: realtime=v1

1. Salve mensagens JSON reutilizáveis:

   • session.update
   • input_audio_buffer.append
   • input_audio_buffer.commit
   • response.create

2. Execute a sessão e capture os eventos do servidor.

3. Compare execuções alterando:

   • voice;
   • reasoning.effort;
   • instruções do sistema;
   • ferramentas;
   • formato de áudio.

Você pode baixar o Apidog, criar uma requisição WebSocket e usar ambientes para variáveis como OPENAI_API_KEY, voice e model.

Para comparação com outro modelo multimodal rápido, consulte Como usar a API Gemini 3 Flash Preview.

FAQ

Qual ID de modelo devo usar?

Use:

gpt-realtime-2

O modelo anterior ainda está disponível como:

gpt-realtime

Para a versão lite:

gpt-realtime-2-mini

Posso transmitir áudio de entrada enquanto o áudio de saída ainda está tocando?

Sim. A API Realtime usa VAD do lado do servidor por padrão. Quando o usuário começa a falar, o modelo pode parar a resposta em andamento. Você também pode desabilitar o VAD e controlar turnos no cliente.

O contexto de 128k inclui tokens de áudio?

Sim. O áudio é tokenizado. Um segundo de áudio equivale aproximadamente a 50 tokens, dependendo do formato. Sessões de voz longas podem consumir contexto rapidamente.

Fine-tuning é suportado?

Ainda não. Conforme o cartão do modelo, o GPT-Realtime-2 ainda não suporta ajuste fino, saídas preditas ou streaming de texto em Chat Completions. O endpoint Realtime transmite áudio inerentemente.

Como isso se compara ao GPT-5.5 com TTS acoplado?

Com GPT-5.5 + TTS, você perde raciocínio de fala ponta a ponta. Um modelo consciente de voz pode considerar tom, hesitação e ênfase. Para agentes que precisam reagir a como o usuário fala, o GPT-Realtime-2 é mais adequado.

Para raciocínio textual puro, consulte Como usar a API GPT-5.5.

Quais limites de taxa se aplicam?

O Nível 1 começa em 40.000 tokens por minuto e escala para 15M TPM no Nível 5. Os limites são por modelo, então a cota existente do GPT-5 não é transferida automaticamente.

Conclusão

O GPT-Realtime-2 aproxima agentes de voz de agentes de texto em capacidade de raciocínio e integração. Com contexto de 128k, entrada de imagem, MCP, SIP e chamadas paralelas de ferramentas, você pode construir um agente que atende uma chamada, analisa uma captura de tela, consulta sistemas externos e responde em voz sem sair do WebSocket.

Para implementar com menos atrito:

1. Comece com reasoning.effort = "low".
2. Use server_vad.
3. Escolha cedar ou marin.
4. Defina ferramentas mínimas primeiro.
5. Teste a sessão WebSocket no Apidog.
6. Aumente o raciocínio apenas quando houver evidência de perda de qualidade.