Learn more about keyless authentication and setting environment variables.

Learn more about finding API keys and setting environment variables.

1. Create the to-audio.js file with the following code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
   const { writeFileSync } = require("node:fs");
   
   // Keyless authentication    
   const credential = new DefaultAzureCredential();
   const scope = "https://ai.azure.com/.default";
   const azureADTokenProvider = getBearerTokenProvider(credential, scope);
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const deployment = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-4o-mini-audio-preview"; 
   const apiVersion = process.env.OPENAI_API_VERSION || "2025-01-01-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       azureADTokenProvider, 
       apiVersion, 
       deployment 
   }); 
   
   async function main() {
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview", 
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: [ 
           { 
               role: "user", 
               content: "Is a golden retriever a good family dog?" 
           } 
           ] 
       }); 
   
   // Inspect returned data 
   console.log(response.choices[0]); 
   
   // Write the output audio data to a file
   writeFileSync( 
       "dog.wav", 
       Buffer.from(response.choices[0].message.audio.data, 'base64'), 
       { encoding: "utf-8" } 
   ); 
   }
   
   main().catch((err) => {
     console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Sign in to Azure with the following command:

   az login
   

3. Run the JavaScript file.

   node to-audio.js
   

1. Create the to-audio.js file with the following code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { writeFileSync } = require("node:fs");
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       apiKey, 
       apiVersion, 
       deployment 
   });  
   
   async function main() {
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview", 
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: [ 
           { 
               role: "user", 
               content: "Is a golden retriever a good family dog?" 
           } 
           ] 
       }); 
   
   // Inspect returned data 
   console.log(response.choices[0]); 
   
   // Write the output audio data to a file
   writeFileSync( 
       "dog.wav", 
       Buffer.from(response.choices[0].message.audio.data, 'base64'), 
       { encoding: "utf-8" } 
   ); 
   }
   
   main().catch((err) => {
     console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Run the JavaScript file.

   node to-audio.js
   

1. Create the from-audio.js file with the following code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
   const fs = require('fs').promises;
   const { writeFileSync } = require("node:fs");
   
   // Keyless authentication    
   const credential = new DefaultAzureCredential();
   const scope = "https://ai.azure.com/.default";
   const azureADTokenProvider = getBearerTokenProvider(credential, scope);
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       azureADTokenProvider, 
       apiVersion, 
       deployment 
   });    
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"],
           audio: { voice: "alloy", format: "wav" }, 
           messages: [
               {
                   role: "user",
                   content: [
                       { 
                           type: "text", 
                           text: "Describe in detail the spoken audio input." 
                       },
                       { 
                           type: "input_audio", 
                           input_audio: { 
                               data: base64str, 
                               format: "wav" 
                           } 
                       }
                   ]
               }
           ]
       });
   
       console.log(response.choices[0]); 
   
       // Write the output audio data to a file
       writeFileSync( 
           "analysis.wav", 
           Buffer.from(response.choices[0].message.audio.data, 'base64'), 
           { encoding: "utf-8" } 
       ); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Sign in to Azure with the following command:

   az login
   

3. Run the JavaScript file.

   node from-audio.js
   

1. Create the from-audio.js file with the following code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const fs = require('fs').promises;
   const { writeFileSync } = require("node:fs");
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       apiKey, 
       apiVersion, 
       deployment 
   });  
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Make the audio chat completions request
       const response = await client.chat.completions.create({
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"],
           audio: { voice: "alloy", format: "wav" }, 
           messages: [
               {
                   role: "user",
                   content: [
                       { 
                           type: "text", 
                           text: "Describe in detail the spoken audio input." 
                       },
                       { 
                           type: "input_audio", 
                           input_audio: { 
                               data: base64str, 
                               format: "wav" 
                           } 
                       }
                   ]
               }
           ]
       });
   
       console.log(response.choices[0]); 
   
       // Write the output audio data to a file
       writeFileSync( 
           "analysis.wav", 
           Buffer.from(response.choices[0].message.audio.data, 'base64'), 
           { encoding: "utf-8" } 
       ); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Run the JavaScript file.

   node from-audio.js
   

