Concurrency-first transactional email for Go microservices & backends
Dispatch thousands of transactional emails concurrently with low latency. Native context cancellation, connection reuse, and 6,000 free sends monthly.
Drop into your application in under 60 seconds
Native typed interfaces with zero unnecessary dependencies. Built for standard fetch and modern edge runtimes.
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"time"
)
type SendEmailPayload struct {
From string `json:"from"`
To string `json:"to"`
Subject string `json:"subject"`
HTML string `json:"html"`
Tags []string `json:"tags"`
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
payload := SendEmailPayload{
From: "alerts@yourdomain.com",
To: "developer@example.com",
Subject: "Worker Deployed: Build #1042",
HTML: "<p>Your service is live on port 8080.</p>",
Tags: []string{"ci", "deploy"},
}
body, _ := json.Marshal(payload)
req, _ := http.NewRequestWithContext(ctx, "POST", "https://api.sadasend.com/emails", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SADASEND_API_KEY"))
req.Header.Set("Content-Type", "application/json")
client := &http.Client{Timeout: 5 * time.Second}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
fmt.Printf("Email dispatched! Status: %s\n", resp.Status)
}Standard Go net/http client with context timeout cancellation, zero CGO dependencies, and fast roundtrips.
Engineered for high deliverability and zero incident risk
Every layer from edge connection pooling to per-key rate limits is designed to keep critical transactional dispatches fast, reliable, and contained.
Goroutine-Safe Concurrent Dispatch
Thread-safe client architecture designed for highly concurrent Go services handling thousands of dispatches per second.
Context Timeout Cancellation
Native context.Context support ensures stalled network operations abort cleanly without leaking goroutines or memory.
Standard Library Net/SMTP Relay
Compatible with standard net/smtp library using smtp.sadasend.com on port 587 with STARTTLS encryption.
High-Throughput Keep-Alive Pools
HTTP/2 multiplexing and persistent TCP connection reuse minimize TLS handshake overhead on high-volume pipelines.
Per-Key Staging Recipient Allowlists
Lock development and test API keys to internal corporate domains to guarantee test runs never leak to customers.
RFC 8058 Automatic Headers
Automatic List-Unsubscribe headers ensure compliance with 2026 Google and Yahoo inbox delivery guidelines.
SadaSend vs net/smtp with Generic Relays
Why Go engineering teams use SadaSend rather than raw net/smtp relays.
| Feature & Capability | SadaSend | net/smtp with Generic Relays |
|---|---|---|
| HTTP REST API with Context Cancellation | Blocking socket calls | |
| DKIM and SPF Pre-Flight Verification | Fails silently if DNS wrong | |
| Per-Key Recipient Containment Allowlists | ||
| HMAC Webhook Ingestion & Delivery Feedback | Requires complex custom logs | |
| Native Port 587 ESMTP Support | ||
| Free Tier with Custom Domain | 6,000 sends forever | Trial only |
Start with 3,000 emails every month at zero cost
No artificial paywalls on security. Unlike legacy providers that reserve recipient allowlists or dedicated IP pools for high enterprise tiers, every SadaSend account receives full safety controls from day one.
Everything you need to know about Go email API
Clear, transparent answers on deliverability, API authentication, and rate limits.
Related developer guides and architectural tutorials
Explore step-by-step production implementation blueprints, benchmarks, and protocols.
REST API Reference & Endpoints
Complete REST API reference for sending emails, managing API keys, tracking delivery events, and configuring recipient allowlists with low latency.
SMTP relay & framework integrations
Connect existing applications, WordPress, Supabase, Laravel, Django, and Nodemailer to SadaSend via standard SMTP relay with zero code changes.
Official Client SDKs (TypeScript & Python)
Official zero-dependency client SDKs for SadaSend. TypeScript and Python packages are live on npm and PyPI with typed results and auto-idempotency.
Go (Golang) Microservice for Email with Circuit Breakers & Retries
Learn how to write a production-grade Go service that dispatches millions of emails with resilient circuit breaking, retries, and zero memory leaks.
Building a transactional email queue on Bun and BullMQ without losing messages
The worst bug an email service can have is not a crash. It is accepting a message, returning 202, and never sending it.
Nodemailer in production: what breaks, and what to do about it
Nodemailer is excellent at composing and transmitting a message. Almost every production incident I have seen with it is about the code around it, not the library.
Why your transactional email goes to spam
People assume transactional mail is exempt from filtering because it was requested. Mailbox providers do not know that, and mostly do not care.
SPF, DKIM and DMARC: what each one actually does
Three records, endlessly confused with each other. Here is the mental model that makes them stop being confusing, and the two mistakes that cause most failures.