TypeScript SDK

import { SenderKit } from "@senderkit/sdk";

const senderkit = new SenderKit({ apiKey: process.env.SENDERKIT_API_KEY! });

const result = await senderkit.send({
  template: "welcome",
  to: "user@example.com",
  vars: { name: "Ada" },
});

console.log(result.id); // "msg_…"

new SenderKit(options: SenderKitOptions)

senderkit.send(request: SendRequest): Promise<SendResponse>

const res = await senderkit.send({
  template: "receipt",
  to: "user@example.com",
  vars: { amount: "$42.00" },
  cc: ["accounting@acme.com"],
  metadata: { orderId: "ord_9" },
  idempotencyKey: "receipt:ord_9",
});
// { id: "msg_…", status: "queued", livemode: true }

senderkit.sendRaw(request: SendRawRequest): Promise<SendResponse>

senderkit.sendBatch(
  requests: Array<SendRequest | SendRawRequest>,
  options?: BatchSendOptions,
): Promise<BatchSendResult[]>

| { ok: true;  index: number; id: string; status: "queued" | "scheduled"; livemode: boolean }
| { ok: false; index: number; error: SenderKitError }

const results = await senderkit.sendBatch(
  recipients.map((to) => ({ template: "digest", to })),
  { concurrency: 10, idempotencyKey: "digest:2026-05-31" },
);

const failed = results.filter((r) => !r.ok);
if (failed.length) console.error(`${failed.length} sends failed`);

senderkit.context(): Promise<SenderKitContext>

const ctx = await senderkit.context();
console.log(ctx.workspace.name); // "Acme Inc"
console.log(ctx.mode);           // "live"

senderkit.templates.list(): Promise<Template[]>
senderkit.templates.get(slug: string): Promise<Template>

const templates = await senderkit.templates.list();
const welcome = await senderkit.templates.get("welcome");
console.log(welcome.currentVersion?.versionNumber);

senderkit.messages.list(params?: ListMessagesParams): Promise<ListMessagesResponse>
senderkit.messages.get(id: string): Promise<Message>
senderkit.messages.cancel(id: string): Promise<CancelMessageResponse>

// Page through every failed email
let cursor: string | undefined;
do {
  const page = await senderkit.messages.list({
    status: "failed",
    channel: "email",
    cursor,
    limit: 100,
  });
  for (const m of page.data) console.log(m.publicId, m.recipient);
  cursor = page.nextCursor ?? undefined;
} while (cursor);

// Cancel a scheduled message
await senderkit.messages.cancel("msg_…");

senderkit.inbound.addresses.list(): Promise<InboundAddress[]>
senderkit.inbound.addresses.create(params?: CreateInboundAddressParams): Promise<InboundAddress>
senderkit.inbound.addresses.delete(id: string): Promise<DeleteInboundAddressResponse>

senderkit.inbound.messages.list(params?: ListInboundMessagesParams): Promise<InboundMessageSummary[]>
senderkit.inbound.messages.get(id: string): Promise<InboundMessage>
senderkit.inbound.messages.raw(id: string): Promise<BinaryResponse>
senderkit.inbound.messages.attachment(id: string, index: number): Promise<BinaryResponse>

senderkit.inbound.domains.list(): Promise<InboundDomain[]>
senderkit.inbound.domains.create(params: CreateInboundDomainParams): Promise<InboundDomain>
senderkit.inbound.domains.delete(id: string): Promise<DeleteInboundDomainResponse>

// Provision an address on the shared receiving domain
const address = await senderkit.inbound.addresses.create({
  localPart: "support",
  forwardTo: "team@acme.com",
});

// Claim a custom domain and publish the DNS records it returns
const domain = await senderkit.inbound.domains.create({ domain: "inbound.acme.com" });
for (const record of domain.records) {
  console.log(record.type, record.name, record.value);
}

// Mint an address on that domain once it verifies, plus a catch-all
await senderkit.inbound.addresses.create({ domainId: domain.id, localPart: "invoices" });
await senderkit.inbound.addresses.create({ domainId: domain.id, localPart: "*" });

// Read what arrived
const recent = await senderkit.inbound.messages.list({ limit: 20 });
const full = await senderkit.inbound.messages.get(recent[0].id);
console.log(full.subject, full.text);

import {
  SenderKit,
  SenderKitPermissionError,
  SenderKitRateLimitError,
  SenderKitValidationError,
  SenderKitError,
} from "@senderkit/sdk";

try {
  await senderkit.send({ template: "welcome", to: "user@example.com" });
} catch (err) {
  if (err instanceof SenderKitValidationError) {
    console.error("Bad request:", err.issues);
  } else if (err instanceof SenderKitPermissionError) {
    console.error("Permission denied — key lacks required scope:", err.code);
  } else if (err instanceof SenderKitRateLimitError) {
    console.error(`Rate limited; retry after ${err.retryAfter}ms`);
  } else if (err instanceof SenderKitError) {
    console.error("Send failed:", err.message);
  } else {
    throw err;
  }
}