Skip to content
High-Performance Go 1.22+ IntegrationGoroutine Safe & Net/SMTP

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.

3,000 emails/month freeZero credit card requiredSub-20ms edge latency
15,000+ req/s
Throughput
Goroutine multiplexing
202 Accepted
Edge Latency
Queued durably before any provider call
6,000 / mo
Free Monthly Tier
Zero credit card required
Developer Ergonomics

Drop into your application in under 60 seconds

Native typed interfaces with zero unnecessary dependencies. Built for standard fetch and modern edge runtimes.

$go get github.com/sadasend/sadasend-go
main.go
go
GOLANG
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.

Core Infrastructure

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.

Architectural Comparison

SadaSend vs net/smtp with Generic Relays

Why Go engineering teams use SadaSend rather than raw net/smtp relays.

Feature & CapabilitySadaSendnet/smtp with Generic Relays
HTTP REST API with Context CancellationBlocking socket calls
DKIM and SPF Pre-Flight VerificationFails silently if DNS wrong
Per-Key Recipient Containment Allowlists
HMAC Webhook Ingestion & Delivery FeedbackRequires complex custom logs
Native Port 587 ESMTP Support
Free Tier with Custom Domain6,000 sends foreverTrial only
Forever Free Tier
Transparent Economics

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.

3,000 dispatches monthly forever with zero credit card
All safety gates, allowlists, and velocity limits included
Scale seamlessly: Starter ($12/mo for 10k), Pro ($19/mo for 50k), Scale ($79/mo for 250k)
Free Developer Plan
$0 / mo

No credit card required

Create Free AccountCompare all paid plan tiers
Frequently Asked Questions

Everything you need to know about Go email API

Clear, transparent answers on deliverability, API authentication, and rate limits.

You can either make standard HTTP POST requests to https://api.sadasend.com/emails using net/http with your Bearer API key, or use standard net/smtp pointing to smtp.sadasend.com:587 with STARTTLS.
Technical Deep Dives

Related developer guides and architectural tutorials

Explore step-by-step production implementation blueprints, benchmarks, and protocols.

Documentation

REST API Reference & Endpoints

Complete REST API reference for sending emails, managing API keys, tracking delivery events, and configuring recipient allowlists with low latency.

Read guide
Documentation

SMTP relay & framework integrations

Connect existing applications, WordPress, Supabase, Laravel, Django, and Nodemailer to SadaSend via standard SMTP relay with zero code changes.

Read guide
Documentation

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.

Read guide
Deep Dive3 min read

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.

Read tutorial
Deep Dive4 min read

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.

Read tutorial
Deep Dive4 min read

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.

Read tutorial
Deep Dive3 min read

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.

Read tutorial
Deep Dive4 min read

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.

Read tutorial