API GPT em Tempo Real para fala e áudio

A API do GPT Realtime do OpenAI do Azure para fala e áudio faz parte da família de modelos GPT-4o que oferece suporte a interações conversacionais de baixa latência, do tipo "fala de entrada, fala de saída".

Você pode usar a API em tempo real via WebRTC ou WebSocket para enviar entrada de áudio para o modelo e receber respostas de áudio em tempo real.

Siga as instruções neste artigo para começar a usar a API do Realtime por meio de WebSockets. Use a API em tempo real por meio de WebSockets em cenários de servidor para servidor em que a baixa latência não é um requisito.

Dica

Na maioria dos casos, recomendamos usar a API em tempo real via WebRTC para streaming de áudio em tempo real em aplicativos do lado do cliente, como um aplicativo Web ou aplicativo móvel. O WebRTC foi projetado para streaming de áudio em tempo real de baixa latência e é a melhor opção para a maioria dos casos de uso.

Modelos com suporte

Os modelos de GPT em tempo real estão disponíveis para implantações globais.

gpt-4o-realtime-preview (versão 2024-12-17)
gpt-4o-mini-realtime-preview (versão 2024-12-17)
gpt-realtime (versão 2025-08-28)
gpt-realtime-mini (versão 2025-10-06)

Para obter mais informações, consulte a documentação de modelos e versões.

Suporte de API

O suporte para a API em tempo real foi adicionado pela primeira vez na versão 2024-10-01-preview da API (desativada). Use a versão 2025-08-28 para acessar os recursos mais recentes da API do Realtime. Recomendamos que você selecione a versão da API disponível em geral (sem sufixo '-preview') quando possível.

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Suporte a Node.js LTS ou ESM.
Um recurso do OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um modelo gpt-realtime com o recurso do OpenAI do Azure. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a função de Cognitive Services OpenAI User à sua conta de usuário. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Implantar um modelo para áudio em tempo real

Para implantar o gpt-realtime modelo no portal do Microsoft Foundry:

Vá para o portal do Foundry e crie ou selecione seu projeto.
Selecione suas implantações de modelo:
1. Para o recurso do Azure OpenAI, selecione Implantações na seção Recursos Compartilhados no painel esquerdo.
2. Para o recurso Foundry, selecione Modelos + pontos de extremidade em Meus ativos no painel esquerdo.
Selecione + Implantar modelo>Implantar modelo base para abrir a janela de implantação.
Pesquise e selecione o modelo gpt-realtime e selecione Confirmar.
Examine os detalhes da implantação e selecione Implantar.
Siga o assistente para concluir a implantação do modelo.

Agora que você tem uma implantação do modelo gpt-realtime, pode interagir com ele no playground Áudio do portal Foundry ou na API em tempo real.

Configuração

Crie uma nova pasta realtime-audio-quickstart-js e vá para a pasta de início rápido com o seguinte comando:
```
mkdir realtime-audio-quickstart-js && cd realtime-audio-quickstart-js
```
Crie o package.json com o seguinte comando:
```
npm init -y
```
Atualize o type para module em package.json com o seguinte comando:
```
npm pkg set type=module
```
Instale a biblioteca de clientes do OpenAI para JavaScript com:
```
npm install openai
```
Instale os pacotes dependentes usados pela biblioteca de clientes OpenAI para JavaScript com:
```
npm install ws
```
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o pacote @azure/identity com:
```
npm install @azure/identity
```

Recuperar as informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do OpenAI do Azure:

Microsoft Entra ID
Chave de API

Nome da variável	Valor
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Esse valor corresponderá ao nome personalizado escolhido para sua implantação ao implantar um modelo. Esse valor pode ser encontrado em Gerenciamento de Recursos>Implantações de Modelos no portal do Azure.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Valor
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Esse valor corresponderá ao nome personalizado escolhido para sua implantação ao implantar um modelo. Esse valor pode ser encontrado em Gerenciamento de Recursos>Implantações de Modelos no portal do Azure.

Saiba mais sobre encontrar as chaves de API e definir as variáveis de ambiente.

Importante

Use as chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se você usar uma chave de API, armazene-a com segurança no Azure Key Vault. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, confira Chaves de API com o Azure Key Vault.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Cuidado

