mailgun-go

To securely handle webhooks, set a signing key using mg.SetWebhookSigningKey(key). When a request arrives, decode the mtypes.WebhookPayload, verify the signature using mg.VerifyWebhookSignature(payload.Signature), and then parse the event data using events.ParseEvent(payload.EventData).

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"

	"github.com/mailgun/mailgun-go/v5"
	"github.com/mailgun/mailgun-go/v5/events"
	"github.com/mailgun/mailgun-go/v5/mtypes"
)

func main() {
	mg := mailgun.NewMailgun("MAILGUN_API_KEY")
	mg.SetWebhookSigningKey("WEBHOOK_SIGNING_KEY")

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		var payload mtypes.WebhookPayload
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			fmt.Printf("decode JSON error: %s", err)
			w.WriteHeader(http.StatusNotAcceptable)
			return
		}

		verified, err := mg.VerifyWebhookSignature(payload.Signature)
		if err != nil {
			fmt.Printf("verify error: %s\n", err)
			w.WriteHeader(http.StatusNotAcceptable)
			return
		}

		if !verified {
			w.WriteHeader(http.StatusNotAcceptable)
			fmt.Printf("failed verification %+v\n", payload.Signature)
			return
		}

		fmt.Printf("Verified Signature\n")

		e, err := events.ParseEvent(payload.EventData)
		if err != nil {
			fmt.Printf("parse event error: %s\n", err)
			return
		}

		switch event := e.(type) {
		case *events.Accepted:
			fmt.Printf("Accepted: auth: %t\n", event.Flags.IsAuthenticated)
		case *events.Delivered:
			fmt.Printf("Delivered transport: %s\n", event.Envelope.Transport)
		}
	})

	fmt.Println("Serve on :9090...")
	if err := http.ListenAndServe(":9090", nil); err != nil {
		fmt.Printf("serve error: %s\n", err)
		os.Exit(1)
	}
}

Templates allow you to manage layouts on the Mailgun server and populate variables at send-time. Use message.SetTemplate(templateName) and message.AddTemplateVariable(key, value) to inject data into the template. The variables are sent as a JSON stringified X-Mailgun-Variables header.

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/mailgun/mailgun-go/v5"
)

var yourDomain = "your-domain-name"
var apiKey = "MAILGUN_API_KEY"

func main() {
	mg := mailgun.NewMailgun(apiKey)

	sender := "sender@example.com"
	subject := "Fancy subject!"
	body := ""
	recipient := "recipient@example.com"

	message := mailgun.NewMessage(yourDomain, sender, subject, body, recipient)
	message.SetTemplate("passwordReset")
	err := message.AddTemplateVariable("passwordResetLink", "some link to your site unique to your user")
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
	defer cancel()

	resp, err := mg.Send(ctx, message)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("ID: %s Resp: %s\n", resp.ID, resp.Message)
}

To retrieve and navigate through multiple pages of mailing lists, use ListMailingLists. This returns a *ListsIterator which allows for paginated traversal.

Iteration Methods

• First(ctx, *[]mtypes.MailingList) bool: Retrieves the first page of items.
• Next(ctx, *[]mtypes.MailingList) bool: Retrieves the next page of items. Returns false when no more pages exist or an error occurs.
• Previous(ctx, *[]mtypes.MailingList) bool: Retrieves the previous page of items.
• Last(ctx, *[]mtypes.MailingList) bool: Retrieves the last page of items. (Must call First or Next before calling Last).
• Err() error: Returns any error encountered during iteration.

iterator := mg.ListMailingLists(&mailgun.ListOptions{Limit: 10})

// Start with the first page
var items []mtypes.MailingList
if iterator.First(ctx, &items) {
    fmt.Println("First page items:", items)
}

// Iterate through subsequent pages
for iterator.Next(ctx, &items) {
    fmt.Println("Next page items:", items)
}

if err := iterator.Err(); err != nil {
    log.Fatal(err)
}

To retrieve a list of subaccounts, use ListSubaccounts. This returns a SubaccountsIterator which allows for paginated traversal of your subaccounts.

Configuration

Pass a *ListSubaccountsOptions to control the results:

• Limit: Number of items per page (defaults to 10 if 0).
• Skip: Number of items to skip.
• SortArray: Field to sort by.
• Enabled: Filter by enabled status.

Iteration Methods

• First(ctx, *[]mtypes.Subaccount) bool: Retrieves the first page. Returns false on error.
• Next(ctx, *[]mtypes.Subaccount) bool: Retrieves the next page. Returns false when no more pages exist or an error occurs.
• Last(ctx, *[]mtypes.Subaccount) bool: Retrieves the last page. Note: Must be called after First() or Next().
• Previous(ctx, *[]mtypes.Subaccount) bool: Retrieves the previous page.
• Err() error: Returns any error encountered during iteration.
• Offset() int: Returns the current offset of the iterator.

opts := &mailgun.ListSubaccountsOptions{
    Limit: 20,
    Enabled: true,
}
iterator := mg.ListSubaccounts(opts)

var subaccounts []mtypes.Subaccount
for iterator.Next(ctx, &subaccounts) {
    // Process subaccounts page by page
    fmt.Println(subaccounts)
}

if err := iterator.Err(); err != nil {
    // Handle iteration error
}