Step by Step Guide to Building an EZ Texting API Integration in Go

Aug 18, 2024 • 6 minute read

Introduction

Hey there, fellow Go enthusiast! Ready to add some texting magic to your Go application? Let's dive into integrating the EZ Texting API. This nifty tool will let you send SMS messages programmatically, opening up a world of possibilities for your projects.

Prerequisites

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

Go installed on your machine (I know you probably do, but just checking!)
An EZ Texting account with API credentials (if you don't have one, go grab it real quick)

Setting up the project

Let's get our hands dirty:

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

Now, let's grab the HTTP client we'll need:

go get -u github.com/go-resty/resty/v2

Authentication

EZ Texting uses API key authentication. Let's set that up:

package main

import (
    "github.com/go-resty/resty/v2"
)

const (
    baseURL = "https://api.eztexting.com/v1"
    apiKey  = "your-api-key-here"
)

func main() {
    client := resty.New()
    client.SetHeader("Content-Type", "application/json")
    client.SetHeader("Authorization", "Bearer "+apiKey)
}

Making API requests

Now that we've got our client set up, let's create a function to send an SMS:

func sendSMS(client *resty.Client, phoneNumber, message string) error {
    resp, err := client.R().
        SetBody(map[string]interface{}{
            "PhoneNumbers": []string{phoneNumber},
            "Message":      message,
        }).
        Post(baseURL + "/sms")

    if err != nil {
        return err
    }

    if resp.IsError() {
        return fmt.Errorf("API error: %s", resp.String())
    }

    fmt.Println("Message sent successfully!")
    return nil
}

Retrieving message status

Let's add a function to check the status of a sent message:

func getMessageStatus(client *resty.Client, messageID string) (string, error) {
    resp, err := client.R().
        Get(baseURL + "/sms/" + messageID)

    if err != nil {
        return "", err
    }

    if resp.IsError() {
        return "", fmt.Errorf("API error: %s", resp.String())
    }

    // Parse the JSON response and extract the status
    // This is a simplified example, you'll need to parse the actual response
    return "Delivered", nil
}

Error handling

Go's error handling is straightforward. We're already returning errors from our functions, but let's use them in our main():

func main() {
    // ... client setup code ...

    err := sendSMS(client, "+1234567890", "Hello from Go!")
    if err != nil {
        log.Fatalf("Failed to send SMS: %v", err)
    }

    status, err := getMessageStatus(client, "message-id-here")
    if err != nil {
        log.Fatalf("Failed to get message status: %v", err)
    }
    fmt.Printf("Message status: %s\n", status)
}

Testing the integration

I won't write out full tests here, but you should definitely add some! Use Go's testing package to write unit tests for your functions, and consider using a mocking library to simulate API responses for thorough testing.

Best practices

Rate limiting: Respect EZ Texting's rate limits. Implement exponential backoff for retries.
Logging: Log all API interactions for debugging and monitoring.
Security: Never hardcode your API key. Use environment variables or a secure configuration management system.

Conclusion

And there you have it! You've just built a solid foundation for integrating EZ Texting into your Go application. Remember, this is just the beginning. You can expand on this to handle bulk messages, schedule texts, or even integrate with other parts of your application.

Keep coding, keep learning, and most importantly, have fun with it!

Resources

Now go forth and text with the power of Go! 🚀