Send Email from Azure Functions (Node.js)

AhaSend lets you send transactional email from Azure Functions in Node.js with the official SDK; this guide builds a protected HTTP function and runs it locally.

Prerequisites

Use a verified sending domain, your account ID, and a domain-scoped send-only API v2 key. Use sandbox mode for every test. Management tasks need a separate full API key. Use Node.js 22 and Azure Functions Core Tools v4. The code uses the Node.js v4 programming model.

Install the Dependencies

Run these commands in a new directory:

npm init -y
npm install --save-exact @ahasend/sdk@0.2.1 @azure/functions@4
npm pkg set main=index.cjs

Try a Sandbox Send

Run this short SDK check locally before adding the longer server integration below. Use a verified sender, a send-only API key, and your account ID. It sends to a reserved test address with sandbox: true, so no email is delivered. In the server project directory, add .env to .gitignore, then create .env with AHASEND_API_KEY, AHASEND_ACCOUNT_ID, and AHASEND_FROM (an address on your verified domain). Keep these values out of browser code and AI prompts. Use Node.js 22 or newer. Save this as quick-send.mjs:

quick-send.mjs

import { AhaSendClient } from "@ahasend/sdk";
try {
  const client = AhaSendClient.fromEnv();
  const result = await client.messages.send({
    from: { email: process.env.AHASEND_FROM },
    recipients: [{ email: "recipient@example.com" }],
    subject: "My first sandbox email",
    text_content: "Hello from AhaSend",
    sandbox: true,
  });
  const statuses = result.data.map((entry) => entry.status);
  console.log({ statuses });
  if (!statuses.length || statuses.some((s) => !["queued", "scheduled"].includes(s)))
    throw new Error("A recipient was rejected");
} catch {
  console.error("Sandbox send failed; check your credentials, sender and account.");
  process.exitCode = 1;
}

Run node --env-file=.env quick-send.mjs from that directory. The output lists each recipient status; queued or scheduled means accepted for sandbox processing. The process exits with a failure if the request or any recipient fails. Continue below for the full integration.

Add the Shared Sending Code

Save this as send-email.cjs beside the function file. Configure AHASEND_API_KEY, AHASEND_ACCOUNT_ID, AHASEND_FROM, AHASEND_TO and a long random SEND_TOKEN on the server. Set AHASEND_TO=recipient@example.com and AHASEND_DELIVERY_MODE=sandbox for local testing. Keep a sandbox credential until you are ready for real delivery; changing the mode to live alone cannot override a sandbox credential.

send-email.cjs

const { createHash, timingSafeEqual } = require("node:crypto");
const { AhaSendClient } = require("@ahasend/sdk");
const digest = (value) => createHash("sha256").update(value).digest();
let client;
exports.sendEmail = async (body, authorization = "") => {
  const token = process.env.SEND_TOKEN;
  if (!token) return [500, { error: "Missing server configuration" }];
  if (!timingSafeEqual(digest(authorization), digest(`Bearer ${token}`)))
    return [401, { error: "Unauthorized" }];
  if (!body || typeof body.event_id !== "string" ||
      !/^[A-Za-z0-9_-]{8,64}$/.test(body.event_id))
    return [400, { error: "event_id must be 8-64 letters, digits, _ or -" }];
  const mode = process.env.AHASEND_DELIVERY_MODE || "sandbox";
  if (!["sandbox", "live"].includes(mode) ||
      !["AHASEND_API_KEY", "AHASEND_ACCOUNT_ID", "AHASEND_FROM", "AHASEND_TO"]
        .every((name) => process.env[name]))
    return [500, { error: "Missing or invalid server configuration" }];
  try {
    client ||= AhaSendClient.fromEnv();
    const result = await client.messages.send({
      from: { email: process.env.AHASEND_FROM },
      recipients: [{ email: process.env.AHASEND_TO }],
      subject: "Welcome", text_content: "Your account is ready.",
      sandbox: mode === "sandbox",
    }, { idempotencyKey: `${mode}-welcome-${body.event_id}` });
    const statuses = result.data.map((item) => item.status);
    if (!statuses.length || statuses.some((s) => !["queued", "scheduled"].includes(s)))
      return [422, { error: "A recipient was rejected" }];
    return [202, { statuses }];
  } catch {
    return [502, { error: "Email request failed" }];
  }
};

The caller supplies only the business event ID. For a real signup, read the recipient from your database after checking the caller’s access. Save the exact message with that event ID and reuse both when retrying. Read the idempotency limits before retrying an uncertain send. Add request limits at the hosting layer and log an internal event ID instead of credentials or message bodies.

Create the HTTP Function

Save this as index.cjs. The function accepts POST requests and also checks your server’s bearer token; Azure’s function key is an additional hosted check.

index.cjs

const { app } = require("@azure/functions");
const { sendEmail } = require("./send-email.cjs");
app.http("sendEmail", {
  methods: ["POST"], authLevel: "function",
  handler: async (request) => {
    const raw = await request.text();
    if (Buffer.byteLength(raw) > 16384) return { status: 413 };
    let body;
    try { body = JSON.parse(raw); }
    catch { return { status: 400, jsonBody: { error: "Invalid JSON" } }; }
    const [status, jsonBody] = await sendEmail(body, request.headers.get("authorization") || "");
    return { status, jsonBody };
  },
});

Create host.json:

host.json

{"version":"2.0"}

Run with Core Tools

Keep .env and local.settings.json out of Git. Export the variables from the shared code, then start the local host:

FUNCTIONS_WORKER_RUNTIME=node func start

In another shell with SEND_TOKEN set, invoke the local function:

curl --fail-with-body http://localhost:7071/api/sendEmail   -H "Authorization: Bearer $SEND_TOKEN" -H 'Content-Type: application/json'   -d '{"event_id":"local-azure-node-001"}'

Expect HTTP 202 with acceptance statuses. Missing or wrong bearer tokens return 401; invalid event IDs return 400. Local Core Tools does not enforce function keys, so the handler keeps its own token check. To repeat a new test use a new event ID; to retry the same job keep its ID and message unchanged.

Prepare the Hosted App

Select Node.js 22 and Functions runtime v4. Put the values in app settings, with Key Vault references for secrets. Send the Azure function key as x-functions-key in addition to the bearer token. Use your application’s identity checks and request limits before allowing callers to trigger mail. Follow Microsoft’s deployment steps to publish the app. Track final delivery with webhooks. Also see Azure in Python, Azure in Go and Node.js SMTP.

Before sending: verify a domain and create a send-only key.
Other ways to send: REST API, SMTP, CLI quickstart, Node.js SDK and Go SDK.
Request rules: API authentication, scopes, idempotency, errors and rate limits.
Testing and events: sandbox mode, CLI webhook testing, event payloads, signature verification and delivery retries.
Data and limits: retention, tracking and plans and feature availability.

SDKs

Integrations

AI Development Tools

Migration Guides

Send Email from Azure Functions (Node.js)

Prerequisites

Install the Dependencies

Try a Sandbox Send

Add the Shared Sending Code

Create the HTTP Function

Run with Core Tools

Prepare the Hosted App

​Prerequisites

​Install the Dependencies

​Try a Sandbox Send

​Add the Shared Sending Code

​Create the HTTP Function

​Run with Core Tools

​Prepare the Hosted App

​Related Guides

Prerequisites

Install the Dependencies

Try a Sandbox Send

Add the Shared Sending Code

Create the HTTP Function

Run with Core Tools

Prepare the Hosted App

Related Guides