1. Create the multi-turn.js file with the following code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
   const fs = require('fs').promises;
   
   // Keyless authentication    
   const credential = new DefaultAzureCredential();
   const scope = "https://ai.azure.com/.default";
   const azureADTokenProvider = getBearerTokenProvider(credential, scope);
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       azureADTokenProvider, 
       apiVersion, 
       deployment 
   }); 
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Initialize messages with the first turn's user input 
       const messages = [
           {
               role: "user",
               content: [
                   { 
                       type: "text", 
                       text: "Describe in detail the spoken audio input." 
                   },
                   { 
                       type: "input_audio", 
                       input_audio: { 
                           data: base64str, 
                           format: "wav" 
                       } 
                   }
               ]
           }
       ];
   
       // Get the first turn's response 
   
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: messages
       }); 
   
       console.log(response.choices[0]); 
   
       // Add a history message referencing the previous turn's audio by ID 
       messages.push({ 
           role: "assistant", 
           audio: { id: response.choices[0].message.audio.id }
       });
   
       // Add a new user message for the second turn
       messages.push({ 
           role: "user", 
           content: [ 
               { 
                   type: "text", 
                   text: "Very concisely summarize the favorability." 
               } 
           ] 
       }); 
   
       // Send the follow-up request with the accumulated messages
       const followResponse = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           messages: messages
       });
   
       console.log(followResponse.choices[0].message.content); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Sign in to Azure with the following command:

   az login
   

3. Run the JavaScript file.

   node multi-turn.js
   

1. Create the multi-turn.js file with the following code:

   require("dotenv").config();
   const { AzureOpenAI } = require("openai");
   const fs = require('fs').promises;
   
   // Set environment variables or edit the corresponding values here.
   const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
   const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
   const apiVersion = "2025-01-01-preview"; 
   const deployment = "gpt-4o-mini-audio-preview"; 
   
   const client = new AzureOpenAI({ 
       endpoint, 
       apiKey, 
       apiVersion, 
       deployment 
   });  
   
   async function main() {
   
       // Buffer the audio for input to the chat completion
       const wavBuffer = await fs.readFile("dog.wav"); 
       const base64str = Buffer.from(wavBuffer).toString("base64"); 
   
       // Initialize messages with the first turn's user input 
       const messages = [
           {
               role: "user",
               content: [
                   { 
                       type: "text", 
                       text: "Describe in detail the spoken audio input." 
                   },
                   { 
                       type: "input_audio", 
                       input_audio: { 
                           data: base64str, 
                           format: "wav" 
                       } 
                   }
               ]
           }
       ];
   
       // Get the first turn's response 
   
       const response = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           modalities: ["text", "audio"], 
           audio: { voice: "alloy", format: "wav" }, 
           messages: messages
       }); 
   
       console.log(response.choices[0]); 
   
       // Add a history message referencing the previous turn's audio by ID 
       messages.push({ 
           role: "assistant", 
           audio: { id: response.choices[0].message.audio.id }
       });
   
       // Add a new user message for the second turn
       messages.push({ 
           role: "user", 
           content: [ 
               { 
                   type: "text", 
                   text: "Very concisely summarize the favorability." 
               } 
           ] 
       }); 
   
       // Send the follow-up request with the accumulated messages
       const followResponse = await client.chat.completions.create({ 
           model: "gpt-4o-mini-audio-preview",
           messages: messages
       });
   
       console.log(followResponse.choices[0].message.content); 
   }
   
   main().catch((err) => {
       console.error("Error occurred:", err);
   });
   
   module.exports = { main };
   

2. Run the JavaScript file.

   node multi-turn.js
   

Learn more about keyless authentication and setting environment variables.

Learn more about finding API keys and setting environment variables.

