Send email from Go with one API call.

package main

import (
    "context"
    "log"
    "time"
)

func main() {
    // NOTIX_API_KEY comes from the environment, never from source.
    // Give every send a deadline so a slow network cannot hold a handler open.
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    id, err := send(ctx) // send.go, next step
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("queued %s", id)
}

package main

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

type apiError struct {
    Error struct {
        Code    string `json:"code"`
        Message string `json:"message"`
    } `json:"error"`
}

func send(ctx context.Context) (string, error) {
    body, _ := json.Marshal(map[string]any{
        "from":    "receipts@acme.com",
        "to":      "customer@example.com",
        "subject": "Your receipt for order 4471",
        "html":    "<p>Thanks for your order.</p>",
        "text":    "Thanks for your order.",
    })

    req, err := http.NewRequestWithContext(ctx, http.MethodPost,
        "https://app.usenotix.dev/api/v1/emails", bytes.NewReader(body))
    if err != nil {
        return "", err
    }
    req.Header.Set("Authorization", "Bearer "+os.Getenv("NOTIX_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    // One key per business event, so a retry can never send twice.
    req.Header.Set("Idempotency-Key", "order-4471-receipt")

    res, err := (&http.Client{Timeout: 10 * time.Second}).Do(req)
    if err != nil {
        return "", err
    }
    defer res.Body.Close()

    if res.StatusCode >= 400 {
        var apiErr apiError
        _ = json.NewDecoder(res.Body).Decode(&apiErr)
        return "", fmt.Errorf("%s: %s", apiErr.Error.Code, apiErr.Error.Message)
    }

    var out struct {
        EmailID string `json:"emailId"`
    }
    if err := json.NewDecoder(res.Body).Decode(&out); err != nil {
        return "", err
    }
    return out.EmailID, nil
}

package main

import (
    "crypto/tls"
    "net/smtp"
    "os"
)

func sendViaRelay() error {
    host := "smtp.usenotix.dev"
    // The SMTP password is a Notix API key; the username is always "notix".
    auth := smtp.PlainAuth("", "notix", os.Getenv("NOTIX_API_KEY"), host)

    // Port 465 is implicit TLS: open the TLS connection first, then speak SMTP
    // over it. (Port 587 is STARTTLS: dial plain, call c.StartTLS, then Auth.)
    conn, err := tls.Dial("tcp", host+":465", &tls.Config{ServerName: host})
    if err != nil {
        return err
    }
    c, err := smtp.NewClient(conn, host)
    if err != nil {
        return err
    }
    defer c.Quit()

    if err := c.Auth(auth); err != nil {
        return err
    }
    if err := c.Mail("receipts@acme.com"); err != nil {
        return err
    }
    if err := c.Rcpt("customer@example.com"); err != nil {
        return err
    }
    w, err := c.Data()
    if err != nil {
        return err
    }
    msg := "From: receipts@acme.com\r\n" +
        "To: customer@example.com\r\n" +
        "Subject: Your receipt for order 4471\r\n" +
        "Content-Type: text/plain; charset=utf-8\r\n\r\n" +
        "Thanks for your order.\r\n"
    if _, err := w.Write([]byte(msg)); err != nil {
        return err
    }
    return w.Close()
}