Para usar a autenticação sem chave recomendada com o SDK, verifique se a variável de ambiente AZURE_OPENAI_API_KEY não está definida.

Crie o arquivo index.js com o seguinte código:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { DefaultAzureCredential, getBearerTokenProvider } from '@azure/identity';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main() {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Microsoft Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // Keyless authentication
    const credential = new DefaultAzureCredential();
    const scope = 'https://cognitiveservices.azure.com/.default';
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const token = await azureADTokenProvider();

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });
    const realtimeClient = await OpenAIRealtimeWS.create(openAIClient, {
        model: deploymentName
    });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({
        'type': 'session.update',
        'session': sessionConfig
    });
    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.    
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{
                type: 'input_text',
                text: 'Please assist the user.'
            }
            ]
        }
    });

    realtimeClient.send({
        type: 'response.create'
    });



    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event.
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(err) {
    if (err instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${err.cause.message}`);
        console.error(`Stack: ${err.cause.stack}`);
    }

    if (throwOnError) {
        throw err;
    }
}

function receiveEvent(event) {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error('The sample encountered an error:', err);
});
export {
    main
};

Entre no Azure com o seguinte comando:
```
az login
```
Execute o arquivo JavaScript.
```
node index.js
```

Crie o arquivo index.js com o seguinte código:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main() {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    const token = process.env.AZURE_OPENAI_API_KEY || '<Your API Key>';

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });

    // Due to the current SDK limitation we need to explicitly
    // pass API key as Header
    const realtimeClient = await OpenAIRealtimeWS.create(
        openAIClient, {
        model: deploymentName,
        options: {
            headers: {
                "api-key": token
            }
        }
    });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({
        'type': 'session.update',
        'session': sessionConfig
    });
    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{
                type: 'input_text',
                text: 'Please assist the user.'
            }
            ]
        }
    });

    realtimeClient.send({
        type: 'response.create'
    });

    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event.
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(err) {
    if (err instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${err.cause.message}`);
        console.error(`Stack: ${err.cause.stack}`);
    }

    if (throwOnError) {
        throw err;
    }
}

function receiveEvent(event) {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error('The sample encountered an error:', err);
});
export {
    main
};

Execute o arquivo JavaScript.
```
node index.js
```

Leva alguns minutos para obter a resposta.

Saída

O script obtém uma resposta do modelo e imprime os dados de transcrição e áudio recebidos.

A saída será semelhante à seguinte:

Waiting for events...
Waiting for session.created event...
Received an event: session.created
Session ID: sess_CQx8YO3vKxD9FaPxrbQ9R
Waiting for session.updated event...
Received an event: session.updated
Session ID: sess_CQx8YO3vKxD9FaPxrbQ9R
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Received an event: response.output_audio_transcript.delta
Transcript delta: Sure
Received an event: response.output_audio_transcript.delta
Transcript delta: ,
Received an event: response.output_audio_transcript.delta
Transcript delta:  I
Waiting for response.done event...
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 4800 bytes
Received an event: response.output_audio.delta
Audio delta length: 7200 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta: 'm
Received an event: response.output_audio_transcript.delta
Transcript delta:  here
Received an event: response.output_audio_transcript.delta
Transcript delta:  to
Received an event: response.output_audio_transcript.delta
Transcript delta:  help
Received an event: response.output_audio_transcript.delta
Transcript delta: .
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  What
Received an event: response.output_audio_transcript.delta
Transcript delta:  do
Received an event: response.output_audio_transcript.delta
Transcript delta:  you
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  need
Received an event: response.output_audio_transcript.delta
Transcript delta:  assistance
Received an event: response.output_audio_transcript.delta
Transcript delta:  with
Received an event: response.output_audio_transcript.delta
Transcript delta: ?
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 28800 bytes
Received an event: response.done
Response ID: resp_CQx8YwQCszDqSUXRutxP9
The final response is: Sure, I'm here to help. What do you need assistance with?
The sample completed successfully.

Pré-requisitos

