Live Streaming Audio Transcription

Live Transcription Parameters

The input parameters for Live/Streaming transcription consist of two parts:

• What options do you want to transcribe the live audio stream
• Obtaining notifications for transcription events

Options are provided via the LiveTranscriptionOptions struct to be provided in the NewWebSocket function. Each of these parameters maps to a feature in the Deepgram API. Reference the features documentation to learn the appropriate features for your request.

The Callback Interface defines what you want to do with the transcription as it happens in real-time. You can receive notifications of two events: Message/Transcriptions and Metadata.

Initiating a Connection

Creating a Live Client can be done by using the following code:

1
// options
2
transcriptOptions := interfaces.LiveTranscriptionOptions{
3
	Language:    "en-US",
4
	Punctuate:   true,
5
	Encoding:    "linear16",
6
	Channels:    1,
7
	Sample_rate: 16000,
8
}
9
10
// create a callback for transcription messages
11
// for example, you can take a look at this example project:
12
// https://github.com/deepgram/deepgram-go-sdk/blob/main/examples/streaming/microphone/main.go
13
14
// create the client
15
dgClient, err := client.NewWebSocketWithDefaults(ctx, transcriptOptions, callback)
16
if err != nil {
17
	log.Println("ERROR creating LiveTranscription connection:", err)
18
	return
19
}
20
21
// call connect!
22
bConencted := dgClient.Connect()
23
if !bConencted {
24
	log.Println("Client.Connect failed")
25
	os.Exit(1)
26
}

Define Options for the Client

ClientOptions defines any options for the client. When creating a new Deepgram LiveTranscription client, pass in the optional config options.

A common config option would be to enable the KeepAlive option with EnableKeepAlive:

1
ctx := context.Background()
2
	apiKey := "DEEPGRAM_API_KEY"
3
	clientOptions := interfaces.ClientOptions{
4
		EnableKeepAlive: true, // Enable KeepAlive option
5
	}
6
7
	transcriptOptions := interfaces.LiveTranscriptionOptions{
8
		Language:    "en-US",
9
		Model:       "nova-3",
10
		SmartFormat: true,
11
	}
12
13
	// Implement your own callback
14
	callback := MyCallback{}
15
16
	// Create a new Deepgram LiveTranscription client with config options
17
	dgClient, err := client.NewWebSocket(ctx, apiKey, clientOptions, transcriptOptions, callback)
18
	if err != nil {
19
		fmt.Println("ERROR creating LiveTranscription connection:", err)
20
		return
21
	}

Events

The live transcription client fires the following events:

Implementing an Event Callback Listener

To receive transcription events, the LiveMessageCallback interface needs to be implemented as defined below:

1
// LiveMessageCallback is a callback used to receive notifcations for platforms messages
2
type LiveMessageCallback interface {
3
	Open(or *OpenResponse) error
4
	Message(mr *MessageResponse) error
5
	Metadata(md *MetadataResponse) error
6
	SpeechStarted(ssr *SpeechStartedResponse) error
7
	UtteranceEnd(ur *UtteranceEndResponse) error
8
	Close(cr *CloseResponse) error
9
	Error(er *ErrorResponse) error
10
	UnhandledEvent(byData []byte) error
11
}

Sending Data/Streams

Go is a very stream-oriented language. Many helpful interfaces are provided natively and, if utilized correctly, dramatically simplify the implementation of your client. The Live Client implements the io.Writer interface, which means one can read data from your audio source and push it into the Deepgram Client.

What this ends up looking like on the client side is:

1
	go func() {
2
		// this is a blocking call
3
		mic.Stream(dgClient)
4
	}()

Closing the Connection

When finished with the Live stream, you can safely close the stream by calling the following function on the client.

1
deepgramLive.finish();

Where To Find Additional Examples

The repository has a good collection of live audio transcription examples. You can find links to them in the README attempts to provide different options for trancribing. Each example below will attempt to provide different options on how you might transcribe a live-streaming source.

• From a Microphone - examples/streaming/microphone
• From a HTTP Endpoint - examples/streaming/http