Go

export SECURESSMTP_API_KEY="qcs_live_..."

// securessmtp/securessmtp.go
package securessmtp

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

const apiURL = "https://securessmtp.com/api/v1/mail/send"

type From struct {
	Name string `json:"name,omitempty"`
}

type Attachment struct {
	Filename    string `json:"filename"`
	Content     string `json:"content"` // base64
	ContentType string `json:"content_type,omitempty"`
}

type Message struct {
	To          []string     `json:"to"`
	Subject     string       `json:"subject"`
	HTML        string       `json:"html,omitempty"`
	Text        string       `json:"text,omitempty"`
	Cc          []string     `json:"cc,omitempty"`
	Bcc         []string     `json:"bcc,omitempty"`
	ReplyTo     string       `json:"reply_to,omitempty"`
	From        *From        `json:"from,omitempty"`
	Attachments []Attachment `json:"attachments,omitempty"`
}

type Result struct {
	OK        bool   `json:"ok"`
	Sent      bool   `json:"sent"`
	Held      bool   `json:"held"`
	Mode      string `json:"mode"`
	MessageID string `json:"message_id"`
	Reason    string `json:"reason"`
	Error     string `json:"error"`
}

// Error is returned when the API answers with "ok": false.
type Error struct {
	Status int    // HTTP status
	Reason string // e.g. rate_limited, over_quota, invalid_payload
	Detail string // the "error" field, set for send_failed
}

func (e *Error) Error() string {
	return fmt.Sprintf("securessmtp: %s (HTTP %d) %s", e.Reason, e.Status, e.Detail)
}

var client = &http.Client{Timeout: 30 * time.Second}

func Send(ctx context.Context, msg Message) (*Result, error) {
	body, err := json.Marshal(msg)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	req.Header.Set("x-securessmtp-api-key", os.Getenv("SECURESSMTP_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := client.Do(req)
	if err != nil {
		return nil, err // network error or timeout
	}
	defer res.Body.Close()

	var result Result
	if err := json.NewDecoder(res.Body).Decode(&result); err != nil {
		return nil, fmt.Errorf("securessmtp: HTTP %d, body is not JSON: %w", res.StatusCode, err)
	}
	if !result.OK {
		reason := result.Reason
		if reason == "" {
			reason = result.Error
		}
		return nil, &Error{Status: res.StatusCode, Reason: reason, Detail: result.Error}
	}
	return &result, nil
}

package main

import (
	"context"
	"errors"
	"log"

	"example.com/yourapp/securessmtp"
)

func main() {
	res, err := securessmtp.Send(context.Background(), securessmtp.Message{
		To:      []string{"[email protected]"},
		Subject: "Your order has shipped",
		HTML:    "<p>Your order is on its way.</p>",
		Text:    "Your order is on its way.",
		From:    &securessmtp.From{Name: "Acme Store"},
		ReplyTo: "[email protected]",
	})

	var apiErr *securessmtp.Error
	switch {
	case errors.As(err, &apiErr) && apiErr.Reason == "rate_limited":
		log.Println("rate limited: wait a minute, then retry")
	case errors.As(err, &apiErr):
		log.Printf("not sent: %v", apiErr)
	case err != nil:
		log.Printf("request failed (the email may or may not have been sent): %v", err)
	default:
		log.Println("sent:", res.MessageID)
	}
}

pdf, err := os.ReadFile("invoice-1042.pdf")
if err != nil {
	log.Fatal(err)
}

_, err = securessmtp.Send(context.Background(), securessmtp.Message{
	To:      []string{"[email protected]"},
	Subject: "Invoice 1042",
	Text:    "Your invoice is attached.",
	Attachments: []securessmtp.Attachment{{
		Filename:    "invoice-1042.pdf",
		Content:     base64.StdEncoding.EncodeToString(pdf),
		ContentType: "application/pdf",
	}},
})

package main

import (
	"errors"
	"log"
	"net/smtp"
	"net/textproto"
	"os"
	"strings"
	"time"
)

func main() {
	host := "smtp.securessmtp.com"
	auth := smtp.PlainAuth("", "securessmtp", os.Getenv("SECURESSMTP_API_KEY"), host)

	msg := strings.Join([]string{
		"From: Acme Store <[email protected]>",
		"To: [email protected]",
		"Subject: Your order has shipped",
		"Date: " + time.Now().Format(time.RFC1123Z),
		"MIME-Version: 1.0",
		"Content-Type: text/plain; charset=UTF-8",
		"",
		"Your order is on its way.",
	}, "\r\n")

	// SendMail upgrades the connection with STARTTLS before it logs in.
	err := smtp.SendMail(host+":587", auth, "[email protected]",
		[]string{"[email protected]"}, []byte(msg))

	var tpErr *textproto.Error
	if errors.As(err, &tpErr) {
		log.Fatalf("rejected: %d %s", tpErr.Code, tpErr.Msg) // e.g. 450, 535, 550
	} else if err != nil {
		log.Fatal(err)
	}
}