Uma assinatura do Azure. Crie um gratuitamente.
Python 3.8 ou versão posterior. É recomendável usar o Python 3.10 ou posterior, mas ter pelo menos Python 3.8 é necessário. Se você não tiver uma versão adequada do Python instalada, poderá seguir as instruções no Tutorial do Python do VS Code para obter a maneira mais fácil de instalar o Python em seu sistema operacional.
Um recurso do OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um modelo gpt-realtime ou gpt-realtime-mini com o recurso do Azure OpenAI. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a função de Cognitive Services OpenAI User à sua conta de usuário. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Implantar um modelo para áudio em tempo real

Para implantar o gpt-realtime modelo no portal do Microsoft Foundry:

Vá para o portal do Foundry e crie ou selecione seu projeto.
Selecione suas implantações de modelo:
1. Para o recurso do Azure OpenAI, selecione Implantações na seção Recursos Compartilhados no painel esquerdo.
2. Para o recurso Foundry, selecione Modelos + pontos de extremidade em Meus ativos no painel esquerdo.
Selecione + Implantar modelo>Implantar modelo base para abrir a janela de implantação.
Pesquise e selecione o modelo gpt-realtime e selecione Confirmar.
Examine os detalhes da implantação e selecione Implantar.
Siga o assistente para concluir a implantação do modelo.

Agora que você tem uma implantação do modelo gpt-realtime, pode interagir com ele no playground Áudio do portal Foundry ou na API em tempo real.

Configuração

