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

Aug 18, 2024 • 6 minute read

Introduction

Hey there, fellow Go enthusiast! Ready to supercharge your email validation game? Let's dive into building a NeverBounce API integration that'll make your life easier and your email lists cleaner. We'll walk through the process step-by-step, so buckle up and let's get coding!

Prerequisites

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

Go installed on your machine (you're a Go dev, so I'm sure you've got this covered!)
A NeverBounce API key (if you don't have one, hop over to their website and grab it)

Setting up the project

Let's kick things off by creating a new Go module:

mkdir neverbounce-integration
cd neverbounce-integration
go mod init github.com/yourusername/neverbounce-integration

Now, let's install the NeverBounce Go client:

go get github.com/NeverBounce/NeverBounceApi-Go

Initializing the NeverBounce client

Time to get our hands dirty! Let's create a new file called main.go and set up our NeverBounce client:

package main

import (
    "fmt"
    "os"

    neverbounce "github.com/NeverBounce/NeverBounceApi-Go"
)

func main() {
    client := neverbounce.New(os.Getenv("NEVERBOUNCE_API_KEY"))
    
    // We'll add more code here soon!
}

Pro tip: Store your API key in an environment variable for security. No hard-coding secrets, folks!

Implementing core functionality

Single email verification

Let's add a function to verify a single email:

func verifyEmail(client *neverbounce.Client, email string) {
    result, err := client.Single.Check(email, false, false)
    if err != nil {
        fmt.Printf("Error verifying email: %v\n", err)
        return
    }
    fmt.Printf("Result for %s: %s\n", email, result.Result)
}

Bulk email verification

Now, let's tackle bulk verification:

func bulkVerify(client *neverbounce.Client, emails []string) {
    job, err := client.Jobs.Create(emails)
    if err != nil {
        fmt.Printf("Error creating job: %v\n", err)
        return
    }
    fmt.Printf("Job created with ID: %d\n", job.JobId)
}

Job status checking

Let's add a function to check the status of a bulk verification job:

func checkJobStatus(client *neverbounce.Client, jobID int) {
    status, err := client.Jobs.Status(jobID)
    if err != nil {
        fmt.Printf("Error checking job status: %v\n", err)
        return
    }
    fmt.Printf("Job %d status: %s\n", jobID, status.JobStatus)
}

Error handling and rate limiting

NeverBounce has rate limits, so let's be good citizens and handle them gracefully:

import "time"

func handleRateLimit(err error) {
    if rateLimitErr, ok := err.(*neverbounce.RateLimitError); ok {
        fmt.Printf("Rate limit exceeded. Waiting for %d seconds.\n", rateLimitErr.RetryAfter)
        time.Sleep(time.Duration(rateLimitErr.RetryAfter) * time.Second)
    }
}

Testing the integration

I won't bore you with full test code, but here's a quick example of how you might test the single email verification:

func TestVerifyEmail(t *testing.T) {
    client := neverbounce.New(os.Getenv("NEVERBOUNCE_API_KEY"))
    result, err := client.Single.Check("[email protected]", false, false)
    if err != nil {
        t.Fatalf("Error verifying email: %v", err)
    }
    if result.Result == "" {
        t.Errorf("Expected a result, got empty string")
    }
}

Best practices and optimization

To make your integration even more awesome:

Cache results to avoid unnecessary API calls
Use goroutines for parallel processing in bulk verifications
Implement exponential backoff for retries

Conclusion

And there you have it! You've just built a solid NeverBounce API integration in Go. You're now armed with the power to keep those email lists squeaky clean. Remember, clean data is happy data!

Feel free to expand on this integration, maybe add a CLI interface or integrate it into your existing projects. The sky's the limit!

Resources

Happy coding, and may your bounce rates be ever in your favor!