Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.whatsable.app/llms.txt

Use this file to discover all available pages before exploring further.

Base44 follows the open AgentSkills specification. Notifyer Agent Skills can be installed globally so any AI coding assistant you use with Base44 — Claude, Cursor, Copilot, or others — knows how to call the Notifyer API.

​
How skills work in Base44

Base44 uses Agent Skills to give external AI coding tools reusable instructions for platform-specific tasks. When you install Notifyer skills globally, your AI assistant gains:
  • Knowledge of all Notifyer API endpoints, auth modes, and CORS rules
  • Ready-to-run Node.js scripts for every Notifyer operation
  • Reference documentation on templates, broadcasts, recipients, webhooks, and chat
The skills are loaded from ~/.agents/skills/ (global) or .agents/skills/ (project-level) and are used by the AI when you ask it to add Notifyer functionality to a Base44 app or backend function.

​
Install the skills

Base44 skills themselves are installed with npx skills add base44/skills -g. Notifyer skills are a separate add-on — install both if you’re building a Base44 app that sends WhatsApp messages via Notifyer.

​
Set up environment variables

The Notifyer scripts need these variables:
VariableRequiredDescription
NOTIFYER_API_BASE_URLyesAlways https://api.insightssystem.com. Must start with https:// — all scripts enforce this at startup.
NOTIFYER_API_TOKENyesJWT token obtained via setup-notifyer/scripts/login.js
NOTIFYER_CHAT_ORIGINnoCORS Origin override for Phase 3 chat endpoints. Defaults to https://chat.notifyer-systems.com.
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..."   # obtained via setup-notifyer/scripts/login.js
For Base44 backend functions that call the Notifyer API directly, store these as project secrets using the Base44 CLI: 
base44 secrets set NOTIFYER_API_BASE_URL=https://api.insightssystem.com
base44 secrets set NOTIFYER_API_TOKEN=eyJ...
Inside your backend function code, access them with Deno.env.get("NOTIFYER_API_TOKEN").
Never hardcode NOTIFYER_API_TOKEN in your Base44 app source. Use base44 secrets set to store it securely — it will be available as an environment variable in your deployed backend functions.

​
Two ways to use Notifyer in a Base44 app

​
1. AI-assisted integration (skills-guided)

Tell your AI coding assistant to add Notifyer functionality to a Base44 backend function. With the skills installed, the AI already knows the correct API endpoints, auth headers, and payload shapes: 
Add a Base44 backend function called sendWhatsAppTemplate that accepts a phone number
and template name, authenticates with the Notifyer API using NOTIFYER_API_TOKEN,
and sends the matching approved template.

Create a Base44 backend function that checks if a recipient's 24-hour WhatsApp
messaging window is open before sending a text message via Notifyer.
The AI will reference the skill’s reference docs (references/messaging-reference.md, references/recipients-reference.md, etc.) to produce accurate code.

​
2. Calling the Notifyer API directly from a Base44 backend function

Base44 backend functions run on Deno — not Node.js. Call the Notifyer REST API directly using the built-in fetch(). The Notifyer scripts (which require Node.js 18+) cannot be executed from within a Deno backend function. The example below sends a WhatsApp template message using the Notifyer Chat API (POST /api:bVXsw_FD/web/send/template). Template messages work at any time — no 24-hour window required. Get the templateId from automate-notifyer/scripts/list-templates.js. 
// Inside a Base44 backend function (Deno)
Deno.serve(async (req) => {
  try {
    const { phone, templateId, variables } = await req.json();

    const token = Deno.env.get("NOTIFYER_API_TOKEN");
    const baseUrl = Deno.env.get("NOTIFYER_API_BASE_URL");

    const res = await fetch(`${baseUrl}/api:bVXsw_FD/web/send/template`, {
      method: "POST",
      headers: {
        "Authorization": token,          // Chat auth — raw JWT, no Bearer prefix
        "Origin": "https://chat.notifyer-systems.com",
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        template: templateId,            // Template ID string from list-templates.js
        variables: variables ?? {},      // e.g. { "body1": "John", "body2": "#12345" }
        current_recipient: {
          phone_number: parseInt(String(phone).replace(/^\+/, ""), 10),
        },
        scheduled_time: 0,              // 0 = send immediately
      }),
    });

    const result = await res.json();

    // Notifyer (Xano) can return HTTP 200 with success: false on Meta rejections
    if (!res.ok || result.success === false) {
      return Response.json(
        { ok: false, error: result },
        { status: res.ok ? 400 : res.status }
      );
    }

    return Response.json({ ok: true, result });
  } catch (error) {
    return Response.json({ ok: false, error: error.message }, { status: 500 });
  }
});
Base44 backend functions use the Deno runtime. Do not import Node.js-specific modules like child_process. Use fetch() to call the Notifyer REST API directly, and use Deno.env.get() to read secrets.

​
Example AI prompts for Base44 projects

With Notifyer skills installed, give your AI assistant these kinds of instructions:

​
Send WhatsApp messages from a Base44 app

Build a Base44 backend function called notifyCustomer.
It should accept { phone, templateName, variables } and send a WhatsApp template
message via the Notifyer API. Use NOTIFYER_API_BASE_URL and NOTIFYER_API_TOKEN
from environment variables. Handle errors and return { ok, message_id } or { ok: false, error }.

​
Trigger a broadcast from a Base44 automation

Add a Base44 automation that runs daily at 9am, fetches all customers from the
Customers entity with status = "trial_expiring", and triggers a Notifyer broadcast
using the trial_reminder template for each one.

​
Webhook receiver in Base44

Create a Base44 backend function to receive incoming Notifyer IO webhook events.
Validate the HMAC signature using NOTIFYER_WEBHOOK_SECRET.
When a new inbound message arrives, create or update a record in the Conversations entity.

​
Chat handoff from a Base44 agent

When a user sends the message "talk to a human" to our Base44 AI agent,
perform a human handover for that contact's WhatsApp conversation in Notifyer.
Use the assign-label workflow: first get the bot's handoff_label from list-bots.js,
then assign that label to the recipient — this automatically stops the AI bot and
routes the conversation to the human agent queue.
The correct handover method is always label-based: assign the bot’s configured handoff_label to the recipient. Notifyer automatically sets is_ai_assistant = false when the handoff label is detected. Do not use a direct PATCH to flip is_ai_assistant — it stops the bot but does not route to the human label queue.

​
API reference for Base44 backend functions

When building backend functions that call Notifyer directly, these are the key details:
Console APIChat API
Base URLNOTIFYER_API_BASE_URLNOTIFYER_API_BASE_URL
Auth headerAuthorization: Bearer <jwt>Authorization: <jwt> (no Bearer)
Originhttps://console.notifyer-systems.comhttps://chat.notifyer-systems.com
Used forTemplates, bots, broadcasts, webhooksRecipients, messaging, labels, handoff
There is also a Developer API key mode (Authorization: <api_key> — no Bearer prefix) used by external tools such as Make, Zapier, and n8n. Retrieve the key with setup-notifyer/scripts/get-api-key.js. This is a separate long-lived credential, distinct from the JWT token. For complete endpoint reference, see the skills’ references/ directory after install:
  • ~/.agents/skills/automate-notifyer/references/
  • ~/.agents/skills/chat-notifyer/references/

​
Keeping skills up to date

npx skills add whatsable/whatsapp-business-agent-skills --all -g
Re-running the install command pulls the latest version from the repository.