I am happy to announce that we have released v0.1.0 of the Symbl.ai Go SDK to the community for an initial evaluation! This marks an interesting turn in how developers and users of the Symbl.ai platform can interact with the APIs to derive all their conversation insights.

The initial release has a significant amount of the API implemented, but still has some work left to round out all of the functionality the Symbl platform offers. Because this is an initial release, I would very much call this release a beta. Much of the functionality is useful to enable developers to hit the ground running, but I would only use this API in non-production workloads in an evaluation mode until we get more insights from the community and harden the SDK to be more robust.

This blog post will cover the Async APIs that are available in the SDK and will highlight some of the important functionality provided. Even though the Streaming API portion of the SDK is implemented in the v0.1.0 release, I didn’t think it would make sense to cram both topics into a single blog post. You can expect to see a second blog post that will cover the streaming portion of the SDK shortly.

Why a Go SDK?

The first question you might ask yourself is why create a Go SDK for the Symbl.ai platform? The majority of the SDKs available target web or mobile platform integrations, which are traditionally used to process conversations on the client side.

While a Python SDK exists to help non-client side conversations, providing a Go binding enables several important use cases:

  • Edge Devices: Suitable for memory-constrained platforms.
  • Headless Devices: Ideal for devices without a Graphical User Interface.
  • Backend Servers: For processing conversations on a backend server-type component that can scale out in an enterprise application.

This SDK ultimately aims to solve the challenge of taking our conversations that are happening on CPaaS platforms (Zoom, Google Meet, etc.) in isolation and aggregating them to unlock more contextual understanding for an ecosystem as a whole.

What do I mean by “in isolation?” If you think about how we add capabilities to understand conversations, we always look at these conversations in discrete, isolated instances or buckets; think of a single Zoom meeting, a tech support call between a customer and support, and the like.

When we start to unlock the context of conversations and break down those walls so that we can make associations between the context in one Zoom meeting with the context in a Google Meet or even a customer support call, that is when you are going to see real mind-blowing advancements.

A demonstration of this style of enterprise application will be coming in the near future. Until then, let’s take a look at the Go SDK’s Async API.

Let’s Dive Into the Async API

Contained within the repo, there are several examples which include posting a file to the Symbl.ai platform, referencing a URL to feed in, managing trackers, etc. Let’s look at the basics of obtaining Topics from posting an audio file to the Symbl.ai platform.

The first thing you need to do before calling any Symbl.ai API is to login to the platform. If you don’t have a free Symbl.ai account, you can sign up here (again, for free) without having to provide a credit card.

Next, you must add your APP_ID and APP_SECRET to your environment variables. We use environment variables since they are easy to configure, support PaaS style deployments, and work very well in containerized environments such as Docker and Kubernetes.


Then, log into the platform and take the restClient object and effectively cast or transform the client into an asyncClient that can access the async APIs.

ctx := context.Background()
restClient, err := symbl.NewRestClient(ctx)
if err == nil {
} else {
   fmt.Printf("New failed. Err: %v\n", err)
asyncClient := async.New(restClient)

The next thing we want to do is POST the .mp3 file to the Symbl platform and wait for the platform to process the audio file.

completed, err := asyncClient.WaitForJobComplete(ctx, interfaces.WaitForJobStatusOpts{JobId: jobConvo.JobID})
if err != nil {
   fmt.Printf("WaitForJobComplete failed. Err: %v\n", err)
if !completed {
   fmt.Printf("WaitForJobComplete failed to complete. Use larger timeout\n")

Finally, to obtain insights about Topics contained within the audio file, you can simply call GetTopics.

topicsResult, err := asyncClient.GetTopics(ctx, jobConvo.ConversationID)
if err != nil {
   fmt.Printf("Topics failed. Err: %v\n", err)

If you are interested in action items, questions, or another Async API call, you simply need to swap out the last GetTopics call with another call in the SDK. Pretty simple!

In the asynchronous processing capabilities of the Symbl.ai Go SDK, it’s essential to highlight how developers can leverage Symbl.ai’s Call Score and Insights UI to transform raw conversation data into actionable intelligence. Powered by generative AI, the Call Score API quantitatively assesses the quality of conversations across multiple metrics such as communication & engagement and question handling, providing a numerical score for each and enabling targeted coaching. Along with this, the Insights UI offers a pre-configured interface that presents conversation insights such as call summaries, sentiments, scores, next steps, objections, and questions and answers, making it easy to quickly scan and comprehend outcomes of conversations. With the Insights UI, there’s no need for developers to create their own presentation layers for showcasing these insights.

What’s Next?

Part 2 in this series will cover the Streaming API, how to use WebSockets in this Go SDK in an easy-to-consume way, how to use some helper libraries to build local applications in a snap, and more importantly, discuss why real-time streaming in this Go SDK is revolutionary.

Until then, check out the Symbl-Go-SDK, provide feedback, file issues that you encounter when using the SDK, and take this SDK and apply them to these new and interesting use cases that are now unlocked.

David vonThenen
David vonThenen
Developer Advocate

David is a self-described Tech geek and Developer Advocate enabling others to process communications to derive conversation intelligence. David talks Kubernetes/containers, VMware virtualization, backup recovery/replication solutions, adaptors in hardware storage connectivity, and everything else that is tech!