Send email from Hono on any runtime.

1. Write the app once.

   Keep the routes in a factory that takes the API key, so the same file serves every entrypoint. The SDK answers { data, error }: a failed send is a value you check, not an exception you forget to catch. The idempotency key is set here, on the send itself.

   src/app.ts

   // src/app.ts
   import { Hono } from "hono";
   import { Notix } from "notix-js";
   
   // One app for every runtime. The key comes from the environment the
   // runtime provides; see the entrypoints below for where that is.
   export function createApp(apiKey: string) {
     const notix = new Notix(apiKey);
     const app = new Hono();
   
     app.post("/send", async (c) => {
       const { to, subject, html, orderId } = await c.req.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 c.json({ error }, 502);
       }
       return c.json({ id: data?.emailId });
     });
   
     return app;
   }
   

2. Add the entrypoint for your runtime.

   Node serves through the adapter, Bun and Deno serve the app's fetch directly, and Workers export the app as the default module and read the key from a binding on c.env. Nothing in the routes changes.

   NodeBunDenoCloudflare Workers

   src/server.ts with @hono/node-server

   // src/server.ts
   import { serve } from "@hono/node-server";
   import { createApp } from "./app";
   
   const app = createApp(process.env.NOTIX_API_KEY!);
   
   serve({ fetch: app.fetch, port: 3000 }, (info) => {
     console.log(`listening on http://localhost:${info.port}`);
   });
   

3. Receive delivery events.

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

   src/webhooks.ts

   // src/webhooks.ts
   import { Hono } from "hono";
   import { Notix } from "notix-js";
   
   export function webhookRoutes(apiKey: string, webhookSecret: string) {
     const webhooks = new Notix(apiKey).webhooks(webhookSecret);
     const app = new Hono();
   
     app.post("/webhooks/notix", async (c) => {
       // The signature is computed over the raw body. Read it as text;
       // parsing it first and re-serialising would change the bytes.
       const rawBody = await c.req.text();
   
       let event;
       try {
         event = webhooks.constructEvent(rawBody, { headers: c.req.raw.headers });
       } catch (error) {
         return c.text((error as Error).message, 400);
       }
   
       switch (event.type) {
         case "email.delivered":
         case "email.bounced":
         case "email.complained":
           // Record the outcome against your own order or user id.
           break;
       }
       return c.text("ok");
     });
   
     return app;
   }
   
   // Mount it next to the send route:
   // app.route("/", webhookRoutes(apiKey, process.env.NOTIX_WEBHOOK_SECRET!));
   

4. Send one and read it back.

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

Coming from Express or a plain Node server? Start with the Node.js guide for the SDK, fetch and Nodemailer side by side. Deploying to Bun or Deno without Hono? The Bun and Deno guides cover the runtime on its own. The free plan does not ask for a card.