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 (
    "context"
    "fmt"
    "log"
    "os"

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

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

// Package scope: created once at cold start, reused while the environment
// is warm. NewClient reads NOTIX_API_KEY itself when passed "".
var client *notix.Client

func init() {
    c, err := notix.NewClient(os.Getenv("NOTIX_API_KEY"))
    if err != nil {
        log.Fatal(err)
    }
    client = c
}

func handler(ctx context.Context, o order) (string, error) {
    // notix-go does not expose the Idempotency-Key header yet. If this
    // function is invoked asynchronously or from SQS, send with net/http
    // and set the header (see the Go guide) so a retry cannot send twice.
    resp, errResp, err := client.Emails.Send(ctx, notix.SendEmailPayload{
        To:      []string{o.Email},
        From:    "receipts@acme.com",
        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),
    })
    if err != nil {
        return "", err // transport failure: worth a retry
    }
    if errResp != nil {
        // The API said no. Log it and return nil so Lambda does not retry a
        // refusal that will fail identically; a 429 is the exception, and
        // the net/http variant in the Go guide can branch on its status.
        log.Printf("send refused: %s", errResp.Message)
        return "", nil
    }
    return resp.EmailID, nil
}

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