Struct TranscriptionRequest 

pub struct TranscriptionRequest {
    pub file: PathBuf,
    pub model: String,
    pub language: Option<String>,
    pub prompt: Option<String>,
    pub response_format: Option<AudioResponseFormat>,
    pub temperature: Option<f32>,
    pub timestamp_granularities: Option<Vec<TimestampGranularity>>,
    pub chunking_strategy: Option<ChunkingStrategy>,
    pub include: Option<Vec<Include>>,
    pub extra_body_map: Option<Map<String, Value>>,
}

Transcribes audio into the input language.

The keywords, languages, known_speaker_names, and known_speaker_references parameters are not covered by this type yet.

Fields

file: PathBuf

The audio file (as a path) to transcribe, in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm. The request must include enough format metadata for the file to be identified; an extension-bearing filename satisfies this.

model: String

ID of the model to use. The options are gpt-transcribe, gpt-4o-transcribe, gpt-4o-mini-transcribe, whisper-1 (which is powered by the open source Whisper V2 model), and gpt-4o-transcribe-diarize.

language: Option<String>

The language of the input audio. Supplying the input language in ISO-639-1 (e.g. en) format will improve accuracy and latency.

prompt: Option<String>

An optional text to guide the model’s style or continue a previous audio segment. The prompt should match the audio language.

response_format: Option<AudioResponseFormat>

The format of the output, in one of these options: json, text, srt, verbose_json, or vtt. For gpt-4o-transcribe and gpt-4o-mini-transcribe, the only supported format is json.

With json / verbose_json, use get_response; with text / srt / vtt, use get_response_string.

temperature: Option<f32>

The sampling temperature, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.

timestamp_granularities: Option<Vec<TimestampGranularity>>

The timestamp granularities to populate for this transcription. response_format must be set to verbose_json to use timestamp granularities. Either or both of these options are supported: word, or segment.

chunking_strategy: Option<ChunkingStrategy>

Controls how the audio is cut into chunks.

When set to auto, the server first normalizes loudness and then uses voice activity detection (VAD) to choose boundaries. A server_vad object can be provided to tweak VAD detection parameters manually. If unset, the audio is transcribed as a single block.

include: Option<Vec<Include>>

Additional information to include in the transcription response. logprobs will return the log probabilities of the tokens in the response.

extra_body_map: Option<Map<String, Value>>

Additional JSON properties, sent as extra multipart text fields (strings verbatim, other JSON values serialized).

Trait Implementations

impl Clone for TranscriptionRequest

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TranscriptionRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TranscriptionRequest

fn default() -> Self

Returns the “default value” for a type.

impl Post for TranscriptionRequest

fn build_url(&self, base_url: &str) -> Result<String, OapiError>

Builds the URL for the request.

base_url should be like https://api.openai.com/v1

fn is_streaming(&self) -> bool

impl PostNoStream for TranscriptionRequest

async fn get_response_string( &self, client: &Client, base_url: &str, options: &RequestOptions, ) -> Result<String, OapiError>

Sends a transcription POST request using multipart/form-data format, following the field layout of the official SDK.

type Response = TranscriptionResponse

fn get_response( &self, client: &Client, url: &str, options: &RequestOptions, ) -> impl Future<Output = Result<Self::Response, OapiError>> + Send + Sync

Sends a POST request and deserializes the response.

impl Serialize for TranscriptionRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.