Send email from Astro, from an endpoint or an Action.

1. Add an API endpoint.

   A file under src/pages/api that exports POST is a server route. It reads the JSON body, sends with an idempotency key derived from the order, and answers with the message id or the SDK's error envelope. The prerender = false line keeps it dynamic when the site is otherwise static.

   src/pages/api/send.ts

   // src/pages/api/send.ts
   export const prerender = false; // not needed in 'server' output mode
   import type { APIRoute } from "astro";
   import { Notix } from "notix-js";
   
   // import.meta.env is Astro's environment object. A variable without the
   // PUBLIC_ prefix is server-only and never reaches the browser bundle.
   const notix = new Notix(import.meta.env.NOTIX_API_KEY);
   
   export const POST: APIRoute = async ({ request }) => {
     const { to, subject, html, orderId } = await request.json();
   
     const { data, error } = await notix.emails.send(
       { from: "receipts@acme.com", to, subject, html },
       // The same key on a retried request returns the first message
       // instead of sending a second one.
       { idempotencyKey: `order-${orderId}-receipt` },
     );
   
     if (error) {
       return new Response(JSON.stringify({ error }), {
         status: 502,
         headers: { "Content-Type": "application/json" },
       });
     }
     return new Response(JSON.stringify({ id: data?.emailId }), {
       headers: { "Content-Type": "application/json" },
     });
   };
   

2. Or define an Action.

   An Action is a server function your pages can call by name. Astro validates the input with the schema before the handler runs, and a thrown ActionError becomes the error the caller reads.

   src/actions/index.ts

   // src/actions/index.ts
   import { defineAction, ActionError } from "astro:actions";
   import { z } from "astro/zod";
   import { Notix } from "notix-js";
   
   const notix = new Notix(import.meta.env.NOTIX_API_KEY);
   
   export const server = {
     sendReceipt: defineAction({
       // Astro validates the input with this schema before the handler runs.
       input: z.object({
         to: z.string().email(),
         orderId: z.string(),
       }),
       handler: async ({ to, orderId }) => {
         const { data, error } = await notix.emails.send(
           {
             from: "receipts@acme.com",
             to,
             templateId: "tpl_receipt_v4",
             variables: { orderId },
           },
           { idempotencyKey: `order-${orderId}-receipt` },
         );
         if (error) {
           throw new ActionError({ code: "BAD_GATEWAY", message: error.message });
         }
         return { id: data?.emailId };
       },
     }),
   };
   

3. Call it from a form or a script.

   A plain HTML form posts to the Action with no client JavaScript and the page re-renders with the result. A client script gets the same { data, error } shape back from a function call.

   HTML formClient script

   src/pages/order.astro, no client JavaScript

   ---
   // A zero-JS form posts straight to the action; the page reloads with
   // the result available through Astro.getActionResult.
   import { actions } from "astro:actions";
   const result = Astro.getActionResult(actions.sendReceipt);
   ---
   
   <form method="POST" action={actions.sendReceipt}>
     <input name="to" type="email" required />
     <input name="orderId" type="hidden" value="48213" />
     <button>Email my receipt</button>
   </form>
   
   {result?.data && <p>Sent: {result.data.id}</p>}
   {result?.error && <p>Could not send: {result.error.message}</p>}
   

4. Receive delivery events.

   A second endpoint 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/pages/api/webhooks/notix.ts

   // src/pages/api/webhooks/notix.ts
   export const prerender = false;
   import type { APIRoute } from "astro";
   import { Notix } from "notix-js";
   
   const webhooks = new Notix(import.meta.env.NOTIX_API_KEY).webhooks(
     import.meta.env.NOTIX_WEBHOOK_SECRET,
   );
   
   export const POST: APIRoute = async ({ request }) => {
     // 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 your own store.
     }
     return new Response("ok");
   };
   

Deploying the whole site to Workers without Astro? The Cloudflare Workers guide covers a bare Worker. Sending magic links from the site? The magic link page has the token flow. The free plan does not ask for a card.