Crie uma nova pasta realtime-audio-quickstart-py e vá para a pasta de início rápido com o seguinte comando:
```
mkdir realtime-audio-quickstart-py && cd realtime-audio-quickstart-py
```
Crie um ambiente virtual. Se você já tiver o Python 3.10 ou superior instalado, crie um ambiente virtual usando os seguintes comandos:
- Windows
- Linux
- macOS
```
py -3 -m venv .venv
.venv\scripts\activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
Ativar o ambiente Python significa que, ao executar python ou pip na linha de comando, você usará o interpretador Python contido na pasta .venv do seu aplicativo. Você pode usar o comando deactivate para sair do ambiente virtual do Python e depois reativar quando necessário.

Dica

Recomendamos que você crie e ative um novo ambiente Python para usar para instalar os pacotes necessários para este tutorial. Não instale pacotes na instalação global do Python. Você sempre deve usar um ambiente virtual ou do Conda ao instalar pacotes do Python, caso contrário, poderá interromper a instalação global do Python.
Instalar a biblioteca de clientes do OpenAI Python com:
```
pip install openai[realtime]
```
Observação

Essa biblioteca é mantida pelo OpenAI. Consulte o histórico de lançamentos para acompanhar as atualizações mais recentes na biblioteca.
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o pacote azure-identity com:
```
pip install azure-identity
```

Recuperar as informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do OpenAI do Azure:

Microsoft Entra ID
Chave de API

Nome da variável	Valor
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Esse valor corresponderá ao nome personalizado escolhido para sua implantação ao implantar um modelo. Esse valor pode ser encontrado em Gerenciamento de Recursos>Implantações de Modelos no portal do Azure.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Valor
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Esse valor corresponderá ao nome personalizado escolhido para sua implantação ao implantar um modelo. Esse valor pode ser encontrado em Gerenciamento de Recursos>Implantações de Modelos no portal do Azure.

Saiba mais sobre encontrar as chaves de API e definir as variáveis de ambiente.

Importante

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Cuidado

Para usar a autenticação sem chave recomendada com o SDK, verifique se a variável de ambiente AZURE_OPENAI_API_KEY não está definida.

Entrada de texto e saída de áudio

Microsoft Entra ID
Chave de API

Crie o arquivo text-in-audio-out.py com o seguinte código:

import os
import base64
import asyncio
from openai import AsyncOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

async def main() -> None:
    """
    When prompted for user input, type a message and hit enter to send it to the model.
    Enter "q" to quit the conversation.
    """

    credential = DefaultAzureCredential()
    token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
    token = token_provider()

    # The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    # environment variable.
    # You can find it in the Microsoft Foundry portal in the Overview page of your Azure OpenAI resource.
    # Example: https://{your-resource}.openai.azure.com
    endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]

    # The deployment name of the model you want to use is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    # environment variable.
    # You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    # Example: gpt-realtime
    deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"]

    base_url = endpoint.replace("https://", "wss://").rstrip("/") + "/openai/v1"

    # The APIs are compatible with the OpenAI client library.
    # You can use the OpenAI client library to access the Azure OpenAI APIs.
    # Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    client = AsyncOpenAI(
        websocket_base_url=base_url,
        api_key=token
    )
    async with client.realtime.connect(
        model=deployment_name,
    ) as connection:
        # after the connection is created, configure the session.
        await connection.session.update(session={
            "instructions": "You are a helpful assistant. You respond by voice and text.",
            "output_modalities": ["audio"],
            "audio": {
                "input": {
                    "transcription": {
                        "model": "whisper-1",
                    },
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    },
                    "turn_detection": {
                        "type": "server_vad",
                        "threshold": 0.5,
                        "prefix_padding_ms": 300,
                        "silence_duration_ms": 200,
                        "create_responese": True,
                    }
                },
                "output": {
                    "voice": "alloy",
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    }
                }
            }
        })

        # After the session is configured, data can be sent to the session.
        while True:
            user_input = input("Enter a message: ")
            if user_input == "q":
                print("Stopping the conversation.")
                break

            await connection.conversation.item.create(
                item={
                    "type": "message",
                    "role": "user",
                    "content": [{"type": "input_text", "text": user_input}],
                }
            )
            await connection.response.create()
            async for event in connection:
                if event.type == "response.output_text.delta":
                    print(event.delta, flush=True, end="")
                elif event.type == "response.output_audio.delta":

                    audio_data = base64.b64decode(event.delta)
                    print(f"Received {len(audio_data)} bytes of audio data.")
                elif event.type == "response.output_audio_transcript.delta":
                    print(f"Received text delta: {event.delta}")
                elif event.type == "response.output_text.done":
                    print()
                elif event.type == "response.done":
                    break

    print("Conversation ended.")
    credential.close()

asyncio.run(main())

Entre no Azure com o seguinte comando:
```
az login
```
Execute o arquivo Python.
```
python text-in-audio-out.py
```
Quando solicitado a inserir uma entrada do usuário, digite uma mensagem e pressione Enter para enviá-la ao modelo. Insira "q" para encerrar a conversa.

Crie o arquivo text-in-audio-out.py com o seguinte código:

import os
import base64
import asyncio
from openai import AsyncOpenAI

async def main() -> None:
    """
    When prompted for user input, type a message and hit enter to send it to the model.
    Enter "q" to quit the conversation.
    """

    # The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    # environment variable.
    # You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource: Use only the base URL, for example, https://{your-resource}.openai.azure.com
    endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]
    base_url = endpoint.replace("https://", "wss://").rstrip("/") + "/openai/v1"

    # The deployment name of the model you want to use is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    # environment variable.
    # You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    # Example: gpt-realtime
    deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"]

    # API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
    # environment variable.
    # You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    token=os.environ["AZURE_OPENAI_API_KEY"]

    # The APIs are compatible with the OpenAI client library.
    # You can use the OpenAI client library to access the Azure OpenAI APIs.
    # Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    client = AsyncOpenAI(
        websocket_base_url=base_url,
        api_key=token
    )
    async with client.realtime.connect(
        model=deployment_name,
    ) as connection:
        # after the connection is created, configure the session.
        await connection.session.update(session={
            "instructions": "You are a helpful assistant. You respond by voice and text.",
            "output_modalities": ["audio"],
            "audio": {
                "input": {
                    "transcription": {
                        "model": "whisper-1",
                    },
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    },
                    "turn_detection": {
                        "type": "server_vad",
                        "threshold": 0.5,
                        "prefix_padding_ms": 300,
                        "silence_duration_ms": 200,
                        "create_responese": True,
                    }
                },
                "output": {
                    "voice": "alloy",
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    }
                }
            }
        })

        # After the session is configured, data can be sent to the session.
        while True:
            user_input = input("Enter a message: ")
            if user_input == "q":
                print("Stopping the conversation.")
                break

            await connection.conversation.item.create(
                item={
                    "type": "message",
                    "role": "user",
                    "content": [{"type": "input_text", "text": user_input}],
                }
            )
            await connection.response.create()
            async for event in connection:
                if event.type == "response.output_text.delta":
                    print(event.delta, flush=True, end="")
                elif event.type == "response.output_audio.delta":

                    audio_data = base64.b64decode(event.delta)
                    print(f"Received {len(audio_data)} bytes of audio data.")
                elif event.type == "response.output_audio_transcript.delta":
                    print(f"Received text delta: {event.delta}")
                elif event.type == "response.output_text.done":
                    print()
                elif event.type == "response.done":
                    break

    print("Conversation ended.")

asyncio.run(main())

Execute o arquivo Python.
```
python text-in-audio-out.py
```
Quando solicitado a inserir uma entrada do usuário, digite uma mensagem e pressione Enter para enviá-la ao modelo. Insira "q" para encerrar a conversa.

Leva alguns minutos para obter a resposta.

Saída

O script obtém uma resposta do modelo e imprime os dados de transcrição e áudio recebidos.

A saída deve ser semelhante a esta:

Enter a message: How are you today?
Received text delta: I
Received text delta: ’m
Received text delta:  feeling
Received text delta:  fantastic
Received text delta: ,
Received 4800 bytes of audio data.
Received 7200 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  thanks
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  for
Received text delta:  asking
Received text delta: !
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  It
Received text delta: ’s
Received text delta:  a
Received text delta:  great
Received text delta:  day
Received text delta:  to
Received text delta:  chat
Received text delta: ,
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  and
Received text delta:  I
Received text delta: ’m
Received text delta:  energized
Received text delta:  and
Received text delta:  ready
Received text delta:  to
Received text delta:  help
Received text delta:  you
Received text delta:  out
Received text delta: .
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  How
Received text delta:  about
Received text delta:  you
Received text delta: ?
Received text delta:  How
Received text delta: ’s
Received text delta:  your
Received text delta:  day
Received text delta:  going
Received text delta:  so
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  far
Received text delta: ?
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 24000 bytes of audio data.
Enter a message: q
Stopping the conversation.
Conversation ended.

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Suporte a Node.js LTS ou ESM.
TypeScript instalado globalmente.
Um recurso do OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um modelo gpt-realtime com o recurso do OpenAI do Azure. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a função de Cognitive Services OpenAI User à sua conta de usuário. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Implantar um modelo para áudio em tempo real

Para implantar o gpt-realtime modelo no portal do Microsoft Foundry:

Vá para o portal do Foundry e crie ou selecione seu projeto.
Selecione suas implantações de modelo:
1. Para o recurso do Azure OpenAI, selecione Implantações na seção Recursos Compartilhados no painel esquerdo.
2. Para o recurso Foundry, selecione Modelos + pontos de extremidade em Meus ativos no painel esquerdo.
Selecione + Implantar modelo>Implantar modelo base para abrir a janela de implantação.
Pesquise e selecione o modelo gpt-realtime e selecione Confirmar.
Examine os detalhes da implantação e selecione Implantar.
Siga o assistente para concluir a implantação do modelo.

Agora que você tem uma implantação do modelo gpt-realtime, pode interagir com ele no playground Áudio do portal Foundry ou na API em tempo real.

Configuração

Crie uma nova pasta realtime-audio-quickstart-ts e vá para a pasta de início rápido com o seguinte comando:
```
mkdir realtime-audio-quickstart-ts && cd realtime-audio-quickstart-ts
```
Crie o package.json com o seguinte comando:
```
npm init -y
```
Atualize o package.json para ECMAScript com o seguinte comando:
```
npm pkg set type=module
```
Instale a biblioteca de clientes do OpenAI para JavaScript com:
```
npm install openai
```
Instale os pacotes dependentes usados pela biblioteca de clientes OpenAI para JavaScript com:
```
npm install ws
```
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o pacote @azure/identity com:
```
npm install @azure/identity
```

Recuperar as informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do OpenAI do Azure:

Microsoft Entra ID
Chave de API

Nome da variável	Valor
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Esse valor corresponderá ao nome personalizado escolhido para sua implantação ao implantar um modelo. Esse valor pode ser encontrado em Gerenciamento de Recursos>Implantações de Modelos no portal do Azure.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Valor
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Esse valor corresponderá ao nome personalizado escolhido para sua implantação ao implantar um modelo. Esse valor pode ser encontrado em Gerenciamento de Recursos>Implantações de Modelos no portal do Azure.

Saiba mais sobre encontrar as chaves de API e definir as variáveis de ambiente.

Importante

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Cuidado

Para usar a autenticação sem chave recomendada com o SDK, verifique se a variável de ambiente AZURE_OPENAI_API_KEY não está definida.

Entrada de texto e saída de áudio

Microsoft Entra ID
Chave de API

Crie o arquivo index.ts com o seguinte código:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { RealtimeSessionCreateRequest } from 'openai/resources/realtime/realtime';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main(): Promise<void> {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Microsoft Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // Keyless authentication
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const token = await azureADTokenProvider();

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });
    const realtimeClient = await OpenAIRealtimeWS.create(openAIClient, { model: deploymentName });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig: RealtimeSessionCreateRequest = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({ 'type': 'session.update', 'session': sessionConfig });

    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{ type: 'input_text', text: 'Please assist the user.' }]
        }
    });

    realtimeClient.send({ type: 'response.create' });

    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event. 
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(errorEvent: OpenAIRealtimeError): void {
    if (errorEvent instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${errorEvent.message}`);
        console.error(`Stack: ${errorEvent.stack}`); errorEvent
    }

    if (throwOnError) {
        throw errorEvent;
    }
}

