Step by Step Guide to Building a Sendinblue API Integration in Go

Aug 9, 2024 • 7 minute read

Hey there, fellow Go developer! Ready to supercharge your email marketing game? Let's dive into building a Sendinblue API integration that'll make your life easier and your emails more powerful.

Introduction

Sendinblue's API is a beast when it comes to email marketing, and we're about to tame it with Go. We'll cover everything from sending transactional emails to managing contact lists and campaigns. Buckle up!

Prerequisites

Before we jump in, make sure you've got:

Go installed (you're a Go dev, so I'm sure you're covered)
A Sendinblue account with an API key (if not, hop over to their site and grab one)

Setting Up the Project

Let's get our hands dirty:

mkdir sendinblue-integration
cd sendinblue-integration
go mod init sendinblue-integration

Now, let's grab the Sendinblue Go library:

go get github.com/sendinblue/APIv3-go-library

Authenticating with the Sendinblue API

Time to make friends with the API:

import (
    "github.com/sendinblue/APIv3-go-library/lib"
)

func main() {
    cfg := lib.NewConfiguration()
    cfg.AddDefaultHeader("api-key", "YOUR_API_KEY")
    client := lib.NewAPIClient(cfg)
}

Replace YOUR_API_KEY with your actual API key. Keep it secret, keep it safe!

Implementing Core Functionalities

Sending Transactional Emails

Let's fire off an email:

emailCampaign := lib.CreateSmtpEmail{
    To:       []map[string]string{{"email": "[email protected]"}},
    Subject:  "Hello from Go!",
    HtmlContent: "<html><body><h1>This is my first transactional email</h1></body></html>",
    Sender:   &lib.SendSmtpEmailSender{Name: "John Doe", Email: "[email protected]"},
}

result, _, err := client.TransactionalEmailsApi.SendTransacEmail(context.Background(), emailCampaign)
if err != nil {
    fmt.Println("Error when calling TransactionalEmailsApi.SendTransacEmail:", err)
    return
}
fmt.Printf("Email sent successfully. Message ID: %s\n", result.MessageId)

Managing Contact Lists

Add a new contact to a list:

createContact := lib.CreateContact{
    Email:      "[email protected]",
    Attributes: map[string]interface{}{"FIRSTNAME": "John", "LASTNAME": "Doe"},
    ListIds:    []int64{2, 4},
}

result, _, err := client.ContactsApi.CreateContact(context.Background(), createContact)
if err != nil {
    fmt.Println("Error when calling ContactsApi.CreateContact:", err)
    return
}
fmt.Printf("Contact created successfully. ID: %s\n", result.Id)

Creating and Sending Campaigns

Let's create a campaign and send it:

campaign := lib.CreateEmailCampaign{
    Name: "My Go Campaign",
    Subject: "Check out our Go integration!",
    Sender: lib.CreateEmailCampaignSender{Name: "John Doe", Email: "[email protected]"},
    Type: "classic",
    HtmlContent: "<html><body><h1>Hello from Go!</h1></body></html>",
    Recipients: lib.CreateEmailCampaignRecipients{ListIds: []int64{2, 4}},
}

result, _, err := client.EmailCampaignsApi.CreateEmailCampaign(context.Background(), campaign)
if err != nil {
    fmt.Println("Error when calling EmailCampaignsApi.CreateEmailCampaign:", err)
    return
}
fmt.Printf("Campaign created successfully. ID: %d\n", result.Id)

// Send the campaign
_, _, err = client.EmailCampaignsApi.SendEmailCampaignNow(context.Background(), result.Id)
if err != nil {
    fmt.Println("Error when calling EmailCampaignsApi.SendEmailCampaignNow:", err)
    return
}
fmt.Println("Campaign sent successfully!")

Error Handling and Best Practices

Always check for errors and handle them gracefully. Respect rate limits by implementing exponential backoff:

func exponentialBackoff(attempt int) time.Duration {
    return time.Duration((1 << uint(attempt)) * 100 * int(time.Millisecond))
}

// Use this in your API calls
for attempt := 0; attempt < maxRetries; attempt++ {
    _, _, err := client.SomeApi.SomeMethod(context.Background(), params)
    if err == nil {
        break
    }
    time.Sleep(exponentialBackoff(attempt))
}

Testing the Integration

Don't forget to write tests! Here's a quick example:

func TestSendTransactionalEmail(t *testing.T) {
    // Setup your test client and mock the API response
    // ...

    result, _, err := client.TransactionalEmailsApi.SendTransacEmail(context.Background(), emailCampaign)
    assert.NoError(t, err)
    assert.NotEmpty(t, result.MessageId)
}

Optimizing Performance

For better performance, use goroutines for concurrent requests:

var wg sync.WaitGroup
for _, email := range emails {
    wg.Add(1)
    go func(e string) {
        defer wg.Done()
        // Send email
    }(email)
}
wg.Wait()

Conclusion

And there you have it! You've just built a solid Sendinblue API integration in Go. You're now equipped to send emails, manage contacts, and create campaigns like a pro. Remember, the Sendinblue API docs are your best friend for more advanced features.

Keep coding, keep sending, and may your open rates be ever in your favor!