1. Create the to-audio.py file with the following code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   token_provider=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default")
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   client=AzureOpenAI(
       azure_ad_token_provider=token_provider,
       azure_endpoint=endpoint,
       api_version="2025-01-01-preview"
   )
   
   # Make the audio chat completions request
   completion=client.chat.completions.create(
       model="gpt-4o-mini-audio-preview",
       modalities=["text", "audio"],
       audio={"voice": "alloy", "format": "wav"},
       messages=[
           {
               "role": "user",
               "content": "Is a golden retriever a good family dog?"
           }
       ]
   )
   
   print(completion.choices[0])
   
   # Write the output audio data to a file
   wav_bytes=base64.b64decode(completion.choices[0].message.audio.data)
   with open("dog.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Run the Python file.

   python to-audio.py
   

1. Create the to-audio.py file with the following code:

   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   client = AzureOpenAI(
       api_version="2025-01-01-preview",  
       api_key=api_key,
       azure_endpoint=endpoint
   )
   
   # Make the audio chat completions request
   completion = client.chat.completions.create(
       model="gpt-4o-mini-audio-preview",
       modalities=["text", "audio"],
       audio={"voice": "alloy", "format": "wav"},
       messages=[
           {
               "role": "user",
               "content": "Is a golden retriever a good family dog?"
           }
       ]
   )
   
   print(completion.choices[0])
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
   with open("dog.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Run the Python file.

   python to-audio.py
   

1. Create the from-audio.py file with the following code:

   import base64
   import os
   from openai import AzureOpenAI
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   token_provider=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default")
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   client=AzureOpenAI(
       azure_ad_token_provider=token_provider,
       azure_endpoint=endpoint,
       api_version="2025-01-01-preview"
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Make the audio chat completions request
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=[ 
           { 
               "role": "user", 
               "content": [ 
                   {  
                       "type": "text", 
                       "text": "Describe in detail the spoken audio input." 
                   }, 
                   { 
                       "type": "input_audio", 
                       "input_audio": { 
                           "data": encoded_string, 
                           "format": "wav" 
                       } 
                   } 
               ] 
           }, 
       ] 
   ) 
   
   print(completion.choices[0].message.audio.transcript)
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
   with open("analysis.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Run the Python file.

   python from-audio.py
   

1. Create the from-audio.py file with the following code:

   import base64
   import os
   from openai import AzureOpenAI
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   client = AzureOpenAI(
       api_version="2025-01-01-preview",  
       api_key=api_key, 
       azure_endpoint=endpoint,
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Make the audio chat completions request
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=[ 
           { 
               "role": "user", 
               "content": [ 
                   {  
                       "type": "text", 
                       "text": "Describe in detail the spoken audio input." 
                   }, 
                   { 
                       "type": "input_audio", 
                       "input_audio": { 
                           "data": encoded_string, 
                           "format": "wav" 
                       } 
                   } 
               ] 
           }, 
       ] 
   ) 
   
   print(completion.choices[0].message.audio.transcript)
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
   with open("analysis.wav", "wb") as f:
       f.write(wav_bytes)
   

2. Run the Python file.

   python from-audio.py
   

1. Create the multi-turn.py file with the following code:

   import base64 
   import os 
   from openai import AzureOpenAI 
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   
   token_provider=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default")
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   client=AzureOpenAI(
       azure_ad_token_provider=token_provider,
       azure_endpoint=endpoint,
       api_version="2025-01-01-preview"
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               { "type": "text", "text": "Describe in detail the spoken audio input." }, 
               { "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   # Get the first turn's response
   
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=messages
   ) 
   
   print("Get the first turn's response:")
   print(completion.choices[0].message.audio.transcript) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.choices[0].message.audio.id)
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.choices[0].message.audio.id } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   # Send the follow-up request with the accumulated messages
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       messages=messages
   ) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.choices[0].message.content)
   

2. Run the Python file.

   python multi-turn.py
   

1. Create the multi-turn.py file with the following code:

   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   client = AzureOpenAI(
       api_version="2025-01-01-preview",  
       api_key=api_key, 
       azure_endpoint=endpoint
   )
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
       encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               { "type": "text", "text": "Describe in detail the spoken audio input." }, 
               { "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   # Get the first turn's response 
   
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       modalities=["text", "audio"], 
       audio={"voice": "alloy", "format": "wav"}, 
       messages=messages
   ) 
   
   print("Get the first turn's response:")
   print(completion.choices[0].message.audio.transcript) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.choices[0].message.audio.id)
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.choices[0].message.audio.id } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   # Send the follow-up request with the accumulated messages 
   completion = client.chat.completions.create( 
       model="gpt-4o-mini-audio-preview", 
       messages=messages
   ) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.choices[0].message.content)
   

2. Run the Python file.

   python multi-turn.py
   

Learn more about keyless authentication and setting environment variables.

Learn more about finding API keys and setting environment variables.

