Struct Audio 

pub struct Audio { /* private fields */ }

Client for interacting with the OpenAI Audio API.

This struct provides methods for text-to-speech, transcription, and translation. Use Audio::new() to create a new instance.

Example

use openai_tools::audio::request::{Audio, TtsOptions, Voice, AudioFormat};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let audio = Audio::new()?;

    let options = TtsOptions {
        voice: Voice::Nova,
        response_format: AudioFormat::Mp3,
        ..Default::default()
    };

    let bytes = audio.text_to_speech("Welcome to our app!", options).await?;
    std::fs::write("welcome.mp3", bytes)?;

    Ok(())
}

Implementations

impl Audio

pub fn new() -> Result<Self>

Creates a new Audio client for OpenAI API.

Initializes the client by loading the OpenAI API key from the environment variable OPENAI_API_KEY. Supports .env file loading via dotenvy.

Returns

• Ok(Audio) - A new Audio client ready for use
• Err(OpenAIToolError) - If the API key is not found in the environment

Example

use openai_tools::audio::request::Audio;

let audio = Audio::new().expect("API key should be set");

pub fn with_auth(auth: AuthProvider) -> Self

Creates a new Audio client with a custom authentication provider

pub fn azure() -> Result<Self>

Creates a new Audio client for Azure OpenAI API

pub fn detect_provider() -> Result<Self>

Creates a new Audio client by auto-detecting the provider

pub fn with_url<S: Into<String>>(base_url: S, api_key: S) -> Self

Creates a new Audio client with URL-based provider detection

pub fn from_url<S: Into<String>>(url: S) -> Result<Self>

Creates a new Audio client from URL using environment variables

pub fn auth(&self) -> &AuthProvider

Returns the authentication provider

pub fn timeout(&mut self, timeout: Duration) -> &mut Self

Sets the request timeout duration.

Arguments

• timeout - The maximum time to wait for a response

Returns

A mutable reference to self for method chaining

pub async fn text_to_speech( &self, text: &str, options: TtsOptions, ) -> Result<Vec<u8>>

Converts text to speech.

Returns audio bytes in the specified format.

Arguments

• text - The text to convert to speech (max 4096 characters)
• options - TTS options (model, voice, format, speed)

Returns

• Ok(Vec<u8>) - The audio data as bytes
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::audio::request::{Audio, TtsOptions, TtsModel, Voice};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let audio = Audio::new()?;

    let options = TtsOptions {
        model: TtsModel::Tts1Hd,
        voice: Voice::Shimmer,
        speed: Some(1.2),
        ..Default::default()
    };

    let bytes = audio.text_to_speech("Hello, this is a test.", options).await?;
    std::fs::write("speech.mp3", bytes)?;

    Ok(())
}

pub async fn transcribe( &self, audio_path: &str, options: TranscribeOptions, ) -> Result<TranscriptionResponse>

Transcribes audio from a file path.

Arguments

• audio_path - Path to the audio file
• options - Transcription options

Returns

• Ok(TranscriptionResponse) - The transcription result
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::audio::request::{Audio, TranscribeOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let audio = Audio::new()?;

    let options = TranscribeOptions {
        language: Some("en".to_string()),
        ..Default::default()
    };

    let response = audio.transcribe("audio.mp3", options).await?;
    println!("Transcription: {}", response.text);

    Ok(())
}

pub async fn transcribe_bytes( &self, audio_data: &[u8], filename: &str, options: TranscribeOptions, ) -> Result<TranscriptionResponse>

Transcribes audio from bytes.

Arguments

• audio_data - The audio data as bytes
• filename - The filename with extension (e.g., “audio.mp3”)
• options - Transcription options

Returns

• Ok(TranscriptionResponse) - The transcription result
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::audio::request::{Audio, TranscribeOptions, SttModel};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let audio = Audio::new()?;

    let audio_data = std::fs::read("recording.mp3")?;
    let options = TranscribeOptions {
        model: Some(SttModel::Whisper1),
        ..Default::default()
    };

    let response = audio.transcribe_bytes(&audio_data, "recording.mp3", options).await?;
    println!("Transcription: {}", response.text);

    Ok(())
}

pub async fn translate( &self, audio_path: &str, options: TranslateOptions, ) -> Result<TranscriptionResponse>

Translates audio to English text.

Only supports translation to English using the whisper-1 model.

Arguments

• audio_path - Path to the audio file
• options - Translation options

Returns

• Ok(TranscriptionResponse) - The translation result
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::audio::request::{Audio, TranslateOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let audio = Audio::new()?;

    let options = TranslateOptions::default();
    let response = audio.translate("french_audio.mp3", options).await?;
    println!("English translation: {}", response.text);

    Ok(())
}

pub async fn translate_bytes( &self, audio_data: &[u8], filename: &str, options: TranslateOptions, ) -> Result<TranscriptionResponse>

Translates audio from bytes to English text.

Arguments

• audio_data - The audio data as bytes
• filename - The filename with extension (e.g., “audio.mp3”)
• options - Translation options

Returns

• Ok(TranscriptionResponse) - The translation result
• Err(OpenAIToolError) - If the request fails