Making Your First Whisper API Request in Go

Welcome back! In the previous lesson, we set up a Go development environment, initialized a Go module, and managed dependencies to interact with the OpenAI API. Today, we're diving into making your first API request using Whisper, which is essential for building a transcription system. This lesson builds on your understanding of Go module setup and dependency management, and now we'll focus on interacting with APIs.

You'll learn how to send audio data to the Whisper API and receive a transcription in return, whether the audio is stored locally or available remotely.

The Whisper API from OpenAI is designed to handle audio transcription. The core idea is to send audio data to the API, which then returns transcribed text. This process begins with a valid API key that authenticates your requests. The API interprets byte-stream data from audio files, transcribing what's spoken into text with varying levels of detail depending on its configuration.

While Whisper handles diverse audio inputs, it primarily focuses on capturing spoken content and might skip nonverbal sounds while ensuring the output is human-readable. The result is a JSON object containing the transcribed text and, sometimes, details like the duration of the audio.

Let's walk through a simple example demonstrating how to make your first transcription request using the Whisper API in Go, this time using the official OpenAI Go SDK. We'll break the code into smaller parts and explain each step.

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
)

Explanation:
We import the necessary packages, including the official OpenAI Go SDK. The main function will call our Transcribe function, which will handle the transcription logic.

// Transcribe an audio file using OpenAI's Whisper API
func Transcribe(filePath string) (string, error) {
    // Read OpenAI credentials from environment variables
    apiKey := os.Getenv("OPENAI_API_KEY")
    baseURL := os.Getenv("OPENAI_BASE_URL") // Optional, can be left empty for default

    // Create an OpenAI client using the provided API key and base URL
    client := openai.NewClient(
        option.WithAPIKey(apiKey),
        option.WithBaseURL(baseURL),
    )

Explanation:
We read the OpenAI API key (and optionally a custom base URL) from environment variables. Then, we create an OpenAI client using these credentials. This client will be used to make requests to the API.

    // Open the audio file you want to transcribe
    file, err := os.Open(filePath)
    if err != nil {
        return "", fmt.Errorf("failed to open audio file: %v", err)
    }
    defer file.Close()

Explanation:
We open the audio file that we want to transcribe. If the file can't be opened, we return an error. The defer file.Close() statement ensures the file is closed when we're done.

    // Call the Whisper transcription endpoint
    resp, err := client.Audio.Transcriptions.New(
        context.Background(),
        openai.AudioTranscriptionNewParams{
            File:  file,
            Model: "whisper-1",
        },
    )
    if err != nil {
        return "", fmt.Errorf("transcription failed: %v", err)
    }

    return resp.Text, nil
}

Explanation:
We use the OpenAI client to call the Whisper transcription endpoint. We pass in the audio file and specify the model (whisper-1). If the API call fails, we return an error. Otherwise, we return the transcribed text.

func main() {
    // Example usage of the Transcribe function
    transcription, err := Transcribe("resources/sample_audio.mp3")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Println("Transcription:", transcription)
}

Explanation:
The main function demonstrates how to use the Transcribe function to transcribe an audio file and print the result.

In many real-world scenarios, you'll need to transcribe audio files that are hosted remotely rather than stored locally. This requires downloading the audio data first, then creating a compatible reader for the API.

When working with remote audio files, you need to download the content first:

import (
    "bytes"
    "io"
    "net/http"
    // ... other imports
)

func downloadAudio(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("failed to download audio: %v", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
    }

    audioBytes, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read audio content: %v", err)
    }
    return audioBytes, nil
}

The Whisper API requires a file-like object with a name. When working with downloaded bytes, you need to create a custom reader:

type NamedReader struct {
    *bytes.Reader
    name string
}

func (nr *NamedReader) Name() string { return nr.name }

This NamedReader wraps a bytes.Reader and provides the Name() method that the API expects, allowing you to specify a filename for the audio data.

Combining these concepts, you can transcribe remote audio files:

func transcribeRemote(url string) (string, error) {
    audioBytes, err := downloadAudio(url)
    if err != nil {
        return "", err
    }

    client := openai.NewClient(
        option.WithAPIKey(os.Getenv("OPENAI_API_KEY")),
        option.WithBaseURL(os.Getenv("OPENAI_BASE_URL")),
    )

    resp, err := client.Audio.Transcriptions.New(
        context.Background(),
        openai.AudioTranscriptionNewParams{
            File:  &NamedReader{bytes.NewReader(audioBytes), "audio.mp3"},
            Model: "whisper-1",
        },
    )
    if err != nil {
        return "", fmt.Errorf("transcription failed: %v", err)
    }

    return resp.Text, nil
}

This approach allows you to transcribe audio files from any accessible URL, making your application more flexible for handling various audio sources.

Now that you know how to make an API request to OpenAI using Go with both local and remote audio files, let's try some practice! Onward and upward!