Start an outbound call

import express from "express";

const app = express();
app.use(express.json());

const AIRCALL_API_BASE_URL = "https://api.aircall.io/v1";

function getBasicAuthHeader() {
  const apiId = process.env.AIRCALL_API_ID;
  const apiToken = process.env.AIRCALL_API_TOKEN;

  if (!apiId || !apiToken) {
    throw new Error("Missing AIRCALL_API_ID or AIRCALL_API_TOKEN");
  }

  // Basic Auth uses your API ID as the username and API token as the password.
  // See: https://developers.aircall.io/api-references/#authentication
  const credentials = Buffer.from(`${apiId}:${apiToken}`).toString("base64");
  return `Basic ${credentials}`;
}

app.post("/start-outbound-call", async (req, res) => {
  const {
    userId,
    numberId,
    to,
    checkAvailability = true,
    focusWorkspace = false,
  } = req.body;

  let authHeader;

  try {
    authHeader = getBasicAuthHeader();
  } catch (error) {
    return res.status(500).json({ error: error.message });
  }

  try {
    if (checkAvailability) {
      // Optional but recommended: check whether the user can place a call before
      // requesting POST /calls. Continue only when the response is `available`.
      // Possible values: available, offline, do_not_disturb, in_call, after_call_work.
      // See: https://developers.aircall.io/api-references/#check-availability-of-a-user
      const availabilityResponse = await fetch(
        `${AIRCALL_API_BASE_URL}/users/$USERID/availability`,
        {
          method: "GET",
          headers: {
            Authorization: authHeader,
            "Content-Type": "application/json",
          },
        }
      );

      if (!availabilityResponse.ok) {
        // Handle errors from GET /users/:id/availability.
        return res.sendStatus(availabilityResponse.status);
      }

      const availabilityData = await availabilityResponse.json();

      if (availabilityData.availability !== "available") {
        return res.status(409).json({
          error: "User is not available.",
          availability: availabilityData.availability,
        });
      }
    }

    if (focusWorkspace) {
      // Optional: pre-fill the user's phone UI with the destination number.
      // This endpoint does not start the call. POST /users/:id/calls below starts it.
      // See: https://developers.aircall.io/api-references/#dial-a-phone-number-in-the-phone
      const dialResponse = await fetch(
        `${AIRCALL_API_BASE_URL}/users/$USERID/dial`,
        {
          method: "POST",
          headers: {
            Authorization: authHeader,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({ to }),
        }
      );

      if (!dialResponse.ok) {
        // Handle errors from POST /users/:id/dial.
        return res.sendStatus(dialResponse.status);
      }

      // POST /dial returns 204 No Content on success, so there is no body to parse.
    }

    // Required: start the outbound call from the selected Aircall number.
    // `number_id` must be an Aircall Number assigned to the user in the path.
    // `to` must be in E.164 format, for example +18001231234.
    // See: https://developers.aircall.io/api-references/#start-an-outbound-call
    const callResponse = await fetch(
      `${AIRCALL_API_BASE_URL}/users/$USERID/calls`,
      {
        method: "POST",
        headers: {
          Authorization: authHeader,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          number_id: Number(numberId),
          to,
        }),
      }
    );

    if (!callResponse.ok) {
      // Handle errors from POST /users/:id/calls.
      return res.sendStatus(callResponse.status);
    }

    // POST /calls returns 204 No Content on success. Return your own app-level
    // response so the client knows the request completed.
    return res.status(200).json({
      status: "started",
      message: "Outbound call started.",
    });
  } catch (error) {
    console.error("Failed to start outbound call:", error);
    return res.status(500).json({
      error: "Failed to start outbound call.",
    });
  }
});

app.listen(3000, () => {
  console.log("Server listening on port 3000");
});

const response = await fetch("http://localhost:3000/start-outbound-call", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    userId: 123456,
    numberId: 987654,
    to: "+18001231234",
    checkAvailability: true,
    focusWorkspace: false,
  }),
});

const result = await response.json();
console.log(result);

{
  "status": "started",
  "message": "Outbound call started."
}