Email infrastructure for the paths that matter

Email you can depend on. Send once. Deliver on time. Know exactly what happened.

A focused outbound email control plane: client-account isolation, SES sender verification, durable 100k+ broadcast fan-out, suppressions, and fine-grained usage facts.

Get started Read the API docs

Official SDK, typed contractsTenant-scoped by design

delivery / request lifecycle

preview

request trace

One clear path to delivery

preview

Accepted

validated

The API validates the message shape and returns a request identifier.

Queued

durable

Queue workers hold dispatch state and retry transient failures.

Provider driver

dispatch

Amazon SES accepts each independently fenced recipient delivery.

Provider feedback

verified

Verified SES events update delivery state, suppressions, and usage facts.

Clover Go SDK · Go modules

import { CloverClient } from "@sendclover/sdk";

const clover = new CloverClient({
  baseUrl: process.env.CLOVER_API_URL!,
  apiKey: process.env.CLOVER_API_KEY!,
});

const accepted = await clover.platformMessages.send(
  {
    accountId: process.env.CLOVER_ACCOUNT_ID!,
    environmentId: process.env.CLOVER_ENVIRONMENT_ID!,
  },
  {
    from: { address: "sender@example.com" },
    to: [{ address: "user@example.com" }],
    subject: "Hello",
    text: "Queued by Clover",
  },
  { idempotencyKey: "send-2026-0001" },
);

console.log(accepted.id, accepted.requestId);

Use the official Go SDK with CLOVER_API_URL, CLOVER_API_KEY, CLOVER_ACCOUNT_ID, and CLOVER_ENVIRONMENT_ID. The client sends Authorization: Bearer and X-Request-ID; pass a stable idempotency key for each mutation.

Core primitives

Platform API + SESDNS verificationVerified feedbackUsage facts

The useful surface area

Infrastructure you can inspect.

Clover keeps the operational primitives close to the request. Configure them once, then follow every state transition without inventing a second control plane.

Client-scoped broadcast API

Create a draft, run preflight, then approve or schedule one transaction for an audience of 100,000 or more recipients.

Domain and DNS verification

Create sender identities, inspect the DNS records your provider requires, and queue authoritative verification.

Queues, retries, and state

Keep dispatch state explicit from queued to delivered, with cancellation and retry paths represented in the API.

Fine-grained usage facts

Export immutable usage by client account, environment, source, delivery, and fact type for central rebilling logic.

Account and environment isolation

Keep every sender, audience, broadcast, key, and delivery inside its client account and environment boundary.

Feedback and suppressions

Verify provider feedback and block unsafe recipients again immediately before every provider submission.

A calm operating model

Know where the message is.

The product surface follows the same sequence your team already reasons about: establish identity, make a request, then observe what happened.

Establish a sender identity

Add a sending domain, apply the trusted SES DNS records, and verify public DNS before enabling a sender.

Make one typed request

Use Clover's typed endpoint contract from your service, worker, or integration test.

Observe the handoff

Follow frozen audience counts, recipient delivery state, verified feedback, suppressions, and usage facts.

@sendclover/sdk · npm install @sendclover/sdk

import { CloverClient } from "@sendclover/sdk";

const clover = new CloverClient({
  baseUrl: process.env.CLOVER_API_URL!,
  apiKey: process.env.CLOVER_API_KEY!,
});

const accepted = await clover.platformMessages.send(
  {
    accountId: process.env.CLOVER_ACCOUNT_ID!,
    environmentId: process.env.CLOVER_ENVIRONMENT_ID!,
  },
  {
    from: { address: "sender@example.com" },
    to: [{ address: "user@example.com" }],
    subject: "Hello",
    text: "Queued by Clover",
  },
  { idempotencyKey: "send-2026-0001" },
);

console.log(accepted.id, accepted.requestId);

202 · queued

SDK availability

The TypeScript npm package, Go SDK, and CLI are supported runnable platform clients. Python, Java, Rust, Swift, and Dart remain deferred until scoped routes and release evidence are complete.

Go SDKAvailable

CLIAvailable

TypeScriptAvailable

PythonDeferred

JavaDeferred

RustDeferred

SwiftDeferred

DartDeferred

Supported integrations

One scoped contract for every client account.

Use the official TypeScript npm package, Go SDK, or Clover CLI against the account/environment platform route. Other language packages remain deferred until their scoped clients are verified; pricing stays outside the operational API.

Generated API

Clover's typed request contract keeps request and response shapes explicit.

Broadcast lifecycle

Draft, preflight, approve or schedule, then observe the frozen fan-out.

Usage export

Read immutable facts for precise client-level attribution and rebilling.

Recipient safety

Use blind-index suppressions to prevent repeat sends to unsafe recipients.

Clover outbound platform

Start with the path you can prove.

Explore the dashboard for a working control room, or read Clover's API reference for contracts, authentication, and every supported surface.

Get started Read the API reference