Send email from a Cloudflare Worker.

1. Send from the fetch handler.

   Read the JSON body, POST to the API with the key from env, and pass the response through. The idempotency key is derived from the order so a repeated request cannot produce a second email. The SDK tab does the same with { data, error } unwrapped for you.

   fetch onlynotix-js

   src/worker.ts, no dependencies

   // src/worker.ts
   export interface Env {
     NOTIX_API_KEY: string;
   }
   
   export default {
     async fetch(request: Request, env: Env): Promise<Response> {
       if (request.method !== "POST") {
         return new Response("Method not allowed", { status: 405 });
       }
       const { to, subject, html, orderId } = await request.json();
   
       // One HTTP call. The idempotency key is a header; the same key on a
       // retried request returns the first message instead of a second one.
       const response = await fetch("https://app.usenotix.dev/api/v1/emails", {
         method: "POST",
         headers: {
           Authorization: `Bearer ${env.NOTIX_API_KEY}`,
           "Content-Type": "application/json",
           "Idempotency-Key": `order-${orderId}-receipt`,
         },
         body: JSON.stringify({ from: "receipts@acme.com", to, subject, html }),
       });
   
       const body = await response.text();
       return new Response(body, {
         status: response.ok ? 200 : 502,
         headers: { "Content-Type": "application/json" },
       });
     },
   } satisfies ExportedHandler<Env>;
   

2. Move the send to a queue for retries.

   Enqueue the job and answer 202. The consumer sends with the same key on every attempt, acknowledges on success or on a 409 (already sent under that key), and asks for redelivery on a 429 or a server error. Queues handle the backoff and the retry count.

   src/worker.ts with a queue consumer

   // src/worker.ts: enqueue in the request, send from the consumer.
   export interface Env {
     NOTIX_API_KEY: string;
     MAIL_QUEUE: Queue<MailJob>;
   }
   
   type MailJob = { to: string; subject: string; html: string; orderId: string };
   
   export default {
     async fetch(request: Request, env: Env): Promise<Response> {
       const job = (await request.json()) as MailJob;
       // Answer the client at once; the consumer below does the send.
       await env.MAIL_QUEUE.send(job);
       return new Response("queued", { status: 202 });
     },
   
     async queue(batch: MessageBatch<MailJob>, env: Env): Promise<void> {
       for (const message of batch.messages) {
         const job = message.body;
         const response = await fetch("https://app.usenotix.dev/api/v1/emails", {
           method: "POST",
           headers: {
             Authorization: `Bearer ${env.NOTIX_API_KEY}`,
             "Content-Type": "application/json",
             // The same key on every attempt: a retry after a timeout can
             // never produce a second email.
             "Idempotency-Key": `order-${job.orderId}-receipt`,
           },
           body: JSON.stringify({
             from: "receipts@acme.com",
             to: job.to,
             subject: job.subject,
             html: job.html,
           }),
         });
   
         if (response.ok || response.status === 409) {
           message.ack(); // sent, or already sent under this key
         } else if (response.status === 429 || response.status >= 500) {
           message.retry(); // Queues redelivers, up to max_retries
         } else {
           message.ack(); // a 4xx is a bad job; do not loop on it
         }
       }
     },
   } satisfies ExportedHandler<Env>;
   

   Or ctx.waitUntil, without redelivery

   // Without a queue: send after responding, still with the same key.
   export default {
     async fetch(request: Request, env: Env, ctx: ExecutionContext) {
       const job = await request.json();
       ctx.waitUntil(sendReceipt(env, job)); // keeps the Worker alive to finish
       return new Response("accepted", { status: 202 });
     },
   };
   

3. Receive delivery events.

   A route for email.delivered, email.bounced and email.complained. Read the body as text, hand it and the request headers to constructEvent, and act on the event it returns. A bad signature throws, and the route answers 400.

   src/webhook.ts

   // src/webhook.ts: a second route, or a second Worker.
   import { Notix } from "notix-js";
   
   export interface Env {
     NOTIX_API_KEY: string;
     NOTIX_WEBHOOK_SECRET: string;
   }
   
   export default {
     async fetch(request: Request, env: Env): Promise<Response> {
       const webhooks = new Notix(env.NOTIX_API_KEY).webhooks(env.NOTIX_WEBHOOK_SECRET);
   
       // The signature covers the raw bytes: read text, never request.json().
       const rawBody = await request.text();
   
       let event;
       try {
         event = webhooks.constructEvent(rawBody, { headers: request.headers });
       } catch (error) {
         return new Response((error as Error).message, { status: 400 });
       }
   
       if (event.type === "email.bounced" && event.data.bounce.type === "Permanent") {
         // Mark the address invalid in KV, D1 or your own API.
       }
       return new Response("ok");
     },
   } satisfies ExportedHandler<Env>;
   

4. Deploy and read it back.

   wrangler deploy, POST to the Worker with curl, then open the message in the dashboard: the log shows its status and every event as delivery progresses, and your webhook Worker logs the same events as they arrive.

The production checklist, with batch sends, scheduling, templates by id and the retry strategy, is in the production Node.js guide, and the webhook headers and tolerance window are on the signature verification page.