Send email from a Lambda, with no sandbox to leave.

import { Notix } from "notix-js";

// Module scope: created once per execution environment, reused across
// warm invocations. Never inside the handler.
const notix = new Notix(process.env.NOTIX_API_KEY);

export const handler = async (event) => {
  // An SQS batch, an EventBridge event, a direct invoke: read your own
  // shape here. One record per email keeps the idempotency key simple.
  const order = JSON.parse(event.Records?.[0]?.body ?? JSON.stringify(event));

  const { data, error } = await notix.emails.send(
    {
      from: "receipts@acme.com",
      to: order.email,
      subject: `Your receipt for order ${order.id}`,
      html: `<p>Thanks for your order ${order.id}.</p>`,
      text: `Thanks for your order ${order.id}.`,
    },
    // Lambda retries a failed async invocation twice and SQS redelivers.
    // The same key on every attempt means at most one email per order.
    { idempotencyKey: `order-${order.id}-receipt` },
  );

  if (error) {
    // Throwing makes Lambda retry (async) or leave the message on the
    // queue (SQS). Only do that for errors a retry can fix.
    if (error.code === "RATE_LIMITED") throw new Error(error.message);
    console.error("send refused", error.code, error.message);
    return { sent: false, code: error.code };
  }

  return { sent: true, emailId: data.emailId };
};

import json
import os

from notix import Notix

# Module scope: one client per execution environment, reused while warm.
# raise_on_error=False returns (None, error) instead of raising, so the
# handler decides which errors are worth a Lambda retry.
client = Notix(os.environ["NOTIX_API_KEY"], raise_on_error=False)


def handler(event, context):
    records = event.get("Records") or [{"body": json.dumps(event)}]
    order = json.loads(records[0]["body"])

    resp, err = client.emails.send(
        payload={
            "from": "receipts@acme.com",
            "to": order["email"],
            "subject": f"Your receipt for order {order['id']}",
            "html": f"<p>Thanks for your order {order['id']}.</p>",
            "text": f"Thanks for your order {order['id']}.",
        },
        # Same key on every retry: Lambda's two async retries and an SQS
        # redelivery all resolve to the one email that already went out.
        options={"idempotency_key": f"order-{order['id']}-receipt"},
    )

    if err is not None:
        if err.get("code") == "RATE_LIMITED":
            raise RuntimeError(err["message"])  # let Lambda retry this one
        print("send refused", err.get("code"), err.get("message"))
        return {"sent": False, "code": err.get("code")}

    return {"sent": True, "emailId": resp["emailId"]}

package main

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

    "github.com/aws/aws-lambda-go/lambda"
)

type order struct {
    ID    string `json:"id"`
    Email string `json:"email"`
}

// Package scope: created once at cold start, reused while the environment
// is warm, so connections are kept alive between invocations.
var client = &http.Client{Timeout: 10 * time.Second}

func handler(ctx context.Context, o order) (string, error) {
    body, _ := json.Marshal(map[string]any{
        "from":    "receipts@acme.com",
        "to":      o.Email,
        "subject": fmt.Sprintf("Your receipt for order %s", o.ID),
        "html":    fmt.Sprintf("<p>Thanks for your order %s.</p>", o.ID),
        "text":    fmt.Sprintf("Thanks for your order %s.", o.ID),
    })
    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")
    // Built from the event, so an asynchronous or SQS retry cannot send twice.
    req.Header.Set("Idempotency-Key", "order-"+o.ID+"-receipt")

    res, err := client.Do(req)
    if err != nil {
        return "", err // transport failure: worth a retry
    }
    defer res.Body.Close()

    if res.StatusCode == http.StatusTooManyRequests || res.StatusCode >= 500 {
        return "", fmt.Errorf("notix answered %d", res.StatusCode) // let Lambda retry
    }
    if res.StatusCode >= 400 {
        // The API said no. Log it and return nil so Lambda does not retry a
        // refusal that will fail identically.
        log.Printf("send refused with status %d", res.StatusCode)
        return "", nil
    }

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

func main() {
    lambda.Start(handler)
}