function receiveEvent(event: any): void {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error("The sample encountered an error:", err);
});

export { main };

Crie o arquivo tsconfig.json para transpilar o código TypeScript e copiar o código a seguir para ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Instalar definições de tipo para Node.js
```
npm i --save-dev @types/node
```
Transcompilar de TypeScript para JavaScript.
```
tsc
```
Entre no Azure com o seguinte comando:
```
az login
```
Execute o código com o seguinte comando:
```
node index.js
```

Crie o arquivo index.ts com o seguinte código:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
import { RealtimeSessionCreateRequest } from 'openai/resources/realtime/realtime';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main(): Promise<void> {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    const token = process.env.AZURE_OPENAI_API_KEY || '<Your API Key>';

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });

    // Due to the current SDK limitation we need to explicitly
    // pass API key as Header
    const realtimeClient = await OpenAIRealtimeWS.create(
        openAIClient, {
        model: deploymentName,
        options: {
            headers: {
                "api-key": token
            }
        }
    });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig: RealtimeSessionCreateRequest = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({
        'type': 'session.update',
        'session': sessionConfig
    });
    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.    
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{
                type: 'input_text',
                text: 'Please assist the user.'
            }
            ]
        }
    });

    realtimeClient.send({
        type: 'response.create'
    });

    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event.
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(errorEvent: OpenAIRealtimeError): void {
    if (errorEvent instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${errorEvent.message}`);
        console.error(`Stack: ${errorEvent.stack}`);
        errorEvent
    }

    if (throwOnError) {
        throw errorEvent;
    }
}

function receiveEvent(event: any): void {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error("The sample encountered an error:", err);
});

export {
    main
};

Crie o arquivo tsconfig.json para transpilar o código TypeScript e copiar o código a seguir para ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Instalar definições de tipo para Node.js
```
npm i --save-dev @types/node
```
Transcompilar de TypeScript para JavaScript.
```
tsc
```
Execute o código com o seguinte comando:
```
node index.js
```

Leva alguns minutos para obter a resposta.

Saída

O script obtém uma resposta do modelo e imprime os dados de transcrição e áudio recebidos.

A saída será semelhante à seguinte:

Waiting for events...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Received an event: session.created
Session ID: sess_CWQkREiv3jlU3gk48bm0a
Waiting for session.updated event...
Waiting for session.updated event...
Received an event: session.updated
Session ID: sess_CWQkREiv3jlU3gk48bm0a
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Received an event: response.output_audio_transcript.delta
Transcript delta: Sure
Received an event: response.output_audio_transcript.delta
Transcript delta: ,
Received an event: response.output_audio_transcript.delta
Transcript delta:  I'm
Received an event: response.output_audio_transcript.delta
Transcript delta:  here
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 4800 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 7200 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  to
Received an event: response.output_audio_transcript.delta
Transcript delta:  help
Received an event: response.output_audio_transcript.delta
Transcript delta: .
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  What
Received an event: response.output_audio_transcript.delta
Transcript delta:  would
Received an event: response.output_audio_transcript.delta
Transcript delta:  you
Received an event: response.output_audio_transcript.delta
Transcript delta:  like
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  to
Received an event: response.output_audio_transcript.delta
Transcript delta:  do
Received an event: response.output_audio_transcript.delta
Transcript delta:  or
Received an event: response.output_audio_transcript.delta
Transcript delta:  know
Received an event: response.output_audio_transcript.delta
Transcript delta:  about
Received an event: response.output_audio_transcript.delta
Transcript delta: ?
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 24000 bytes
Received an event: response.done
Response ID: resp_CWQkRBrCcCjtHgIEapA92
The final response is: Sure, I'm here to help. What would you like to do or know about?
The sample completed successfully.

Implantar um modelo para áudio em tempo real

Para implantar o gpt-realtime modelo no portal do Microsoft Foundry:

Vá para o portal do Foundry e crie ou selecione seu projeto.
Selecione suas implantações de modelo:
1. Para o recurso do Azure OpenAI, selecione Implantações na seção Recursos Compartilhados no painel esquerdo.
2. Para o recurso Foundry, selecione Modelos + pontos de extremidade em Meus ativos no painel esquerdo.
Selecione + Implantar modelo>Implantar modelo base para abrir a janela de implantação.
Pesquise e selecione o modelo gpt-realtime e selecione Confirmar.
Examine os detalhes da implantação e selecione Implantar.
Siga o assistente para concluir a implantação do modelo.

Agora que você tem uma implantação do modelo gpt-realtime, pode interagir com ele no playground Áudio do portal Foundry ou na API em tempo real.

Usar o áudio do GPT em tempo real

Para conversar com o modelo gpt-realtime implantado no playground Microsoft FoundryÁudio em tempo real, siga estas etapas:

Vá para o portal do Foundry e selecione o projeto que tem seu modelo implantado gpt-realtime .
Selecione Playgrounds no painel esquerdo.
Selecione Playground de áudio>Experimente o playground de áudio.

Observação

O Chat playground não dá suporte ao modelo gpt-realtime. Use o Playground de áudio, conforme descrito nesta seção.
Selecione o modelo gpt-realtime implantado na lista de seleção Implantação.
Opcionalmente, você pode editar o conteúdo na caixa de texto Fornecer instruções e contexto ao modelo. Forneça ao modelo instruções sobre como ele deve se comportar e qualquer contexto que ele deve referenciar ao gerar uma resposta. Você pode descrever a personalidade do assistente, dizer a ele o que ele deve ou não responder e como formatar as respostas.
Se quiser, altere as configurações, como limite, preenchimento de prefixo e duração do silêncio.
Selecione Começar a ouvir para iniciar a sessão. Você pode falar no microfone para iniciar um chat.
Você pode interromper o chat a qualquer momento, falando. Você pode encerrar o chat selecionando o botão Parar de ouvir.

Saiba mais sobre Como usar a API em tempo real
Consulte a referência de API em tempo real
Saiba mais sobre as cotas e limites do OpenAI do Azure
Saiba mais sobre suporte a idiomas e vozes para o serviço de Fala

Comentários

Esta página foi útil?

Last updated on 2025-11-18

Compartilhar via

API GPT em Tempo Real para fala e áudio

Modelos com suporte

Suporte de API

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Implantar um modelo para áudio em tempo real

Configuração

Recuperar as informações do recurso

Entrada de texto e saída de áudio

Saída

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Implantar um modelo para áudio em tempo real

Configuração

Recuperar as informações do recurso

Entrada de texto e saída de áudio

Saída

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Implantar um modelo para áudio em tempo real

Configuração

Recuperar as informações do recurso

Entrada de texto e saída de áudio

Saída

Implantar um modelo para áudio em tempo real

Usar o áudio do GPT em tempo real

Conteúdo relacionado

Comentários

Recursos adicionais