Go (Golang) WhatsApp API Integration

Why Zaptilo with Go?

• Idiomatic Go — no third-party wrapper required, just net/http
• Pay-as-you-go INR pricing — from ₹0.04 / message at volume
• No monthly subscription, no per-server fee
• Worker-pool friendly — scale to thousands of concurrent sends with goroutines
• Works with Cloud Run, Lambda, GKE, Fly.io, Railway — anywhere Go runs
• India-based support, GST-compliant invoicing

Step 1: Create a Zaptilo client

package zaptilo

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type Client struct {
    Token   string
    BaseURL string
    HTTP    *http.Client
}

func NewClient(token string) *Client {
    return &Client{
        Token:   token,
        BaseURL: "https://web.zaptilo.ai",
        HTTP:    &http.Client{Timeout: 15 * time.Second},
    }
}

type templatePayload struct {
    Phone    string                 `json:"phone"`
    Template map[string]interface{} `json:"template"`
}

// SendTemplate posts a template message to the user.
func (c *Client) SendTemplate(phone, name, lang string, bodyValues []string) error {
    params := make([]map[string]string, len(bodyValues))
    for i, v := range bodyValues {
        params[i] = map[string]string{"type": "text", "text": v}
    }

    payload := templatePayload{
        Phone: phone,
        Template: map[string]interface{}{
            "name":     name,
            "language": map[string]string{"code": lang},
            "components": []map[string]interface{}{
                {"type": "body", "parameters": params},
            },
        },
    }

    body, err := json.Marshal(payload)
    if err != nil {
        return err
    }

    req, err := http.NewRequest("POST", c.BaseURL+"/api/send/template", bytes.NewBuffer(body))
    if err != nil {
        return err
    }
    req.Header.Set("Authorization", "Bearer "+c.Token)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.HTTP.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode >= 300 {
        return fmt.Errorf("zaptilo: %s", resp.Status)
    }
    return nil
}

Step 2: Send from a Gin handler

package main

import (
    "log"
    "os"

    "github.com/gin-gonic/gin"
    "myapp/zaptilo"
)

func main() {
    wa := zaptilo.NewClient(os.Getenv("ZAPTILO_API_TOKEN"))
    r := gin.Default()

    r.POST("/order-placed", func(c *gin.Context) {
        var body struct {
            Phone   string `json:"phone"`
            Name    string `json:"name"`
            OrderID string `json:"order_id"`
        }
        if err := c.BindJSON(&body); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }

        if err := wa.SendTemplate(
            "91"+body.Phone,
            "order_confirmation", "en",
            []string{body.Name, body.OrderID},
        ); err != nil {
            log.Println("zaptilo:", err)
        }
        c.JSON(200, gin.H{"ok": true})
    })

    r.Run(":8080")
}

Same pattern works with Echo (e.POST), Fiber (app.Post), or stdlib http.HandleFunc.

Step 3: Worker pool for bulk sends

// Bulk send with a worker pool — useful for OTPs / campaigns.
type Job struct {
    Phone, Template, Lang string
    Values                []string
}

func worker(id int, jobs <-chan Job, wa *zaptilo.Client) {
    for j := range jobs {
        if err := wa.SendTemplate(j.Phone, j.Template, j.Lang, j.Values); err != nil {
            log.Printf("worker %d: %v", id, err)
        }
    }
}

func main() {
    wa := zaptilo.NewClient(os.Getenv("ZAPTILO_API_TOKEN"))
    jobs := make(chan Job, 1000)

    for w := 1; w <= 50; w++ {
        go worker(w, jobs, wa)
    }

    // ... feed jobs from your queue / DB / message broker
}

Use cases for Indian Go teams

Frequently asked questions