1. Create the to-audio.py file with the following code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       {
         "role": "user",
         "content": [
           {
             "type": "text",
             "text": "Is a golden retriever a good family dog?"
           }
         ]
       }
     ]
   }
   
   # Make the audio chat completions request
   completion = requests.post(url, headers=headers, json=body)
   audio_data = completion.json()['choices'][0]['message']['audio']['data']
   
   # Write the output audio data to a file
   wav_bytes = base64.b64decode(audio_data)
   with open("dog.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Run the Python file.

   python to-audio.py
   

1. Create the to-audio.py file with the following code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       {
         "role": "user",
         "content": [
           {
             "type": "text",
             "text": "Is a golden retriever a good family dog?"
           }
         ]
       }
     ]
   }
   
   # Make the audio chat completions request
   completion = requests.post(url, headers=headers, json=body)
   audio_data = completion.json()['choices'][0]['message']['audio']['data']
   
   # Write the output audio data to a file 
   wav_bytes = base64.b64decode(audio_data)
   with open("dog.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Run the Python file.

   python to-audio.py
   

1. Create the from-audio.py file with the following code:

   import requests
   import base64
   import os
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }, 
     ]
   }
   
   completion = requests.post(url, headers=headers, json=body)
   
   print(completion.json()['choices'][0]['message']['audio']['transcript'])
   
   # Write the output audio data to a file
   audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
   wav_bytes = base64.b64decode(audio_data)
   with open("analysis.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Run the Python file.

   python from-audio.py
   

1. Create the from-audio.py file with the following code:

   import requests
   import base64
   import os
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }, 
     ]
   }
   
   completion = requests.post(url, headers=headers, json=body)
   
   print(completion.json()['choices'][0]['message']['audio']['transcript'])
   
   # Write the output audio data to a file
   audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
   wav_bytes = base64.b64decode(audio_data)
   with open("analysis.wav", "wb") as f: 
     f.write(wav_bytes) 
   

2. Run the Python file.

   python from-audio.py
   

1. Create the multi-turn.py file with the following code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI 
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": messages
   }
   
   # Get the first turn's response, including generated audio 
   completion = requests.post(url, headers=headers, json=body)
   
   print("Get the first turn's response:")
   print(completion.json()['choices'][0]['message']['audio']['transcript']) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.json()['choices'][0]['message']['audio']['id'])
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   body = {
     "model": "gpt-4o-mini-audio-preview",
     "messages": messages
   }
   
   # Send the follow-up request with the accumulated messages
   completion = requests.post(url, headers=headers, json=body) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.json()['choices'][0]['message']['content'])
   

2. Run the Python file.

   python multi-turn.py
   

1. Create the multi-turn.py file with the following code:

   import requests
   import base64 
   import os 
   from openai import AzureOpenAI 
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
   api_key = os.environ['AZURE_OPENAI_API_KEY']
   
   api_version = '2025-01-01-preview'
   url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   
   # Read and encode audio file  
   with open('dog.wav', 'rb') as wav_reader: 
     encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 
   
   # Initialize messages with the first turn's user input 
   messages = [
       { 
           "role": "user", 
           "content": [ 
               {  
                   "type": "text", 
                   "text": "Describe in detail the spoken audio input." 
               }, 
               { 
                   "type": "input_audio", 
                   "input_audio": { 
                       "data": encoded_string, 
                       "format": "wav" 
                   } 
               } 
           ] 
       }] 
   
   body = {
     "modalities": ["audio", "text"],
     "model": "gpt-4o-mini-audio-preview",
     "audio": {
         "format": "wav",
         "voice": "alloy"
     },
     "messages": messages
   }
   
   
   # Get the first turn's response, including generated audio 
   completion = requests.post(url, headers=headers, json=body)
   
   print("Get the first turn's response:")
   print(completion.json()['choices'][0]['message']['audio']['transcript']) 
   
   print("Add a history message referencing the first turn's audio by ID:")
   print(completion.json()['choices'][0]['message']['audio']['id'])
   
   # Add a history message referencing the first turn's audio by ID 
   messages.append({ 
       "role": "assistant", 
       "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
   }) 
   
   # Add the next turn's user message 
   messages.append({ 
       "role": "user", 
       "content": "Very briefly, summarize the favorability." 
   }) 
   
   body = {
     "model": "gpt-4o-mini-audio-preview",
     "messages": messages
   }
   
   # Send the follow-up request with the accumulated messages
   completion = requests.post(url, headers=headers, json=body) 
   
   print("Very briefly, summarize the favorability.")
   print(completion.json()['choices'][0]['message']['content'])
   

2. Run the Python file.

   python multi-turn.py