` around your text.
| Text Size | How to write it | Result |
| ----------- | ------------------------ | ---------------------- |
| Superscript | `superscript` | superscript |
| Subscript | `subscript` | subscript |
## Linking to Pages
You can add a link by wrapping text in `[]()`. You would write `[link to google](https://google.com)` to [link to google](https://google.com).
Links to pages in your docs need to be root-relative. Basically, you should include the entire folder path. For example, `[link to text](/writing-content/text)` links to the page "Text" in our components section.
Relative links like `[link to text](../text)` will open slower because we cannot optimize them as easily.
## Blockquotes
### Singleline
To create a blockquote, add a `>` in front of a paragraph.
> Dorothy followed her through many of the beautiful rooms in her castle.
```md theme={null}
> Dorothy followed her through many of the beautiful rooms in her castle.
```
### Multiline
> Dorothy followed her through many of the beautiful rooms in her castle.
>
> The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood.
```md theme={null}
> Dorothy followed her through many of the beautiful rooms in her castle.
>
> The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood.
```
### LaTeX
Mintlify supports [LaTeX](https://www.latex-project.org) through the Latex component.
8 x (vk x H1 - H2) = (0,1)
```md theme={null}
8 x (vk x H1 - H2) = (0,1)
```
# Navigation
Source: https://docs.whatsable.app/essentials/navigation
The navigation field in docs.json defines the pages that go in the navigation menu
The navigation menu is the list of links on every website.
You will likely update `docs.json` every time you add a new page. Pages do not show up automatically.
## Navigation syntax
Our navigation syntax is recursive which means you can make nested navigation groups. You don't need to include `.mdx` in page names.
```json Regular Navigation theme={null}
"navigation": {
"tabs": [
{
"tab": "Docs",
"groups": [
{
"group": "Getting Started",
"pages": ["quickstart"]
}
]
}
]
}
```
```json Nested Navigation theme={null}
"navigation": {
"tabs": [
{
"tab": "Docs",
"groups": [
{
"group": "Getting Started",
"pages": [
"quickstart",
{
"group": "Nested Reference Pages",
"pages": ["nested-reference-page"]
}
]
}
]
}
]
}
```
## Folders
Simply put your MDX files in folders and update the paths in `docs.json`.
For example, to have a page at `https://yoursite.com/your-folder/your-page` you would make a folder called `your-folder` containing an MDX file called `your-page.mdx`.
You cannot use `api` for the name of a folder unless you nest it inside another folder. Mintlify uses Next.js which reserves the top-level `api` folder for internal server calls. A folder name such as `api-reference` would be accepted.
```json Navigation With Folder theme={null}
"navigation": {
"tabs": [
{
"tab": "Docs",
"groups": [
{
"group": "Group Name",
"pages": ["your-folder/your-page"]
}
]
}
]
}
```
## Hidden Pages
MDX files not included in `docs.json` will not show up in the sidebar but are accessible through the search bar and by linking directly to them.
# Reusable Snippets
Source: https://docs.whatsable.app/essentials/reusable-snippets
Reusable, custom snippets to keep content in sync
One of the core principles of software development is DRY (Don't Repeat
Yourself). This is a principle that apply to documentation as
well. If you find yourself repeating the same content in multiple places, you
should consider creating a custom snippet to keep your content in sync.
## Creating a custom snippet
**Pre-condition**: You must create your snippet file in the `snippets` directory.
Any page in the `snippets` directory will be treated as a snippet and will not
be rendered into a standalone page. If you want to create a standalone page
from the snippet, import the snippet into another file and call it as a
component.
### Default export
1. Add content to your snippet file that you want to re-use across multiple
locations. Optionally, you can add variables that can be filled in via props
when you import the snippet.
```mdx snippets/my-snippet.mdx theme={null}
Hello world! This is my content I want to reuse across pages. My keyword of the
day is {word}.
```
The content that you want to reuse must be inside the `snippets` directory in
order for the import to work.
2. Import the snippet into your destination file.
```mdx destination-file.mdx theme={null}
---
title: My title
description: My Description
---
import MySnippet from '/snippets/path/to/my-snippet.mdx';
## Header
Lorem impsum dolor sit amet.
```
### Reusable variables
1. Export a variable from your snippet file:
```mdx snippets/path/to/custom-variables.mdx theme={null}
export const myName = 'my name';
export const myObject = { fruit: 'strawberries' };
```
2. Import the snippet from your destination file and use the variable:
```mdx destination-file.mdx theme={null}
---
title: My title
description: My Description
---
import { myName, myObject } from '/snippets/path/to/custom-variables.mdx';
Hello, my name is {myName} and I like {myObject.fruit}.
```
### Reusable components
1. Inside your snippet file, create a component that takes in props by exporting
your component in the form of an arrow function.
```mdx snippets/custom-component.mdx theme={null}
export const MyComponent = ({ title }) => (
{title}
... snippet content ...
);
```
MDX does not compile inside the body of an arrow function. Stick to HTML
syntax when you can or use a default export if you need to use MDX.
2. Import the snippet into your destination file and pass in the props
```mdx destination-file.mdx theme={null}
---
title: My title
description: My Description
---
import { MyComponent } from '/snippets/custom-component.mdx';
Lorem ipsum dolor sit amet.
```
# Global Settings
Source: https://docs.whatsable.app/essentials/settings
Mintlify gives you complete control over the look and feel of your documentation using the docs.json file
Every Mintlify site needs a `docs.json` file with the core configuration settings. Learn more about the [properties](#properties) below.
## Properties
Name of your project. Used for the global title.
Example: `mintlify`
An array of groups with all the pages within that group
The name of the group.
Example: `Settings`
The relative paths to the markdown files that will serve as pages.
Example: `["customization", "page"]`
Path to logo image or object with path to "light" and "dark" mode logo images
Path to the logo in light mode
Path to the logo in dark mode
Where clicking on the logo links you to
Path to the favicon image
Hex color codes for your global theme
The primary color. Used for most often for highlighted content, section
headers, accents, in light mode
The primary color for dark mode. Used for most often for highlighted
content, section headers, accents, in dark mode
The primary color for important buttons
The color of the background in both light and dark mode
The hex color code of the background in light mode
The hex color code of the background in dark mode
Array of `name`s and `url`s of links you want to include in the topbar
The name of the button.
Example: `Contact us`
The url once you click on the button. Example: `https://mintlify.com/docs`
Link shows a button. GitHub shows the repo information at the url provided including the number of GitHub stars.
If `link`: What the button links to.
If `github`: Link to the repository to load GitHub information from.
Text inside the button. Only required if `type` is a `link`.
Array of version names. Only use this if you want to show different versions
of docs with a dropdown in the navigation bar.
An array of the anchors, includes the `icon`, `color`, and `url`.
The [Font Awesome](https://fontawesome.com/search?q=heart) icon used to feature the anchor.
Example: `comments`
The name of the anchor label.
Example: `Community`
The start of the URL that marks what pages go in the anchor. Generally, this is the name of the folder you put your pages in.
The hex color of the anchor icon background. Can also be a gradient if you pass an object with the properties `from` and `to` that are each a hex color.
Used if you want to hide an anchor until the correct docs version is selected.
Pass `true` if you want to hide the anchor until you directly link someone to docs inside it.
One of: "brands", "duotone", "light", "sharp-solid", "solid", or "thin"
Override the default configurations for the top-most anchor.
The name of the top-most anchor
Font Awesome icon.
One of: "brands", "duotone", "light", "sharp-solid", "solid", or "thin"
An array of navigational tabs.
The name of the tab label.
The start of the URL that marks what pages go in the tab. Generally, this
is the name of the folder you put your pages in.
Configuration for API settings. Learn more about API pages at [API Components](/api-playground/demo).
The base url for all API endpoints. If `baseUrl` is an array, it will enable for multiple base url
options that the user can toggle.
The authentication strategy used for all API endpoints.
The name of the authentication parameter used in the API playground.
If method is `basic`, the format should be `[usernameName]:[passwordName]`
The default value that's designed to be a prefix for the authentication input field.
E.g. If an `inputPrefix` of `AuthKey` would inherit the default input result of the authentication field as `AuthKey`.
Configurations for the API playground
Whether the playground is showing, hidden, or only displaying the endpoint with no added user interactivity `simple`
Learn more at the [playground guides](/api-playground/demo)
Enabling this flag ensures that key ordering in OpenAPI pages matches the key ordering defined in the OpenAPI file.
This behavior will soon be enabled by default, at which point this field will be deprecated.
A string or an array of strings of URL(s) or relative path(s) pointing to your
OpenAPI file.
Examples:
```json Absolute theme={null}
"openapi": "https://example.com/openapi.json"
```
```json Relative theme={null}
"openapi": "/openapi.json"
```
```json Multiple theme={null}
"openapi": ["https://example.com/openapi1.json", "/openapi2.json", "/openapi3.json"]
```
An object of social media accounts where the key:property pair represents the social media platform and the account url.
Example:
```json theme={null}
{
"x": "https://x.com/mintlify",
"website": "https://mintlify.com"
}
```
One of the following values `website`, `facebook`, `x`, `discord`, `slack`, `github`, `linkedin`, `instagram`, `hacker-news`
Example: `x`
The URL to the social platform.
Example: `https://x.com/mintlify`
Configurations to enable feedback buttons
Enables a button to allow users to suggest edits via pull requests
Enables a button to allow users to raise an issue about the documentation
Customize the dark mode toggle.
Set if you always want to show light or dark mode for new users. When not
set, we default to the same mode as the user's operating system.
Set to true to hide the dark/light mode toggle. You can combine `isHidden` with `default` to force your docs to only use light or dark mode. For example:
```json Only Dark Mode theme={null}
"modeToggle": {
"default": "dark",
"isHidden": true
}
```
```json Only Light Mode theme={null}
"modeToggle": {
"default": "light",
"isHidden": true
}
```
A background image to be displayed behind every page. See example with
[Infisical](https://infisical.com/docs) and [FRPC](https://frpc.io).
# Error Handling
Source: https://docs.whatsable.app/guides/error-handling
Handle errors when using WhatsAble APIs: HTTP status codes, error format, and retry strategies.
# Error Handling
This guide explains how to handle errors when using WhatsAble APIs.
## HTTP Status Codes
All WhatsAble APIs use standard HTTP status codes:
* `200 OK`: Request successful
* `400 Bad Request`: Invalid request parameters
* `401 Unauthorized`: Invalid or missing API key
* `403 Forbidden`: Insufficient permissions
* `404 Not Found`: Resource not found
* `429 Too Many Requests`: Rate limit exceeded
* `500 Internal Server Error`: Server-side error
## Error Response Format
All error responses follow this format:
```json theme={null}
{
"error": {
"code": "error_code",
"message": "Human-readable error message"
}
}
```
## Common Error Codes
### Authentication Errors
* `invalid_api_key`: API key is invalid or expired
* `missing_api_key`: API key is missing from request
### Request Errors
* `invalid_phone_number`: Phone number format is incorrect
* `invalid_template`: Template ID is invalid or not found
* `missing_required_field`: Required field is missing
* `invalid_variables`: Template variables are invalid
### Rate Limit Errors
* `rate_limit_exceeded`: Too many requests in a time period
* `quota_exceeded`: Monthly quota exceeded
## Best Practices
1. **Always Check Status Codes**: Don't assume success
2. **Implement Retry Logic**: For 429 and 500 errors
3. **Log Errors**: For debugging and monitoring
4. **Handle Timeouts**: Set appropriate timeout values
5. **Validate Input**: Before making API calls
## Example Error Handling
```javascript theme={null}
async function sendMessage() {
try {
const response = await fetch('https://api.insightssystem.com/api:hFrjh8a1/send_template_message_by_api', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer YOUR_TOKEN'
},
body: JSON.stringify({
template: 'template_id',
variables: {},
phone_number: '+1234567890'
})
});
if (!response.ok) {
const error = await response.json();
throw new Error(error.error.message);
}
const data = await response.json();
return data;
} catch (error) {
console.error('Error sending message:', error);
// Handle error appropriately
}
}
```
# Embedding Process
Source: https://docs.whatsable.app/guides/notifier-system/embedding-process
Connect your WhatsApp Business Account to the Notifyer System to enable automated messaging capabilities
# WhatsApp Business Account Integration
## Overview
Notifyer System enables businesses to send automated WhatsApp messages to customers through a direct integration with the WhatsApp Business Platform. This guide walks you through the embedding process to connect your WhatsApp Business Account with Notifyer System.
This process uses Meta's Embedded Signup flow, which allows you to create or connect your WhatsApp Business Account directly within Notifyer System.
## Prerequisites
Active Notifyer System account with a subscription plan or pay-as-you-go credit
Meta Business Portfolio (or willingness to create one during the process)
A phone number that isn't currently associated with any WhatsApp account
The phone number you use for your WhatsApp Business Account cannot have an existing WhatsApp account associated with it. If you're using a number that already has WhatsApp, you'll need to delete that account or use a different number.
## Integration Process
1. Log in to your Notifyer System dashboard
2. Navigate to **Your Templates** section
3. Make sure you're on the **Connect to WhatsApp** tab
4. Click the **Connect your WhatsApp Number** button in the center of the page
![]()
You can track your progress through the onboarding process using the steps indicator in the bottom-left corner of the screen.
1. Log in with your Facebook account when prompted
2. If already logged in, click **Continue as \[your Facebook username]**
3. Review the permissions Notifyer System is requesting
4. Click **Get Started** to begin the configuration process
![Connecting with Facebook]()
Select an existing business portfolio or create a new one
If you choose to create a new business portfolio, fill out the required fields:
Your official business name (must be unique among your portfolios)
A valid email that can receive verification messages
Your business website URL or social media profile
Country where your business is located
![Entering required information in Business Information section]()
Choose a business portfolio you've already configured in Meta Business Suite
See how to [create a business portfolio in Meta Business Suite and Business Manager.](https://www.facebook.com/business/help/1710077379203657)
If you select an existing portfolio, your business name, website, and country will be automatically populated from your Meta Business configuration.
Select whether to create a new account or use an existing one
**Recommended** for first-time users (default option)
Only available if you have existing WhatsApp Business accounts
Select whether to create a new profile or use an existing one
**Recommended** for first-time users (default option)
Only available if you connect an existing WhatsApp Business profile
![Selecting options for WhatsApp Business Account and Profile]()
The internal name of your account (used for management purposes)
The name your customers will see when receiving messages from your business
This is the name your customers will see when receiving messages from your business. Choose carefully as it impacts brand recognition.
Business category that best represents your industry (will be displayed on your profile)
![Entering required information in Create a WhatsApp business profile section]()
Choose how to add your phone number
Use your own business phone number
WhatsApp will generate a +1 555 number (limited functionality)
Choose how to receive your verification code
Receive verification code via SMS
Receive verification code via automated call
![Entering required informstion in Create a WhatsApp business profile section]()
Enter the verification code received via your selected method
![Entering required informstion in Create a WhatsApp business profile section]()
1. After verification, you'll see a "You're now ready to chat with people on WhatsApp" screen
2. Click the **Add Payment Method** button
3. You'll be redirected to the Facebook Business "Billing & Payments" page
4. Select "Payment Methods" from the left menu
5. Ensure you're on the "WhatsApp Business accounts" tab
6. Select your WhatsApp account from the dropdown (verify WhatsApp account ID)
7. Click "Add Payment Method" and provide the required information
8. Set your payment method as the default option
This step is critical for ensuring you can send messages without restrictions. Unverified businesses may experience limited functionality.
1. Navigate to Settings in your Facebook Business Manager
2. Select "WhatsApp accounts" under the "Accounts" section
3. Scroll down to the "Business verification" section
4. Click "Start verification" to access the Security Center
5. Complete the business verification process by providing the requested business information and documentation
## Account Dashboard Overview
Once your WhatsApp Business Account is connected, you'll have access to the following tabs in the "Your Templates" section:
Connect your WhatsApp Business Account using the "Sign up with Facebook" option
Design message templates and submit them to Meta for approval
View, manage, and monitor the approval status of your message templates
## Integration Options
After successfully embedding your WhatsApp Business Account, you can integrate Notifyer System with your preferred automation platform:
Connect Notifyer System with Make to create powerful automation workflows.
[View Make Documentation →](https://docs.whatsable.app/guides/notifier-system/make-overview)
Integrate with Zapier to connect WhatsApp messaging with thousands of applications.
[View Zapier Documentation →](https://docs.whatsable.app/guides/notifier-system/zapier-overview)
Use n8n for advanced workflow automation with WhatsApp messaging.
[View n8n Documentation →](https://docs.whatsable.app/guides/notifier-system/n8n-overview)
Implement custom integrations using our comprehensive API.
[Try API Reference →](https://docs.whatsable.app/api-reference/introduction)
## API Reference
Retrieve all your approved message templates
Send messages using your approved templates
Handle incoming messages from customers
Experiment with the Get Templates API and view responses in real-time
## Alternative Option: Notifier
If the embedding process is too complex for your needs, you can use Notifier by WhatsAble instead, which allows you to send automated messages through our WhatsApp bot without going through the full embedding process.
Discover a simpler way to send automated WhatsApp messages using Notifier by WhatsAble
## Troubleshooting
If your phone number verification fails:
1. Ensure the phone number isn't already linked to a WhatsApp account
2. Wait 24 hours before trying again with the same number
3. Try a different verification method (SMS vs. call)
4. Contact support if issues persist
If you encounter problems with business verification:
1. Ensure all business information is accurate and matches official documents
2. Provide clear, high-quality images of requested documentation
3. Allow 1-2 business days for verification review
4. Submit an appeal if verification is rejected
## Resources
Manage your Meta business profiles and portfolios
Learn more about the WhatsApp Business Platform
Meta's official documentation on embedded signup
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the chat button in the bottom right corner of the Notifyer System dashboard
# Notifier System Features
Source: https://docs.whatsable.app/guides/notifier-system/features
Explore the enterprise features of Notifier System
# Notifier System Features
Notifier System provides comprehensive enterprise-grade features for WhatsApp messaging.
## Core Features
### Message Types
* Text messages
* Media messages (images, documents, audio, video)
* Location sharing
* Contact sharing
* Interactive messages
* List messages
* Button messages
* Product messages
* Order messages
### Message Management
* Message status tracking
* Delivery receipts
* Read receipts
* Message history
* Message templates
* Bulk messaging
* Scheduled messages
* Priority queuing
* Message routing
### Security
* End-to-end encryption
* API key authentication
* Rate limiting
* IP whitelisting
* Two-factor authentication
* Audit logs
* Data encryption at rest
* Compliance monitoring
## Enterprise Features
### Multi-tenant Support
* Multiple business units
* Separate message queues
* Custom branding
* Independent analytics
* Role-based access
### Advanced Templates
* Pre-approved message templates
* Dynamic variables
* Multi-language support
* Template analytics
* Template versioning
* Template approval workflow
* Template categories
### Automation
* Workflow automation
* Conditional messaging
* Event-based triggers
* Custom webhooks
* Integration with third-party services
* Business rules engine
* Custom scripting
### Analytics
* Message delivery rates
* Response times
* User engagement
* Template performance
* Custom reports
* Real-time dashboards
* Export capabilities
* API access
## Best Practices
### Enterprise Setup
* Define clear workflows
* Set up proper monitoring
* Implement security measures
* Configure backup systems
* Document processes
### Message Strategy
* Use approved templates
* Implement proper error handling
* Monitor message status
* Follow WhatsApp guidelines
* Regular template updates
* A/B testing
* Performance optimization
## Next Steps
* Learn about [Integrations](/guides/notifier-system/integrations)
* Explore [Enterprise Features](/guides/notifier-system/enterprise/security)
* Check out our [API Reference](/api-reference/notifier-system)
* Read our [Getting Started](/guides/notifier-system/getting-started) guide
# Getting Started with Notifier System
Source: https://docs.whatsable.app/guides/notifier-system/getting-started
Learn how to get started with Notifier System, the flagship WhatsApp messaging solution
# Getting Started with Notifier System
Notifier System is our flagship WhatsApp messaging solution, designed for enterprise-level communication needs.
## Prerequisites
* WhatsApp Business API account
* Business verification
* Technical team for integration
* Understanding of enterprise messaging
* Your Notifier System API credentials
## Quick Setup
1. Contact our sales team for enterprise setup
2. Complete business verification
3. Set up your WhatsApp Business API account
4. Configure your Notifier System instance
5. Get your API credentials
6. Set up webhooks and monitoring
## First Message
Here's a quick example of sending your first message:
```bash theme={null}
curl -X POST https://api.notifiersystem.com/v1/messages \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"to": "+1234567890",
"template": "enterprise_welcome",
"variables": {
"name": "John",
"company": "Enterprise Corp",
"department": "Sales"
},
"metadata": {
"campaign_id": "welcome_2024",
"segment": "enterprise",
"priority": "high"
}
}'
```
## Enterprise Features
* Multi-tenant support
* Role-based access control
* Advanced security features
* Custom integrations
* Enterprise-grade support
## Next Steps
* Learn about [Features](/guides/notifier-system/features)
* Explore [Integrations](/guides/notifier-system/integrations)
* Check out [Enterprise Features](/guides/notifier-system/enterprise/security)
* Review our [API Reference](/api-reference/notifier-system)
# Notifier System Integrations
Source: https://docs.whatsable.app/guides/notifier-system/integrations
Learn how to integrate Notifier System with your enterprise applications
# Notifier System Integrations
Integrate Notifier System with your enterprise tools and platforms.
## Available Integrations
### Enterprise Platforms
* Salesforce
* SAP
* Oracle
* Microsoft Dynamics
* ServiceNow
### CRM Systems
* Salesforce
* HubSpot
* Zoho CRM
* Pipedrive
* Microsoft Dynamics
* Custom CRM solutions
### E-commerce Platforms
* Shopify Plus
* Magento Enterprise
* SAP Commerce
* Oracle Commerce
* Custom e-commerce solutions
### Marketing Tools
* Adobe Marketing Cloud
* Salesforce Marketing Cloud
* Oracle Marketing Cloud
* HubSpot Enterprise
* Custom marketing platforms
## Custom Integration
### REST API
```javascript theme={null}
const axios = require('axios');
const sendEnterpriseMessage = async (message) => {
try {
const response = await axios.post(
'https://api.notifiersystem.com/v1/messages',
message,
{
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_SYSTEM_API_KEY}`,
'Content-Type': 'application/json',
'X-Tenant-ID': process.env.TENANT_ID
}
}
);
return response.data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
```
### Webhooks
Configure webhooks for enterprise-level monitoring:
```json theme={null}
{
"event": "message.status",
"data": {
"message_id": "msg_123",
"status": "delivered",
"template": "enterprise_welcome",
"variables": {
"name": "John",
"company": "Enterprise Corp",
"department": "Sales"
},
"metadata": {
"campaign_id": "welcome_2024",
"segment": "enterprise",
"priority": "high"
},
"timestamp": "2024-03-20T10:00:00Z"
}
}
```
## Enterprise Features
### Multi-tenant Support
* Separate API keys per tenant
* Custom webhook endpoints
* Tenant-specific templates
* Independent analytics
* Custom branding
### Security
* IP whitelisting
* API key rotation
* Audit logging
* Data encryption
* Compliance monitoring
### Monitoring
* Real-time status
* Error tracking
* Performance metrics
* Usage analytics
* Cost tracking
## Best Practices
### Integration
* Use environment variables
* Implement retry logic
* Handle rate limits
* Monitor webhook delivery
* Use template variables
* Implement proper error handling
* Set up monitoring
* Regular security audits
### Development
* Follow API guidelines
* Use SDK when available
* Test thoroughly
* Document integration
* Version control
* CI/CD pipeline
* Regular updates
## Next Steps
* Read our [Getting Started](/guides/notifier-system/getting-started) guide
* Explore [Features](/guides/notifier-system/features)
* Check out [Enterprise Features](/guides/notifier-system/enterprise/security)
* Review our [API Reference](/api-reference/notifier-system)
# Make
Source: https://docs.whatsable.app/guides/notifier-system/make-overview
Learn how to seamlessly integrate Make with the Notifyer System for enterprise-level WhatsApp automation
# Notifyer System Integration with Make
![]()
This guide walks you through connecting Notifyer System with Make to create powerful automated WhatsApp messaging workflows for your business
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Make](https://www.make.com/en/register) workflow automation platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform embedding process, which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
To connect Notifyer System with Make, you'll need an API key:
1. In your Notifyer dashboard, navigate to [**API Keys**](https://console.notifyer-systems.com/api-key)
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Connect Notifyer System to Make
Now that you have Notifyer System set up, let's connect it to Make to automate your scenarios.
1. Log in to your Make account
2. Navigate to Notifyer System dashboard and select **Connect to Make** in the side menu
3. Click **Continue** in the connection guide popup
4. Click **Install**, select your organization at the bottom of the screen, then click **Install** again. (Note: You need Admin, Owner, or App Developer role in your organization to install apps.)
You're now ready to create scenarios with the Notifyer System app
![Installing Notifyer System in Make]()
1. Log in to your Make account
2. Create a new scenario by clicking **+ Create a new scenario**
3. (Optional) Add a trigger module of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up a module/trigger Make]()
1. Click the **+** button to add a new module
2. Search for **Notifyer System** in the apps or modules library
3. Select the module with the official Notifyer System logo
![Adding the Notifyer System module]()
1. Once you click on Notifyer System module, select '**Send a WhatsApp Message with Your Template**' or '**Send a WhatsApp Message without Template**' from the **ACTIONS**
2. Click **Create a connection** in the **Connection** section of Notifyer System module and you will be prompted to enter your API Key
3. Enter your Notifyer System API key that you copied earlier
4. Rename your connection name if needed
5. Click **Save** to store your credential
![Configuring Notifyer System credentials]()
Depending on your messaging needs, choose one of the following operations:
Complete the required fields:
Enter the recipient's phone number with country code (e.g., +1234567890) or use dynamic data from previous nodes
Select from your pre-approved templates in the dropdown
Enter publicly accessible media URL for Media (image/video/document) header.
This field will only appear if you have a Media (image/video/document) header configured in your selected template.
Fill in values for each variable in your template, mapping them to dynamic data when applicable
Add note for internal tracking. This data won't be sent to the recipient
Select label(s) for internal tracking. This data won't be sent to the recipient
![Template Message Configuration]()
Complete the required fields:
Enter the recipient's phone number with country code (e.g., +1234567890) or use dynamic data from previous nodes
Choose from the following message types:
For plain text messages
For sending images (JPEG, PNG, etc.)
For sending videos (MP4, 3GP, etc.)
For sending documents (PDF, Word, etc.)
For sending videos (MP3, OGG, etc.)
For messages with button that contain URL or dynamic URL
Keep the option at the default 'No'. If there is a link/URL in the text body and you want the recipient to see a preview, select 'Yes'
Enter the text message content
Enter the publicly accessible URL for your image file
Optional caption for the image
Enter the publicly accessible URL for your video file
Optional caption for the video
Enter the publicly accessible URL for your document
Optional caption for the document
Enter the filename (e.g., report.pdf)
Enter the publicly accessible URL for your audio file (MP3, OGG)
Enter optional text to show at the top
Enter the main content of the message
Enter the text to display on button
Enter the URL for the button
Enter the optional text to show at bottom
Select label(s) for internal tracking. This data won't be sent to the recipient
![Non-Template Message Configuration]()
1. Click **Save** to save your message configuration
2. Right click on the WhatsAble module and select **Run this module only** to verify the module is working correctly
* or click **Run once** in the bottom-left corner of the screen to test the entire scenario
3. If the test is successful, you'll see a confirmation message
4. Click **Save** icon in the bottom-left corner to save your scenario (You can also set timer intarval for the scenario)
5. Toggle the **Active** switch in the bottom-left corner with time to activate your scenario
![Testing and activating your scenario]()
## Example use cases
Send automatic order confirmations when new orders are placed
Schedule reminders before upcoming appointments
Alert your sales team when new leads come in
Route support inquiries to the appropriate team member
Keep customers informed about their delivery status
Send automatic payment reminders for overdue accounts
## Best practices
Always test your workflows with test phone numbers before activating them for production use.
Whenever possible, use pre-approved templates for better deliverability and compliance.
Include customer names and specific details to increase engagement and response rates.
Ensure all message content complies with WhatsApp Business policies to avoid account restrictions.
Regularly check your message delivery rates in your Notifyer dashboard.
## Troubleshooting
Ensure your API key is entered correctly in the Make credentials
Confirm phone numbers are in the correct international format (e.g., +14155552671)
Verify your Notifyer subscription is active and has available credits
For template messages, ensure you're using an approved template
Verify all required variables are included in your template message
Check that variable formats match the expected values (text, number, date, etc.)
Ensure you're using the correct template name exactly as it appears in your dashboard
Confirm your media URLs are publicly accessible (test in an incognito browser)
Verify the file format is supported by WhatsApp
Check that file sizes are within WhatsApp limits:
* Images: up to 5MB
* Videos: up to 16MB
* Documents: up to 100MB
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations (Make.com, Zapier, etc.), please contact our support team or check our integration documentation.
# n8n
Source: https://docs.whatsable.app/guides/notifier-system/n8n-overview
Learn how to seamlessly integrate n8n with the Notifyer System for enterprise-level WhatsApp automation
# Notifyer System Integration with n8n
![]()
This guide walks you through connecting Notifyer System with n8n to create powerful automated WhatsApp messaging workflows for your business
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [n8n](https://app.n8n.cloud/login) workflow automation platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform embedding process, which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
To connect Notifyer System with n8n, you'll need an API key:
1. In your Notifyer dashboard, navigate to [**API Keys**](https://console.notifyer-systems.com/api-key)
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Integrating with n8n
1. Log in to your n8n account
2. Create a new workflow by clicking **Create Workflow**
3. Add a trigger node of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
The WhatsAble trigger node enables your workflow to respond automatically to incoming WhatsApp messages. This setup is optional but recommended for building reactive communication flows.
Follow these steps to add the WhatsAble trigger node to your workflow:
1. Click the **+** button in your workflow canvas to add a new node
2. Search for "WhatsAble" in the node library search bar
3. Select the node displaying the official WhatsAble logo
4. From the available trigger options, choose **On new Incoming message event**
![WhatsAble node selection showing trigger options]()
The trigger node will automatically listen for incoming messages and initiate your workflow when a new message is received.
Set up your WhatsAble API credentials to establish a secure connection:
**Webhook URL Configuration:**
1. In the WhatsAble Trigger node parameters, locate the **Webhook URLs** section at the top
2. Select **Production URL** and copy the generated URL by clicking on it
3. Store this URL securely as you'll need it for the credential setup
![Production URL selection and copy interface]()
**Credential Creation:**
1. In the **Credential to connect with** dropdown, click **+ Create new credential**
2. Select **WhatsAble Notifyer System API** as your connection method
3. Enter your Notifyer System API key in the **API Key** field
4. Paste the Production URL you copied earlier into the **Production URL** field
5. Assign a descriptive name to your credential (e.g., "WhatsAble Production")
6. Click **Save** to securely store your credentials
![WhatsAble credential configuration interface]()
Your API credentials are encrypted and stored securely. Never share your API key publicly or commit it to version control.
Complete the setup by testing and activating your trigger:
**Response Configuration:**
1. In the **Respond** dropdown, select your preferred response timing:
* **Immediately**: Responds as soon as the trigger fires
* **When Last Node Finishes**: Waits for the entire workflow to complete before responding
**Testing:**
1. Click **Execute step** on the WhatsAble node to run a test
2. Verify the connection is working by checking for a success confirmation
3. Review any error messages if the test fails and adjust your configuration accordingly
Once activated, your workflow will automatically process incoming messages according to your configured logic.
Remember to test your workflow thoroughly before activating it in production to ensure it behaves as expected.
1. Click the **+** button after your trigger node
2. Search for "WhatsAble" in the nodes panel
3. Select the node with the official WhatsAble logo
4. After selecting the WhatsAble node, choose 'Send template via Notifyer' or 'Send non-template via Notifyer' as needed.
![WhatsAble node selection]()
1. In the WhatsAble node **Parameters**, find the **Credential to connect with** dropdown
2. Select **+ Create new credential**
3. Enter your Notifyer System API key that you copied earlier
4. Name your credential (e.g., "Notifyer Production")
5. Click **Save** to store your credential
![Configuring Notifyer System credential]()
1. In **Resource** dropdown, select **Send Message**
2. In the **Operation** dropdown, choose **Send template via Notifyer** for template messages or **Send non‑template via Notifyer** for regular messages (only works within the 24‑hour window).
3. Complete the required fields:
Complete the required fields:
Enter the recipient's phone number with country code (e.g., +14155552671) or use dynamic data from previous nodes
Select from your pre-approved templates in the dropdown
Based on your selected Template message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
For all media types, ensure your file URLs are publicly accessible and match the supported file formats.
(Optional) Include a note in the template message for internal tracking
(Optional) Select the label(s) you created in Chat Notifyer for internal tracking
(Optional) Select the date and time to schedule when your message will be sent
Enter the **Phone Number** with country code
Choose from the following message types:
For plain text messages
For sending documents (PDF, Word, etc.)
For sending images (JPEG, PNG, etc.)
For sending videos (MP4, 3GP, etc.)
Based on your selected message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
For all media types, ensure your file URLs are publicly accessible and match the supported file formats.
(Optional) Select the label(s) you created in Chat Notifyer for internal tracking
(Optional) Select the date and time to schedule when your message will be sent
1. Click **Test Step** on the Notifyer node to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Return to your workflow
4. Click **Save** to save your entire workflow
5. Toggle the **Active** switch in the top-right corner to activate your workflow
Your automated messaging workflow is now operational! Whenever your trigger conditions are met, n8n will automatically send WhatsApp messages through Notifyer System.
## Example use cases
Send automatic order confirmations when new orders are placed
Schedule reminders before upcoming appointments
Alert your sales team when new leads come in
Route support inquiries to the appropriate team member
Keep customers informed about their delivery status
Send automatic payment reminders for overdue accounts
## Best practices
Always test your workflows with test phone numbers before activating them for production use.
Whenever possible, use pre-approved templates for better deliverability and compliance.
Include customer names and specific details to increase engagement and response rates.
Ensure all message content complies with WhatsApp Business policies to avoid account restrictions.
Regularly check your message delivery rates in your Notifyer dashboard.
## Troubleshooting
Ensure your API key is entered correctly in the n8n credentials
Confirm phone numbers are in the correct international format (e.g., +14155552671)
Verify your Notifyer subscription is active and has available credits
For template messages, ensure you're using an approved template
Verify all required variables are included in your template message
Check that variable formats match the expected values (text, number, date, etc.)
Ensure you're using the correct template name exactly as it appears in your dashboard
Confirm your media URLs are publicly accessible (test in an incognito browser)
Verify the file format is supported by WhatsApp
Check that file sizes are within WhatsApp limits:
* Images: up to 5MB
* Videos: up to 16MB
* Documents: up to 100MB
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer dashboard
For additional automation platform integrations (Make.com, Zapier, etc.), please contact our support team or check our integration documentation.
# Pipedrive
Source: https://docs.whatsable.app/guides/notifier-system/pipedrive-overview
Learn how to seamlessly integrate Pipedrive with the Notifyer System for automated WhatsApp messaging
# Notifyer System Integration with Pipedrive
![]()
This guide walks you through connecting Notifyer System with Pipedrive to create powerful automated WhatsApp messaging workflows for your sales and CRM processes
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Pipedrive](https://www.pipedrive.com/) CRM platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform [embedding process](/guides/notifier-system/embedding-process), which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
Follow these simple steps to integrate your Pipedrive account with Notifyer System:
In your Notifyer dashboard, go to [**Connect to Pipedrive**](https://console.notifyer-systems.com/pipedrive).
Click the 'Connect Pipedrive Organization' button.
You'll be redirected to Pipedrive's authorization page. Review the permissions and click 'Authorize' to grant Notifyer System access to your Pipedrive organization.
After authorization, you'll be automatically redirected back to your Notifyer System dashboard. Look for the connection status showing 'Connected to Pipedrive' to confirm the integration was successful.
![Connecting Notifyer System with Pipedrive]()
## Sending WhatsApp Messages from Pipedrive
WhatsAble's integration with Pipedrive allows you to send WhatsApp messages directly from your deals and contacts without leaving your CRM. This guide will walk you through the complete process.
### Verifying Prerequisites
Before sending WhatsApp messages, ensure the following requirements are met:
Must show as **PAID**
Must show as **ACTIVE**
Must be properly synced with WhatsAble
You can verify these settings in the WhatsAble Integration section of any deal or contact.
## Sending Messages from Deals
### Accessing the WhatsAble Integration Panel
1. Go to your **Pipedrive Dashboard**
2. Open your desired **Pipeline**
3. Select a **Deal** from your pipeline
1. On the right-hand panel, scroll down past the Summary section
2. Find the **WhatsAble Integration** section
![WhatsAble Integration Panel]()
### Understanding the Integration Panel
The WhatsAble Integration panel displays important connection information:
Confirms your subscription is active
Shows which WhatsApp Business account is connected
Indicates if your WhatsApp connection is active
Displays the date and time of the most recent message
Provides a direct link to the conversation
### Sending Options
Within the WhatsAble Integration section, you'll find a green **"Live Chat"** button with a dropdown menu offering three options:
Opens the WhatsAble chat interface directly within Pipedrive
Schedule a message to be sent at a specific date and time
Send a pre-configured template message immediately
## Option 1: Send Scheduled Message
Use this option when you want to send a message at a specific future date and time.
1. Click the dropdown next to the **Live Chat** button
2. Select **"Send Scheduled Message"**
3. A modal window will appear with the following fields
The recipient's phone number(s) associated with the deal. This field is automatically populated from the deal's contact information.
Your connected WhatsApp Business account. This field is pre-filled and cannot be modified from this interface.
Choose from your pre-created message templates. These templates must be created beforehand in the **Notifyer by WhatsAble** dashboard.
Once you select a template, all required placeholder fields will appear dynamically. Fill in each field carefully to personalize your message (e.g., customer name, appointment time, order details).
Select the exact date and time you want the message to be sent.
Specify the timezone from which you're scheduling the message to ensure accurate delivery timing.
Include an internal note for your team. This note is only visible within Pipedrive and helps with tracking and context.
Assign labels to categorize and organize your communications for easier filtering and reporting.
At the top of the modal, you'll see your **most recent messages** with this contact (if any previous conversations exist), providing helpful context before sending.
1. Review all information carefully
2. Click the **"Schedule Template"** button at the bottom of the modal
3. Your message is now scheduled and will be sent automatically at the specified time
Message successfully scheduled! It will be sent at the specified time.
![Schedule Template Modal]()
## Option 2: Send Template (Immediate)
Use this option to send a pre-configured template message immediately without scheduling.
1. Click the dropdown next to the **Live Chat** button
2. Select **"Send Template"**
3. A modal window will appear with the following fields
The recipient's phone number(s) associated with the deal. This field is automatically populated from the deal's contact information.
Your connected WhatsApp Business account. This field is pre-filled and cannot be modified from this interface.
Choose from your pre-created message templates. These templates must be created beforehand in the **Notifyer by WhatsAble** dashboard.
Once you select a template, all required placeholder fields will appear dynamically. Fill in each field carefully to personalize your message (e.g., customer name, product details, tracking numbers).
Include an internal note for your team. This note is only visible within Pipedrive and helps with tracking and context.
Assign labels to categorize and organize your communications for easier filtering and reporting.
At the top of the modal, you'll see your **most recent messages** with this contact (if any previous conversations exist), providing helpful context before sending.
1. Review all information carefully
2. Click the **"Send Template"** button at the bottom of the modal
3. Your message will be sent immediately
Message sent successfully!
![Send Template Modal]()
## Sending Messages from Contacts
The process for sending WhatsApp messages from contacts is nearly identical to sending from deals, with minor differences noted below.
### Accessing the WhatsAble Integration Panel
1. Go to your **Pipedrive Dashboard**
2. Navigate to the **Contacts** menu
3. Select your desired **Contact**
1. On the right-hand panel, scroll down past the Summary section
2. Find the **WhatsAble Integration** section
![WhatsAble Integration Panel]()
### Understanding the Integration Panel
The WhatsAble Integration panel displays the same connection information as in deals:
Confirms your subscription is active
Shows which WhatsApp Business account is connected
Indicates if your WhatsApp connection is active
Displays the date and time of the most recent message
Provides a direct link to the conversation
### Sending Options
The same three options are available:
Opens the WhatsAble chat interface directly within Pipedrive
Schedule a message for a specific date and time
Send a template message immediately
**Key Difference**: Phone numbers are pulled from the contact's information rather than deal-specific numbers. All other fields and processes remain identical to sending from deals.
## Best Practices
**Before Sending Messages**
Always check that your WhatsApp connection shows as ACTIVE before attempting to send messages to avoid delivery failures.
**Template Management**
* Ensure your message templates are up-to-date in the Notifyer dashboard
* Test templates with yourself before using them with customers
* Create templates in advance for different scenarios
**Phone Number Verification**
* Confirm the recipient's phone number is correct
* Verify the number includes the country code (e.g., +1 for US)
* Update contact information if numbers are missing or incorrect
**Message Organization**
* Develop a clear labeling system for easier tracking
* Apply consistent labels across your team
* Use labels for reporting and analytics purposes
**Documentation Best Practices**
* Document the purpose of each message for future reference
* Include context that will help team members understand the communication
* Keep notes concise but informative
**Maintain Context**
* Always check conversation history before sending new messages
* Avoid sending duplicate or redundant information
* Ensure message continuity for better customer experience
**Timing Considerations**
* Consider your recipient's timezone when scheduling messages
* Avoid sending messages during off-hours or weekends unless necessary
* Set reminders to follow up if no response is received
**Template Creation**
* Make placeholder fields intuitive for anyone on your team
* Use descriptive variable names (e.g., customer\_name, order\_date)
* Test variable population before mass sending
## Troubleshooting
Reconnect your WhatsApp Business account in the WhatsAble dashboard
Verify your WhatsApp Business account is properly configured
Contact WhatsAble support if the issue persists after reconnection
Create templates in the Notifyer by WhatsAble dashboard first
Ensure templates are approved by WhatsApp (if required for your template type)
Refresh your Pipedrive page after creating new templates to see them appear
Verify your WhatsApp connection was active at the scheduled time
Check that the timezone was set correctly when scheduling
Review the message logs in WhatsAble for error details and delivery status
Ensure the contact or deal has a valid phone number in Pipedrive
Verify the phone number format includes the country code (e.g., +1234567890)
Update the contact information if the phone number is missing or incorrect
Ensure variable names in your template match the fields you're filling
Confirm the data source (contact or deal) has the required information
Send a test message to yourself to verify variable population before sending to customers
Confirm the recipient has an active WhatsApp account on that number
Ensure your message complies with WhatsApp's business messaging policies
Verify your WhatsAble account has sufficient credits or an active subscription
If issues persist, contact WhatsAble support with the message details
For more information about template creation and management, visit the Notifyer by WhatsAble dashboard or contact our support team.
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations and advanced configurations, please contact our support team or check our integration documentation.
# Zapier
Source: https://docs.whatsable.app/guides/notifier-system/zapier-overview
Learn how to seamlessly integrate Zapier with the Notifyer System for enterprise-level WhatsApp automation
# Notifyer System Integration with Zapier
![]()
This guide walks you through connecting Notifyer System with Zapier to create powerful automated WhatsApp messaging workflows for your business
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Zapier](https://zapier.com/sign-up/) workflow automation platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform embedding process, which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
To connect Notifyer System with Zapier, you'll need an API key:
1. In your Notifyer dashboard, navigate to [**API Keys**](https://console.notifyer-systems.com/api-key)
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Connect Notifyer System to Zapier
Now that you have your Notifyer System account configured, let's connect it to Zapier to automate your messaging workflows.
1. Log in to your Zapier account
2. Navigate to Notifyer System dashboard and select **Connect to Zapier** in the side menu
3. Click **Continue** in the connection guide popup
4. Click **Accept & Build a Zap** on the invitation page
You're now ready to create Zaps with the Notifyer System app
![Connecting Notifyer System to Zapier]()
1. Log in to your Zapier account
2. Create a new workflow/Zap by clicking **+ Create** and select **Zaps**/**New Zap**
3. Add a trigger step of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up Zapier Zaps]()
1. Select the next **Action** step or click the **+** button to add a new step
2. Search for "Notifyer System" in the apps and tools library
3. Select the app with the official Notifyer System logo
![Adding the WhatsAble app]()
1. In the Notifyer System app Setup, select [**Send a WhatsApp Message with your template**](/guides/notifier-system/zapier-overview#template-messages) or [**Send WhatsApp Message Without Template**](/guides/notifier-system/zapier-overview#non-template-messages) in the **Action event** dropdown depending on your messaging needs
2. Click **Sign In** in the **Account** field and you will be prompted to enter your API Key
3. Enter your Notifyer System API key that you copied earlier
4. Click **Yes, Continue to Notifyer System** to store your credential
5. Next, click the **Continue** button in the Setup screen to proceed to the **Configure** section
![Configuring Notifyer System credentials]()
Depending on your messaging needs, choose one of the following operations:
In the **Setup** section, select **Send a WhatsApp Message with your template** in the **Action event** dropdown and continue to the **Configure** section
Complete the required fields in the **Configure** section:
Select from your pre-approved templates in the dropdown
Enter the recipient's phone number with country code (e.g., +14155552671) or use dynamic data from previous nodes
Add note for internal tracking. This data won't be sent to the recipient
Select label(s) for internal tracking. This data won't be sent to the recipient
Enter publicly accessible media URL for Media (image/video/document) header.
This field will only appear if you have a Media (image/video/document) header configured in your selected template.
Fill in values for each Body(s) in your template, mapping them to dynamic data when applicable
Fill in values for each button in your template, mapping them to dynamic data when applicable.
This field(s) will only appear if you have configured button(s) in your selected template. You will see the button name as the field name.
Based on your selected message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
![Template Message Configuration]()
In the **Operation Name or ID** dropdown, select **Send Non Template Message**
Enter the **Phone Number** with country code
Choose from the following message types:
For plain text messages
For sending documents (PDF, Word, etc.)
For sending images (JPEG, PNG, etc.)
For sending videos (MP4, 3GP, etc.)
Based on your selected message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
For all media types, ensure your file URLs are publicly accessible and match the supported file formats.
![Non-Template Message Configuration]()
1. Click **Continue** and then click **Test step** in the **Test** to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Click **Publish** to save your entire Zap
4. Toggle the **Active** switch in the top-left corner to activate your Zap
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Workflow Diagram
```mermaid theme={null}
flowchart LR
A[Trigger Step] --> B[Data Transformation]
B --> C[Notifyer System App]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Example use cases
Send automatic order confirmations when new orders are placed
Schedule reminders before upcoming appointments
Alert your sales team when new leads come in
Route support inquiries to the appropriate team member
Keep customers informed about their delivery status
Send automatic payment reminders for overdue accounts
## Best practices
Always test your workflows with test phone numbers before activating them for production use.
Whenever possible, use pre-approved templates for better deliverability and compliance.
Include customer names and specific details to increase engagement and response rates.
Ensure all message content complies with WhatsApp Business policies to avoid account restrictions.
Regularly check your message delivery rates in your Notifyer dashboard.
## Troubleshooting
Ensure your API key is entered correctly in the Zapier credentials
Confirm phone numbers are in the correct international format (e.g., +14155552671)
Verify your Notifyer subscription is active and has available credits
For template messages, ensure you're using an approved template
Verify all required variables are included in your template message
Check that variable formats match the expected values (text, number, date, etc.)
Ensure you're using the correct template name exactly as it appears in your dashboard
Confirm your media URLs are publicly accessible (test in an incognito browser)
Verify the file format is supported by WhatsApp
Check that file sizes are within WhatsApp limits:
* Images: up to 5MB
* Videos: up to 16MB
* Documents: up to 100MB
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations (Make.com, n8n, etc.), please contact our support team or check our integration documentation.
# Message Analytics
Source: https://docs.whatsable.app/guides/notifier/advanced/analytics
Learn how to track and analyze your WhatsApp messages with Notifier by WhatsAble
# Message Analytics
Track and analyze your WhatsApp messaging performance with comprehensive analytics.
## Key Metrics
### Message Performance
* Delivery rates
* Read rates
* Response rates
* Response times
* Error rates
### Template Performance
* Usage by template
* Success rates
* Response patterns
* Conversion rates
* Cost per message
### User Engagement
* Active users
* Message frequency
* Response patterns
* User segments
* Retention rates
## Analytics Dashboard
### Real-time Monitoring
```javascript theme={null}
// Example: Track message status
app.post('/webhook/message-status', async (req, res) => {
const { message_id, status, timestamp } = req.body;
await updateMessageStatus({
message_id,
status,
timestamp,
metrics: {
delivery_time: calculateDeliveryTime(message_id),
response_time: calculateResponseTime(message_id)
}
});
});
```
### Custom Reports
```javascript theme={null}
// Example: Generate daily report
async function generateDailyReport() {
const report = {
date: new Date(),
metrics: {
total_messages: await getTotalMessages(),
delivered_messages: await getDeliveredMessages(),
read_messages: await getReadMessages(),
response_rate: await calculateResponseRate(),
average_response_time: await calculateAverageResponseTime()
},
templates: await getTemplatePerformance(),
errors: await getErrorSummary()
};
return report;
}
```
## Data Export
### Export Formats
* CSV
* JSON
* Excel
* PDF
* API endpoints
### Export Options
* Date range
* Metrics selection
* Template filtering
* User segmentation
* Custom fields
## Best Practices
### Data Collection
* Track all relevant metrics
* Use consistent naming
* Validate data quality
* Store historical data
* Implement data retention
### Analysis
* Set clear KPIs
* Monitor trends
* Compare performance
* Identify patterns
* Make data-driven decisions
## Integration
### Third-party Tools
* Google Analytics
* Mixpanel
* Amplitude
* Custom dashboards
* Business intelligence tools
### API Access
```javascript theme={null}
// Example: Fetch analytics data
const getAnalytics = async (params) => {
const response = await axios.get(
'https://api.insightssystem.com/api:-GWQv5aM/analytics',
{
params,
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_API_KEY}`
}
}
);
return response.data;
};
```
## Next Steps
* Learn about [Templates](/guides/notifier/advanced/templates)
* Explore [Automation](/guides/notifier/advanced/automation)
* Check out our [API Reference](/api-reference/notifier)
* Read our [Getting Started](/guides/notifier/getting-started) guide
# Message Automation
Source: https://docs.whatsable.app/guides/notifier/advanced/automation
Learn how to automate your WhatsApp messages with Notifier by WhatsAble
# Message Automation
Automate your WhatsApp messaging workflows to save time and improve efficiency.
## Workflow Types
### Event-Based Triggers
```javascript theme={null}
// Example: Send welcome message on user signup
app.post('/webhook/signup', async (req, res) => {
const { user } = req.body;
await sendTemplateMessage({
to: user.phone,
template: 'welcome_message',
variables: {
name: user.name,
company: 'Acme Inc'
}
});
});
```
### Scheduled Messages
```javascript theme={null}
// Example: Send appointment reminder
const schedule = require('node-schedule');
schedule.scheduleJob('0 9 * * *', async () => {
const appointments = await getTodaysAppointments();
for (const appointment of appointments) {
await sendTemplateMessage({
to: appointment.patient.phone,
template: 'appointment_reminder',
variables: {
name: appointment.patient.name,
time: appointment.time,
doctor: appointment.doctor.name
}
});
}
});
```
## Automation Features
### Conditional Logic
* If/else conditions
* Switch statements
* Multiple conditions
* Nested conditions
### Workflow Steps
1. Trigger
2. Conditions
3. Actions
4. Delays
5. Notifications
### Integration Points
* Webhooks
* API endpoints
* Database triggers
* Third-party services
## Best Practices
### Workflow Design
* Keep workflows simple
* Use clear naming conventions
* Document your workflows
* Test thoroughly
* Monitor performance
### Error Handling
* Implement retry logic
* Set up error notifications
* Log all actions
* Handle timeouts
* Validate inputs
## Monitoring
Track your automated workflows:
* Success rates
* Error rates
* Response times
* Resource usage
* Cost analysis
## Next Steps
* Learn about [Templates](/guides/notifier/advanced/templates)
* Explore [Analytics](/guides/notifier/advanced/analytics)
* Check out our [API Reference](/api-reference/notifier)
* Read our [Getting Started](/guides/notifier/getting-started) guide
# Message Templates
Source: https://docs.whatsable.app/guides/notifier/advanced/templates
Learn how to use and manage message templates in Notifier by WhatsAble
# Message Templates
Message templates are pre-approved message formats that you can use to send WhatsApp messages to your customers.
## Template Types
### Text Templates
```json theme={null}
{
"name": "welcome_message",
"language": "en",
"category": "UTILITY",
"components": [
{
"type": "BODY",
"text": "Welcome to {{company}}! We're excited to have you on board, {{name}}."
}
]
}
```
### Media Templates
```json theme={null}
{
"name": "product_announcement",
"language": "en",
"category": "MARKETING",
"components": [
{
"type": "HEADER",
"format": "IMAGE",
"example": {
"header_url": ["https://example.com/image.jpg"]
}
},
{
"type": "BODY",
"text": "Check out our new product: {{product_name}}! Only {{price}} for a limited time."
},
{
"type": "BUTTON",
"sub_type": "URL",
"index": "0",
"parameters": [
{
"type": "text",
"text": "Shop Now"
}
]
}
]
}
```
## Template Management
### Creating Templates
1. Go to the Templates section in your dashboard
2. Click "Create New Template"
3. Choose the template type
4. Add your content and variables
5. Submit for approval
### Template Variables
* Use `{{variable_name}}` syntax
* Variables are case-sensitive
* Maximum 10 variables per template
* Supported types: text, currency, date, time
### Best Practices
* Keep templates concise
* Use clear variable names
* Test templates before submission
* Monitor template performance
* Update templates regularly
## Template Analytics
Track your template performance:
* Delivery rates
* Response rates
* Conversion rates
* User engagement
* Error rates
## Next Steps
* Learn about [Automation](/guides/notifier/advanced/automation)
* Explore [Analytics](/guides/notifier/advanced/analytics)
* Check out our [API Reference](/api-reference/notifier)
* Read our [Getting Started](/guides/notifier/getting-started) guide
# API Documentation
Source: https://docs.whatsable.app/guides/notifier/api-documentation
Notifier by WhatsAble API Documentation
# API
# 📚 Notifier by WhatsAble API Documentation
Welcome to the Notifier by WhatsAble API Documentation! This guide provides comprehensive details on how to use the Notifier API to send WhatsApp messages programmatically. Below, you'll find information on the API endpoint, authentication, request and response structures, error handling, and supported attachment types.
***
## 🚀 API Overview
The Notifier API allows you to send WhatsApp messages, including text and attachments, to customers. It's designed to be simple and easy to integrate into your applications or workflows.
***
## 📌 API Endpoint
* **POST**: `https://api.insightssystem.com/api:-GWQv5aM/send`
***
## 🔑 Authentication
To use the API, you need to include an Authorization Token in the request headers. The token must be prefixed with Bearer.
### Headers
* `Content-Type`: `application/json`
* `Authorization`: `Bearer YOUR_TOKEN_HERE`
***
## 📤 Request Payload
The request body should be a JSON object with the following fields:
| Field | Type | Description |
| ------------ | ------ | ------------------------------------------------------------------------------- |
| `phone` | String | The recipient's phone number in **international format** (e.g., `+1234567890`). |
| `text` | String | The message content you want to send. |
| `attachment` | String | (Optional) A public URL to an attachment (e.g., image, PDF, video). |
| `filename` | String | (Optional) The name of the attachment file. |
### Example Request Body
```json theme={null}
{
"phone": "+1234567890",
"text": "Hello, this is a test message from Notifier!",
"attachment": "https://example.com/image.jpg",
"filename": "image.jpg"
}
```
The API responds with a JSON object. Below are examples of
success and
error responses.
### Success Response
```json theme={null}
{
"message": "Message sent successfully"
}
```
### Error Response
```json theme={null}
{
"message": "Message sending failed | Reason: Message limit for this number reached."
}
```
The API provides detailed error messages to help you troubleshoot issues. Common errors include:
1. Invalid Phone Number: Ensure the phone number is in E.164 format.
2. Message Limit Reached: You've exceeded the allowed number of messages for a specific phone number.
3. Attachment Issues: Ensure the attachment URL is public and accessible.
4. Authentication Failure: Verify that the `Authorization` token is correct.
5. Insufficient Credits: Your account balance is insufficient to send the message.
6. Subscription Expired: Your subscription has ended, and you need to renew it.
7. Rate Limit Exceeded: You've exceeded the allowed number of messages per minute or hour.
8. Unique Number Limit Reached: You've reached the limit of unique phone numbers you can message.
9. File Size or Type Error: The attachment does not meet WhatsApp's size or type requirements.
10. No WhatsApp Account: The recipient does not have an active WhatsApp account.
***
## 📋 Code Examples
### 1. cURL
```bash theme={null}
curl -X POST https://api.insightssystem.com/api:-GWQv5aM/send \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_TOKEN_HERE" \
-d '{
"phone": "+1234567890",
"text": "Hello, this is a test message from Notifier!",
"attachment": "https://example.com/image.jpg",
"filename": "image.jpg"
}'
```
### 2. JavaScript (Fetch API)
```javascript theme={null}
fetch("https://api.insightssystem.com/api:-GWQv5aM/send", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: "Bearer YOUR_TOKEN_HERE",
},
body: JSON.stringify({
phone: "+1234567890",
text: "Hello, this is a test message from Notifier!",
attachment: "https://example.com/image.jpg",
filename: "image.jpg",
}),
})
.then((response) => response.json())
.then((data) => console.log(data))
.catch((error) => console.error(error));
```
### 3. Python (Requests Library)
```python theme={null}
import requests
import json
url = "https://api.insightssystem.com/api:-GWQv5aM/send"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer YOUR_TOKEN_HERE"
}
payload = {
"phone": "+1234567890",
"text": "Hello, this is a test message from Notifier!",
"attachment": "https://example.com/image.jpg",
"filename": "image.jpg"
}
response = requests.post(url, headers=headers, data=json.dumps(payload))
print(response.json())
```
### 4. Go
```go theme={null}
package main
import (
"bytes"
"fmt"
"net/http"
)
func main() {
url := "https://api.insightssystem.com/api:-GWQv5aM/send"
payload := []byte(`{
"phone": "+1234567890",
"text": "Hello, this is a test message from Notifier!",
"attachment": "https://example.com/image.jpg",
"filename": "image.jpg"
}`)
req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer YOUR_TOKEN_HERE")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
fmt.Println("Response Status:", resp.Status)
}
```
### 5. Java (HttpURLConnection)
```java theme={null}
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main {
public static void main(String[] args) {
try {
URL url = new URL("https://api.insightssystem.com/api:-GWQv5aM/send");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", "application/json");
conn.setRequestProperty("Authorization", "Bearer YOUR_TOKEN_HERE");
conn.setDoOutput(true);
String payload = "{\"phone\": \"+1234567890\", \"text\": \"Hello, this is a test message from Notifier!\", \"attachment\": \"https://example.com/image.jpg\", \"filename\": \"image.jpg\"}";
try (OutputStream os = conn.getOutputStream()) {
byte[] input = payload.getBytes("utf-8");
os.write(input, 0, input.length);
}
int responseCode = conn.getResponseCode();
System.out.println("Response Code: " + responseCode);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
The Notifier API supports sending attachments with WhatsApp messages. Below are the supported file types and their size limits:
### Supported Media Types
| **Media Type** | **File Extensions** | **MIME Types** | **Max Size** |
| -------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------ |
| **Images** | `.jpeg`, `.png` | `image/jpeg`, `image/png` | 5 MB |
| **Videos** | `.mp4`, `.3gp` | `video/mp4`, `video/3gpp` | 16 MB |
| **Documents** | `.pdf`, `.doc`, `.xls`, `.ppt`, `.txt` | `application/pdf`, `application/msword`, `application/vnd.ms-excel`, `application/vnd.ms-powerpoint`, `text/plain` | 100 MB |
| **Audio** | `.mp3`, `.aac`, `.m4a`, `.ogg` | `audio/mpeg`, `audio/aac`, `audio/mp4`, `audio/ogg` | 16 MB |
***
## 📌 Key Points to Remember
* **Phone Number Format**: Always use the **E.164 format** (e.g., `+1234567890`).
* **Attachment URL**: Ensure the attachment URL is public and accessible.
* **Authorization Token**: Include the `Bearer` token in the `Authorization` header.
* **Error Handling**: Check the `message` field in the response for detailed error information.
* **Line Break**: In the message for line break or for starting a new line, `\n` needs to be added before the new line. Example:
Input:
`Hi there,\nThis is John from Acme Co.`
Output:
Hi there,
This is John from Acme Co.
***
## ❓ Need Help?
If you encounter any issues or need further assistance, feel free to reach out to our support team:
* **Email Support**: [support@whatsable.app](mailto:support@whatsable.app)
* **Documentation**: [Notifier API Documentation](https://www.notion.so/Documentation-for-Whatsable-Notifier-API-871f707adcd1451bb437f47db27e8abb?pvs=21)
***
🚀 Start Sending WhatsApp Messages Today!
***
**Disclaimer**: This service is not affiliated with nor endorsed by WhatsApp Inc. The tool uses the WhatsApp API but is not affiliated with WhatsApp.
# Notifier by WhatsAble Features
Source: https://docs.whatsable.app/guides/notifier/features
Explore the advanced features of Notifier by WhatsAble
# Notifier by WhatsAble Features
Notifier by WhatsAble provides a comprehensive set of features for complex WhatsApp messaging needs.
## Core Features
### Message Types
* Text messages
* Media messages (images, documents, audio, video)
* Location sharing
* Contact sharing
* Interactive messages
* List messages
* Button messages
### Message Management
* Message status tracking
* Delivery receipts
* Read receipts
* Message history
* Message templates
* Bulk messaging
* Scheduled messages
### Security
* End-to-end encryption
* API key authentication
* Rate limiting
* IP whitelisting
* Two-factor authentication
* Audit logs
## Advanced Features
### Templates
* Pre-approved message templates
* Dynamic variables
* Multi-language support
* Template analytics
* Template versioning
### Automation
* Workflow automation
* Conditional messaging
* Event-based triggers
* Custom webhooks
* Integration with third-party services
### Analytics
* Message delivery rates
* Response times
* User engagement
* Template performance
* Custom reports
## Best Practices
* Use approved templates
* Implement proper error handling
* Monitor message status
* Follow WhatsApp guidelines
* Regular template updates
## Next Steps
* Learn about [Integrations](/guides/notifier/integrations)
* Explore [Advanced Features](/guides/notifier/advanced/templates)
* Check out our [API Reference](/api-reference/notifier)
* Read our [Getting Started](/guides/notifier/getting-started) guide
# Getting Started with Notifier by WhatsAble
Source: https://docs.whatsable.app/guides/notifier/getting-started
Learn how to get started with Notifier by WhatsAble, the complex WhatsApp messaging solution
# Getting Started with Notifier by WhatsAble
Notifier by WhatsAble provides advanced WhatsApp messaging capabilities for businesses. This guide will help you get started with our complex solution.
## Prerequisites
* A WhatsApp Business account
* Understanding of API integration
* Your Notifier API key
* Basic knowledge of webhooks
## Quick Setup
1. Sign up for a Notifier by WhatsAble account
2. Configure your WhatsApp Business account
3. Get your API key from the dashboard
4. Set up webhooks for message status updates
## First Message
Here's a quick example of sending your first message:
```bash theme={null}
curl -X POST https://api.insightssystem.com/api:-GWQv5aM/send \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"to": "+1234567890",
"message": "Hello from Notifier by WhatsAble!",
"template": "welcome_message",
"variables": {
"name": "John",
"company": "Acme Inc"
}
}'
```
## Next Steps
* Learn about [Features](/guides/notifier/features)
* Explore [Integrations](/guides/notifier/integrations)
* Check out [Advanced Features](/guides/notifier/advanced/templates)
* Review our [API Reference](/api-reference/notifier)
# Notifier by WhatsAble Integrations
Source: https://docs.whatsable.app/guides/notifier/integrations
Learn how to integrate Notifier by WhatsAble with your applications
# Notifier by WhatsAble Integrations
Integrate Notifier by WhatsAble with your business tools and platforms.
## Available Integrations
### No-Code Platforms
* Zapier
* Make (formerly Integromat)
* n8n
* Pipedream
* Microsoft Power Automate
### CRM Systems
* Salesforce
* HubSpot
* Zoho CRM
* Pipedrive
* Microsoft Dynamics
### E-commerce Platforms
* Shopify
* WooCommerce
* Magento
* BigCommerce
* PrestaShop
### Marketing Tools
* Mailchimp
* ActiveCampaign
* Klaviyo
* SendGrid
* HubSpot Marketing
## Custom Integration
### REST API
```javascript theme={null}
const axios = require('axios');
const sendTemplateMessage = async (to, template, variables) => {
try {
const response = await axios.post(
'https://api.insightssystem.com/api:-GWQv5aM/send',
{
to,
template,
variables
},
{
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_API_KEY}`,
'Content-Type': 'application/json'
}
}
);
return response.data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
```
### Webhooks
Configure webhooks to receive real-time updates:
```json theme={null}
{
"event": "message.status",
"data": {
"message_id": "msg_123",
"status": "delivered",
"template": "welcome_message",
"variables": {
"name": "John",
"company": "Acme Inc"
},
"timestamp": "2024-03-20T10:00:00Z"
}
}
```
## Best Practices
* Use environment variables for API keys
* Implement retry logic with exponential backoff
* Handle rate limits appropriately
* Monitor webhook delivery
* Use template variables for dynamic content
## Next Steps
* Read our [Getting Started](/guides/notifier/getting-started) guide
* Explore [Features](/guides/notifier/features)
* Check out [Advanced Features](/guides/notifier/advanced/templates)
* Review our [API Reference](/api-reference/notifier)
# Make
Source: https://docs.whatsable.app/guides/notifier/make
Connect Notifier with Make to automate powerful WhatsApp messaging scenarios
# Notifier Integration with Make
![]()
Notifier enables you to send automated WhatsApp messages through your favorite scenario automation tools. This guide walks you through integrating Notifier with Make to create powerful messaging scenarios
## Prerequisites
Before getting started, make sure you have:
Active Notifier account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Make](https://www.make.com/en/register/) scenario automation platform
New to Notifier? [Sign up here](https://notifier.whatsable.app/)
## Set up your Notifier account
First, let's set up your business profile in Notifier:
1. Log in to your Notifier dashboard
2. Navigate to **Business Information**
3. Complete all required fields:
* **Business Name**: Enter the name that will appear in messages sent to recipients
* **Business Website or Social Media**: Add your website or social media URL
* **Preferred Language**: Select the language for standard WhatsApp message elements
* **Default Reply Text**: Create a template message that appears when recipients click "Reply"
* **WhatsApp Number**: Add your business WhatsApp number where replies will be directed
![Configuring business information]()
After entering your WhatsApp number, Notifier will send a verification code to this number. Enter the code to verify ownership.
Once saved, you'll see a preview of how your messages will appear to recipients. The actual message structure may vary slightly based on variables and attachments you include.
To connect Notifier with Make, you'll need your API key:
1. In your Notifier dashboard, go to **API Keys**
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
## Connect Notifier to Make
Now that you have Notifier set up, let's connect it to Make to automate your scenarios.
1. Log in to your Make account
2. Navigate to Notifier dashboard and select **Connect to Make** in the side menu
3. Click **Continue** in the connection guide popup
4. Click **Install**, select your organization at the bottom of the screen, then click **Install** again. (Note: You need Admin, Owner, or App Developer role in your organization to install apps.)
You're now ready to create scenarios with the Notifier app
1. Log in to your Make account
2. Create a new scenario by clicking **+ Create a new scenario**
3. (Optional) Add a trigger module of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up Make module]()
1. Click the **+** button to add a new module
2. Search for **Notifier WhatsAble** in the apps or modules library
3. Select the module with the official Notifer logo
![Adding the Notifier module]()
1. Once you click on Notifier module, select **Send a WhatsApp Message** from the **ACTIONS**
2. Click **Create a connection** in the **Connection** section of Notifier module and you will be prompted to enter your API Key
3. Enter your Notifier API key that you copied earlier
4. Rename your connection name if needed
5. Click **Save** to store your credential
![Configuring Notifier credentials]()
Complete the required fields:
Enter the recipient’s phone number (with country code) or use dynamic data from previous module (*Make sure that the phone number is valid and that you are only sending to one phone number per step.*)
Type your message text or use variables from previous module
Enter public URL of a file, image, or video to send with your message
Specify a custom filename for your attachment
Customize advanced options as needed
![Configuring message]()
1. Click **Save** to save your message configuration
2. Right click on the WhatsAble module and select **Run this module only** to verify the module is working correctly
* or click **Run once** in the bottom-left corner of the screen to test the entire scenario
3. If the test is successful, you'll see a confirmation message
4. Click **Save** icon in the bottom-left corner to save your scenario (You can also set timer intarval for the scenario)
5. Toggle the **Active** switch in the bottom-left corner with time to activate your scenario
![Testing and activating your scenario]()
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Scenario Diagram
```mermaid theme={null}
flowchart LR
A[Trigger Module] --> B[Data Transformation]
B --> C[Notifier Module]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Best practices
For optimal results when using Notifier with Make:
Use data from previous modules in your workflow to create personalized, relevant messages for each recipient.
Focus on a single call-to-action and keep your messages brief to maintain recipient engagement.
Always run complete tests of your workflow before deploying to production to catch any potential issues.
Regularly check your Notifier dashboard to monitor delivery rates and optimize your messaging strategy.
Always provide clear opt-out instructions and respect recipient preferences regarding messaging.
## Troubleshooting
Verify that your Notifier account is active and has available credits
Ensure your business information is complete and properly verified
Double-check that your API key is entered correctly in Make
Confirm that the recipient's phone number is in the correct format (including country code)
Check your message template for any invalid characters or formatting issues
Ensure variables from previous modules are properly formatted
Verify your message doesn't exceed WhatsApp's length limitations
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifier dashboard
For additional automation platform integrations (Zapier, n8n, etc.), please contact our support team or check our integration documentation.
# n8n
Source: https://docs.whatsable.app/guides/notifier/n8n
Connect Notifier with n8n to automate powerful WhatsApp messaging workflows
# Notifier Integration with n8n
![]()
Notifier enables you to send automated WhatsApp messages through your favorite workflow automation tools. This guide walks you through integrating Notifier with n8n to create powerful messaging workflows
## Prerequisites
Before getting started, make sure you have:
Active Notifier account with a subscription plan (Monthly or Pay-as-you-go)
Access to [n8n](https://app.n8n.cloud/login) workflow automation platform
New to Notifier? [Sign up here](https://notifier.whatsable.app/)
## Set up your Notifier account
First, let's set up your business profile in Notifier:
1. Log in to your Notifier dashboard
2. Navigate to **Business Information**
3. Complete all required fields:
* **Business Name**: Enter the name that will appear in messages sent to recipients
* **Business Website or Social Media**: Add your website or social media URL
* **Preferred Language**: Select the language for standard WhatsApp message elements
* **Default Reply Text**: Create a template message that appears when recipients click "Reply"
* **WhatsApp Number**: Add your business WhatsApp number where replies will be directed
![Configuring business information]()
After entering your WhatsApp number, Notifier will send a verification code to this number. Enter the code to verify ownership.
Once saved, you'll see a preview of how your messages will appear to recipients. The actual message structure may vary slightly based on variables and attachments you include.
To connect Notifier with n8n, you'll need your API key:
1. In your Notifier dashboard, go to **API Keys**
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
## Connect Notifier to n8n
Now that you have your Notifier account configured, let's connect it to n8n to automate your messaging workflows.
1. Log in to your n8n account
2. Create a new workflow/Zap by clicking **+ Create**
3. Add a trigger node of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
The WhatsAble trigger node enables your workflow to respond automatically to incoming WhatsApp messages. This setup is optional but recommended for building reactive communication flows.
Follow these steps to add the WhatsAble trigger node to your workflow:
1. Click the **+** button in your workflow canvas to add a new node
2. Search for "WhatsAble" in the node library search bar
3. Select the node displaying the official WhatsAble logo
4. From the available trigger options, choose **On new Incoming message event**
![WhatsAble node selection showing trigger options]()
The trigger node will automatically listen for incoming messages and initiate your workflow when a new message is received.
Set up your WhatsAble API credentials to establish a secure connection:
**Webhook URL Configuration:**
1. In the WhatsAble Trigger node parameters, locate the **Webhook URLs** section at the top
2. Select **Production URL** and copy the generated URL by clicking on it
3. Store this URL securely as you'll need it for the credential setup
![Production URL selection and copy interface]()
**Credential Creation:**
1. In the **Credential to connect with** dropdown, click **+ Create new credential**
2. Select **WhatsAble Notifier API** as your connection method
3. Enter your Notifier by WhatsAble API key in the **API Key** field
4. Paste the Production URL you copied earlier into the **Production URL** field
5. Assign a descriptive name to your credential (e.g., "WhatsAble Production")
6. Click **Save** to securely store your credentials
![WhatsAble credential configuration interface]()
Your API credentials are encrypted and stored securely. Never share your API key publicly or commit it to version control.
Complete the setup by testing and activating your trigger:
**Response Configuration:**
1. In the **Respond** dropdown, select your preferred response timing:
* **Immediately**: Responds as soon as the trigger fires
* **When Last Node Finishes**: Waits for the entire workflow to complete before responding
**Testing:**
1. Click **Execute step** on the WhatsAble node to run a test
2. Verify the connection is working by checking for a success confirmation
3. Review any error messages if the test fails and adjust your configuration accordingly
Once activated, your workflow will automatically process incoming messages according to your configured logic.
Remember to test your workflow thoroughly before activating it in production to ensure it behaves as expected.
1. Click the **+** button to add a new node
2. Search for "WhatsAble" in the node library
3. Select the node with the official WhatsAble logo
4. After selecting the WhatsAble node, choose 'Send message via notifier' from the available actions menu
![WhatsAble node selection]()
1. In the WhatsAble node **Parameters**, find the **Credential to connect with** dropdown
2. Select **+ Create new credential**
3. Enter your Notifier API key that you copied earlier
4. Name your credential (e.g., "Notifier Production")
5. Click **Save** to store your credential
![Configuring Notifier credential]()
1. In **Resource** dropdown, select **Send Message**
2. In the **Operation** dropdown, select **Send Message Via Notifier**
3. Complete the required fields:
Enter the recipient's phone number (with country code) or use dynamic data from previous nodes
Type your message text or use variables from previous nodes
Enter the URL of the file, image, or video you want to send with your message or use variables from previous nodes
Specify a custom filename for your attachment
1. Click **Test Step** on the Notifier node to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Return to your workflow
4. Click **Save** to save your entire workflow
5. Toggle the **Active** switch in the top-right corner to activate your workflow
Congratulations! Your Notifier and n8n integration is now complete! Your automated messaging workflow is now operational! Whenever your trigger conditions are met, n8n will automatically send WhatsApp messages through Notifier.
## Example workflows
Here are some powerful automation workflows you can build with Notifier and n8n:
Send personalized WhatsApp messages to new leads who fill out your contact form
Automatically notify customers when their order is placed, shipped, or delivered
Send timely WhatsApp reminders before scheduled events or appointments
Request feedback via WhatsApp after a customer interaction or purchase
Keep customers informed about the status of their support requests
## Workflow Diagram
```mermaid theme={null}
flowchart LR
A[Trigger node] --> B[Data Transformation]
B --> C[Notifier App]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Best practices
For optimal results when using Notifier with n8n:
Use data from previous nodes in your workflow to create personalized, relevant messages for each recipient.
Focus on a single call-to-action and keep your messages brief to maintain recipient engagement.
Always run complete tests of your workflow before deploying to production to catch any potential issues.
Regularly check your Notifier dashboard to monitor delivery rates and optimize your messaging strategy.
Always provide clear opt-out instructions and respect recipient preferences regarding messaging.
## Troubleshooting
Verify that your Notifier account is active and has available credits
Ensure your business information is complete and properly verified
Double-check that your API key is entered correctly in n8n
Confirm that the recipient's phone number is in the correct format (including country code)
Check your message template for any invalid characters or formatting issues
Ensure variables from previous nodes are properly formatted
Verify your message doesn't exceed WhatsApp's length limitations
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifier dashboard
For additional automation platform integrations (Make.com, Zapier, etc.), please contact our support team or check our integration documentation.
# Zapier
Source: https://docs.whatsable.app/guides/notifier/zapier
Connect Notifier with Zapier to automate powerful WhatsApp messaging workflows
# Notifier Integration with Zapier
![]()
Notifier enables you to send automated WhatsApp messages through your favorite workflow automation tools. This guide walks you through integrating Notifier with Zapier to create powerful messaging workflows
## Prerequisites
Before getting started, make sure you have:
Active Notifier account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Zapier](https://zapier.com/sign-up) workflow automation platform
New to Notifier? [Sign up here](https://notifier.whatsable.app/)
## Set up your Notifier account
First, let's set up your business profile in Notifier:
1. Log in to your Notifier dashboard
2. Navigate to **Business Information**
3. Complete all required fields:
* **Business Name**: Enter the name that will appear in messages sent to recipients
* **Business Website or Social Media**: Add your website or social media URL
* **Preferred Language**: Select the language for standard WhatsApp message elements
* **Default Reply Text**: Create a template message that appears when recipients click "Reply"
* **WhatsApp Number**: Add your business WhatsApp number where replies will be directed
![Configuring business information]()
After entering your WhatsApp number, Notifier will send a verification code to this number. Enter the code to verify ownership.
Once saved, you'll see a preview of how your messages will appear to recipients. The actual message structure may vary slightly based on variables and attachments you include.
To connect Notifier with Zapier, you'll need your API key:
1. In your Notifier dashboard, go to **API Keys**
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
## Connect Notifier to Zapier
Now that you have your Notifier account configured, let's connect it to Zapier to automate your messaging workflows.
1. Log in to your Zapier account
2. Navigate to Notifier dashboard and select **Connect to Zapier** in the side menu
3. Click **Continue** in the connection guide popup
4. Select Accept & Build a Zap on the invitation page
You're now ready to create Zaps with the Notifier app
1. Log in to your Zapier account
2. Create a new workflow/Zap by clicking **+ Create** and select **Zaps**/**New Zap**
3. Add a trigger step of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up Zapier Zaps]()
1. Select the next **Action** step or click the **+** button to add a new step
2. Search for "Notifier by WhatsAble" in the apps and tools library
3. Select the app with the official Notifier logo
![Adding the WhatsAble app]()
1. In the Notifier app Setup, select **Send WhatsApp Message** in the **Action event** dropdown
2. Click **Sign In** in the **Account** field and you will be prompted to enter your API Key
3. Enter your Notifier API key that you copied earlier
4. Click **Yes, Continue to Notifier** to store your credential
5. Next, click the **Continue** button in the Setup screen to proceed to the **Configure** section
![Configuring Notifier credentials]()
Complete the required fields:
Enter the recipient’s phone number (with country code) or use dynamic data from previous steps
Type your message text or use variables from previous steps
Enter public URL of a file, image, or video to send with your message
Specify a custom filename for your attachment
Customize advanced options as needed
![Configuring message]()
1. Click **Continue** and then click **Test step** in the **Test** to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Click **Publish** to save your entire Zap
4. Toggle the **Active** switch in the top-left corner to activate your Zap
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Workflow Diagram
```mermaid theme={null}
flowchart LR
A[Trigger Step] --> B[Data Transformation]
B --> C[Notifier App]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Best practices
For optimal results when using Notifier with Zapier:
Use data from previous steps in your workflow to create personalized, relevant messages for each recipient.
Focus on a single call-to-action and keep your messages brief to maintain recipient engagement.
Always run complete tests of your workflow before deploying to production to catch any potential issues.
Regularly check your Notifier dashboard to monitor delivery rates and optimize your messaging strategy.
Always provide clear opt-out instructions and respect recipient preferences regarding messaging.
## Troubleshooting
Verify that your Notifier account is active and has available credits
Ensure your business information is complete and properly verified
Double-check that your API key is entered correctly in Zapier
Confirm that the recipient's phone number is in the correct format (including country code)
Check your message template for any invalid characters or formatting issues
Ensure variables from previous steps are properly formatted
Verify your message doesn't exceed WhatsApp's length limitations
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifier dashboard
For additional automation platform integrations (Make.com, n8n, etc.), please contact our support team or check our integration documentation.
# Auth & environment
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/auth-and-env
Environment variables, auth header modes (Console vs Chat vs Developer), and origin/CORS behavior used by Notifyer Agent Skills.
Never commit tokens or API keys to Git. Treat `NOTIFYER_API_TOKEN` and the Developer API key as production secrets.
## Required environment variables
| Variable | Required | Default | Used for |
| ----------------------- | ---------------------: | ----------------------------------- | -------------------------------------------------------------------- |
| `NOTIFYER_API_BASE_URL` | **yes** | — | Base API host (must be HTTPS), e.g. `https://api.insightssystem.com` |
| `NOTIFYER_API_TOKEN` | **yes** (most scripts) | — | JWT returned by `setup-notifyer/scripts/login.js` |
| `NOTIFYER_CHAT_ORIGIN` | no | `https://chat.notifyer-systems.com` | Origin header for chat endpoints when overridden |
```bash theme={null}
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..."
```
## Auth modes (critical)
Notifyer has **three auth modes** depending on the API surface. **The same JWT** is used for Console and Chat modes — only the header formatting differs.
| Mode | Header | Where it’s used |
| ------------- | -------------------------------- | --------------------------------------------------------------- |
| **Console** | `Authorization: Bearer ` | `setup-notifyer` and `automate-notifyer` (most endpoints) |
| **Chat** | `Authorization: ` (raw) | `chat-notifyer` and some web endpoints (labels/recipients/chat) |
| **Developer** | `Authorization: ` (raw) | Make/Zapier/n8n modules + direct developer send APIs |
If you see HTTP 401 across many scripts, your JWT likely expired. Re-run `setup-notifyer/scripts/login.js` and re-export `NOTIFYER_API_TOKEN`.
## Origin headers & CORS behavior
Many Xano endpoints enforce allowed origins. The skills’ shared HTTP client automatically sends a correct `Origin` header per mode:
* Console-mode requests use `Origin: https://console.notifyer-systems.com`
* Chat-mode requests use `Origin: https://chat.notifyer-systems.com` (override with `NOTIFYER_CHAT_ORIGIN`)
This is important because “missing Origin” can cause silent or confusing auth failures on endpoints that validate it.
## Persisting environment variables
Add these exports to your shell profile:
```bash theme={null}
# ~/.zshrc
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..."
```
```bash theme={null}
# ~/.bashrc
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..."
```
## Security notes for CLI usage
Passing secrets via CLI flags (like `--password`) can expose them via process lists (`ps aux`) on shared machines. Prefer using a password manager/secure terminal, and avoid logging stdout in shared CI environments.
## Related pages
* [`setup-notifyer`](/guides/notifyer-system/agent-skills/setup-notifyer) (login, doctor, API key)
* [`chat-notifyer`](/guides/notifyer-system/agent-skills/chat-notifyer) (chat origin and 24h window policy)
* [Security](/guides/notifyer-system/agent-skills/security)
# automate-notifyer
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/automate-notifyer
Automation scripts for templates, AI bots, broadcasts, analytics, and webhooks.
`automate-notifyer` builds on `setup-notifyer`. Always run `setup-notifyer/scripts/doctor.js` before sending templates, creating broadcasts, or configuring webhooks.
## What this skill covers
* **Templates**: create/list/get/delete; monitor Meta approval lifecycle
* **AI bots**: create/update/delete bots; set default bot
* **Broadcasts**: create/schedule campaigns using template + recipient CSV
* **Analytics & logs**: read rates, delivery rates, message logs
* **Webhooks**: create/update/delete **dev** and **IO** webhooks; optional HMAC signatures
## Prerequisites
Some features require a Pro or Agency plan (and an OpenAI key configured in Notifyer settings for bots). If you’re not sure, check with `setup-notifyer/scripts/get-user-plan.js`.
## Setup
```bash theme={null}
cd skills/automate-notifyer
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..."
```
## Templates
List templates:
```bash theme={null}
node scripts/list-templates.js --pretty
node scripts/list-templates.js --status approved --pretty
```
Create a template (text with variables):
```bash theme={null}
node scripts/create-template.js \
--name order_confirmation \
--category MARKETING \
--body "Hello {{1}}, your order #{{2}} is confirmed." \
--variables '{"1":"John","2":"12345"}'
```
`list-templates.js` auto-syncs `PENDING` template statuses from Meta on each call — you can re-run it to observe approval changes.
Delete a template:
```bash theme={null}
node scripts/delete-template.js --id 987654321 --confirm
```
## AI bots
```bash theme={null}
node scripts/list-bots.js --pretty
node scripts/create-bot.js --name "Support Bot" \
--mission "Help users resolve support issues." \
--knowledge-base "Return policy: 30 days. Shipping: 3-5 days." \
--tone "Friendly" --delay 3 \
--trigger-keywords "agent,human" --notification --default
node scripts/update-bot.js --id 12 --tone "Professional" --delay 5
node scripts/set-default-bot.js --id 12 --pretty
node scripts/delete-bot.js --id 12 --confirm --pretty
```
## Broadcasts
Create and schedule a broadcast (3-step flow):
```bash theme={null}
node scripts/create-broadcast.js \
--name "January Sale" \
--template-id 42 \
--test-phone "+14155550123" \
--recipients ./recipients.csv \
--schedule "25/01/2025 14:00" \
--delivery-mode smart \
--delivery-size 4
```
Phone numbers in the CSV must be **integers without `+`**. The schedule format is strictly `DD/MM/YYYY HH:mm` and is timezone-sensitive.
## Analytics & logs
```bash theme={null}
node scripts/get-message-analytics.js --days 30 --pretty
node scripts/get-message-analytics.js --from 2025-01-01 --to 2025-01-31 --pretty
node scripts/get-message-logs.js --filter broadcast --phone 14155550123 --pretty
```
## Webhooks
List webhooks:
```bash theme={null}
node scripts/list-webhooks.js --type dev --pretty
node scripts/list-webhooks.js --type io --pretty
```
Create a dev webhook (Make/Zapier/n8n style):
```bash theme={null}
node scripts/create-webhook.js --type dev \
--url "https://hook.eu2.make.com/abc" \
--incoming --outgoing --signature
```
Create an IO webhook (bidirectional pipeline style):
```bash theme={null}
node scripts/create-webhook.js --type io \
--url "https://myapp.com/webhook" \
--signature
```
Update/delete:
```bash theme={null}
node scripts/update-webhook.js --type dev --id 5 --status false
node scripts/delete-webhook.js --type dev --id 5 --confirm
```
Dev webhook `id` is an integer. IO webhook `id` is a **text UUID** — treat it as a string.
## Next
* Operate conversations: [`chat-notifyer`](/guides/notifyer-system/agent-skills/chat-notifyer)
* See end-to-end automation flows: [Use cases](/guides/notifyer-system/agent-skills/use-cases)
# chat-notifyer
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/chat-notifyer
Live chat operations: recipients, messaging (text/template/attachments), labels, handoff, scheduling, notes, and conversation history.
Use `chat-notifyer` when you want an agent to operate active WhatsApp conversations (similar to `chat.notifyer-systems.com`) via scripts.
## Prerequisites
* You have a valid JWT in `NOTIFYER_API_TOKEN` (from `setup-notifyer/scripts/login.js`)
* WhatsApp connection is active (verify with `setup-notifyer/scripts/get-connection-status.js`)
## Auth mode difference (don’t miss this)
Chat endpoints use **raw JWT** auth: `Authorization: ` (no `Bearer` prefix). Console endpoints use `Authorization: Bearer `.
The shared client handles this automatically. See [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env).
## The 24-hour window rule (critical)
WhatsApp allows **free text** and **attachments** only within **24 hours** of a user’s last inbound message.
| Window | Allowed |
| ------ | -------------------------------- |
| Open | Text ✓, Template ✓, Attachment ✓ |
| Closed | Template only ✓ |
Check window state:
```bash theme={null}
node scripts/get-recipient.js --phone 14155550123 --pretty
```
`send-text.js` enforces this automatically and will refuse if the window is closed.
## Common workflows
### List/search recipients
```bash theme={null}
node scripts/list-recipients.js --pretty
node scripts/list-recipients.js --search "John" --pretty
node scripts/list-recipients.js --status unread --pretty
```
### Filter recipients by label
```bash theme={null}
node scripts/filter-recipients-by-label.js --labels "Support" --status unread --pretty
```
### Send a text message
```bash theme={null}
node scripts/send-text.js --phone 14155550123 --text "Hello! How can I help?"
```
### Send a template message (works any time)
```bash theme={null}
node scripts/send-template.js --list
node scripts/send-template.js --phone 14155550123 --name order_confirm \
--variables '{"body1":"John","body2":"#12345"}'
node scripts/send-template.js --phone 14155550123 --name order_confirm --dry-run
```
### Send an attachment
```bash theme={null}
node scripts/send-attachment.js --phone 14155550123 --file ./invoice.pdf --pretty
node scripts/send-attachment.js --phone 14155550123 --file ./photo.jpg --caption "Your order photo"
```
### Schedule a send
```bash theme={null}
node scripts/send-template.js --phone 14155550123 --name order_confirm --schedule "25/01/2025 14:00"
node scripts/list-scheduled.js --pretty
node scripts/delete-scheduled.js --id 7 --confirm
```
### Labels (assign/remove)
```bash theme={null}
node scripts/assign-label.js --phone 14155550123 --label "Support" --pretty
node scripts/remove-label.js --phone 14155550123 --label "Support" --pretty
```
Labels must exist first (create via `setup-notifyer/create-label.js`).
### AI ↔ Human handoff
```bash theme={null}
node scripts/set-handoff.js --phone 14155550123 --mode human --pretty
node scripts/set-handoff.js --phone 14155550123 --mode bot --pretty
```
Assign a specific bot:
```bash theme={null}
node scripts/list-bots.js --pretty
node scripts/assign-bot.js --phone 14155550123 --bot-id 5 --pretty
```
### Conversation + notes
```bash theme={null}
node scripts/get-conversation.js --phone 14155550123 --pretty
node scripts/get-conversation-log.js --phone 14155550123 --pretty
node scripts/get-notes.js --phone 14155550123 --pretty
node scripts/add-note.js --phone 14155550123 --append "Requested callback on 15 Feb"
```
`get-conversation.js` returns the **full** thread (sent + received). `get-conversation-log.js` is **outbound-only** delivery history.
## Next
* End-to-end operational playbooks: [Use cases](/guides/notifyer-system/agent-skills/use-cases)
* If you hit send failures: [Troubleshooting](/guides/notifyer-system/agent-skills/troubleshooting)
# Agent Skills (Notifyer)
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/overview
What Notifyer Agent Skills are, what they enable, and how they map to setup, automation, and chat operations.
Agent Skills let AI coding agents (Cursor, OpenClaw, Claude Code, Copilot, etc.) authenticate into Notifyer and operate your workspace programmatically — using the same backend API surface as the Notifyer Console and Chat apps.
## What are Agent Skills?
**Notifyer Agent Skills** are a set of **Node.js scripts + a `SKILL.md` instruction file** that teach compatible AI agents how to:
* Authenticate into a Notifyer workspace
* Validate prerequisites (connection, plan, token health)
* Configure workspace infrastructure (labels, team, API key)
* Manage automation primitives (templates, AI bots, broadcasts, webhooks, analytics)
* Operate live chat workflows (recipients, messages, handoff, notes, scheduling)
They follow the open [AgentSkills standard](https://agentskills.io/specification), which allows many agents to discover and load skills on demand.
## How this fits inside Notifyer System docs
Notifyer System can be operated via:
Use API keys for Make/Zapier/n8n or your backend services. This is the best choice when you’re building **event-driven automations** and do not need to manage workspace configuration.
Use Agent Skills when you want an AI coding agent to **set up**, **configure**, or **operate** a Notifyer workspace end-to-end: onboarding, template lifecycle, broadcasts, webhooks, and live chat operations.
Use the web apps when you’re doing the initial WhatsApp onboarding, billing changes, or manual team operations.
## Skill set overview (3 phases)
The skills are designed as a progressive sequence.
| Phase | Skill | Primary purpose |
| ----- | ------------------- | ------------------------------------------------------------------------------------------------------------ |
| 1 | `setup-notifyer` | Authentication, workspace identity, WhatsApp connection status, plans, team/roles, labels, Developer API key |
| 2 | `automate-notifyer` | Templates, AI bots, broadcasts, analytics/logs, webhooks |
| 3 | `chat-notifyer` | Recipients, messaging, labels, AI/human handoff, scheduled sends, notes, conversation history |
## What you can automate (examples)
* **Workspace onboarding**: create labels, invite members, verify connection and plan, fetch the Developer API key.
* **Template lifecycle**: create templates, monitor Meta approval status, use approved templates in broadcasts.
* **Customer support ops**: fetch conversation context, take over from bot, respond, label, add notes, return to bot.
* **Webhook configuration**: create dev and IO webhooks with HMAC signature, list and update triggers, rotate URLs.
For end-to-end workflows, see [Use cases](/guides/notifyer-system/agent-skills/use-cases).
## Important constraints (read before you automate)
Some actions are intentionally not scriptable:
* First-time WhatsApp connection (embedded signup / QR scan) is **browser-only**.
* Billing changes and Stripe flows are **browser-only**.
* Meta template approval timing is **not controllable** via API.
## Next steps
* Start with [Quickstart](/guides/notifyer-system/agent-skills/quickstart)
* Configure [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env)
* Dive into each skill:
* [`setup-notifyer`](/guides/notifyer-system/agent-skills/setup-notifyer)
* [`automate-notifyer`](/guides/notifyer-system/agent-skills/automate-notifyer)
* [`chat-notifyer`](/guides/notifyer-system/agent-skills/chat-notifyer)
Official repository for Notifyer Agent Skills, including scripts, reference material, and `SKILL.md` entrypoints.
# Using with Base44
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/platforms/base44
Install Notifyer Agent Skills so your AI coding assistant can build and operate Notifyer integrations inside Base44 apps.
Base44 follows the open [AgentSkills specification](https://agentskills.io/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
Makes the skills available across all your Base44 projects. Use `--all` to install all three skills at once without an interactive prompt:
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills --all -g
```
This installs `setup-notifyer`, `automate-notifyer`, and `chat-notifyer` together.
To install interactively (choose which skills to include):
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills -g
```
To install a single skill only:
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills --skill chat-notifyer -g
```
Installs only into the current project directory:
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills --all
```
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:
| Variable | Required | Description |
| ----------------------- | -------- | ---------------------------------------------------------------------------------------------------------- |
| `NOTIFYER_API_BASE_URL` | **yes** | Always `https://api.insightssystem.com`. Must start with `https://` — all scripts enforce this at startup. |
| `NOTIFYER_API_TOKEN` | **yes** | JWT token obtained via `setup-notifyer/scripts/login.js` |
| `NOTIFYER_CHAT_ORIGIN` | no | CORS Origin override for Phase 3 chat endpoints. Defaults to `https://chat.notifyer-systems.com`. |
```bash theme={null}
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:
```bash theme={null}
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`.
```typescript theme={null}
// 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 API | Chat API |
| --------------- | -------------------------------------- | -------------------------------------- |
| **Base URL** | `NOTIFYER_API_BASE_URL` | `NOTIFYER_API_BASE_URL` |
| **Auth header** | `Authorization: Bearer ` | `Authorization: ` (no Bearer) |
| **Origin** | `https://console.notifyer-systems.com` | `https://chat.notifyer-systems.com` |
| **Used for** | Templates, bots, broadcasts, webhooks | Recipients, messaging, labels, handoff |
There is also a **Developer API key** mode (`Authorization: ` — 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
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills --all -g
```
Re-running the install command pulls the latest version from the repository.
***
## Related pages
* [Quickstart](/guides/notifyer-system/agent-skills/quickstart)
* [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env)
* [Use cases](/guides/notifyer-system/agent-skills/use-cases)
* [Base44 Skills docs](https://docs.base44.com/developers/backend/overview/skills)
* [Base44 Backend Functions](https://docs.base44.com/developers/backend/resources/backend-functions/overview)
* [Base44 Secrets (`secrets set`)](https://docs.base44.com/developers/references/cli/commands/secrets-set)
# Using with Cursor
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/platforms/cursor
Install Notifyer Agent Skills into Cursor and have its Agent operate your Notifyer workspace from inside your IDE.
Cursor has **native support** for the AgentSkills standard. Skills installed via `npx skills add` are automatically discovered by Cursor Agent — no manual configuration needed.
## How it works in Cursor
Cursor Agent loads skills from these directories and presents them as available capabilities:
| Location | Scope |
| -------------------------------- | --------------------- |
| `.cursor/skills//` | Current project only |
| `.agents/skills//` | Current project only |
| `~/.cursor/skills//` | All projects (global) |
| `~/.agents/skills//` | All projects (global) |
When a skill is installed, Agent reads its `SKILL.md` file and automatically decides when to apply it based on what you ask. You can also invoke any skill explicitly by typing `/skill-name` in the Agent chat.
Skills are visible in **Cursor Settings → Rules → Agent Decides**.
***
## Install the skills
Installs the skills for all your projects. Run once:
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills -g
```
This puts all 3 skills under `~/.agents/skills/`:
* `~/.agents/skills/setup-notifyer/`
* `~/.agents/skills/automate-notifyer/`
* `~/.agents/skills/chat-notifyer/`
Installs only into the current project's `.agents/skills/` directory:
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills
```
When prompted, select the skills you want, or select **All 3 skills** to install everything at once.
```bash theme={null}
npx skills add whatsable/whatsapp-business-agent-skills --skill setup-notifyer
npx skills add whatsable/whatsapp-business-agent-skills --skill automate-notifyer
npx skills add whatsable/whatsapp-business-agent-skills --skill chat-notifyer
```
The scripts in these skills are **Node.js CLI tools** that run in your terminal, not inside Cursor's chat UI. Cursor Agent reads the skill instructions and executes scripts using its terminal tool when needed.
***
## Set up environment variables
The scripts need two variables before Agent can use them:
```bash theme={null}
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..." # obtained via setup-notifyer/scripts/login.js
```
Add these to your shell profile (`~/.zshrc` or `~/.bashrc`) so they're always available when Cursor's terminal runs scripts. Alternatively, add a `.env` file to your project — Cursor Agent can read it if you reference it in your prompt.
Never commit `NOTIFYER_API_TOKEN` to Git. The `.gitignore` in the agent-skills repo already excludes `.env` and `.env.*` files.
For full environment variable reference, see [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env).
***
## Verify discovery
After installing, confirm Cursor can see the skills:
1. Open **Cursor Settings** → **Rules**
2. Look for `setup-notifyer`, `automate-notifyer`, and `chat-notifyer` in the **Agent Decides** section
Or run in Cursor Agent chat:
```
/setup-notifyer
```
Agent will display the skill instructions and confirm it's loaded.
***
## Example Agent prompts
Once installed, use natural language in Cursor Agent chat. Agent will identify the relevant skill and execute the appropriate scripts.
### Workspace setup
```
Log in to Notifyer with email=me@company.com and run a full health check.
Tell me if the WhatsApp connection is active and what plan we're on.
```
```
Create three labels: Sales, Support, and VIP.
For each one, set up relevant keywords (e.g. "pricing, quote" for Sales).
```
### Template management
```
List all our approved WhatsApp templates and show me which ones have variables.
```
```
Create a new template called order_shipped in the UTILITY category.
Body: "Hi {{1}}, your order {{2}} has shipped and will arrive by {{3}}."
```
### Live chat operations
```
Find all unread conversations labeled VIP and show me the full context for each one.
```
```
Check if the 24-hour messaging window is open for +14155550123, then send them
"Hi! Just following up on your recent enquiry." if it is.
```
```
Assign the Support label to +14155550123, take over from the bot, and add a note:
"Customer escalated — awaiting approval from billing team."
```
### Broadcast campaigns
```
Create a broadcast called Feb Promo using template ID 42.
Test it on +14155550123 first, then schedule it for 01/02/2026 at 10:00.
```
***
## Manually invoking a skill
If Agent doesn't pick up a skill automatically, invoke it with the `/` command:
```
/setup-notifyer Run doctor.js and tell me what's wrong.
```
```
/chat-notifyer Get the last 20 messages from the conversation with +14155550123.
```
```
/automate-notifyer List all webhooks and show me which ones have signatures enabled.
```
***
## How Agent runs the scripts
When you give Agent a task, it:
1. Reads the relevant `SKILL.md` to understand available scripts and their flags
2. Opens a terminal in the skill's directory (`skills/setup-notifyer/`, etc.)
3. Runs the script with the correct flags
4. Parses the JSON output (`ok`/`err` structure) and summarises the result
All scripts output structured JSON, which Agent can read and act on — for example, it can check if `isConnected: false` and automatically suggest running `refresh-connection.js`.
***
## Keeping skills up to date
```bash theme={null}
# Re-run the install command to pull the latest version
npx skills add whatsable/whatsapp-business-agent-skills -g
```
***
## Related pages
* [Quickstart](/guides/notifyer-system/agent-skills/quickstart)
* [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env)
* [Use cases](/guides/notifyer-system/agent-skills/use-cases)
* [Cursor Agent Skills docs](https://cursor.com/docs/skills)
# Using with Lovable
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/platforms/lovable
Teach Lovable's AI agent how to build Notifyer WhatsApp integrations into your app using Knowledge and AGENTS.md.
Lovable's web agent does not read skill files from `.agents/skills/` or `.cursor/skills/` — it only reads **Project knowledge**, **Workspace knowledge**, `AGENTS.md`, and `CLAUDE.md` from your GitHub repo. The `npx skills add` CLI has no direct effect on what Lovable sees.
However, Lovable projects are GitHub-backed. If you also work on the same project locally in **Cursor** (a common hybrid workflow), you should install the skills there too — see the [Cursor guide](/guides/notifyer-system/agent-skills/platforms/cursor).
## How Lovable reads context
Lovable's agent considers several context sources when generating code:
| Source | How to set it | Scope |
| ----------------------------- | --------------------------------------------- | ------------------------------------------ |
| **Project knowledge** | Project settings → Knowledge | One project |
| **Workspace knowledge** | Settings → Knowledge | All projects in workspace |
| **`AGENTS.md` / `CLAUDE.md`** | Root of the GitHub repo linked to the project | Always loaded regardless of session length |
| **Integration knowledge** | Via connected services (e.g. Supabase) | Per integration |
`AGENTS.md` and `CLAUDE.md` at the repo root are always read by Lovable, even in very long sessions where project or workspace knowledge may not always be followed consistently. Use them for rules that must never be lost.
For Notifyer integrations, the most reliable approach is to put the critical API context in **Project knowledge** and keep the `AGENTS.md` file for structural rules that must persist across long sessions.
***
## Option 1 — Project Knowledge (recommended)
Add the following to your project's **Project settings → Knowledge**. This tells Lovable's agent exactly how to call the Notifyer API when building your app.
```text theme={null}
Notifyer WhatsApp API integration
Base URL: stored in env var NOTIFYER_API_BASE_URL (e.g. https://api.insightssystem.com)
Auth token: stored in env var NOTIFYER_API_TOKEN (JWT from login)
Auth headers:
- Console API (templates, bots, broadcasts, webhooks):
Authorization: Bearer
Origin: https://console.notifyer-systems.com
- Chat API (recipients, messaging, labels, handoff):
Authorization: (no Bearer prefix)
Origin: https://chat.notifyer-systems.com
Key API groups:
- /api:AFRA_QCy/ — templates
- /api:ox_LN9zX/ — bots
- /api:Mk_r6mq0/ — broadcasts
- /api:bVXsw_FD/ — chat recipients and messaging
- /api:qh9OQ3OW/ — message logs and analytics
- /api:0hqyGRIz/ — webhooks
Critical rules:
- Never hardcode NOTIFYER_API_TOKEN in source code — always use env vars.
- Text and attachment messages require the recipient to have messaged in the last 24 hours.
If window is closed, use a template message instead.
- global_label is a string[] of label names, not IDs.
- PATCH /web/recipient/:id requires the full recipient body (fetch first, then patch).
- Schedule timestamp is ms since epoch; 0 means immediate send.
- NOTIFYER_API_BASE_URL must be HTTPS — reject any http:// value.
Reference:
- Full API documentation: https://github.com/Whatsable/whatsapp-business-agent-skills
- Script reference: skills/chat-notifyer/scripts/ and skills/automate-notifyer/scripts/
```
Project Knowledge supports up to **10,000 characters**. The block above is intentionally concise. Expand it with specific endpoint shapes or payload examples if your project needs precise API call generation.
***
## Option 2 — AGENTS.md in your GitHub repo
For rules that must survive long Lovable chat sessions, add an `AGENTS.md` file to the root of the GitHub repository linked to your Lovable project. Lovable always reads root-level `AGENTS.md` files regardless of session length.
Create `AGENTS.md` in your repo root:
```markdown theme={null}
# Notifyer WhatsApp Integration Rules
## Authentication
- Console API: `Authorization: Bearer ${NOTIFYER_API_TOKEN}` + `Origin: https://console.notifyer-systems.com`
- Chat API: `Authorization: ${NOTIFYER_API_TOKEN}` (no Bearer) + `Origin: https://chat.notifyer-systems.com`
- Base URL from `NOTIFYER_API_BASE_URL` env var (always HTTPS)
## 24-hour messaging window
- Free-text and media can only be sent if the recipient messaged us within the last 24 hours
- If window is closed, use a template message
- Check window via GET /api:bVXsw_FD/web/recipient — look at expiration_timestamp
## Safe PATCH pattern
- Before PATCH /web/recipient/:id, always GET the full record first
- Include all existing fields in the PATCH body (name, phone_number, phone_number_string,
global_label, is_ai_assistant, note) to prevent accidental data wipe
## Environment variables
- NOTIFYER_API_BASE_URL — required
- NOTIFYER_API_TOKEN — required, JWT from login
- Never commit tokens to Git
```
***
## Example Lovable prompts
With the project knowledge or `AGENTS.md` in place, use Lovable's Agent mode to build Notifyer-powered features:
### Send a WhatsApp message from a form
```
Add a "Send WhatsApp" button to the CustomerDetail page.
When clicked, it should call a Supabase Edge Function that sends a WhatsApp text message
via the Notifyer Chat API to the customer's phone number.
Use NOTIFYER_API_BASE_URL and NOTIFYER_API_TOKEN from environment variables.
Only send if the 24-hour window is open; otherwise show an error: "Window closed — use a template."
```
### Send a template when window is closed
```
In the CustomerDetail page, add a "Send Reminder" button.
The Edge Function should first check the recipient's expiration_timestamp.
If the 24h window is open, send a free-text message.
If closed, send the payment_reminder WhatsApp template instead.
Both paths use the Notifyer Chat API with the correct auth header (no Bearer prefix).
```
### Broadcast from the dashboard
```
Add a "Send Broadcast" section to the Marketing page.
It should let the user pick an approved template from a dropdown (fetched from
GET /api:AFRA_QCy/templates_web on the Notifyer Console API with Bearer auth),
upload a CSV of phone numbers, and trigger a broadcast via the Notifyer API.
```
### Webhook receiver
```
Create a Supabase Edge Function at /notifyer-webhook that receives POST requests
from Notifyer's IO webhook. Validate the HMAC-SHA256 signature using NOTIFYER_WEBHOOK_SECRET.
When a new inbound message event arrives, insert a row into the messages table
with { phone, body, direction: "inbound", received_at }.
```
### Label and handoff from the app UI
```
In the ConversationView component, add two buttons:
1. "Assign to Human" — calls PATCH /api:bVXsw_FD/web/recipient/:id with is_ai_assistant: false
using the Notifyer Chat API (Authorization: without Bearer).
2. "Assign Label" — shows a dropdown of available labels and calls the same PATCH endpoint
with the updated global_label array.
Both should fetch the full recipient record first before patching.
```
***
## Using Plan mode before building
For complex integrations, click **Plan** next to the message input to switch to Plan mode before any code is written. Plan mode never modifies your code — it only reasons and proposes an approach.
```
I want to integrate Notifyer WhatsApp messaging into this app.
We need to: send template messages when a new order is created, receive inbound
messages via webhook and store them, and show chat history in the CustomerDetail page.
What's the best architecture using Supabase Edge Functions?
```
When you're happy with the plan, approve it and Lovable automatically switches to **Agent mode** to implement each piece. The approved plan is saved to `.lovable/plan.md` in your project.
***
## Environment variables by backend
Lovable supports two distinct backends. The env var workflow is different for each.
Lovable Cloud is Lovable's own full-stack hosting platform — no external Supabase account needed. It handles the backend automatically.
When Lovable generates an Edge Function that calls the Notifyer API, instruct it to read secrets from environment variables:
```
Store NOTIFYER_API_BASE_URL and NOTIFYER_API_TOKEN as secrets in
Lovable Cloud and read them inside the Edge Function with
Deno.env.get("NOTIFYER_API_TOKEN").
```
Lovable Cloud manages the secret injection automatically as part of the Cloud environment. You can review and manage Cloud settings via **Connectors → App connectors → Lovable Cloud → Manage permissions**.
If your project uses the Supabase integration (you connected your own Supabase project via **Project settings → Integrations → Supabase**):
1. Open your **Supabase dashboard** → **Settings → Edge Functions → Secrets**
2. Add `NOTIFYER_API_BASE_URL` and `NOTIFYER_API_TOKEN` as secrets
3. Reference them in Edge Functions with `Deno.env.get("NOTIFYER_API_TOKEN")`
Never pass `NOTIFYER_API_TOKEN` as a hardcoded string in Edge Function code — it would be visible in your GitHub repository.
If you've exported your Lovable project to GitHub and are hosting it yourself, configure environment variables through your host's standard mechanism (e.g. Vercel env vars, Railway secrets, `.env` on a VPS).
***
## Important constraints
These operations **cannot** be done via Lovable or any API — they require the Notifyer Console web UI:
* Initial WhatsApp number connection (embedded signup / QR scan)
* Billing and Stripe plan changes
* Meta template approval (timing is controlled by Meta, not the API)
***
## Related pages
* [Quickstart](/guides/notifyer-system/agent-skills/quickstart)
* [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env)
* [Security](/guides/notifyer-system/agent-skills/security)
* [Using with Cursor](/guides/notifyer-system/agent-skills/platforms/cursor) — install skills locally if you work on the Lovable project in Cursor
* [Lovable Agent mode docs](https://docs.lovable.dev/features/agent-mode)
* [Lovable Knowledge docs](https://docs.lovable.dev/features/knowledge)
* [Lovable Plan mode docs](https://docs.lovable.dev/features/plan-mode)
# Quickstart
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/quickstart
Install Notifyer Agent Skills and run the first health checks and API calls.
This guide assumes **Node.js 18+**. The skills use native `fetch` and ESM and intentionally avoid third-party dependencies.
## Choose an installation path
If your agent supports the AgentSkills ecosystem, install directly from the repository:
```bash theme={null}
# Interactive — choose which skills to install
npx skills add whatsable/whatsapp-business-agent-skills
```
```bash theme={null}
# Install all 3 skills at once (no prompt)
npx skills add whatsable/whatsapp-business-agent-skills --all
```
```bash theme={null}
# Install only one skill
npx skills add whatsable/whatsapp-business-agent-skills --skill chat-notifyer
```
If your goal is “just make my agent fully capable in Notifyer”, use `--all` so it can load `setup-notifyer`, `automate-notifyer`, and `chat-notifyer` as needed.
```bash theme={null}
git clone https://github.com/Whatsable/whatsapp-business-agent-skills
cd whatsapp-business-agent-skills
```
Each skill is self-contained under `skills//`.
## Set required environment variables
You need:
* `NOTIFYER_API_BASE_URL`
* `NOTIFYER_API_TOKEN` (JWT from `setup-notifyer/scripts/login.js`)
```bash theme={null}
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..." # set after login
```
For deeper detail (auth modes, origins, and safety), see [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env).
## Log in and capture a token
```bash theme={null}
cd skills/setup-notifyer
node scripts/login.js --email you@example.com --password "YourPassword@1"
```
The output includes `authToken`. Export it:
```bash theme={null}
export NOTIFYER_API_TOKEN="eyJ..."
```
If you’re also running the Notifyer Chat frontend locally for UI testing, use the pinned dev URL `http://localhost:5173/` as documented in `chat.notifyer_frontend/README.md`.
## Run a pre-flight health check
Before running any automation or chat script, validate the account is in a healthy state.
```bash theme={null}
cd skills/setup-notifyer
node scripts/doctor.js --pretty
```
`doctor.js` validates, in one command:
* Base URL is set and HTTPS
* Token is valid (`/auth/me`)
* WhatsApp connection is usable (`isConnected` + degraded detection)
* Subscription is in an allowed state
## Verify identity + WhatsApp connection
```bash theme={null}
node scripts/get-me.js --pretty
node scripts/get-connection-status.js --pretty
```
## Next steps (pick your goal)
* **Workspace setup & infra**: [`setup-notifyer`](/guides/notifyer-system/agent-skills/setup-notifyer)
* **Automation primitives**: [`automate-notifyer`](/guides/notifyer-system/agent-skills/automate-notifyer)
* **Live chat ops**: [`chat-notifyer`](/guides/notifyer-system/agent-skills/chat-notifyer)
If you’re stuck, see [Troubleshooting](/guides/notifyer-system/agent-skills/troubleshooting).
# Security
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/security
Security model and best practices for using Notifyer Agent Skills, JWTs, Developer API keys, and webhook signatures.
## Secrets you must protect
| Secret | What it does | Treat as |
| -------------------------- | -------------------------------------------------------- | ------------------------- |
| `NOTIFYER_API_TOKEN` (JWT) | Authenticates Console + Chat script access | Session secret |
| Developer API key | Authenticates Make/Zapier/n8n + developer send endpoints | Long-lived API secret |
| Webhook signature secret | Validates inbound webhook authenticity (HMAC) | Long-lived signing secret |
Do not store any of these in Git, client-side code, screenshots, or public pastebins.
## Recommended storage
* **Local dev**: `.env` (gitignored) or your shell profile + a password manager
* **CI/CD**: secrets manager (GitHub Actions secrets, Vercel env, 1Password, etc.)
* **Servers**: environment variables provisioned at deploy time
## CLI operational security
### Avoid leaking passwords via process lists
When using `--password` flags, be aware flags can show up in process lists while the script is running. On shared machines, consider running login in a private terminal session and avoid persistent command history.
### Avoid logging tokens
Some scripts print structured JSON to stdout by design. If you pipe outputs into logs, redact secrets.
## Webhook authenticity
If you enable `--signature` during webhook creation, Notifyer generates an HMAC secret. You should:
* Store it immediately
* Verify webhook payload signatures on your server
* Rotate by creating a new webhook (if rotation is needed)
If you lose the signature secret, you generally cannot retrieve it again. Create a new webhook.
## Least privilege + operational controls
* Prefer using an **Admin** token only when required (team, labels, bot defaults).
* Use `setup-notifyer/scripts/doctor.js` as a gating step before production automation runs.
* For incident response, revoke/rotate credentials in the UI where available and update your secrets store.
# setup-notifyer
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/setup-notifyer
Account + workspace setup scripts: login, health checks, WhatsApp connection status, plans, team/roles, labels, and Developer API key.
Start here. `setup-notifyer` provides authentication and **pre-flight validation** used by all other skills.
## What this skill covers
`setup-notifyer` is used for:
* Creating accounts and logging in (JWT acquisition)
* Verifying token, plan status, and WhatsApp connection health
* Managing team members, roles, and label assignment
* Creating and managing workspace labels + keywords
* Retrieving the **Developer API key** used by Make/Zapier/n8n modules
## Setup
```bash theme={null}
cd skills/setup-notifyer
```
Set env vars (see [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env)):
```bash theme={null}
export NOTIFYER_API_BASE_URL="https://api.insightssystem.com"
export NOTIFYER_API_TOKEN="eyJ..." # after login
```
## Core workflows
### 1) Login (get a JWT)
```bash theme={null}
node scripts/login.js --email you@example.com --password "YourPassword@1"
```
Export `authToken` into `NOTIFYER_API_TOKEN`.
### 2) Pre-flight health check (recommended before any automation)
```bash theme={null}
node scripts/doctor.js --pretty
```
This checks:
* Base URL is HTTPS
* Token is valid via `/auth/me`
* WhatsApp connection is **connected** and not **degraded**
* Plan is in an allowed state
### 3) WhatsApp connection checks
```bash theme={null}
node scripts/get-connection-status.js --pretty
```
If connection state is stale after UI onboarding:
```bash theme={null}
node scripts/refresh-connection.js --pretty
```
Initial WhatsApp connection (embedded signup / QR scan) is **browser-only**. Scripts can manage a connection *after* it exists, but cannot complete first-time setup.
### 4) Plans & usage
```bash theme={null}
node scripts/list-plans.js --pretty
node scripts/get-user-plan.js --pretty
```
If you’re guiding an automation that needs integrations or bots, gate it by plan status first using `get-user-plan.js`.
### 5) Team & roles
```bash theme={null}
node scripts/list-members.js --labels --pretty
node scripts/invite-member.js --name "John" --email john@co.com --password "Pass@1" --role "Team Member" --labels "Sales,Support"
node scripts/update-member.js --id --role Admin
node scripts/remove-member.js --id --confirm
```
Roles:
* `Admin`
* `Team Member (All Labels)`
* `Team Member`
### 6) Labels & keywords
```bash theme={null}
node scripts/list-labels.js --pretty
node scripts/create-label.js --label "Support" --keywords "help,issue,ticket"
node scripts/update-label-keywords.js --id 5 --add "urgent"
node scripts/delete-label.js --id 5 --confirm
```
## Developer API key (Make/Zapier/n8n)
Retrieve the Developer API key:
```bash theme={null}
node scripts/get-api-key.js --pretty
```
The Developer API key is **not** the JWT token. It is used as `Authorization: ` (raw) by external tools and developer endpoints.
## Script index (high-signal)
* **Auth**: `create-account.js`, `login.js`, `get-me.js`
* **Health**: `doctor.js`
* **Connection**: `get-connection-status.js`, `refresh-connection.js`
* **Plans**: `list-plans.js`, `get-user-plan.js`
* **Team**: `list-members.js`, `invite-member.js`, `update-member.js`, `remove-member.js`
* **Labels**: `list-labels.js`, `create-label.js`, `update-label-keywords.js`, `delete-label.js`
* **API key**: `get-api-key.js`
## Next
* Move to automation: [`automate-notifyer`](/guides/notifyer-system/agent-skills/automate-notifyer)
* Or operate live chat: [`chat-notifyer`](/guides/notifyer-system/agent-skills/chat-notifyer)
# Troubleshooting
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/troubleshooting
Diagnose common failures (401, degraded WhatsApp connection, plan blocks, template status, 24h window, webhooks).
## First command to run
Before debugging anything else:
```bash theme={null}
cd skills/setup-notifyer
node scripts/doctor.js --pretty
```
It validates the most common root causes in one pass (base URL, token, connection, plan).
## Authentication failures (HTTP 401 / 403)
### Token expired or missing
Symptoms:
* Most scripts return 401
* `get-me.js` fails
Fix:
```bash theme={null}
cd skills/setup-notifyer
node scripts/login.js --email you@example.com --password "YourPassword@1"
export NOTIFYER_API_TOKEN="eyJ..."
node scripts/get-me.js --pretty
```
### Wrong auth mode header
Symptoms:
* Console scripts work, chat scripts fail (or vice versa)
What to know:
* Console uses `Authorization: Bearer `
* Chat uses `Authorization: ` (raw)
The skills handle this automatically, but custom wrappers often get it wrong. See [Auth & environment](/guides/notifyer-system/agent-skills/auth-and-env).
## WhatsApp connection issues
### `isConnected: false`
Run:
```bash theme={null}
cd skills/setup-notifyer
node scripts/get-connection-status.js --pretty
```
If the number was just connected in the UI, refresh:
```bash theme={null}
node scripts/refresh-connection.js --pretty
```
If this is a first-time setup, you must complete the embedded signup / QR scan in the console UI. It is not scriptable.
### `degraded: true`
This can mean Meta returned hidden errors that may cause silent send failures. Treat it as “not healthy” until resolved. Use the console UI to resolve Meta-side issues, then re-check status.
## Plan blocks (features not available)
Symptoms:
* Developer API key exists but integrations/bots fail
* Bot creation fails due to missing OpenAI key/settings
Check:
```bash theme={null}
cd skills/setup-notifyer
node scripts/get-user-plan.js --pretty
```
## Template issues
### Template not usable yet
Templates must be `APPROVED` by Meta before use in automation/broadcasts.
```bash theme={null}
cd skills/automate-notifyer
node scripts/list-templates.js --pretty
node scripts/list-templates.js --status approved --pretty
```
## Message send failures in chat
### 24-hour window is closed
If free text fails, check:
```bash theme={null}
cd skills/chat-notifyer
node scripts/get-recipient.js --phone 14155550123 --pretty
```
Fix: use a template send (`send-template.js`) until the recipient messages again.
## Webhook issues
### Wrong webhook type / id
* Dev webhook id is **integer**
* IO webhook id is a **text UUID**
```bash theme={null}
cd skills/automate-notifyer
node scripts/list-webhooks.js --type dev --pretty
node scripts/list-webhooks.js --type io --pretty
```
### Signature secret lost
If you created a webhook with `--signature`, the secret is shown only once. If you didn’t store it, create a new webhook and deprecate the old one.
# Use cases
Source: https://docs.whatsable.app/guides/notifyer-system/agent-skills/use-cases
End-to-end playbooks: onboarding, templates, broadcasts, chat triage, and webhook-driven operations.
## Workspace onboarding automation
Goal: create a clean, operational workspace baseline that’s ready for automation and live chat.
```bash theme={null}
# 1) Authenticate
cd skills/setup-notifyer
node scripts/login.js --email you@example.com --password "YourPassword@1"
export NOTIFYER_API_TOKEN="eyJ..."
# 2) Validate health
node scripts/doctor.js --pretty
# 3) Create labels
node scripts/create-label.js --label "Sales" --keywords "pricing,quote,buy"
node scripts/create-label.js --label "Support" --keywords "help,issue,ticket"
node scripts/create-label.js --label "VIP"
# 4) Invite team
node scripts/invite-member.js --name "Amina" --email amina@co.com --password "Pass@1" --role "Team Member" --labels "Support"
node scripts/invite-member.js --name "Omar" --email omar@co.com --password "Pass@1" --role "Team Member" --labels "Sales"
# 5) Fetch Developer API key (for Make/Zapier/n8n)
node scripts/get-api-key.js --pretty
```
## Template lifecycle management
Goal: submit a template, track approval, then use it in a broadcast.
```bash theme={null}
cd skills/automate-notifyer
# Create template
node scripts/create-template.js \
--name order_shipped \
--category UTILITY \
--body "Hi {{1}}, your order {{2}} has shipped!" \
--variables '{"1":"John","2":"#12345"}'
# Poll status (also syncs PENDING from Meta)
node scripts/list-templates.js --pretty
# Use only after approved
node scripts/list-templates.js --status approved --pretty
```
## Broadcast campaign management
Goal: test + upload audience + schedule a bulk send.
```bash theme={null}
cd skills/automate-notifyer
node scripts/create-broadcast.js \
--name "Feb Promo" \
--template-id 42 \
--test-phone "+14155550123" \
--recipients ./recipients.csv \
--schedule "01/02/2026 10:00" \
--delivery-mode smart \
--delivery-size 4
node scripts/list-broadcasts.js --status upcoming --pretty
```
## Live support triage loop
Goal: find unread high-priority conversations, take over, respond, document, and return to bot.
```bash theme={null}
cd skills/chat-notifyer
# 1) Find unread VIP
node scripts/filter-recipients-by-label.js --labels "VIP" --status unread --pretty
# 2) Load context
node scripts/get-recipient.js --phone 14155550123 --pretty
node scripts/get-notes.js --phone 14155550123 --pretty
node scripts/get-conversation.js --phone 14155550123 --pretty
# 3) Take over + respond
node scripts/set-handoff.js --phone 14155550123 --mode human
node scripts/send-text.js --phone 14155550123 --text "Hi — I’m looking into this now."
# 4) Record internal context + route
node scripts/add-note.js --phone 14155550123 --append "Escalated — awaiting refund approval"
node scripts/assign-label.js --phone 14155550123 --label "Escalated"
# 5) Return to bot
node scripts/set-handoff.js --phone 14155550123 --mode bot
```
## Pre-flight gating before any send
These checks prevent most “why didn’t it send?” incidents.
```bash theme={null}
# Workspace health: token + connection + plan
cd skills/setup-notifyer
node scripts/doctor.js --pretty
# Recipient window state (templates always allowed; text/media need window open)
cd ../chat-notifyer
node scripts/get-recipient.js --phone 14155550123 --pretty
```
## Webhook-driven automation setup
Goal: configure a webhook endpoint and secure it with HMAC signature.
```bash theme={null}
cd skills/automate-notifyer
node scripts/create-webhook.js --type dev \
--url "https://my.app/webhook" \
--incoming --outgoing --signature
node scripts/list-webhooks.js --type dev --pretty
```
# Bot Configuration
Source: https://docs.whatsable.app/guides/notifyer-system/ai-chatbot/configuration
A complete reference for every field in the AI Chatbot configuration form — identity, knowledge base, response settings, and human handoff.
You can create as many bots as needed and designate one as the **default**. The configuration form is identical whether you are creating a new bot or editing an existing one.
## Opening the form
* **Create**: From the [AI Chatbots](/guides/notifyer-system/ai-chatbot/overview) dashboard, click **Create New Bot**.
* **Edit**: Click **Edit** on any existing bot card. The form loads with all saved values pre-filled.
The form is divided into four sections: **Core Identity & Mission**, **Knowledge Base**, **Response Settings**, and **Notifications**.
***
## Core Identity & Mission
Defines who your bot is and what it is trying to achieve. These two fields are **required** — the bot cannot be saved without them.
An internal label for this bot (e.g. `Support Specialist`, `Sales Assistant`). Visible in the bot dashboard card and internal logs. Not shown to customers.
A plain-language description of what your business does and what this bot should help customers with. The AI uses this as its primary framing context for every reply.
**Good example:** `We are a SaaS company selling project management software. The bot should help prospects understand our pricing tiers, answer questions about integrations, and guide trial users through onboarding steps.`
Keep this focused. The more specific the mission, the more accurate and on-topic the bot's replies will be.
***
## Knowledge Base
The knowledge base is the information the bot draws on when answering customer questions. At least one of — **text** or **uploaded files** — must contain content before the bot can be saved.
A freeform text block containing everything the bot should know: FAQs, pricing, business hours, product descriptions, policies, contact details, and so on.
You can leave this empty if you are supplying all content via uploaded files, but combining both is recommended for best coverage.
Upload documents to supplement or replace the text knowledge base. Files are parsed server-side to extract plain text, which is then embedded alongside any manual text you have entered.
| Supported format | Notes |
| ---------------- | ------------------------------------------------------------------------- |
| `.txt` | Plain text; read as-is |
| `.csv` | Read as plain text; useful for product catalogues or FAQs in tabular form |
| `.pdf` | Text is extracted automatically; image-only PDFs will yield no content |
| `.docx` | Word documents; text is extracted automatically |
**Limits:** Each file must be **10 MB or smaller**. There is no cap on the number of files.
Uploaded files appear in the **Connected Sources** list below the text area. Click the trash icon on any source to remove it.
If both the text knowledge base **and** all uploaded files are empty, the save button will return a validation error: *"Please add some content to the Knowledge Base."*
***
## Custom Instructions
Additional behavioural rules layered on top of the knowledge base (mapped to `system_prompt` internally). These instructions are injected directly into the AI system prompt, giving you fine-grained control over bot behaviour.
Use this field to:
* Restrict topics the bot should never discuss
* Define mandatory questions the bot must ask before proceeding
* Set formatting rules (e.g. "always reply in bullet points")
* Override default politeness patterns
**Example:** `Always ask for the customer's order number before discussing any refund. Never mention competitor products. If a customer asks about pricing, direct them to our pricing page at https://example.com/pricing.`
This field is optional. Leave it blank if the Mission and Knowledge Base are sufficient.
***
## Response Settings
Controls how the bot communicates, not what it says.
### Conversation Tone
Sets the overall communication style of all AI-generated replies.
| Value | Description |
| -------------- | ---------------------------------------------------------------------------------------- |
| `friendly` | Warm, approachable, and conversational — good for consumer brands and lifestyle products |
| `professional` | Formal and precise — good for B2B, legal, financial, or healthcare contexts |
| `balanced` | A middle ground between friendly and professional — suitable for most businesses |
| `enthusiastic` | High energy and upbeat — good for e-commerce, events, or promotional contexts |
Selecting a tone shapes word choice, sentence structure, and the overall feel of every response. It does not affect factual accuracy.
### Response Delay
How many seconds the bot waits after receiving a message before sending a reply. Adjustable between **5** and **60** seconds via a slider.
A short delay makes the bot feel more human. When a customer sends multiple messages in quick succession — e.g. "Hi", then "I have a question about my order" — waiting a few seconds lets the bot read all of them before replying once with full context, rather than reacting to each message individually.
**Recommended starting point:** 8–12 seconds for most businesses. Reduce to 5 seconds for high-volume support queues where speed is critical. Increase toward 30+ seconds if your customers tend to send long, multi-message context before asking their question.
***
## Notifications
Governs what happens when the AI cannot — or should not — handle a conversation any further and a human needs to take over.
### Human Agent Request Notification
When **enabled**, WhatsAble sends you a real-time notification the moment the system detects a customer wants to speak with a human agent.
Detection is triggered by:
1. Any message that matches one of the configured **Trigger Keywords**
2. Any situation described in the **Custom Handoff Scenarios** field
Enable this if your team should be alerted and available to take over the conversation.
### Trigger Keywords
A list of words or short phrases that, when detected anywhere in an incoming customer message, signal that the customer wants human assistance.
The bot stops its automated replies when a match is found and (if notification is enabled) alerts your team.
**Common examples:** `agent`, `human`, `speak to someone`, `real person`, `talk to a person`, `help me`
You can add as many keywords as needed using the **+** button. Remove any with the **×** button. Matching is case-insensitive.
Trigger keywords work independently of the Handoff Scenarios. Both mechanisms can be active simultaneously — keywords catch explicit requests, while Handoff Scenarios catch contextual ones.
### Custom Handoff Scenarios
A plain-language description of **situational** escalation conditions — circumstances where the AI should transfer to a human even if the customer has not explicitly asked for one.
The AI reads this field as part of its system prompt and uses it to decide when to stop replying.
**Example:** `Escalate to a human agent when: the customer expresses strong frustration or uses angry language; the conversation involves a refund request over $500; the customer reports a product safety issue; three or more back-and-forth exchanges have not resolved the customer's issue.`
Leave blank if you only want keyword-based handoff.
***
## Saving the configuration
Click **Save Configuration** (bottom-right of the form). The bot validates that:
1. **Agent Name** is not empty
2. **Business Mission** is not empty
3. **Knowledge Base** contains at least some content (text or files)
If all checks pass, the bot is created (or updated) and you are returned to the AI Chatbots dashboard. The new bot is not set as default automatically — use **Set Default** on the dashboard to promote it.
Editing a bot does **not** affect any conversations already in progress. Changes take effect for the next incoming message processed after the save completes.
***
## Next steps
Dashboard actions, plan requirements, and how a bot processes messages end-to-end.
Connect a WhatsApp number to your workspace before a bot can go live.
# AI Chatbots
Source: https://docs.whatsable.app/guides/notifyer-system/ai-chatbot/overview
Create and manage AI-powered WhatsApp assistants that handle customer conversations automatically — 24/7, on-brand, and with built-in human handoff.
AI Chatbots are available on the **Pro** and **Agency** plans. Bulk Message subscribers will see an upgrade prompt instead of the bot dashboard.
## What are AI Chatbots?
WhatsAble AI Chatbots are intelligent WhatsApp assistants powered by OpenAI. Each bot is trained with your business's own knowledge base and configured with a distinct personality, response style, and escalation rules — so customers get accurate, on-brand answers around the clock without any manual effort.
Once live, your bot:
* Reads each incoming WhatsApp message and generates a contextually accurate reply from your knowledge base
* Waits a configurable delay before sending (to feel human, not robotic)
* Detects human-handoff keywords and notifies your team the moment a customer asks to speak with someone
* Follows your custom escalation instructions for edge cases that go beyond the knowledge base
## Dashboard overview
The AI Chatbots dashboard (`/ai-bots`) lists every bot in your workspace as cards. The default bot always appears first with a **Default** star badge.
| Action | How |
| ------------------ | --------------------------------------------------------------------------------- |
| **Create a bot** | Click **Create New Bot** in the top-right corner |
| **Search** | Type in the search bar to filter bots by name |
| **Sort** | Use the sort dropdown to switch between **Newest** and **Oldest** |
| **Edit** | Click **Edit** on a bot card to open the full configuration form |
| **Set as default** | Click **Set Default** on any non-default bot card |
| **Duplicate** | Open the ⋮ menu → **Duplicate** — clones all settings as a new bot named `(Copy)` |
| **Delete** | Open the ⋮ menu → **Delete** — requires confirmation |
Only one bot can be **default** at a time. The default bot is the one WhatsAble uses when no specific bot is assigned to an incoming conversation.
## Plan requirements
AI Chatbots require a **Pro** or **Agency** subscription. Workspace owners on the Bulk Message plan will see an upgrade notice in place of the bot dashboard. Visit your [Pricing Plans](/pricing-plans) page to upgrade.
| Plan | AI Chatbot access |
| ------------ | -------------------------------------- |
| Bulk Message | ✗ Not included |
| Pro | ✓ Full access |
| Agency | ✓ Full access + multiple phone numbers |
## How a bot processes a message
A customer sends a WhatsApp message to your connected number.
The bot waits for the configured **Response Delay** (5–60 seconds). If the customer sends more messages in that window, they are batched and answered together.
The bot constructs a response using your **Business Mission**, **Knowledge Base**, **Custom Instructions**, and selected **Tone**.
If any **Trigger Keyword** is detected, or the **Custom Handoff Scenarios** condition is met, the bot stops replying and (optionally) sends you a notification.
The response is delivered to the customer over WhatsApp.
***
## Bot assignment in Notifyer Chat
Once you have bots configured, you control which bot handles each conversation from the [Notifyer Chat](https://chat.notifyer-systems.com/) interface. Assignment can be automatic (via the default bot) or manually overridden per conversation.
### Auto-assignment — the default bot
When a new inbound WhatsApp message starts a conversation and no specific bot has been manually assigned to that contact, the system automatically uses the bot marked as **Default** in your AI Chatbots dashboard.
Only one bot can be the default at a time. To change which bot handles new conversations automatically, go to the [AI Chatbots dashboard](/guides/notifyer-system/ai-chatbot/overview) and click **Set Default** on the bot you want.
### Manual assignment per conversation
Every conversation in Notifyer Chat has a right-side contact panel. Inside that panel, under the **AI Assistant** section, is a **Bot Assign** dropdown.
In [Notifyer Chat](https://chat.notifyer-systems.com/), select any conversation. The contact details panel opens on the right.
Scroll to the **AI Assistant** section. Below the AI / Human Agent toggle you will see a **Bot Assign** selector showing either the currently assigned bot name or **Select Bot**.
Click the dropdown and choose any bot from your workspace. The assignment updates immediately — the selected bot takes over responses for that conversation from the next incoming message.
A checkmark appears next to the currently assigned bot so you always know which one is active.
If a bot is already assigned, the dropdown shows an **Unassign Bot** option at the top. Selecting it removes the bot assignment from that contact entirely and falls back to the default bot for any future messages.
### AI Assistant / Human Agent toggle
Alongside bot assignment, each conversation has a **Human Agent ↔ AI Assistant** toggle.
| Position | Behaviour |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| **AI Assistant** (on) | The assigned bot handles replies automatically; messages are also synced with connected automation tools (Zapier, Make, n8n, etc.) |
| **Human Agent** (off) | The bot stops replying; a team member takes over manually; automation sync is paused |
When a customer triggers a **handoff keyword** or the bot's **Custom Handoff Scenarios** are met, flip this toggle to **Human Agent** to mute the bot and take control of the conversation yourself.
### Assignment priority summary
| Scenario | Bot used |
| ------------------------------------------ | ---------------------- |
| New conversation, no manual assignment | Default bot |
| Manual assignment set in the contact panel | Manually assigned bot |
| Bot unassigned in the contact panel | Default bot (fallback) |
| Toggle switched to Human Agent | No bot — human only |
***
## Next steps
A field-by-field breakdown of every setting in the bot configuration form — identity, knowledge base, tone, delay, and handoff.
Connect a WhatsApp number to your workspace before deploying a bot.
# Get Templates
Source: https://docs.whatsable.app/guides/notifyer-system/api/get-templates
Retrieve and manage your WhatsApp message templates
Templates are pre-approved message formats that ensure your WhatsApp communications comply with WhatsApp Business policies while maintaining consistent messaging with your audience.
WhatsApp templates are essential for business messaging, enabling you to send structured communications to customers while complying with WhatsApp's policies. This guide covers how to retrieve your templates using our API.
## Overview
Templates serve as the foundation for all non-session messages on WhatsApp Business. Each template:
* Must be pre-approved by WhatsApp before use
* Belongs to a specific category (Marketing, Utility, Authentication)
* Can include variables that personalize messages for each recipient
* Supports multiple languages and formats (text, media, interactive components)
Experiment with the Get Templates API and view responses in real-time
## Get Templates
Retrieve all WhatsApp templates associated with your account, including approval status, variables, and other key properties.
### Endpoint
```
GET https://api.insightssystem.com/api:AFRA_QCy/get_templates
```
### Authentication
All API requests require authentication using your API key. Never share your API keys in client-side code.
Include your API key in all requests using Bearer authentication:
```bash theme={null}
Authorization: Bearer YOUR_API_KEY
```
```javascript theme={null}
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
```
### Response
The API returns an array of template objects, each containing detailed information about your WhatsApp templates.
Unique identifier for the template
UUID of the account that owns the template
Unique name identifier of the template
Promotional content and offers
Transactional messages like order confirmations
Security codes and verification messages
Format type of the template (text, media, etc.)
Language code (e.g., "en", "en\_US")
Template is ready to use
Template is awaiting WhatsApp review
Template was rejected by WhatsApp
Number of variable placeholders in the template
Format string showing variable placement (e.g., "\[b:7]")
UUID of the template in our system
### Example Request
```bash cURL theme={null}
curl -X GET \
https://api.insightssystem.com/api:AFRA_QCy/get_templates \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY'
```
```javascript Node.js theme={null}
const axios = require('axios');
async function getTemplates() {
try {
const response = await axios.get(
'https://api.insightssystem.com/api:AFRA_QCy/get_templates',
{
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer YOUR_API_KEY'
}
}
);
console.log(response.data);
return response.data;
} catch (error) {
console.error('Error fetching templates:', error);
}
}
getTemplates();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:AFRA_QCy/get_templates"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer YOUR_API_KEY"
}
response = requests.get(url, headers=headers)
print(response.json())
```
### Example Response
```json Response theme={null}
[
{
"id": 300,
"user_id": "a9d7c221-62d2-43b5-810a-8a1a71c7820c",
"name": "exclusive_offer_alert",
"category": "MARKETING",
"type": "text",
"language": "en",
"status": "APPROVED",
"variable_counts": 7,
"template_formate": "[b:7]",
"template_id": "6f6e4113-cc8a-4fbe-b98d-2c631d299c6b"
},
{
"id": 150,
"user_id": "a9d7c221-62d2-43b5-810a-8a1a71c7820c",
"name": "general_communication_message",
"category": "UTILITY",
"type": "text",
"language": "en",
"status": "REJECTED",
"variable_counts": 0,
"template_formate": "[]",
"template_id": "75521873-72cd-4c33-9072-c8b901d6f687"
}
]
```
## Response Codes
Your request was successful and the templates have been returned.
Authentication failed. Check that you're using a valid API key.
```json theme={null}
{
"error": {
"code": "unauthorized",
"message": "Invalid API key provided"
}
}
```
Your account doesn't have permission to access templates.
You've exceeded the rate limit. Implement exponential backoff in your requests.
Something went wrong on our end. Please contact support if the issue persists.
```json theme={null}
{
"error": {
"code": "server_error",
"message": "An internal server error occurred"
}
}
```
## Working with Templates
Use the Get Templates API to fetch all templates associated with your account.
Verify that your templates are in the "APPROVED" status before using them.
Note the `variable_counts` and `template_formate` to understand how many variables need to be provided when sending a message.
Use the template ID and required variables to send messages via the [Send Template API](/api-reference/notifier-system/send-template).
## Template Best Practices
Keep track of which variables correspond to which placeholders in your template. Consider creating a mapping in your application.
Templates can't be edited after submission, but you can create new versions. Use a versioning system in your template names (e.g., welcome\_v2).
Regularly check the status of your templates, as WhatsApp can change approval statuses based on user feedback.
Create templates in multiple languages to communicate with your global audience in their preferred language.
## FAQs
WhatsApp typically reviews templates within 24-48 hours, but this can vary depending on template content and current review volumes.
Templates may be rejected if they violate WhatsApp's Business Policy, contain prohibited content, or don't match the selected category. Check our [Template Guidelines](/guides/whatsapp/template-guidelines) for more information.
No, once submitted, templates cannot be modified. You'll need to create a new template with your desired changes.
Text-only templates have a limit of 1,024 characters. Templates with media have different limits based on the header type.
Our support team is available 24/7 to assist with template issues, API integration, or any other questions.
# Incoming Messages
Source: https://docs.whatsable.app/guides/notifyer-system/api/incoming-message
Receive and manage real-time WhatsApp message notifications via webhooks
Incoming message webhooks deliver real-time notifications when your recipients reply, enabling immediate responses and interactive conversations through WhatsApp.
The Incoming Messages system provides a robust webhook infrastructure that enables your application to receive and process WhatsApp messages from your recipients in real-time. This guide covers how to configure, manage, and handle incoming message webhooks.
## Overview
Webhooks are HTTP callbacks that deliver notifications to your server whenever specific events occur - in this case, when recipients reply to your WhatsApp messages. Benefits include:
* **Real-time processing** of customer responses
* **Seamless integration** with your existing systems
* **Automated workflows** triggered by customer messages
* **Enhanced customer experience** through timely interactions
## Webhook Configuration
### Managing Endpoints
Navigate to the Developer section in your dashboard sidebar to manage webhook configurations.
Add a new webhook URL where you want to receive incoming message notifications.
### Endpoint Requirements
All webhook endpoints must be publicly accessible via HTTPS and configured to accept POST requests with JSON payloads. HTTP endpoints are not supported in production environments.
Your webhook endpoint must:
1. Accept HTTP POST requests
2. Process JSON payloads
3. Return a 2xx status code within 10 seconds
4. Implement idempotency handling (see best practices below)
## Webhook Payload
When a user replies to your WhatsApp message, we'll send a POST request to your configured endpoint with a detailed payload.
### Sample Payload
```json Incoming Text Message theme={null}
{
"last_messages": [
{
"type": "user",
"content": "Thank you for the quick response. Can you provide more details about your premium service plans?",
"timestamp": "2025-06-09T22:08:11.990Z",
"content_type": "text"
},
{
"type": "bot",
"content": "I'd be happy to help you explore our premium service options. Let me connect you with a specialist who can provide detailed information.",
"timestamp": "2025-06-09T21:45:30.417Z",
"content_type": "text"
}
],
"conversation_paragraph": "User (10:08:11 PM): Thank you for the quick response. Can you provide more details about your premium service plans? ; Bot (9:45:30 PM): I'd be happy to help you explore our premium service options. Let me connect you with a specialist who can provide detailed information.",
"phone_number": "14155552671",
"recipient_name": "Sarah Johnson",
"user_id": "9232fcef-a570-4a2c-b46b-6cab53aec304",
"last_message_of_user": "Thank you for the quick response. Can you provide more details about your premium service plans?",
"last_message_of_bot": "I'd be happy to help you explore our premium service options. Let me connect you with a specialist who can provide detailed information.",
"message_type": "text",
"user_last_message_time": 1749506891,
"bot_last_message_time": 1749504330,
"attachment_url": null,
"note": "",
"note_automation": "",
"labels": "sales, premium-inquiry"
}
```
```json Incoming Media Message theme={null}
{
"last_messages": [
{
"type": "user",
"content": "",
"timestamp": "2025-06-09T14:05:12.000Z",
"content_type": "document",
"media_url": "https://api.insightssystem.com/vault/LSMumRx1/VR-1aHOci6nP28eHWHJH7JauJkc/Ew7R9w../contract_proposal_v2.pdf"
},
{
"type": "bot",
"content": "Please upload the signed contract document when ready, and I'll process it immediately.",
"timestamp": "2025-06-09T14:03:20.000Z",
"content_type": "text"
}
],
"conversation_paragraph": "User (2:05:12 PM): [Document] ; Bot (2:03:20 PM): Please upload the signed contract document when ready, and I'll process it immediately.",
"phone_number": "14155552671",
"recipient_name": "Sarah Johnson",
"user_id": "9232fcef-a570-4a2c-b46b-6cab53aec304",
"last_message_of_user": "", // For image, video & document files, this field contains the caption if provided
"last_message_of_bot": "Please upload the signed contract document when ready, and I'll process it immediately.",
"message_type": "document",
"user_last_message_time": 1749472312,
"bot_last_message_time": 1749472200,
"attachment_url": "https://api.insightssystem.com/vault/LSMumRx1/VR-1aHOci6nP28eHWHJH7JauJkc/Ew7R9w../contract_proposal_v2.pdf",
"note": "",
"note_automation": "",
"labels": "contracts, document-processing"
}
```
### Payload Fields
Array containing the recent messages in the conversation
Sender type ("user" or "bot")
Message content (empty for media messages)
ISO 8601 timestamp when the message was sent
Type of content (text, image, audio, video, document, location)
URL to media file if applicable (valid for 24 hours)
Human-readable summary of the recent conversation
The phone number of the recipient who sent the message
The name of the recipient if available
Unique identifier for the user in your system
The last message sent by the user
The last message sent by your system
The type of the latest message (text, image, audio, video, document, location)
Unix timestamp of the user's last message
Unix timestamp of your system's last message
URL to media file if the latest message contains media (null for text messages)
Custom note field for additional context
Automation-related notes
Comma-separated labels for categorizing the conversation
## Webhook Management API
You can programmatically manage your webhook endpoints using our API.
### Create Webhook Endpoint
`POST https://api.insightssystem.com/api:qh9OQ3OW/webhook/dev/create`
Register a new webhook endpoint to receive incoming message notifications. Send a valid **Bearer** token (same credential used for the dashboard).
#### Request Body
Full HTTPS URL of your endpoint.
Whether the webhook is enabled.
Incoming message trigger on/off.
Schedule activity trigger on/off. When enabled, your bot can send multiple sequential messages with natural delays between them — useful for simulating human-like conversation flow.
**How to enable in the dashboard**
Navigate to **Incoming Webhooks**, click the settings icon next to your webhook, then enable **Schedule Activity**. A dropdown will appear where you can select your preferred delay duration between messages.
![How to enable Schedule Activity and set delay duration]()
**Example workflow**
When a user sends an incoming message, you can respond with a sequence of messages each sent after a specified delay:
```json theme={null}
{
"messages": [
{
"text": "Great! Let me check available slots for you...",
"delay": 0
},
{
"text": "I can see openings on Monday and Wednesday.",
"delay": 2000
},
{
"text": "Which day works better for you?",
"delay": 3500
}
]
}
```
Set `waiting_duration` to the maximum delay window you need. When `schedule_activity` is `false`, set `waiting_duration` to `0`.
How long (in **seconds**) to wait for schedule activity when `schedule_activity` is `true`. Set to `0` when schedule activity is off.
Dashboard presets: `15`, `30`, `60`, `1800`, `3600`, `18000`, `36000`, `86400`, `172800`, `259200`, `432000`, `604800`, `1209600`, `2592000`, `5184000` (15 seconds → 2 months). Prefer these values if mirroring the app UI.
If `true`, enables request signing. The server returns a `signature_secret` **once** in the response — copy and store it immediately, as it will not be shown again.
![Webhook signature toggle in the Add Endpoint dialog]()
```bash cURL theme={null}
curl -X POST \
https://api.insightssystem.com/api:qh9OQ3OW/webhook/dev/create \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_TOKEN' \
-d '{
"webhooks": "https://your-domain.com/api/webhooks/whatsapp",
"status": true,
"incoming": true,
"schedule_activity": false,
"waiting_duration": 0,
"active_signature": false
}'
```
```javascript Node.js theme={null}
const axios = require('axios');
async function createWebhook() {
try {
const response = await axios.post(
'https://api.insightssystem.com/api:qh9OQ3OW/webhook/dev/create',
{
webhooks: "https://your-domain.com/api/webhooks/whatsapp",
status: true,
incoming: true,
schedule_activity: false,
waiting_duration: 0,
active_signature: false
},
{
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer YOUR_TOKEN'
}
}
);
console.log(response.data);
return response.data;
} catch (error) {
console.error('Error creating webhook:', error);
}
}
createWebhook();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:qh9OQ3OW/webhook/dev/create"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer YOUR_TOKEN"
}
data = {
"webhooks": "https://your-domain.com/api/webhooks/whatsapp",
"status": True,
"incoming": True,
"schedule_activity": False,
"waiting_duration": 0,
"active_signature": False
}
response = requests.post(url, headers=headers, json=data)
print(response.json())
```
#### Response
Returns a JSON object for the created webhook row.
Webhook ID.
Whether the webhook is enabled.
Incoming message trigger.
Outgoing message trigger.
Stored endpoint URL.
Unix timestamp in milliseconds.
Schedule activity wait time in seconds.
Schedule activity flag.
When `active_signature` was `true`: a **one-time** secret string — copy and store it immediately, it will not be retrievable again. When `active_signature` was `false`: `null`.
```json With Signature (active_signature: true) theme={null}
{
"id": 1205,
"status": true,
"incoming": true,
"outgoing": false,
"webhooks": "https://your-domain.com/api/webhooks/whatsapp",
"created_at": 1775471874139,
"signature_secret": "",
"waiting_duration": 0,
"schedule_activity": false
}
```
```json Without Signature (active_signature: false) theme={null}
{
"id": 1205,
"status": true,
"incoming": true,
"outgoing": false,
"webhooks": "https://your-domain.com/api/webhooks/whatsapp",
"created_at": 1775471874139,
"signature_secret": null,
"waiting_duration": 0,
"schedule_activity": false
}
```
When `active_signature` is `true`, the `signature_secret` is returned **only once** at creation time. Store it securely — it cannot be retrieved again. Use it to verify the authenticity of incoming webhook requests.
### Webhook Signature Verification
When a webhook is created with `active_signature: true`, every request our system sends to your endpoint will include an **`X-Webhook-Signature`** header. Use it to confirm the request genuinely came from us and was not tampered with.
| Header | Example value |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `X-Webhook-Signature` | `RNEefV2V_tiDZeiOpeqMzWsR3X4zGOxIYARIF5-Ia2MXWIgT48jO-M4A1-bgr9bxdoHy5vb7azy_Vd-Gsp4qoAVhQCVyWZxhD1ZNJTQi9VNezJ6C7mnPy--osqcDSq1bfjjppAXBlyenWIa8_506ez5Z92p-eGucalu3-1g6wOk` |
The value is derived from the `signature_secret` returned at creation time. Compare it in your endpoint handler to validate each incoming request.
If `active_signature` was `false` when the webhook was created, this header will **not** be present in requests sent to your endpoint.
Never log or expose your `signature_secret` in client-side code or public repositories. If it is compromised, delete the webhook and create a new one with a fresh secret.
## Troubleshooting
* Verify your endpoint is publicly accessible
* Check for HTTP 4xx or 5xx responses
* Ensure proper SSL certificate configuration
* Verify your webhook is enabled in the dashboard
Each endpoint URL must be unique. If you submit a `webhooks` URL that is already registered, the API will return a **"Same webhook exist"** error.
To resolve this:
* Check your existing webhooks in the **Developer → Incoming Webhooks** tab of the dashboard to confirm whether the URL is already registered.
* If you want to update settings on an existing webhook (e.g. toggle `incoming`, change `waiting_duration`), use the update/edit endpoint instead of re-creating it.
* If you genuinely need a fresh webhook at the same URL, delete the existing one first, then create a new one.
Our technical support team is available to assist with webhook configuration, payload handling, and integration questions.
# Non-Template Message
Source: https://docs.whatsable.app/guides/notifyer-system/api/non-template-message
Send direct WhatsApp messages with text, media, and rich content without templates
Send instant WhatsApp messages directly to your customers without requiring pre-approved templates. Perfect for quick responses, customer support, and media sharing during ongoing conversations.
The Send Non-Template Message API enables you to send immediate WhatsApp messages including text, images, videos, audio, and documents. This is ideal for customer support scenarios and ongoing conversations where template approval is not required.
## Overview
The Send Non-Template Message API enables you to:
* Send instant text messages with URL previews
* Share images, videos, and documents with captions
* Send audio files and voice messages
* Organize messages with custom labels for analytics
* Respond quickly in customer support scenarios
* Continue conversations without template restrictions
## Send Non-Template Message
Send various types of WhatsApp messages directly to a specific phone number without requiring pre-approved templates.
### Endpoint
```
POST https://api.insightssystem.com/api:U9ztporN/send/message
```
### Authentication
All API requests require authentication using your API key. Never share your API keys in client-side code or public repositories.
Include your API key in all requests using Bearer authentication:
```bash theme={null}
Authorization: Bearer YOUR_API_KEY
```
```javascript theme={null}
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
```
### Request Body
The recipient's phone number in international format with country code (e.g., "+15551234567").
The type of message to send. Must be one of: `text`, `image`, `video`, `audio`, `document`.
The type of recipient. Always use "individual" for single recipients.
The messaging platform. Always use "whatsapp".
Array of strings for message categorization and analytics (e.g., \["support", "urgent"]).
### Message Type-Specific Parameters
Text message configuration
The text content of the message (max 4096 characters)
Whether to show URL previews for links in the message
Image message configuration
Public URL to the image file (JPG, JPEG, PNG)
Text caption for the image (max 1024 characters)
Video message configuration
Public URL to the video file (MP4, 3GPP)
Text caption for the video (max 1024 characters)
Audio message configuration
Public URL to the audio file (MP3, AAC, AMR, OGG)
Document message configuration
Public URL to the document file
Text caption for the document (max 1024 characters)
Custom filename for the document (with extension)
### Response
The API returns a detailed response indicating whether the message was accepted for delivery and provides WhatsApp message identifiers for tracking.
Indicates if the request was successfully processed
Details from the WhatsApp Business API about the message delivery
Always "whatsapp" for WhatsApp messages
Information about the message recipient
The phone number that was provided in the request
WhatsApp's unique identifier for the recipient
Details about the sent message
Unique message identifier (wamid) for tracking status
Initial status of the message (typically "accepted")
Present only when an error occurs
Error code identifier
Human-readable error description
### Example Requests
```bash cURL theme={null}
curl -X POST \
https://api.insightssystem.com/api:U9ztporN/send/message \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"to": "+15551234567",
"type": "text",
"text": {
"body": "Hello! Thank you for contacting our support team. How can we help you today?",
"preview_url": true
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "greeting"]
}'
```
```javascript Node.js theme={null}
const apiKey = 'YOUR_API_KEY';
async function sendTextMessage() {
try {
const response = await fetch('https://api.insightssystem.com/api:U9ztporN/send/message', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiKey}`
},
body: JSON.stringify({
to: '+15551234567',
type: 'text',
text: {
body: 'Hello! Thank you for contacting our support team. How can we help you today?',
preview_url: true
},
recipient_type: 'individual',
messaging_product: 'whatsapp',
labels: ['support', 'greeting']
})
});
const result = await response.json();
console.log(result);
return result;
} catch (error) {
console.error('Error sending message:', error);
}
}
sendTextMessage();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:U9ztporN/send/message"
api_key = "YOUR_API_KEY"
payload = {
"to": "+15551234567",
"type": "text",
"text": {
"body": "Hello! Thank you for contacting our support team. How can we help you today?",
"preview_url": True
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "greeting"]
}
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```bash cURL theme={null}
curl -X POST \
https://api.insightssystem.com/api:U9ztporN/send/message \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"to": "+15551234567",
"type": "image",
"image": {
"link": "https://storage.googleapis.com/your-bucket/product-demo.jpg",
"caption": "Here'\''s a visual guide to help you get started with our product!"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "tutorial"]
}'
```
```javascript Node.js theme={null}
const apiKey = 'YOUR_API_KEY';
async function sendImageMessage() {
try {
const response = await fetch('https://api.insightssystem.com/api:U9ztporN/send/message', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiKey}`
},
body: JSON.stringify({
to: '+15551234567',
type: 'image',
image: {
link: 'https://storage.googleapis.com/your-bucket/product-demo.jpg',
caption: 'Here\'s a visual guide to help you get started with our product!'
},
recipient_type: 'individual',
messaging_product: 'whatsapp',
labels: ['support', 'tutorial']
})
});
const result = await response.json();
console.log(result);
return result;
} catch (error) {
console.error('Error sending image:', error);
}
}
sendImageMessage();
```
```bash cURL theme={null}
curl -X POST \
https://api.insightssystem.com/api:U9ztporN/send/message \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"to": "+15551234567",
"type": "video",
"video": {
"link": "https://storage.googleapis.com/your-bucket/tutorial-video.mp4",
"caption": "Watch this step-by-step tutorial to get started quickly!"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "tutorial"]
}'
```
```javascript Node.js theme={null}
const apiKey = 'YOUR_API_KEY';
async function sendVideoMessage() {
try {
const response = await fetch('https://api.insightssystem.com/api:U9ztporN/send/message', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiKey}`
},
body: JSON.stringify({
to: '+15551234567',
type: 'video',
video: {
link: 'https://storage.googleapis.com/your-bucket/tutorial-video.mp4',
caption: 'Watch this step-by-step tutorial to get started quickly!'
},
recipient_type: 'individual',
messaging_product: 'whatsapp',
labels: ['support', 'tutorial']
})
});
const result = await response.json();
console.log(result);
return result;
} catch (error) {
console.error('Error sending video:', error);
}
}
sendVideoMessage();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:U9ztporN/send/message"
api_key = "YOUR_API_KEY"
payload = {
"to": "+15551234567",
"type": "video",
"video": {
"link": "https://storage.googleapis.com/your-bucket/tutorial-video.mp4",
"caption": "Watch this step-by-step tutorial to get started quickly!"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "tutorial"]
}
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```bash cURL theme={null}
curl -X POST \
https://api.insightssystem.com/api:U9ztporN/send/message \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"to": "+15551234567",
"type": "audio",
"audio": {
"link": "https://storage.googleapis.com/your-bucket/voice-instructions.mp3"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "voice-note"]
}'
```
```javascript Node.js theme={null}
const apiKey = 'YOUR_API_KEY';
async function sendAudioMessage() {
try {
const response = await fetch('https://api.insightssystem.com/api:U9ztporN/send/message', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiKey}`
},
body: JSON.stringify({
to: '+15551234567',
type: 'audio',
audio: {
link: 'https://storage.googleapis.com/your-bucket/voice-instructions.mp3'
},
recipient_type: 'individual',
messaging_product: 'whatsapp',
labels: ['support', 'voice-note']
})
});
const result = await response.json();
console.log(result);
return result;
} catch (error) {
console.error('Error sending audio:', error);
}
}
sendAudioMessage();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:U9ztporN/send/message"
api_key = "YOUR_API_KEY"
payload = {
"to": "+15551234567",
"type": "audio",
"audio": {
"link": "https://storage.googleapis.com/your-bucket/voice-instructions.mp3"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "voice-note"]
}
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```bash cURL theme={null}
curl -X POST \
https://api.insightssystem.com/api:U9ztporN/send/message \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"to": "+15551234567",
"type": "document",
"document": {
"link": "https://storage.googleapis.com/your-bucket/user-manual.pdf",
"caption": "Here is the complete user manual you requested.",
"filename": "Product_User_Manual_v2.1.pdf"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "documentation"]
}'
```
```javascript Node.js theme={null}
const apiKey = 'YOUR_API_KEY';
async function sendDocumentMessage() {
try {
const response = await fetch('https://api.insightssystem.com/api:U9ztporN/send/message', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiKey}`
},
body: JSON.stringify({
to: '+15551234567',
type: 'document',
document: {
link: 'https://storage.googleapis.com/your-bucket/user-manual.pdf',
caption: 'Here is the complete user manual you requested.',
filename: 'Product_User_Manual_v2.1.pdf'
},
recipient_type: 'individual',
messaging_product: 'whatsapp',
labels: ['support', 'documentation']
})
});
const result = await response.json();
console.log(result);
return result;
} catch (error) {
console.error('Error sending document:', error);
}
}
sendDocumentMessage();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:U9ztporN/send/message"
api_key = "YOUR_API_KEY"
payload = {
"to": "+15551234567",
"type": "document",
"document": {
"link": "https://storage.googleapis.com/your-bucket/user-manual.pdf",
"caption": "Here is the complete user manual you requested.",
"filename": "Product_User_Manual_v2.1.pdf"
},
"recipient_type": "individual",
"messaging_product": "whatsapp",
"labels": ["support", "documentation"]
}
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
### Example Response
```json Success Response theme={null}
{
"success": true,
"whatsapp_response_info": {
"messaging_product": "whatsapp",
"contacts": [
{
"input": "+15551234567",
"wa_id": "15551234567"
}
],
"messages": [
{
"id": "wamid.HBgLMTU1NTEyMzQ1NjcVAgAERgINQTlEOEJDNzM5QzQwAA==",
"message_status": "accepted"
}
]
}
}
```
```json Error Response theme={null}
{
"success": false,
"error": {
"code": "invalid_phone_number",
"message": "The phone number format is invalid. Please use international format with country code."
}
}
```
## Response Codes
Your request was successful and the message has been accepted for delivery.
The request was invalid. Check the error message for details about missing or invalid parameters.
```json theme={null}
{
"success": false,
"error": {
"code": "missing_required_field",
"message": "The 'to' field is required and must be a valid phone number"
}
}
```
Authentication failed. Verify that you're using a valid API key in the Authorization header.
```json theme={null}
{
"success": false,
"error": {
"code": "unauthorized",
"message": "Invalid API key provided"
}
}
```
Your account doesn't have permission to send messages or has reached its usage limit.
The media file or message content exceeds size limits.
```json theme={null}
{
"success": false,
"error": {
"code": "file_too_large",
"message": "The media file exceeds the maximum allowed size"
}
}
```
The request contains invalid data or the media URL is not accessible.
```json theme={null}
{
"success": false,
"error": {
"code": "invalid_media_url",
"message": "The provided media URL is not accessible"
}
}
```
You've exceeded the rate limit. Implement exponential backoff and retry logic.
An internal server error occurred. Contact support if the issue persists.
```json theme={null}
{
"success": false,
"error": {
"code": "server_error",
"message": "An internal server error occurred. Please try again later."
}
}
```
## Message Types Guide
Understanding the different message types and their optimal use cases will help you choose the right format for your communication needs.
### Text Messages
* Keep messages concise and actionable
* Use URL previews for important links
* Break long messages into multiple shorter ones
* Include clear call-to-action when needed
* Customer support responses
* Order confirmations
* Quick updates and notifications
* FAQ responses
### Media Messages
* **Formats**: JPG, JPEG, PNG
* **Max Size**: 5MB
* **Optimal**: 1080x1080px or 16:9 ratio
* **Use for**: Product photos, screenshots, infographics
* **Formats**: MP4, 3GPP
* **Max Size**: 16MB
* **Max Duration**: 90 seconds
* **Use for**: Tutorials, product demos, explanations
* **Formats**: MP3, AAC, AMR, OGG
* **Max Size**: 16MB
* **Max Duration**: 30 minutes
* **Use for**: Voice messages, audio instructions
* **Formats**: PDF, DOC, DOCX, PPT, PPTX, XLS, XLSX
* **Max Size**: 100MB
* **Use for**: Manuals, invoices, reports, contracts
## Media Requirements
All media URLs must be publicly accessible via HTTPS without requiring authentication. For security-sensitive content, consider using signed URLs with expiration times.
### URL Requirements
Ensure your media URLs are publicly accessible without authentication headers or login requirements.
All media URLs must use HTTPS protocol. HTTP URLs will be rejected.
URLs should point directly to the file, not to a page that contains the file or requires redirects.
Your server should return appropriate Content-Type headers for media files to ensure proper handling.
### Supported Formats
| Media Type | Supported Formats | Max Size | Notes |
| ---------- | ------------------------------------ | -------- | -------------------------------------- |
| Images | JPG, JPEG, PNG | 5MB | Animated GIFs not supported |
| Videos | MP4, 3GPP | 16MB | H.264 codec recommended |
| Audio | MP3, AAC, AMR, OGG | 16MB | Stereo or mono |
| Documents | PDF, DOC, DOCX, PPT, PPTX, XLS, XLSX | 100MB | Password-protected files not supported |
## Best Practices
Keep messages concise and actionable. Use rich media when it adds value. Always include clear next steps or calls-to-action when appropriate.
Implement comprehensive error handling with retries. Store failed messages for later retry. Monitor success rates and investigate patterns in failures.
Use CDN for media hosting to ensure fast loading. Implement media validation before sending. Consider file size optimization for better delivery rates.
Use labels consistently for message categorization. Track message IDs for delivery status monitoring. Implement webhook handling for real-time status updates.
## Security Considerations
* Never expose API keys in client-side code
* Use environment variables for key storage
* Rotate keys regularly
* Implement IP whitelisting when possible
* Avoid sending sensitive data in message content
* Use secure, time-limited URLs for confidential documents
* Implement proper access controls
* Follow GDPR and other privacy regulations
## FAQs
Non-template messages can only be sent to users who have initiated a conversation with your WhatsApp Business account within the last 24 hours. For proactive messaging, use the [Template Message API](/api-reference/notifier-system/templates/send-template-message).
Common reasons include: media URL not publicly accessible, incorrect file format, file size exceeding limits, or missing Content-Type headers. Ensure your media URLs return proper HTTP responses and correct MIME types.
Use the message ID returned in the response to track status via webhooks or the [Message Status API](/api-reference/notifier-system/message-status). The initial response only confirms WhatsApp accepted the message, not final delivery.
This API sends messages immediately. For scheduled messaging, implement your own scheduling logic or use our [Scheduled Messages API](/api-reference/notifier-system/scheduled-messages).
Messages will fail if sent to phone numbers without active WhatsApp accounts. The API will return an error indicating the recipient is not reachable on WhatsApp.
Consider implementing timezone-aware sending in your application logic. Send messages during business hours in the recipient's local timezone for better engagement rates.
Our support team is available 24/7 to help with API integration, troubleshooting, or any questions about sending messages.
# Template Message
Source: https://docs.whatsable.app/guides/notifyer-system/api/template-message
Send personalized WhatsApp messages using pre-approved templates
Templates enable personalized communication while ensuring compliance with WhatsApp's business policies. This API lets you send template-based messages to your customers with dynamic content.
WhatsApp requires businesses to use pre-approved templates for initiating conversations. This API allows you to send template messages with personalized variables, media attachments, and interactive components to your customers.
## Overview
The Send Template Message API enables you to:
* Send WhatsApp messages using your pre-approved templates
* Dynamically replace variables with personalized content
* Attach media (images, videos, documents) when supported by the template
* Include interactive elements like buttons and quick replies
* Track delivery status through WhatsApp response information
Experiment with the Send Template Message API and view responses in real-time
## Send Template Message
Send a personalized WhatsApp template message to a specific phone number.
### Endpoint
```
POST https://api.insightssystem.com/api:hFrjh8a1/send_template_message_by_api
```
### Authentication
All API requests require authentication using your API key. Never share your API keys in client-side code.
Include your API key in all requests using Bearer authentication:
```bash theme={null}
Authorization: Bearer YOUR_API_KEY
```
```javascript theme={null}
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
```
### Request Body
The unique identifier of the template to use. You can retrieve this from the [Get Templates API](/api-reference/notifier-system/templates/get-templates).
The recipient's phone number in international format with country code (e.g., "+123476529999").
Object containing key-value pairs for template variables. The keys must match the variable names defined in your template.
Text variables that replace placeholders in the message body (e.g., body1, body2, etc.)
Text variables that replace placeholders in the message header
Public URL to media content (image, video, or document) for templates with media support
Set to "1" to enable dynamic button links in interactive templates
### Response
The API returns a detailed response indicating whether the message was accepted for delivery and provides WhatsApp message identifiers for tracking.
Indicates if the request was successfully processed
Details from the WhatsApp Business API about the message delivery
Always "whatsapp" for WhatsApp messages
Information about the message recipient
The phone number that was provided in the request
WhatsApp's unique identifier for the recipient
Details about the sent message
Unique message identifier (wamid) for tracking status
Initial status of the message (typically "accepted")
Present only when an error occurs
Error code identifier
Human-readable error description
### Example Request
```bash cURL theme={null}
curl -X POST \
'https://api.insightssystem.com/api:hFrjh8a1/send_template_message_by_api' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"template": "f10695a9-38d6-4f5f-8444-1f7bf52c6164",
"phone_number": "+123476529999",
"variables": {
"body1": "Axel",
"body2": "Shampoo",
"body3": "$1",
"media": "https://drive.google.com/file/d/1D35uTbceRPmCgwxVfBJZ2yxD2lQgs0bi/view?usp=sharing",
"visit_website": "1"
}
}'
```
```javascript Node.js theme={null}
const fetch = require("node-fetch");
async function sendTemplateMessage() {
try {
const response = await fetch(
'https://api.insightssystem.com/api:hFrjh8a1/send_template_message_by_api',
{
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: "Bearer YOUR_API_KEY",
},
body: JSON.stringify({
template: "f10695a9-38d6-4f5f-8444-1f7bf52c6164",
phone_number: "+123476529999",
variables: {
body1: "Axel",
body2: "Shampoo",
body3: "$1",
media: "https://drive.google.com/file/d/1D35uTbceRPmCgwxVfBJZ2yxD2lQgs0bi/view?usp=sharing",
visit_website: "1"
}
}),
}
);
const data = await response.json();
console.log(data);
return data;
} catch (error) {
console.error('Error sending template message:', error.response?.data || error.message);
}
}
sendTemplateMessage();
```
```python Python theme={null}
import requests
url = "https://api.insightssystem.com/api:hFrjh8a1/send_template_message_by_api"
payload = {
"template": "f10695a9-38d6-4f5f-8444-1f7bf52c6164",
"phone_number": "+123476529999",
"variables": {
"body1": "Axel",
"body2": "Shampoo",
"body3": "$1",
"media": "https://drive.google.com/file/d/1D35uTbceRPmCgwxVfBJZ2yxD2lQgs0bi/view?usp=sharing",
"visit_website": "1"
}
}
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer YOUR_API_KEY"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.insightssystem.com/api:hFrjh8a1/send_template_message_by_api"
// Create request payload
payload := map[string]interface{}{
"template": "f10695a9-38d6-4f5f-8444-1f7bf52c6164",
"phone_number": "+123476529999",
"variables": map[string]interface{}{
"body1": "Axel",
"body2": "Shampoo",
"body3": "$1",
"media": "https://drive.google.com/file/d/1D35uTbceRPmCgwxVfBJZ2yxD2lQgs0bi/view?usp=sharing",
"visit_website": "1",
},
}
// Convert payload to JSON
jsonPayload, err := json.Marshal(payload)
if err != nil {
fmt.Println("Error creating JSON payload:", err)
return
}
// Create request
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonPayload))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
// Add headers
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
// Send request
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
// Read response
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response:", err)
return
}
fmt.Println("Response:", string(body))
}
```
### Example Response
```json Success Response theme={null}
{
"success": true,
"whatsapp_response_info": {
"messaging_product": "whatsapp",
"contacts": [
{
"input": "+123476529999",
"wa_id": "123476529999"
}
],
"messages": [
{
"id": "wamid.HBgLMTIzNDc2NTI5OTk5FQIAERgSNUU2RjM4NzM1M0Q5OEIwQTQwAA==",
"message_status": "accepted"
}
]
}
}
```
```json Error Response theme={null}
{
"success": false,
"error": {
"code": "invalid_template",
"message": "The template ID provided does not exist or is not approved"
}
}
```
## Response Codes
Your request was successful and the message has been accepted for delivery.
The request was invalid. Check the error message for details.
```json theme={null}
{
"success": false,
"error": {
"code": "invalid_request",
"message": "Missing required field: template"
}
}
```
Authentication failed. Check that you're using a valid API key.
```json theme={null}
{
"success": false,
"error": {
"code": "unauthorized",
"message": "Invalid API key provided"
}
}
```
Your account doesn't have permission to send messages.
The template specified doesn't exist.
```json theme={null}
{
"success": false,
"error": {
"code": "template_not_found",
"message": "Template with ID 'f10695a9-38d6-4f5f-8444-1f7bf52c6164' not found"
}
}
```
The request was well-formed but contains invalid parameters.
```json theme={null}
{
"success": false,
"error": {
"code": "invalid_phone_number",
"message": "The phone number format is invalid"
}
}
```
You've exceeded the rate limit. Implement exponential backoff in your requests.
Something went wrong on our end. Please contact support if the issue persists.
```json theme={null}
{
"success": false,
"error": {
"code": "server_error",
"message": "An internal server error occurred"
}
}
```
## Working with Template Variables
Templates contain placeholders that are replaced with dynamic content when sending messages. Understanding how to map your data to these variables is essential.
### Variable Types
Body and header variables replace text placeholders in your template. They are named `body1`, `body2`, etc., or `header1`, `header2`, etc.
Media variables allow you to attach images, videos, or documents to your template. Provide a public URL in the `media` property.
Used for dynamic buttons in interactive templates. Use `visit_website` set to "1" to enable dynamic button URLs.
For templates with quick reply buttons, provide the text to display on each button.
### Variable Mapping
Examine your template structure to identify which variables are required. You can find this information using the [Get Templates API](/api-reference/notifier-system/templates/get-templates).
Format your data to match the expected variable structure. Ensure values meet any length or format requirements.
Create a `variables` object with keys matching your template's variable names and values from your data.
For media templates, ensure your media URL is publicly accessible and in a WhatsApp-supported format.
## Media Guidelines
When including media in your templates, follow these guidelines for optimal delivery:
* Supported formats: JPG, JPEG, PNG
* Max size: 5MB
* Recommended aspect ratio: 1.91:1
* Supported formats: MP4, 3GPP
* Max size: 16MB
* Max duration: 1 minute
* Supported formats: PDF, DOC, DOCX, PPT, PPTX, XLS, XLSX
* Max size: 100MB
* Must be publicly accessible
* Direct file links (no redirects)
* HTTPS required
Media URLs must be publicly accessible without requiring authentication. For security, we recommend using signed URLs with limited-time access.
## Best Practices
Implement comprehensive error handling to manage API failures gracefully. Always check the `success` field in responses and handle various error scenarios.
Store the returned `message_id` values to track delivery status using the [Message Status API](/api-reference/notifier-system/message-status).
Implement request throttling when sending to multiple recipients to avoid hitting rate limits and ensure reliable delivery.
Test your templates with various inputs to ensure variables are correctly replaced and messages appear as expected.
## FAQs
Messages may fail to deliver for several reasons: invalid phone number, recipient has blocked your WhatsApp Business number, template issues, or WhatsApp temporary service interruptions. Check the error code returned for specific details.
No, recipients must have an active WhatsApp account associated with the phone number you're sending to.
The initial response only confirms that WhatsApp accepted the message. For actual delivery status, implement webhook handling using our [Webhooks API](/api-reference/webhook) or query the [Message Status API](/api-reference/notifier-system/message-status).
No, WhatsApp messages cannot be edited once sent. You would need to send a new message with the corrected information.
Our support team is available 24/7 to assist with template issues, API integration, or any other questions.
# Attio
Source: https://docs.whatsable.app/guides/notifyer-system/attio-overview
Learn how to sync WhatsApp conversations with Attio CRM using the Notifyer System
# Notifyer System Integration with Attio
![Attio Sync Settings screen in Notifyer showing CRM Record Matching with Person object and Phone numbers field]()
This guide walks you through connecting Notifyer System with Attio so WhatsApp conversations show up inside your CRM — matched to the right contact, logged as a note, and kept up to date as messages are sent and received.
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a connected WhatsApp number and subscription plan (Pro or Agency)
Access to an [Attio](https://attio.com/) workspace, with permission to install and authorize third-party apps
Your WhatsApp number must already be connected inside Notifyer before you start the Attio integration. If you haven't done that yet, complete the [embedding process](/guides/notifyer-system/embedding-process) first.
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## What you get with this integration
Every WhatsApp message is matched to the right Attio record by phone number — no manual lookup needed
New WhatsApp senders that don't exist in your CRM yet can be created automatically, with their name and phone number filled in
Incoming and outgoing messages are written into an Attio Note on the matching record, so your team can read conversation history without leaving Attio
Last message, timestamps, labels, country, and more update on the record — visible in your People list
A Live Chat Link field on every record opens the complete WhatsApp thread in Notifyer's live console, already matched to that contact
You choose which Attio object and which attributes receive WhatsApp data — nothing is hard-coded to People only
![Attio People list showing WhatsApp last message and timestamp columns kept up to date]()
## Setting up your Notifyer System account
Before any WhatsApp message can sync anywhere, you must complete the platform [embedding process](/guides/notifyer-system/embedding-process), which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Unlike the Pipedrive and Monday.com integrations, the Attio integration does not currently include an action to send WhatsApp template messages from inside Attio. Attio is a sync-in integration today: WhatsApp conversations flow into Attio automatically, but sending messages still happens from the Notifyer chat console, Zapier, Make, n8n, or the WhatsAble API. You do not need to set up message templates specifically for Attio.
## Connect Notifyer System to Attio
1. Log in to your **Notifyer Console**
2. In the left sidebar, look for **Attio** in your list of connected tools (you'll see a **New** badge next to it)
3. Click **Attio**, or open it directly at [notifyer.whatsable.app/attio](https://notifyer.whatsable.app/attio)
If you're going through the onboarding checklist for the first time, you'll also find an **Attio** card under **Connect Tools** with the description "See your messages inside Attio Notes and schedule follow-ups."
On the Attio integration page, click **Connect Attio** (it may read **Authorize Attio** if your workspace was already installed but not yet authorized by you — both start the same OAuth flow).
You'll be redirected to Attio's authorization screen. Review the requested access and approve the connection so Notifyer can read and write records, attributes, and notes in your workspace.
After you approve, Attio redirects you back to the Notifyer Console. You'll land on a green **Attio workspace connected** card showing:
* **Workspace** — your Attio workspace name, slug, and logo
* **Authorized by** — the name and email of the teammate who connected the account
* **Connected at** — the date and time the connection was made
If you see this card, your Attio workspace is linked to Notifyer System. Continue below to configure how WhatsApp data flows into it.
Until **Sync Settings** and **Attribute Mapping** are fully configured and saved, Notifyer will not sync WhatsApp messages into Attio. Required fields are marked with a red asterisk (**\***). If anything is missing, **Save settings** shows a validation error.
## Sync Settings reference
Once connected, scroll to **Sync Settings**. This is where you tell Notifyer which Attio object and fields should receive your WhatsApp data.
| Setting | Options | Description |
| ------------------------------------- | ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| **Object** (CRM Record Matching) | Person / Company / Deal / User / Workspace, or any custom object | The Attio object incoming WhatsApp numbers are matched against. This also drives auto-create |
| **Phone field** (CRM Record Matching) | Any phone-number attribute on the selected object | Field used to match a WhatsApp number to a record. Only phone-type attributes appear here |
| **Note Destination** | Any object in your workspace | Which Attio object receives the synced WhatsApp conversation note |
| **Note grouping** | Date-wise notes / Combined note | Whether messages are split into a new note per calendar day, or kept in one ongoing note |
| **Auto-create person** | On / Off | Whether Notifyer creates a new record when an incoming WhatsApp number has no match |
| **Timezone** | Any IANA timezone (e.g. `Asia/Dhaka`, `America/New_York`) | Used for message timestamps and for where one "day" starts and ends in date-wise mode |
### CRM Record Matching
Open the **Object** dropdown and pick the Attio object you want WhatsApp contacts matched against. Every object in your workspace appears here — native ones like **Person**, **Company**, **Deal**, **User**, and **Workspace** are labeled **Native**, and anything you built yourself is labeled **Custom**.
Most teams should choose **Person**. It's Attio's default object for individual contacts, and it has the most built-in features (activity feed, emails, calls, tasks) compared to a custom object.
After you pick an object, Notifyer shows: *"This object drives later sync actions, including auto-create."* That means new contacts are created on this object, and later settings (like Auto-create) refer back to it.
Open the **Phone field** dropdown. It only lists attributes on your chosen object whose type is **phone number**. Attio stores phone numbers in that dedicated field type (with a country code selector), so only those attributes can reliably match a WhatsApp number.
If the object you picked has no phone-number field yet, the dropdown is empty (common on **Deal** or some custom objects). In Attio, add a phone-number attribute to that object — or use the built-in **Phone numbers** field on Person — then return to Notifyer and refresh.
Once selected, Notifyer confirms: *"WhatsApp numbers will be matched using the \[field] field on \[object]."*
### Note Destination and Note grouping
In **Note Destination**, choose the object that should receive the WhatsApp conversation note. In most setups this is the same object you picked for CRM Record Matching (for example Person), but you can point it elsewhere when contacts are linked to another object and you want the conversation there.
Notifyer explains the behavior: *"If a contact is linked to \[match object], notes go to \[note destination]. With no link, notes are saved on \[match object]."*
Pick one of the two **Note grouping** options:
* **Date-wise notes** — a new note is created for each calendar day, titled like "WhatsApp Conversation - Jul 30, 2026." Useful for busy conversations you want to scan by day.
* **Combined note** — every message with that contact lives in one growing note, with each line timestamped (for example "at 9:10 pm: message"). Useful when you want the full history in one place.
### Auto-create person
![Attio Person profile showing WhatsAble automatically creating a Person and WhatsApp Conversation note]()
Turn this toggle **on** if you want Notifyer to create a new record on your matched object whenever a WhatsApp number that doesn't exist in Attio messages you for the first time. Notifyer fills in the recipient's name (or "Unnamed person" if WhatsApp doesn't provide one) and their phone number, then logs the first message as a note.
Leave it **off** if you only want to sync conversations for contacts already in Attio — messages from unknown numbers are skipped, with no error and no partial record created.
Despite the label **Auto-create person**, creation always uses the object you selected under **CRM Record Matching** — not only Attio's Person object.
### Timezone Settings
Select your timezone from the dropdown (for example `(GMT+6) Asia/Dhaka`). This controls how message times appear in Attio notes and mapped timestamp fields, and — for date-wise notes — where the boundary between "today" and "tomorrow" falls.
When every Sync Settings field and Attribute Mapping field below is complete, click **Save settings**. You'll see a **Configuration Updated** confirmation when the save succeeds.
## Attribute Mapping reference
Scroll to **Attribute Mapping**. Instead of writing WhatsApp data into fixed columns, you choose which Attio attribute each Notifyer data point should update.
![Attribute Mapping section showing Name, last messages, timestamps, Labels, Country, Note, Automation Note, and Live chat link]()
| WhatsApp / Notifyer data point | What gets written | Allowed attribute type |
| ----------------------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| **Name column** | The contact's display name | `personal-name` (when the object is People/Person) or `text` (other objects) |
| **Last incoming message** | Most recent message text received from this contact | `text` |
| **Last outgoing message** | Most recent message text your team or AI sent | `text` |
| **Last incoming message time/date** | Timestamp of the last received message | `timestamp` |
| **Last outgoing message time/date** | Timestamp of the last sent message | `timestamp` |
| **Labels** | Labels assigned to the conversation in Notifyer | `text` |
| **Country** | Country detected from the contact's phone number | `text` |
| **Note** | The chat note from Notifyer for that contact (if any) | `text` |
| **Automation Note** | A note injected by an upstream automation rule, if one applies | `text` |
| **Live chat link** | Clickable link that opens this contact's full conversation in Notifyer's live console | `text` |
For every row, open the dropdown and choose an attribute on your matched object. If you need a purpose-built field (for example a custom "Last incoming message" text attribute), create it in Attio first, then refresh Notifyer.
Each option shows a badge: **System** for Attio built-in attributes, **Custom** for attributes you or your team created.
Each Attio attribute can be used only once across the mapping. If it's already assigned elsewhere, it shows as **Already used** and can't be selected again.
When every required field in **Sync Settings** and **Attribute Mapping** is filled in, click **Save settings**. You'll see **Configuration Updated** / *Sync settings have been saved successfully.*
Your Attio sync is configured. Send yourself a test WhatsApp message before rolling it out to your team.
If any required field is empty, Notifyer highlights incomplete fields with a red border and shows **"Please complete all required fields."**
## How matching and auto-create work
Notifyer checks the phone number against the **Phone field** on your **Object** in CRM Record Matching.
The message is logged to that record's note (per Note Destination and Note grouping), and every mapped attribute is updated on the record.
A new record is created on your matched object with the sender's name and phone number. Future messages from that number sync to this record — Notifyer does not create a second record for the same number.
The message is skipped. No record is created and no error is raised. Sync for that number starts only after the contact exists in Attio.
## Message logging behavior
![Attio Note titled WhatsApp Conversation showing a threaded chat between Lisa Kraus and Axel]()
Every incoming and outgoing WhatsApp message is written into an Attio Note on the matching record:
* **Sender is shown correctly.** Incoming messages show the contact's name (or phone number if no name is available). Outgoing messages show the teammate who sent it, or **AI Assistant** when your AI bot replied.
* **Timestamps use your configured timezone.** In date-wise mode, the date is in the note title, so lines inside the note show time only. In combined mode, lines include a fuller time stamp (for example "at 8:41 pm, Jul 29, 2026").
* **Media-only messages** (image, document, or voice note with no caption) show the media link instead of a blank line.
* **Date-wise mode** creates a fresh note per day, titled "WhatsApp Conversation - \[date]."
* **Combined mode** keeps one ongoing note per contact. New messages are appended; the newest line is shown in bold so recent activity is easy to spot.
![Attio note modal showing WhatsApp Conversation for Jul 30, 2026 on Axel's Person record]()
## Field auto-update reference
Beyond the conversation note, these mapped fields update on the matched (or newly created) record when a message is sent or received:
Text of the most recent message in each direction
Exact time of the most recent message in each direction, in your configured timezone
Labels Notifyer has assigned to the conversation
Country detected from the contact's phone number
Chat note from Notifyer for that contact, when one exists
Populated only when a Notifyer automation rule injects a note; otherwise blank
Always-current link to the full conversation for that contact
## The Live Chat Link
![Promotional overview of Live Chat Link opening WhatsAble Live Chat from Attio]()
Every synced record can include a **Live chat link** attribute — a clickable link that opens that contact's full WhatsApp conversation in Notifyer's live chat console.
Click the **Live chat link** value on the record. It opens Notifyer's live console (for example at `chat.notifyer-systems.com`).
The link includes a phone-number reference. Notifyer opens the correct conversation automatically — you don't need to search for the contact.
After the conversation loads, the URL parameter is removed so the address bar shows a clean URL with nothing exposed.
If you're not signed in to Notifyer in that browser, you'll be asked to log in first. After you sign in, open the link again from Attio to land on the conversation.
![Notifyer live chat console for Axel showing labels, Human Agent / AI Assistant handoff, and AI summary]()
This is one click into the full conversation, not an embedded chat window inside Attio. Attio does not support embedding external apps via iframe, so the conversation opens in Notifyer's console in a new tab. From there, your team can see AI activity, hand off to a human, assign the chat, and manage labels — in Notifyer, not inside Attio itself.
## Automation and workflows
Unlike the Monday.com integration, Attio does not yet expose native WhatsAble triggers or actions inside Attio's Workflow Builder.
**Coming soon.** Attio's Workflows SDK does not currently pass authentication context (such as a user or account ID) to workflow-triggered actions — only an API key is available, with no way to tie the run back to a specific Notifyer account. Until that is supported, we cannot ship the equivalent of Monday's "when a new WhatsApp message arrives → do something in Attio" workflow triggers and actions.
Today, build automation around Attio + WhatsApp through:
Connect Attio and Notifyer System through your automation platform — see the [Zapier](/guides/notifyer-system/zapier-overview), [Make](/guides/notifyer-system/make-overview), and [n8n](/guides/notifyer-system/n8n-overview) guides
Call the [Notifyer System API](/guides/notifyer-system/api/template-message) from your backend or from an Attio automation that can reach external webhooks
## Known limitations
WhatsAble triggers and actions inside Attio Workflows are not available yet because Attio's workflow runtime does not provide the user/account authentication context Notifyer needs. Use Zapier, Make, n8n, or the WhatsAble API for automation today.
Attio does not support iframe embeds, so Notifyer cannot render a live chat window inside Attio. Use the **Live chat link** attribute to open the full conversation in Notifyer's console instead.
Attio's note API does not support editing an existing note. Notifyer works around this by finding the note by title, reading its content, and rewriting it with the new message appended. Day to day this is invisible, but it can cause small formatting differences between older and newer lines. If someone deletes a WhatsApp conversation note in Attio, Notifyer creates a new one on the next message.
You cannot send WhatsApp templates or schedule messages from inside Attio yet. Reply, schedule, and broadcast from the Notifyer chat console (or Zapier / Make / n8n / API).
## Disconnecting
To remove the connection, open **Attio** in your Notifyer Console and click **Disconnect Attio** on the connected workspace card.
Disconnecting stops the sync immediately — no further WhatsApp messages are written to Attio until you reconnect.
To reconnect, repeat the [connection steps](#connect-notifyer-system-to-attio). After authorizing again, open **Sync Settings** and **Attribute Mapping**, confirm every required field, and click **Save settings** before relying on sync again.
## Best practices
Person is Attio's native contact object and usually already has a system **Phone numbers** field. Custom objects work too, but they need a phone-number attribute before matching can work.
Matching only uses Attio phone-number attributes (with country code). Don't store WhatsApp numbers in a plain text field if you need reliable matching.
Create purpose-built text and timestamp attributes in Attio (for example "Last incoming message", "Live chat link") before you map them in Notifyer. That keeps your People list easy to scan.
After saving settings, send a test message from a known phone number and confirm the Attio record, note, and mapped fields update as expected.
## Troubleshooting
Open **Sync Settings** and confirm **Object** and **Phone field** under **CRM Record Matching** are set, and that the phone field holds the number you're testing with.
Every required Sync Settings and Attribute Mapping field must be filled. Click **Save settings** and wait for **Configuration Updated** before testing again.
Notifyer matches by phone number and should not create duplicates for the same number. If you see duplicates, check whether the same contact exists twice in Attio with different phone formats (with and without country code, for example).
If duplicates persist, contact WhatsAble support with both record IDs so we can investigate.
Open **Sync Settings** and confirm **Timezone** matches the timezone your team expects when reading messages.
Attio does not support patching an existing note. Notifyer finds the note by title and rewrites it with new content appended. Small bold/spacing differences between older and newer lines can appear because of that workaround.
If someone deletes a WhatsApp conversation note in Attio, Notifyer creates a new one on the next message for that contact.
The **Phone field** dropdown only lists phone-number attributes on the selected object. If none exist (common on custom objects or Deal), add a phone-number attribute in Attio, then refresh the Notifyer settings page.
The Live Chat Link opens Notifyer's live console and requires a signed-in Notifyer session in that browser. Log in once, then open the link again from the Attio record.
Each mapping field only lists compatible types (for example `timestamp` for time/date fields, `text` for message fields, `personal-name` for Name on Person). Create an attribute of the correct type in Attio if needed.
Attributes already used elsewhere show as **Already used**. Clear the other mapping first if you want to reuse that attribute.
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations (Make, Zapier, n8n, Pipedrive, Monday.com), please contact our support team or check our integration documentation.
# Embedding Process
Source: https://docs.whatsable.app/guides/notifyer-system/embedding-process
Connect your WhatsApp Business Account to the Notifyer System to enable automated messaging capabilities
# WhatsApp Business Account Integration
## Overview
Notifyer System enables businesses to send automated WhatsApp messages to customers through a direct integration with the WhatsApp Business Platform. This guide walks you through the embedding process to connect your WhatsApp Business Account with Notifyer System.
This process uses Meta's Embedded Signup flow, which allows you to create or connect your WhatsApp Business Account directly within Notifyer System.
## Prerequisites
Active Notifyer System account with a subscription plan or pay-as-you-go credit
Meta Business Portfolio (or willingness to create one during the process)
A phone number that isn't currently associated with any WhatsApp account
The phone number you use for your WhatsApp Business Account cannot have an existing WhatsApp account associated with it. If you're using a number that already has WhatsApp, you'll need to delete that account or use a different number.
## Integration Process
1. Log in to your Notifyer System dashboard
2. Navigate to **Your Templates** section
3. Make sure you're on the **Connect to WhatsApp** tab
4. Click the **Connect your WhatsApp Number** button in the center of the page
![]()
You can track your progress through the onboarding process using the steps indicator in the bottom-left corner of the screen.
1. Log in with your Facebook account when prompted
2. If already logged in, click **Continue as \[your Facebook username]**
3. Review the permissions Notifyer System is requesting
4. Click **Get Started** to begin the configuration process
![Connecting with Facebook]()
Select an existing business portfolio or create a new one
If you choose to create a new business portfolio, fill out the required fields:
Your official business name (must be unique among your portfolios)
A valid email that can receive verification messages
Your business website URL or social media profile
Country where your business is located
![Entering required information in Business Information section]()
Choose a business portfolio you've already configured in Meta Business Suite
See how to [create a business portfolio in Meta Business Suite and Business Manager.](https://www.facebook.com/business/help/1710077379203657)
If you select an existing portfolio, your business name, website, and country will be automatically populated from your Meta Business configuration.
Select whether to create a new account or use an existing one
**Recommended** for first-time users (default option)
Only available if you have existing WhatsApp Business accounts
Select whether to create a new profile or use an existing one
**Recommended** for first-time users (default option)
Only available if you connect an existing WhatsApp Business profile
![Selecting options for WhatsApp Business Account and Profile]()
The internal name of your account (used for management purposes)
The name your customers will see when receiving messages from your business
This is the name your customers will see when receiving messages from your business. Choose carefully as it impacts brand recognition.
Business category that best represents your industry (will be displayed on your profile)
![Entering required information in Create a WhatsApp business profile section]()
Choose how to add your phone number
Use your own business phone number
WhatsApp will generate a +1 555 number (limited functionality)
Choose how to receive your verification code
Receive verification code via SMS
Receive verification code via automated call
![Entering required informstion in Create a WhatsApp business profile section]()
Enter the verification code received via your selected method
![Entering required informstion in Create a WhatsApp business profile section]()
1. After verification, you'll see a "You're now ready to chat with people on WhatsApp" screen
2. Click the **Add Payment Method** button
3. You'll be redirected to the Facebook Business "Billing & Payments" page
4. Select "Payment Methods" from the left menu
5. Ensure you're on the "WhatsApp Business accounts" tab
6. Select your WhatsApp account from the dropdown (verify WhatsApp account ID)
7. Click "Add Payment Method" and provide the required information
8. Set your payment method as the default option
This step is critical for ensuring you can send messages without restrictions. Unverified businesses may experience limited functionality.
1. Navigate to Settings in your Facebook Business Manager
2. Select "WhatsApp accounts" under the "Accounts" section
3. Scroll down to the "Business verification" section
4. Click "Start verification" to access the Security Center
5. Complete the business verification process by providing the requested business information and documentation
## Account Dashboard Overview
Once your WhatsApp Business Account is connected, you'll have access to the following tabs in the "Your Templates" section:
Connect your WhatsApp Business Account using the "Sign up with Facebook" option
Design message templates and submit them to Meta for approval
View, manage, and monitor the approval status of your message templates
## Integration Options
After successfully embedding your WhatsApp Business Account, you can integrate Notifyer System with your preferred automation platform:
Connect Notifyer System with Make to create powerful automation workflows.
[View Make Documentation →](https://docs.whatsable.app/guides/notifyer-system/make-overview)
Integrate with Zapier to connect WhatsApp messaging with thousands of applications.
[View Zapier Documentation →](https://docs.whatsable.app/guides/notifyer-system/zapier-overview)
Use n8n for advanced workflow automation with WhatsApp messaging.
[View n8n Documentation →](https://docs.whatsable.app/guides/notifyer-system/n8n-overview)
Implement custom integrations using our comprehensive API.
[Try API Reference →](https://docs.whatsable.app/api-reference/introduction)
## API Reference
Retrieve all your approved message templates
Send messages using your approved templates
Handle incoming messages from customers
Experiment with the Get Templates API and view responses in real-time
## Alternative Option: Notifier
If the embedding process is too complex for your needs, you can use Notifier by WhatsAble instead, which allows you to send automated messages through our WhatsApp bot without going through the full embedding process.
Discover a simpler way to send automated WhatsApp messages using Notifier by WhatsAble
## Troubleshooting
If your phone number verification fails:
1. Ensure the phone number isn't already linked to a WhatsApp account
2. Wait 24 hours before trying again with the same number
3. Try a different verification method (SMS vs. call)
4. Contact support if issues persist
If you encounter problems with business verification:
1. Ensure all business information is accurate and matches official documents
2. Provide clear, high-quality images of requested documentation
3. Allow 1-2 business days for verification review
4. Submit an appeal if verification is rejected
## Resources
Manage your Meta business profiles and portfolios
Learn more about the WhatsApp Business Platform
Meta's official documentation on embedded signup
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the chat button in the bottom right corner of the Notifyer System dashboard
# Enterprise Customization
Source: https://docs.whatsable.app/guides/notifyer-system/enterprise/customization
Learn how to customize Notifyer System for your enterprise needs
# Enterprise Customization
Notifyer System provides extensive customization options for enterprise-level WhatsApp messaging.
## Customization Features
### Branding
* Custom templates
* Brand colors
* Logo integration
* Custom fonts
* Brand voice
* Message styling
* Media assets
### Workflow
* Custom workflows
* Business rules
* Automation rules
* Integration points
* Custom scripts
* Event handlers
* Process automation
### Integration
* Custom APIs
* Webhook endpoints
* SDK customization
* Plugin system
* Custom connectors
* Data mapping
* Format conversion
## Customization Implementation
### Custom Template
```javascript theme={null}
// Example: Creating a custom template
const createCustomTemplate = async (template) => {
try {
const response = await axios.post(
'https://api.notifiersystem.com/v1/templates',
{
name: template.name,
language: template.language,
category: template.category,
components: [
{
type: 'HEADER',
format: 'IMAGE',
example: {
header_url: [template.headerImage]
}
},
{
type: 'BODY',
text: template.body,
variables: template.variables
},
{
type: 'BUTTON',
sub_type: 'URL',
index: '0',
parameters: template.buttonParameters
}
],
customizations: {
branding: template.branding,
styling: template.styling,
metadata: template.metadata
}
},
{
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_SYSTEM_API_KEY}`,
'Content-Type': 'application/json',
'X-Tenant-ID': process.env.TENANT_ID
}
}
);
return response.data;
} catch (error) {
console.error('Error creating template:', error);
throw error;
}
};
```
### Custom Workflow
```javascript theme={null}
// Example: Implementing a custom workflow
const processCustomWorkflow = async (message) => {
try {
// Apply business rules
const rules = await getBusinessRules(message.tenant_id);
const processedMessage = applyBusinessRules(message, rules);
// Apply custom transformations
const transformedMessage = await applyCustomTransformations(processedMessage);
// Apply automation rules
const automationRules = await getAutomationRules(message.tenant_id);
const automatedMessage = applyAutomationRules(transformedMessage, automationRules);
// Send the message
return await sendMessage(automatedMessage);
} catch (error) {
console.error('Error processing workflow:', error);
throw error;
}
};
```
## Best Practices
### Branding
* Maintain consistency
* Follow guidelines
* Test templates
* Monitor performance
* Update regularly
* Document changes
* Version control
### Workflow
* Keep it simple
* Document processes
* Test thoroughly
* Monitor performance
* Handle errors
* Regular review
* Continuous improvement
### Integration
* Use standards
* Document APIs
* Version control
* Test integration
* Monitor performance
* Handle errors
* Regular updates
## Monitoring
### Customization Monitoring
* Template performance
* Workflow efficiency
* Integration status
* Error rates
* Response times
* User feedback
* ROI metrics
### Business Impact
* Message effectiveness
* User engagement
* Conversion rates
* Cost efficiency
* Process efficiency
* Business goals
* Success metrics
## Next Steps
* Learn about [Security](/guides/notifyer-system/enterprise/security)
* Explore [Scaling](/guides/notifyer-system/enterprise/scaling)
* Check out our [API Reference](/api-reference/notifier-system)
* Read our [Getting Started](/guides/notifyer-system/getting-started) guide
# Enterprise Scaling
Source: https://docs.whatsable.app/guides/notifyer-system/enterprise/scaling
Learn how to scale your WhatsApp messaging with Notifyer System
# Enterprise Scaling
Notifyer System provides robust scaling capabilities for enterprise-level WhatsApp messaging.
## Scaling Features
### Infrastructure
* Auto-scaling
* Load balancing
* High availability
* Geographic distribution
* Disaster recovery
* Backup systems
* Monitoring
### Performance
* Message queuing
* Priority queuing
* Rate limiting
* Caching
* CDN integration
* Database optimization
* Resource management
### Capacity
* Unlimited messages
* Multiple channels
* Concurrent processing
* Batch processing
* Bulk messaging
* Scheduled messages
* Message routing
## Scaling Implementation
### Message Queue
```javascript theme={null}
// Example: Implementing message queuing
const queueMessage = async (message) => {
try {
const queueItem = {
message,
priority: message.metadata?.priority || 'normal',
timestamp: new Date(),
retryCount: 0
};
await messageQueue.add(queueItem, {
priority: getPriorityWeight(queueItem.priority),
attempts: 3,
backoff: {
type: 'exponential',
delay: 1000
}
});
} catch (error) {
console.error('Error queueing message:', error);
throw error;
}
};
```
### Load Balancing
```javascript theme={null}
// Example: Load balanced API call
const sendScaledMessage = async (message) => {
try {
const response = await axios.post(
'https://api.notifiersystem.com/v1/messages',
message,
{
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_SYSTEM_API_KEY}`,
'Content-Type': 'application/json',
'X-Tenant-ID': process.env.TENANT_ID,
'X-Load-Balancer-Key': generateLoadBalancerKey()
}
}
);
return response.data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
```
## Best Practices
### Infrastructure
* Monitor system resources
* Set up auto-scaling
* Implement load balancing
* Use CDN for media
* Optimize database
* Regular maintenance
* Backup strategy
### Performance
* Implement caching
* Use message queues
* Optimize API calls
* Monitor response times
* Handle rate limits
* Error handling
* Retry logic
### Capacity Planning
* Monitor usage
* Set up alerts
* Plan for growth
* Resource allocation
* Cost optimization
* Performance testing
* Load testing
## Monitoring
### System Monitoring
* Resource usage
* Performance metrics
* Error rates
* Response times
* Queue lengths
* Cache hit rates
* Database performance
### Business Metrics
* Message volume
* Success rates
* Response rates
* Cost per message
* User engagement
* ROI metrics
* Growth metrics
## Next Steps
* Learn about [Security](/guides/notifyer-system/enterprise/security)
* Explore [Customization](/guides/notifyer-system/enterprise/customization)
* Check out our [API Reference](/api-reference/notifier-system)
* Read our [Getting Started](/guides/notifyer-system/getting-started) guide
# Enterprise Security
Source: https://docs.whatsable.app/guides/notifyer-system/enterprise/security
Learn about enterprise-grade security features in Notifyer System
# Enterprise Security
Notifyer System provides comprehensive security features for enterprise-level WhatsApp messaging.
## Security Features
### Authentication
* API key authentication
* OAuth 2.0 support
* Two-factor authentication
* Role-based access control
* Session management
* IP whitelisting
* API key rotation
### Data Protection
* End-to-end encryption
* Data encryption at rest
* Secure data transmission
* Data backup
* Data retention policies
* Data access controls
* Audit logging
### Compliance
* GDPR compliance
* CCPA compliance
* HIPAA compliance
* SOC 2 compliance
* ISO 27001 compliance
* Regular security audits
* Compliance reporting
## Security Implementation
### API Security
```javascript theme={null}
// Example: Secure API call with multiple security headers
const sendSecureMessage = async (message) => {
try {
const response = await axios.post(
'https://api.notifiersystem.com/v1/messages',
message,
{
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_SYSTEM_API_KEY}`,
'Content-Type': 'application/json',
'X-Tenant-ID': process.env.TENANT_ID,
'X-Request-ID': uuidv4(),
'X-Security-Token': await generateSecurityToken()
}
}
);
return response.data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
```
### Webhook Security
```javascript theme={null}
// Example: Secure webhook endpoint
app.post('/webhook/message-status',
validateWebhookSignature,
rateLimit,
async (req, res) => {
const { message_id, status, timestamp } = req.body;
await updateMessageStatus({
message_id,
status,
timestamp,
security: {
ip_address: req.ip,
user_agent: req.headers['user-agent'],
request_id: req.headers['x-request-id']
}
});
});
```
## Best Practices
### Security Measures
* Regular security audits
* Penetration testing
* Vulnerability scanning
* Security monitoring
* Incident response
* Security training
* Documentation
### Access Control
* Role-based access
* Least privilege principle
* Access logging
* Access reviews
* Access revocation
* Session management
* Password policies
### Data Protection
* Data classification
* Data encryption
* Data backup
* Data retention
* Data disposal
* Data access logs
* Data breach response
## Monitoring
### Security Monitoring
* Real-time alerts
* Security logs
* Access logs
* Error logs
* Performance metrics
* Compliance reports
* Security dashboards
### Incident Response
* Incident detection
* Incident investigation
* Incident containment
* Incident resolution
* Incident reporting
* Post-incident review
* Documentation
## Next Steps
* Learn about [Scaling](/guides/notifyer-system/enterprise/scaling)
* Explore [Customization](/guides/notifyer-system/enterprise/customization)
* Check out our [API Reference](/api-reference/notifier-system)
* Read our [Getting Started](/guides/notifyer-system/getting-started) guide
# Notifyer System Features
Source: https://docs.whatsable.app/guides/notifyer-system/features
Explore the enterprise features of Notifyer System
# Notifyer System Features
Notifyer System provides comprehensive enterprise-grade features for WhatsApp messaging.
## Core Features
### Message Types
* Text messages
* Media messages (images, documents, audio, video)
* Location sharing
* Contact sharing
* Interactive messages
* List messages
* Button messages
* Product messages
* Order messages
### Message Management
* Message status tracking
* Delivery receipts
* Read receipts
* Message history
* Message templates
* Bulk messaging
* Scheduled messages
* Priority queuing
* Message routing
### Security
* End-to-end encryption
* API key authentication
* Rate limiting
* IP whitelisting
* Two-factor authentication
* Audit logs
* Data encryption at rest
* Compliance monitoring
## Enterprise Features
### Multi-tenant Support
* Multiple business units
* Separate message queues
* Custom branding
* Independent analytics
* Role-based access
### Advanced Templates
* Pre-approved message templates
* Dynamic variables
* Multi-language support
* Template analytics
* Template versioning
* Template approval workflow
* Template categories
### Automation
* Workflow automation
* Conditional messaging
* Event-based triggers
* Custom webhooks
* Integration with third-party services
* Business rules engine
* Custom scripting
### Analytics
* Message delivery rates
* Response times
* User engagement
* Template performance
* Custom reports
* Real-time dashboards
* Export capabilities
* API access
## Best Practices
### Enterprise Setup
* Define clear workflows
* Set up proper monitoring
* Implement security measures
* Configure backup systems
* Document processes
### Message Strategy
* Use approved templates
* Implement proper error handling
* Monitor message status
* Follow WhatsApp guidelines
* Regular template updates
* A/B testing
* Performance optimization
## Next Steps
* Learn about [Integrations](/guides/notifyer-system/integrations)
* Explore [Enterprise Features](/guides/notifyer-system/enterprise/security)
* Check out our [API Reference](/api-reference/notifier-system)
* Read our [Getting Started](/guides/notifyer-system/getting-started) guide
# Getting Started with Notifyer System
Source: https://docs.whatsable.app/guides/notifyer-system/getting-started
Learn how to get started with Notifyer System, the flagship WhatsApp messaging solution
# Getting Started with Notifyer System
Notifyer System is our flagship WhatsApp messaging solution, designed for enterprise-level communication needs.
## Prerequisites
* WhatsApp Business API account
* Business verification
* Technical team for integration
* Understanding of enterprise messaging
* Your Notifyer System API credentials
## Quick Setup
1. Contact our sales team for enterprise setup
2. Complete business verification
3. Set up your WhatsApp Business API account
4. Configure your Notifyer System instance
5. Get your API credentials
6. Set up webhooks and monitoring
## First Message
Here's a quick example of sending your first message:
```bash theme={null}
curl -X POST https://api.notifiersystem.com/v1/messages \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"to": "+1234567890",
"template": "enterprise_welcome",
"variables": {
"name": "John",
"company": "Enterprise Corp",
"department": "Sales"
},
"metadata": {
"campaign_id": "welcome_2024",
"segment": "enterprise",
"priority": "high"
}
}'
```
## Enterprise Features
* Multi-tenant support
* Role-based access control
* Advanced security features
* Custom integrations
* Enterprise-grade support
## Next Steps
* Learn about [Features](/guides/notifyer-system/features)
* Explore [Integrations](/guides/notifyer-system/integrations)
* Check out [Enterprise Features](/guides/notifyer-system/enterprise/security)
* Review our [API Reference](/api-reference/notifier-system)
# Notifyer System Integrations
Source: https://docs.whatsable.app/guides/notifyer-system/integrations
Learn how to integrate Notifyer System with your enterprise applications
# Notifyer System Integrations
Integrate Notifyer System with your enterprise tools and platforms.
## Available Integrations
### Enterprise Platforms
* Salesforce
* SAP
* Oracle
* Microsoft Dynamics
* ServiceNow
### CRM Systems
* Salesforce
* HubSpot
* Zoho CRM
* Pipedrive
* Microsoft Dynamics
* Custom CRM solutions
### E-commerce Platforms
* Shopify Plus
* Magento Enterprise
* SAP Commerce
* Oracle Commerce
* Custom e-commerce solutions
### Marketing Tools
* Adobe Marketing Cloud
* Salesforce Marketing Cloud
* Oracle Marketing Cloud
* HubSpot Enterprise
* Custom marketing platforms
## Custom Integration
### REST API
```javascript theme={null}
const axios = require('axios');
const sendEnterpriseMessage = async (message) => {
try {
const response = await axios.post(
'https://api.notifiersystem.com/v1/messages',
message,
{
headers: {
'Authorization': `Bearer ${process.env.NOTIFIER_SYSTEM_API_KEY}`,
'Content-Type': 'application/json',
'X-Tenant-ID': process.env.TENANT_ID
}
}
);
return response.data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
```
### Webhooks
Configure webhooks for enterprise-level monitoring:
```json theme={null}
{
"event": "message.status",
"data": {
"message_id": "msg_123",
"status": "delivered",
"template": "enterprise_welcome",
"variables": {
"name": "John",
"company": "Enterprise Corp",
"department": "Sales"
},
"metadata": {
"campaign_id": "welcome_2024",
"segment": "enterprise",
"priority": "high"
},
"timestamp": "2024-03-20T10:00:00Z"
}
}
```
## Enterprise Features
### Multi-tenant Support
* Separate API keys per tenant
* Custom webhook endpoints
* Tenant-specific templates
* Independent analytics
* Custom branding
### Security
* IP whitelisting
* API key rotation
* Audit logging
* Data encryption
* Compliance monitoring
### Monitoring
* Real-time status
* Error tracking
* Performance metrics
* Usage analytics
* Cost tracking
## Best Practices
### Integration
* Use environment variables
* Implement retry logic
* Handle rate limits
* Monitor webhook delivery
* Use template variables
* Implement proper error handling
* Set up monitoring
* Regular security audits
### Development
* Follow API guidelines
* Use SDK when available
* Test thoroughly
* Document integration
* Version control
* CI/CD pipeline
* Regular updates
## Next Steps
* Read our [Getting Started](/guides/notifyer-system/getting-started) guide
* Explore [Features](/guides/notifyer-system/features)
* Check out [Enterprise Features](/guides/notifyer-system/enterprise/security)
* Review our [API Reference](/api-reference/notifier-system)
# Make
Source: https://docs.whatsable.app/guides/notifyer-system/make-overview
Learn how to seamlessly integrate Make with the Notifyer System for enterprise-level WhatsApp automation
# Notifyer System Integration with Make
![]()
This guide walks you through connecting Notifyer System with Make to create powerful automated WhatsApp messaging workflows for your business
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Make](https://www.make.com/en/register) workflow automation platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform embedding process, which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
To connect Notifyer System with Make, you'll need an API key:
1. In your Notifyer dashboard, navigate to [**API Keys**](https://console.notifyer-systems.com/api-key)
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Connect Notifyer System to Make
Now that you have Notifyer System set up, let's connect it to Make to automate your scenarios.
1. Log in to your Make account
2. Navigate to Notifyer System dashboard and select **Connect to Make** in the side menu
3. Click **Continue** in the connection guide popup
4. Click **Install**, select your organization at the bottom of the screen, then click **Install** again. (Note: You need Admin, Owner, or App Developer role in your organization to install apps.)
You're now ready to create scenarios with the Notifyer System app
![Installing Notifyer System in Make]()
1. Log in to your Make account
2. Create a new scenario by clicking **+ Create a new scenario**
3. (Optional) Add a trigger module of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up a module/trigger Make]()
1. Click the **+** button to add a new module
2. Search for **Notifyer System** in the apps or modules library
3. Select the module with the official Notifyer System logo
![Adding the Notifyer System module]()
1. Once you click on Notifyer System module, select '**Send a WhatsApp Message with Your Template**' or '**Send a WhatsApp Message without Template**' from the **ACTIONS**
2. Click **Create a connection** in the **Connection** section of Notifyer System module and you will be prompted to enter your API Key
3. Enter your Notifyer System API key that you copied earlier
4. Rename your connection name if needed
5. Click **Save** to store your credential
![Configuring Notifyer System credentials]()
Depending on your messaging needs, choose one of the following operations:
Complete the required fields:
Enter the recipient's phone number with country code (e.g., +1234567890) or use dynamic data from previous nodes
Select from your pre-approved templates in the dropdown
Enter publicly accessible media URL for Media (image/video/document) header.
This field will only appear if you have a Media (image/video/document) header configured in your selected template.
Fill in values for each variable in your template, mapping them to dynamic data when applicable
Add note for internal tracking. This data won't be sent to the recipient
Select label(s) for internal tracking. This data won't be sent to the recipient
![Template Message Configuration]()
Complete the required fields:
Enter the recipient's phone number with country code (e.g., +1234567890) or use dynamic data from previous nodes
Choose from the following message types:
For plain text messages
For sending images (JPEG, PNG, etc.)
For sending videos (MP4, 3GP, etc.)
For sending documents (PDF, Word, etc.)
For sending videos (MP3, OGG, etc.)
For messages with button that contain URL or dynamic URL
Keep the option at the default 'No'. If there is a link/URL in the text body and you want the recipient to see a preview, select 'Yes'
Enter the text message content
Enter the publicly accessible URL for your image file
Optional caption for the image
Enter the publicly accessible URL for your video file
Optional caption for the video
Enter the publicly accessible URL for your document
Optional caption for the document
Enter the filename (e.g., report.pdf)
Enter the publicly accessible URL for your audio file (MP3, OGG)
Enter optional text to show at the top
Enter the main content of the message
Enter the text to display on button
Enter the URL for the button
Enter the optional text to show at bottom
Select label(s) for internal tracking. This data won't be sent to the recipient
![Non-Template Message Configuration]()
1. Click **Save** to save your message configuration
2. Right click on the WhatsAble module and select **Run this module only** to verify the module is working correctly
* or click **Run once** in the bottom-left corner of the screen to test the entire scenario
3. If the test is successful, you'll see a confirmation message
4. Click **Save** icon in the bottom-left corner to save your scenario (You can also set timer intarval for the scenario)
5. Toggle the **Active** switch in the bottom-left corner with time to activate your scenario
![Testing and activating your scenario]()
## Example use cases
Send automatic order confirmations when new orders are placed
Schedule reminders before upcoming appointments
Alert your sales team when new leads come in
Route support inquiries to the appropriate team member
Keep customers informed about their delivery status
Send automatic payment reminders for overdue accounts
## Best practices
Always test your workflows with test phone numbers before activating them for production use.
Whenever possible, use pre-approved templates for better deliverability and compliance.
Include customer names and specific details to increase engagement and response rates.
Ensure all message content complies with WhatsApp Business policies to avoid account restrictions.
Regularly check your message delivery rates in your Notifyer dashboard.
## Troubleshooting
Ensure your API key is entered correctly in the Make credentials
Confirm phone numbers are in the correct international format (e.g., +14155552671)
Verify your Notifyer subscription is active and has available credits
For template messages, ensure you're using an approved template
Verify all required variables are included in your template message
Check that variable formats match the expected values (text, number, date, etc.)
Ensure you're using the correct template name exactly as it appears in your dashboard
Confirm your media URLs are publicly accessible (test in an incognito browser)
Verify the file format is supported by WhatsApp
Check that file sizes are within WhatsApp limits:
* Images: up to 5MB
* Videos: up to 16MB
* Documents: up to 100MB
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations (Make.com, Zapier, etc.), please contact our support team or check our integration documentation.
# Monday.com
Source: https://docs.whatsable.app/guides/notifyer-system/monday-overview
Learn how to seamlessly integrate Monday.com with the Notifyer System for automated WhatsApp messaging directly inside your boards
# Notifyer System Integration with Monday.com
![Monday.com integration with Notifyer System]()
This guide walks you through connecting Notifyer System with Monday.com to create powerful automated WhatsApp messaging workflows — syncing conversations to your boards and triggering messages from board events, all through Monday's built-in Workflow Builder.
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a connected WhatsApp number and subscription plan (Pro or Agency)
Access to [Monday.com](https://monday.com/) with admin or member-level permissions
Your WhatsApp number must already be connected inside Notifyer before starting the Monday integration.
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform [embedding process](/guides/notifyer-system/embedding-process), which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
To use the **Send Template Message** action in Monday workflows, configure your templates in Notifyer first. Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications within the 24-hour window, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
## Connect Notifyer System to Monday.com
Now that your Notifyer System account is configured, follow these steps to connect Monday.com and start building workflows.
1. Log in to your **Notifyer Console**
2. In the left sidebar, scroll to the **Connect To** section
3. Click **Monday** from the list of available integrations (Make, Zapier, n8n, Pipedrive, Monday)
![Monday option in the Notifyer sidebar under Connect To]()
The Monday integration page opens with the **Get Started in 3 Simple Steps** panel.
1. On the integration page, click the green **Install WhatsAble** button next to Step 1
2. You will be redirected to the Monday.com marketplace listing
3. Follow Monday's standard installation flow to add WhatsAble to your workspace
![Install WhatsAble button on the Monday integration page]()
If you are already logged into Monday.com in your browser, the installation proceeds directly. Otherwise, Monday will prompt you to log in first.
1. Sign in to Monday.com using **Email and password**, **Google**, or **Microsoft**
2. Review the permission consent screen titled **Authorize WhatsAble — WhatsApp Automation with AI**
3. Click **Authorize** to grant the required permissions
![Monday authorization permissions screen for WhatsAble]()
WhatsAble requests the following permissions exclusively for workflow automation:
| Permission | Purpose |
| ------------------------------------------------------------ | ------------------------------------------- |
| Modify any of your boards' data | Create and update items on your boards |
| Read user's documents | Access documents for workflow actions |
| Modify user's documents | Attach files and notes to board items |
| Read all of your workspaces data | Access the correct workspace for automation |
| Modify any of your workspaces data | Configure automation within your workspace |
| Read the profile information of the users in your account | Identify users in workflow context |
| Modify the profile information of the users on the account | Update user-related workflow data |
| Read general information about your account | Link your Monday account to WhatsAble |
| Send notifications on your behalf | Deliver workflow-triggered notifications |
| Post or edit updates on your behalf | Add message activity to board items |
| Read updates and replies that you can see | Sync conversation context to workflows |
| Read information of files that were uploaded to your account | Access attachments for board sync |
| Read your account's tags | Map labels and tags in workflow logic |
| Read information about teams in your account | Route workflows by team context |
| Create and modify teams in your account | Configure team-based automation |
| Create and modify webhooks | Enable real-time workflow triggers |
| Read existing webhooks configuration | Verify and manage webhook setup |
| Read your profile information | Identify the connected user |
WhatsAble is an official Meta Tech Provider and the integration is safe to authorize.
After authorization, you will be redirected back to the Notifyer Console. The green **Successfully Connected to Monday** banner confirms the integration is live.
![Successfully Connected to Monday confirmation screen]()
The panel displays your **User ID**, **Account ID**, and **Connected** timestamp. You can now start building workflows in Monday's Workflow Builder.
Your Notifyer System account is now linked to Monday.com. Proceed to create workflows using the triggers and actions below.
## Workflow automation
With the integration connected, WhatsAble exposes **3 triggers** and **2 actions** directly inside Monday's Workflow Builder.
### What you can do
Create a Monday item automatically when a new WhatsApp contact messages your business
Update existing items when follow-up messages are sent or received
Send WhatsApp template messages when board item status changes
Map phone number, country, label, AI state, attachments, and timestamps to board columns
### Triggers
Triggers define *when* a workflow fires.
#### Trigger 1 — When New Incoming Chat Received
**Fires:** Once, the first time an unknown contact sends your business a WhatsApp message.
This trigger activates when a message arrives from a phone number that does not yet exist as a recipient in your WhatsAble system. If the contact already exists, this trigger will not fire again.
![WhatsAble trigger: When you receive a WhatsApp message from a new phone number]()
**Best for:** Creating a new Monday item (lead, support ticket, customer record) the moment a brand-new contact reaches out.
**Output fields:**
| Field | Type | Description |
| ------------------- | --------- | -------------------------------------------- |
| `name` | Text | Contact's display name |
| `phone` | Phone | Number in international format |
| `country` | Text | Country detected from the phone number |
| `label` | Text | Label auto-assigned by WhatsAble rules |
| `message` | Text | Body of the incoming message |
| `attachment_url` | URL | Direct link to any media attachment |
| `last_message_time` | Date/Time | Timestamp of the incoming message |
| `ai_enabled` | Boolean | Whether the AI agent is active for this chat |
| `automation_note` | Text | Note injected by an upstream automation rule |
`sent_by` and `is_incoming` are not available on this trigger — the message is always incoming by definition.
***
#### Trigger 2 — When New Outgoing Chat Created
**Fires:** Once, the first time you send a WhatsApp message to a contact that does not yet exist in your WhatsAble system.
This trigger activates when your team initiates a conversation with a brand-new contact, whether via WhatsAble's chat interface, Make, Zapier, n8n, or any connected platform.
![WhatsAble trigger: When you send a message to a new WhatsApp contact]()
**Best for:** Automatically logging a Monday item when your sales team reaches out to a new prospect.
**Output fields:**
| Field | Type | Description |
| ------------------- | --------- | --------------------------------------------------------- |
| `name` | Text | Contact's display name (may be blank if not yet resolved) |
| `phone` | Phone | Contact's phone number |
| `country` | Text | Detected country |
| `label` | Text | Label assigned to the contact |
| `message` | Text | Body of the outgoing message |
| `attachment_url` | URL | Link to any attached media |
| `last_message_time` | Date/Time | Timestamp of the outgoing message |
| `sent_by` | Text | Sender name — team member or automation/app name |
| `ai_enabled` | Boolean | Whether the AI agent is active |
| `automation_note` | Text | Note from an automation rule, if applicable |
`is_incoming` is not available on this trigger — the message is always outgoing by definition.
***
#### Trigger 3 — When New Message Received or Sent in WhatsApp
**Fires:** Every time, for every message — both incoming and outgoing — for any contact, new or existing.
Unlike Triggers 1 and 2, this trigger is not limited to first-time contacts. It fires on every message event, making it ideal for keeping Monday items continuously in sync with live conversations.
![WhatsAble trigger: When you receive or send any WhatsApp message]()
**Best for:** Updating an existing Monday item's status, last message time, or activity log every time a conversation progresses.
**Output fields:**
| Field | Type | Description |
| ------------------- | --------- | ------------------------------------------ |
| `name` | Text | Contact's display name |
| `phone` | Phone | Contact's phone number |
| `country` | Text | Detected country |
| `label` | Text | Assigned label |
| `message` | Text | Message body |
| `attachment_url` | URL | URL of any media attachment |
| `last_message_time` | Date/Time | Message timestamp |
| `sent_by` | Text | Sender identifier (outgoing messages only) |
| `is_incoming` | Boolean | `true` if received, `false` if sent |
| `ai_enabled` | Boolean | AI agent state |
| `automation_note` | Text | Automation-injected note, if any |
Map `is_incoming` to a **Checkbox** column in Monday to visually distinguish customer messages from agent replies at a glance.
***
#### Trigger quick reference
| Trigger | Fires for existing contacts? | Fires multiple times? | Direction |
| ---------------------------- | ---------------------------- | --------------------- | --------- |
| New Incoming Chat Received | No | First time only | Inbound |
| New Outgoing Chat Created | No | First time only | Outbound |
| New Message Received or Sent | Yes | Every message | Both |
**Rule of thumb:** Use Triggers 1 and 2 for contact *creation*. Use Trigger 3 for ongoing conversation *updates*.
***
### Actions
Actions define *what happens* when a trigger fires. WhatsAble provides two actions.
#### Action 1 — Send Template Message
Sends an approved WhatsApp Business template message to a contact.
![WhatsAble action: Send a template message]()
**Configuration:**
1. Select **Send Template Message** from the WhatsAble action list in Workflow Builder
2. Choose the template from the dropdown — all Meta-approved templates in your WABA account are listed
3. Map each template variable (e.g. `{{1}}`, `{{2}}`) to a column value from your Monday board
4. Map the **phone number** field to your board's phone/mobile column
Only Meta-approved WhatsApp Business templates appear in the dropdown. Templates pending review will not be listed.
#### Action 2 — Send Follow-Up Message
This action is currently **in development** and will be available in a future release. It will support scheduled follow-up messages with timezone-aware delivery windows.
***
### Data field reference
**Accessing trigger data:** All trigger fields are accessible inside Monday's action configuration via the dynamic data picker. When mapping a field, click the dropdown and look for **Step 1 — \[Trigger Name]** to find WhatsAble's data outputs.
**Boolean fields:** `ai_enabled` and `is_incoming` return `true` or `false`. Map these to **Checkbox** columns in Monday. They cannot be mapped to text or status columns directly.
**Attachment handling:** `attachment_url` returns a direct URL to any media file sent in the message — image, video, PDF, or audio. Map it to a **Link** column to make files accessible from the board. When mapped inside a **Create Update** action, the media appears inline in the board item's activity feed.
**`sent_by` field:** Identifies the sender of an outgoing message — returns the logged-in user's name from WhatsAble chat UI, or the automation/app name for Make, Zapier, n8n, or API. Not available on Trigger 1 (Incoming Chat).
**`automation_note` field:** Populated only when a WhatsAble automation rule explicitly injects a note. Blank for manually sent messages or automations without a configured note.
***
## Workflow examples
The following examples are real working workflows you can replicate inside Monday's Workflow Builder using WhatsAble triggers and actions.
***
### Example 1 — Sync Every WhatsApp Message to Your Board
**What it does:** Every time a WhatsApp message is sent or received — from any contact, new or existing — this workflow either updates the matching Monday item or creates a new one if it doesn't exist yet. This is the recommended workflow for teams who want a live, always-current view of their WhatsApp conversations inside Monday.
**Trigger:** When New Message Received or Sent in WhatsApp
**Workflow structure:**
* Step 1 — Trigger: When you receive or send any WhatsApp message
* Step 2 — Find matching item (Column: mobile)
* Found → Step 3: Create update on the matched item
* Not found → Step 4: Create item on the Development board
* Step 5: Create update on the new item
![Workflow: Sync Every WhatsApp Message to Your Board]()
**How to build it:**
1. Open **Workflow Builder** on your Monday board → **Create Workflow**
2. Add trigger → search *WhatsAble* → select **When New Message Received or Sent in WhatsApp**
3. Add **Find Matching Item** (Monday native):
* **Board:** your target board
* **Column:** your phone/mobile column
* **Value:** `{phone}` from Step 1
* **If multiple matches:** Last Created Item
4. **Found** branch → Add **Create Update**:
* **Item:** Item ID from Step 2
* **Update body:** `{message}` from Step 1
5. **Not Found** branch → Add **Create Item**:
* **Board:** your target board
* Map **Name** → `{name}`, **Phone** → `{phone}`, **Country** → `{country}`, **Label** → `{label}`, **Last Message Time** → `{last_message_time}`, **AI Active** → `{ai_enabled}`
6. Below Create Item → Add **Create Update**:
* **Item:** Item ID from Step 4
* **Update body:** `{message}` from Step 1
7. Click **Publish**
**Result:** New contacts are created automatically. Returning contacts get their board item updated with every new message. The activity feed on each item becomes a full log of the conversation.
This workflow uses Monday's **Find Matching Item** block to prevent duplicate items. Phone numbers are matched in E.164 format (e.g. `+34612345678`) — make sure your mobile column stores numbers in the same format.
***
### Example 2 — Log New Outbound Contacts as Monday Items
**What it does:** The moment your team sends a WhatsApp message to a contact that doesn't yet exist in WhatsAble, this workflow automatically creates a Monday item on your board and logs the opening message as a board activity update.
**Trigger:** When New Outgoing Chat Created
**Workflow structure:**
* Step 1 — Trigger: When you send a message to a new WhatsApp contact
* Step 2 — Create item on the Development board
* Step 3 — Create update on the new item (Item ID from Step 2)
![Workflow: Log New Outbound Contacts as Monday Items]()
**How to build it:**
1. Open **Workflow Builder** → **Create Workflow**
2. Add trigger → search *WhatsAble* → select **When New Outgoing Chat Created**
3. Add **Create Item** (Monday native):
* **Board:** your target board
* **Group:** your preferred group (e.g. Leads, Prospects)
* Map **Name** → `{name}`, **Phone** → `{phone}`, **Country** → `{country}`, **Label** → `{label}`, **Sent By** → `{sent_by}`, **Last Message Time** → `{last_message_time}`, **AI Active** → `{ai_enabled}`
4. Add **Create Update**:
* **Item:** Item ID from Step 2
* **Update body:** `{message}` from Step 1
5. Click **Publish**
**Result:** Every new outbound conversation your team initiates is instantly captured in Monday — complete with the contact's details and the first message your team sent. The `sent_by` field tells you which team member or automation initiated the conversation.
This trigger fires **only once per contact** — the first time you message them. If the contact already exists in WhatsAble, this workflow will not fire. For ongoing message tracking, combine this workflow with Example 1.
***
### Example 3 — Notify Customer via WhatsApp on Status Change
**What it does:** When a Monday item's status column changes, this workflow automatically sends the contact an approved WhatsApp template message. Use it to notify customers when their order is shipped, their ticket is resolved, their proposal is ready, or any other status-driven event.
**Trigger:** Monday native — When status changes to something
**Workflow structure:**
* Step 1 — Trigger: When status changes to \[value] (Monday native)
* Step 2 — Send a template message (WhatsAble action)
![Workflow: Notify Customer via WhatsApp on Status Change]()
**How to build it:**
1. Open **Workflow Builder** → **Create Workflow**
2. Add trigger → use Monday's default **When status changes to something**:
* Select your **Status** column
* Set the value to the status that should fire the workflow (e.g. Done, Shipped, Resolved)
3. Add WhatsAble action **Send a Template Message**:
* Select your approved template from the dropdown
* Map each template variable (e.g. `{{1}}`) to a board column — typically the contact's name
* Map **Phone Number** → your board's phone/mobile column
4. Click **Publish**
**Result:** The moment your team moves an item to the configured status, the contact automatically receives a WhatsApp message — no manual outreach required.
You can create multiple versions of this workflow for different status values — one for *Shipped*, another for *Resolved*, another for *Awaiting Payment* — each sending a different approved template.
Only **Meta-approved** WhatsApp Business templates can be sent via this action. Make sure your template is approved before publishing the workflow, or the action will fail silently.
***
## Example use cases
Automatically create Monday items when new WhatsApp contacts reach out
Sync support conversations to your board and track resolution status
Send template messages when order status changes to Done
Log outbound prospecting messages as new Monday items
Keep board items in sync with every message sent or received
Trigger WhatsApp reminders when board status changes
***
## Disconnecting
To remove the connection, go to **Notifyer Console → Connect To → Monday** and click the red **Disconnect WhatsAble from Monday** button.
Disconnecting immediately stops all active WhatsAble-powered workflows in Monday. Any workflows using WhatsAble triggers or actions will fail until the integration is reconnected.
To reconnect, repeat the connection steps above. Your existing Monday workflow configurations remain intact — only the authorization needs to be re-established.
***
## Best practices
Use Monday's native **Find Matching Item** block filtering on the phone column to avoid duplicate items. Match type: `equals` | Result: `last_created_item` | Branch: `found` / `not_found`
WhatsAble returns phone numbers in E.164 format (e.g. `+34612345678`). Ensure your Monday phone column stores numbers in the same format for reliable matching.
Whenever possible, use pre-approved templates for better deliverability and compliance with WhatsApp Business policies.
Always test your workflows with test phone numbers before activating them for production use.
Regularly check **Run History** in Monday's Workflow Builder to identify and resolve any failed runs.
***
## Troubleshooting
Pop-ups may be blocked in your browser. Allow popups from your Notifyer Console URL.
Refresh the Notifyer Console page. It needs a reload to detect that Step 1 is complete before enabling the Authorize button.
Ensure you are authorizing with a Monday account that has admin or sufficient member-level permissions. Guest accounts cannot authorize third-party integrations.
If using Trigger 1 or 2, verify whether the contact already exists in your WhatsAble system. These triggers only fire for first-time contacts. Use Trigger 3 for existing contacts.
WhatsAble returns phone numbers in E.164 format (e.g. `+34612345678`). Ensure your Monday phone column stores numbers in the same format.
Only Meta-approved templates are listed. Check the template status in Notifyer under **Settings → Templates**.
`sent_by` is only populated on outgoing messages. It is always empty on Trigger 1 (Incoming Chat), and blank for incoming messages on Trigger 3.
Open **Run History** in Monday's Workflow Builder. Expand the failed run to see which step errored. Common causes: unmapped required phone number field on Send Template, invalid template variables, or a deleted board column that was previously mapped.
***
## Technical reference
This section describes the integration's behavior in structured terms for programmatic parsing and AI-assisted automation building.
**App identifier in Monday Workflow Builder:** Search for *"WhatsAble"* or *"Words"*. App category: *"Automation with AI"*.
**Trigger schemas:**
```
Trigger: when_new_incoming_chat_received
fires_once_per_contact: true
direction: inbound
output_fields: name, phone, country, label, message, attachment_url,
last_message_time, ai_enabled, automation_note
Trigger: when_new_outgoing_chat_created
fires_once_per_contact: true
direction: outbound
output_fields: name, phone, country, label, message, attachment_url,
last_message_time, sent_by, ai_enabled, automation_note
Trigger: when_new_message_received_or_sent
fires_once_per_contact: false
fires_on_every_message: true
direction: both
output_fields: name, phone, country, label, message, attachment_url,
last_message_time, sent_by, is_incoming, ai_enabled, automation_note
```
**Action schemas:**
```
Action: send_template_message
status: available
required_inputs: template_id, phone_number
optional_inputs: template_variables[] (mapped from board columns)
Action: send_follow_up_message
status: in_development
```
**Idempotency notes:**
* Triggers 1 and 2 are inherently idempotent per contact (fire at most once per phone number)
* Trigger 3 fires on every message event and requires explicit deduplication via the Find Matching Item pattern
***
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations (Make, Zapier, n8n, Pipedrive), please contact our support team or check our integration documentation.
# n8n
Source: https://docs.whatsable.app/guides/notifyer-system/n8n-overview
Learn how to seamlessly integrate n8n with the Notifyer System for enterprise-level WhatsApp automation
# Notifyer System Integration with n8n
![]()
This guide walks you through connecting Notifyer System with n8n to create powerful automated WhatsApp messaging workflows for your business
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [n8n](https://app.n8n.cloud/login) workflow automation platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform embedding process, which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
To connect Notifyer System with n8n, you'll need an API key:
1. In your Notifyer dashboard, navigate to [**API Keys**](https://console.notifyer-systems.com/api-key)
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Integrating with n8n
1. Log in to your n8n account
2. Create a new workflow by clicking **Create Workflow**
3. Add a trigger node of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
The WhatsAble trigger node enables your workflow to respond automatically to incoming WhatsApp messages. This setup is optional but recommended for building reactive communication flows.
Follow these steps to add the WhatsAble trigger node to your workflow:
1. Click the **+** button in your workflow canvas to add a new node
2. Search for "WhatsAble" in the node library search bar
3. Select the node displaying the official WhatsAble logo
4. From the available trigger options, choose **On new Incoming message event**
![WhatsAble node selection showing trigger options]()
The trigger node will automatically listen for incoming messages and initiate your workflow when a new message is received.
Set up your WhatsAble API credentials to establish a secure connection:
**Webhook URL Configuration:**
1. In the WhatsAble Trigger node parameters, locate the **Webhook URLs** section at the top
2. Select **Production URL** and copy the generated URL by clicking on it
3. Store this URL securely as you'll need it for the credential setup
![Production URL selection and copy interface]()
**Credential Creation:**
1. In the **Credential to connect with** dropdown, click **+ Create new credential**
2. Select **WhatsAble Notifyer System API** as your connection method
3. Enter your Notifyer System API key in the **API Key** field
4. Paste the Production URL you copied earlier into the **Production URL** field
5. Assign a descriptive name to your credential (e.g., "WhatsAble Production")
6. Click **Save** to securely store your credentials
![WhatsAble credential configuration interface]()
Your API credentials are encrypted and stored securely. Never share your API key publicly or commit it to version control.
Complete the setup by testing and activating your trigger:
**Response Configuration:**
1. In the **Respond** dropdown, select your preferred response timing:
* **Immediately**: Responds as soon as the trigger fires
* **When Last Node Finishes**: Waits for the entire workflow to complete before responding
**Testing:**
1. Click **Execute step** on the WhatsAble node to run a test
2. Verify the connection is working by checking for a success confirmation
3. Review any error messages if the test fails and adjust your configuration accordingly
Once activated, your workflow will automatically process incoming messages according to your configured logic.
Remember to test your workflow thoroughly before activating it in production to ensure it behaves as expected.
1. Click the **+** button after your trigger node
2. Search for "WhatsAble" in the nodes panel
3. Select the node with the official WhatsAble logo
4. After selecting the WhatsAble node, choose 'Send template via Notifyer' or 'Send non-template via Notifyer' as needed.
![WhatsAble node selection]()
1. In the WhatsAble node **Parameters**, find the **Credential to connect with** dropdown
2. Select **+ Create new credential**
3. Enter your Notifyer System API key that you copied earlier
4. Name your credential (e.g., "Notifyer Production")
5. Click **Save** to store your credential
![Configuring Notifyer System credential]()
1. In **Resource** dropdown, select **Send Message**
2. In the **Operation** dropdown, choose **Send template via Notifyer** for template messages or **Send non‑template via Notifyer** for regular messages (only works within the 24‑hour window).
3. Complete the required fields:
Complete the required fields:
Enter the recipient's phone number with country code (e.g., +14155552671) or use dynamic data from previous nodes
Select from your pre-approved templates in the dropdown
Based on your selected Template message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
For all media types, ensure your file URLs are publicly accessible and match the supported file formats.
(Optional) Include a note in the template message for internal tracking
(Optional) Select the label(s) you created in Chat Notifyer for internal tracking
(Optional) Select the date and time to schedule when your message will be sent
Enter the **Phone Number** with country code
Choose from the following message types:
For plain text messages
For sending documents (PDF, Word, etc.)
For sending images (JPEG, PNG, etc.)
For sending videos (MP4, 3GP, etc.)
Based on your selected message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
For all media types, ensure your file URLs are publicly accessible and match the supported file formats.
(Optional) Select the label(s) you created in Chat Notifyer for internal tracking
(Optional) Select the date and time to schedule when your message will be sent
1. Click **Test Step** on the Notifyer node to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Return to your workflow
4. Click **Save** to save your entire workflow
5. Toggle the **Active** switch in the top-right corner to activate your workflow
Your automated messaging workflow is now operational! Whenever your trigger conditions are met, n8n will automatically send WhatsApp messages through Notifyer System.
## Example use cases
Send automatic order confirmations when new orders are placed
Schedule reminders before upcoming appointments
Alert your sales team when new leads come in
Route support inquiries to the appropriate team member
Keep customers informed about their delivery status
Send automatic payment reminders for overdue accounts
## Best practices
Always test your workflows with test phone numbers before activating them for production use.
Whenever possible, use pre-approved templates for better deliverability and compliance.
Include customer names and specific details to increase engagement and response rates.
Ensure all message content complies with WhatsApp Business policies to avoid account restrictions.
Regularly check your message delivery rates in your Notifyer dashboard.
## Troubleshooting
Ensure your API key is entered correctly in the n8n credentials
Confirm phone numbers are in the correct international format (e.g., +14155552671)
Verify your Notifyer subscription is active and has available credits
For template messages, ensure you're using an approved template
Verify all required variables are included in your template message
Check that variable formats match the expected values (text, number, date, etc.)
Ensure you're using the correct template name exactly as it appears in your dashboard
Confirm your media URLs are publicly accessible (test in an incognito browser)
Verify the file format is supported by WhatsApp
Check that file sizes are within WhatsApp limits:
* Images: up to 5MB
* Videos: up to 16MB
* Documents: up to 100MB
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer dashboard
For additional automation platform integrations (Make.com, Zapier, etc.), please contact our support team or check our integration documentation.
# Pipedrive
Source: https://docs.whatsable.app/guides/notifyer-system/pipedrive-overview
Learn how to seamlessly integrate Pipedrive with the Notifyer System for automated WhatsApp messaging
# Notifyer System Integration with Pipedrive
![]()
This guide walks you through connecting Notifyer System with Pipedrive to create powerful automated WhatsApp messaging workflows for your sales and CRM processes
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Pipedrive](https://www.pipedrive.com/) CRM platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform [embedding process](/guides/notifyer-system/embedding-process), which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
Follow these simple steps to integrate your Pipedrive account with Notifyer System:
In your Notifyer dashboard, go to [**Connect to Pipedrive**](https://console.notifyer-systems.com/pipedrive).
Click the 'Connect Pipedrive Organization' button.
You'll be redirected to Pipedrive's authorization page. Review the permissions and click 'Authorize' to grant Notifyer System access to your Pipedrive organization.
After authorization, you'll be automatically redirected back to your Notifyer System dashboard. Look for the connection status showing 'Connected to Pipedrive' to confirm the integration was successful.
![Connecting Notifyer System with Pipedrive]()
## Sending WhatsApp Messages from Pipedrive
WhatsAble's integration with Pipedrive allows you to send WhatsApp messages directly from your deals and contacts without leaving your CRM. This guide will walk you through the complete process.
### Verifying Prerequisites
Before sending WhatsApp messages, ensure the following requirements are met:
Must show as **PAID**
Must show as **ACTIVE**
Must be properly synced with WhatsAble
You can verify these settings in the WhatsAble Integration section of any deal or contact.
## Sending Messages from Deals
### Accessing the WhatsAble Integration Panel
1. Go to your **Pipedrive Dashboard**
2. Open your desired **Pipeline**
3. Select a **Deal** from your pipeline
1. On the right-hand panel, scroll down past the Summary section
2. Find the **WhatsAble Integration** section
![WhatsAble Integration Panel]()
### Understanding the Integration Panel
The WhatsAble Integration panel displays important connection information:
Confirms your subscription is active
Shows which WhatsApp Business account is connected
Indicates if your WhatsApp connection is active
Displays the date and time of the most recent message
Provides a direct link to the conversation
### Sending Options
Within the WhatsAble Integration section, you'll find a green **"Live Chat"** button with a dropdown menu offering three options:
Opens the WhatsAble chat interface directly within Pipedrive
Schedule a message to be sent at a specific date and time
Send a pre-configured template message immediately
## Option 1: Send Scheduled Message
Use this option when you want to send a message at a specific future date and time.
1. Click the dropdown next to the **Live Chat** button
2. Select **"Send Scheduled Message"**
3. A modal window will appear with the following fields
The recipient's phone number(s) associated with the deal. This field is automatically populated from the deal's contact information.
Your connected WhatsApp Business account. This field is pre-filled and cannot be modified from this interface.
Choose from your pre-created message templates. These templates must be created beforehand in the **Notifyer by WhatsAble** dashboard.
Once you select a template, all required placeholder fields will appear dynamically. Fill in each field carefully to personalize your message (e.g., customer name, appointment time, order details).
Select the exact date and time you want the message to be sent.
Specify the timezone from which you're scheduling the message to ensure accurate delivery timing.
Include an internal note for your team. This note is only visible within Pipedrive and helps with tracking and context.
Assign labels to categorize and organize your communications for easier filtering and reporting.
At the top of the modal, you'll see your **most recent messages** with this contact (if any previous conversations exist), providing helpful context before sending.
1. Review all information carefully
2. Click the **"Schedule Template"** button at the bottom of the modal
3. Your message is now scheduled and will be sent automatically at the specified time
Message successfully scheduled! It will be sent at the specified time.
![Schedule Template Modal]()
## Option 2: Send Template (Immediate)
Use this option to send a pre-configured template message immediately without scheduling.
1. Click the dropdown next to the **Live Chat** button
2. Select **"Send Template"**
3. A modal window will appear with the following fields
The recipient's phone number(s) associated with the deal. This field is automatically populated from the deal's contact information.
Your connected WhatsApp Business account. This field is pre-filled and cannot be modified from this interface.
Choose from your pre-created message templates. These templates must be created beforehand in the **Notifyer by WhatsAble** dashboard.
Once you select a template, all required placeholder fields will appear dynamically. Fill in each field carefully to personalize your message (e.g., customer name, product details, tracking numbers).
Include an internal note for your team. This note is only visible within Pipedrive and helps with tracking and context.
Assign labels to categorize and organize your communications for easier filtering and reporting.
At the top of the modal, you'll see your **most recent messages** with this contact (if any previous conversations exist), providing helpful context before sending.
1. Review all information carefully
2. Click the **"Send Template"** button at the bottom of the modal
3. Your message will be sent immediately
Message sent successfully!
![Send Template Modal]()
## Sending Messages from Contacts
The process for sending WhatsApp messages from contacts is nearly identical to sending from deals, with minor differences noted below.
### Accessing the WhatsAble Integration Panel
1. Go to your **Pipedrive Dashboard**
2. Navigate to the **Contacts** menu
3. Select your desired **Contact**
1. On the right-hand panel, scroll down past the Summary section
2. Find the **WhatsAble Integration** section
![WhatsAble Integration Panel]()
### Understanding the Integration Panel
The WhatsAble Integration panel displays the same connection information as in deals:
Confirms your subscription is active
Shows which WhatsApp Business account is connected
Indicates if your WhatsApp connection is active
Displays the date and time of the most recent message
Provides a direct link to the conversation
### Sending Options
The same three options are available:
Opens the WhatsAble chat interface directly within Pipedrive
Schedule a message for a specific date and time
Send a template message immediately
**Key Difference**: Phone numbers are pulled from the contact's information rather than deal-specific numbers. All other fields and processes remain identical to sending from deals.
## Best Practices
**Before Sending Messages**
Always check that your WhatsApp connection shows as ACTIVE before attempting to send messages to avoid delivery failures.
**Template Management**
* Ensure your message templates are up-to-date in the Notifyer dashboard
* Test templates with yourself before using them with customers
* Create templates in advance for different scenarios
**Phone Number Verification**
* Confirm the recipient's phone number is correct
* Verify the number includes the country code (e.g., +1 for US)
* Update contact information if numbers are missing or incorrect
**Message Organization**
* Develop a clear labeling system for easier tracking
* Apply consistent labels across your team
* Use labels for reporting and analytics purposes
**Documentation Best Practices**
* Document the purpose of each message for future reference
* Include context that will help team members understand the communication
* Keep notes concise but informative
**Maintain Context**
* Always check conversation history before sending new messages
* Avoid sending duplicate or redundant information
* Ensure message continuity for better customer experience
**Timing Considerations**
* Consider your recipient's timezone when scheduling messages
* Avoid sending messages during off-hours or weekends unless necessary
* Set reminders to follow up if no response is received
**Template Creation**
* Make placeholder fields intuitive for anyone on your team
* Use descriptive variable names (e.g., customer\_name, order\_date)
* Test variable population before mass sending
## Troubleshooting
Reconnect your WhatsApp Business account in the WhatsAble dashboard
Verify your WhatsApp Business account is properly configured
Contact WhatsAble support if the issue persists after reconnection
Create templates in the Notifyer by WhatsAble dashboard first
Ensure templates are approved by WhatsApp (if required for your template type)
Refresh your Pipedrive page after creating new templates to see them appear
Verify your WhatsApp connection was active at the scheduled time
Check that the timezone was set correctly when scheduling
Review the message logs in WhatsAble for error details and delivery status
Ensure the contact or deal has a valid phone number in Pipedrive
Verify the phone number format includes the country code (e.g., +1234567890)
Update the contact information if the phone number is missing or incorrect
Ensure variable names in your template match the fields you're filling
Confirm the data source (contact or deal) has the required information
Send a test message to yourself to verify variable population before sending to customers
Confirm the recipient has an active WhatsApp account on that number
Ensure your message complies with WhatsApp's business messaging policies
Verify your WhatsAble account has sufficient credits or an active subscription
If issues persist, contact WhatsAble support with the message details
For more information about template creation and management, visit the Notifyer by WhatsAble dashboard or contact our support team.
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations and advanced configurations, please contact our support team or check our integration documentation.
# Zapier
Source: https://docs.whatsable.app/guides/notifyer-system/zapier-overview
Learn how to seamlessly integrate Zapier with the Notifyer System for enterprise-level WhatsApp automation
# Notifyer System Integration with Zapier
![]()
This guide walks you through connecting Notifyer System with Zapier to create powerful automated WhatsApp messaging workflows for your business
## Prerequisites
Before getting started, make sure you have:
Active Notifyer System account with a subscription plan (Monthly or Pay-as-you-go)
Access to [Zapier](https://zapier.com/sign-up/) workflow automation platform
New to Notifyer System? [Sign up here](https://console.notifyer-systems.com/)
## Setting up your Notifyer System account
Before sending WhatsApp messages, you must complete the platform embedding process, which connects your WhatsApp Business account to Notifyer System.
The embedding process is required by Meta to ensure proper business verification and compliance with WhatsApp Business Platform policies.
Notifyer System provides two methods for sending WhatsApp messages:
WhatsApp templates are pre-approved message formats that allow for personalization while maintaining compliance with WhatsApp policies.
Go to **Your Templates** in your Notifyer dashboard
Click the **Create Template** tab at the top of the page
Complete the template creation form with the following details:
Choose a descriptive name for internal reference
Choose your template's primary language
Select the appropriate message category
Optional: Add an image, document, or video header
Craft your message content
Add placeholders using `{{1}}`, `{{2}}` format for personalization
Optional: Configure call-to-action buttons
Click **Preview and Submit**
![Template Creation Interface]()
Templates typically get reviewed within 24 hours. Creating compliant templates that avoid promotional language increases approval chances.
For simpler communications, you can send non-template messages that include:
Plain text messages within the 24-hour window
Photos and graphics in supported formats
PDFs, Word docs, and other file types
MP4 and other supported video formats
Non-template messages can only be sent within the 24-hour customer service window after a customer initiates contact with your business.
To connect Notifyer System with Zapier, you'll need an API key:
1. In your Notifyer dashboard, navigate to [**API Keys**](https://console.notifyer-systems.com/api-key)
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Connect Notifyer System to Zapier
Now that you have your Notifyer System account configured, let's connect it to Zapier to automate your messaging workflows.
1. Log in to your Zapier account
2. Navigate to Notifyer System dashboard and select **Connect to Zapier** in the side menu
3. Click **Continue** in the connection guide popup
4. Click **Accept & Build a Zap** on the invitation page
You're now ready to create Zaps with the Notifyer System app
![Connecting Notifyer System to Zapier]()
1. Log in to your Zapier account
2. Create a new workflow/Zap by clicking **+ Create** and select **Zaps**/**New Zap**
3. Add a trigger step of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up Zapier Zaps]()
1. Select the next **Action** step or click the **+** button to add a new step
2. Search for "Notifyer System" in the apps and tools library
3. Select the app with the official Notifyer System logo
![Adding the WhatsAble app]()
1. In the Notifyer System app Setup, select [**Send a WhatsApp Message with your template**](/guides/notifyer-system/zapier-overview#template-messages) or [**Send WhatsApp Message Without Template**](/guides/notifyer-system/zapier-overview#non-template-messages) in the **Action event** dropdown depending on your messaging needs
2. Click **Sign In** in the **Account** field and you will be prompted to enter your API Key
3. Enter your Notifyer System API key that you copied earlier
4. Click **Yes, Continue to Notifyer System** to store your credential
5. Next, click the **Continue** button in the Setup screen to proceed to the **Configure** section
![Configuring Notifyer System credentials]()
Depending on your messaging needs, choose one of the following operations:
In the **Setup** section, select **Send a WhatsApp Message with your template** in the **Action event** dropdown and continue to the **Configure** section
Complete the required fields in the **Configure** section:
Select from your pre-approved templates in the dropdown
Enter the recipient's phone number with country code (e.g., +14155552671) or use dynamic data from previous nodes
Add note for internal tracking. This data won't be sent to the recipient
Select label(s) for internal tracking. This data won't be sent to the recipient
Enter publicly accessible media URL for Media (image/video/document) header.
This field will only appear if you have a Media (image/video/document) header configured in your selected template.
Fill in values for each Body(s) in your template, mapping them to dynamic data when applicable
Fill in values for each button in your template, mapping them to dynamic data when applicable.
This field(s) will only appear if you have configured button(s) in your selected template. You will see the button name as the field name.
Based on your selected message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
![Template Message Configuration]()
In the **Operation Name or ID** dropdown, select **Send Non Template Message**
Enter the **Phone Number** with country code
Choose from the following message types:
For plain text messages
For sending documents (PDF, Word, etc.)
For sending images (JPEG, PNG, etc.)
For sending videos (MP4, 3GP, etc.)
Based on your selected message type, fill in the required fields:
* For text messages: Enter your message content
* For media messages: Provide a publicly accessible URL to your file
* Optional caption (for media files)
For all media types, ensure your file URLs are publicly accessible and match the supported file formats.
![Non-Template Message Configuration]()
1. Click **Continue** and then click **Test step** in the **Test** to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Click **Publish** to save your entire Zap
4. Toggle the **Active** switch in the top-left corner to activate your Zap
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Workflow Diagram
```mermaid theme={null}
flowchart LR
A[Trigger Step] --> B[Data Transformation]
B --> C[Notifyer System App]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Example use cases
Send automatic order confirmations when new orders are placed
Schedule reminders before upcoming appointments
Alert your sales team when new leads come in
Route support inquiries to the appropriate team member
Keep customers informed about their delivery status
Send automatic payment reminders for overdue accounts
## Best practices
Always test your workflows with test phone numbers before activating them for production use.
Whenever possible, use pre-approved templates for better deliverability and compliance.
Include customer names and specific details to increase engagement and response rates.
Ensure all message content complies with WhatsApp Business policies to avoid account restrictions.
Regularly check your message delivery rates in your Notifyer dashboard.
## Troubleshooting
Ensure your API key is entered correctly in the Zapier credentials
Confirm phone numbers are in the correct international format (e.g., +14155552671)
Verify your Notifyer subscription is active and has available credits
For template messages, ensure you're using an approved template
Verify all required variables are included in your template message
Check that variable formats match the expected values (text, number, date, etc.)
Ensure you're using the correct template name exactly as it appears in your dashboard
Confirm your media URLs are publicly accessible (test in an incognito browser)
Verify the file format is supported by WhatsApp
Check that file sizes are within WhatsApp limits:
* Images: up to 5MB
* Videos: up to 16MB
* Documents: up to 100MB
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the green chat button in the bottom right corner of the Notifyer System dashboard
For additional automation platform integrations (Make.com, n8n, etc.), please contact our support team or check our integration documentation.
# Rate limits
Source: https://docs.whatsable.app/guides/rate-limits
# Webhooks
Source: https://docs.whatsable.app/guides/webhooks
Receive real-time notifications for message status and incoming messages via webhooks.
# Webhooks
Webhooks allow you to receive real-time notifications about message status and incoming messages.
## Overview
Webhooks provide a way for our system to send data to your application in real-time whenever:
* A message status changes
* A recipient replies to your message
* A new message is received
## Setting Up Webhooks
1. Go to your WhatsAble dashboard
2. Navigate to Developer Settings
3. Click "Add Webhook"
4. Enter your webhook URL
5. Select the events you want to receive
## Webhook Events
### Message Status Events
```json theme={null}
{
"event": "message_status",
"data": {
"message_id": "wamid.123456789",
"status": "delivered",
"timestamp": "2024-03-23T21:41:44.477Z"
}
}
```
### Incoming Message Events
```json theme={null}
{
"event": "incoming_message",
"data": {
"last_messages": "[{\"type\":\"user\",\"content\":\"Hello!\",\"timestamp\":\"2024-03-23T21:41:44.477Z\",\"content_type\":\"text\"}]",
"conversation_paragraph": "User (9:41:44 PM): Hello!",
"phone_number": "8801734363287",
"recipient_name": "John Doe",
"user_id": "6fb11ff2-d9b2-4560-8437-0fe58ec9f4a6",
"last_message_of_user": "Hello!",
"last_message_of_bot": "Hi there!",
"message_type": "text",
"user_timestamp": 1234567890,
"bot_timestamp": 1234567890,
"attachment_url": "https://api.insightssystem.com/vault/attachment.jpg"
}
}
```
## Webhook Security
1. **HTTPS Required**: All webhook endpoints must be accessible via HTTPS
2. **Authentication**: Verify webhook signatures
3. **IP Whitelisting**: Configure allowed IP addresses
4. **Rate Limiting**: Handle multiple events efficiently
## Best Practices
1. **Idempotency**: Handle duplicate events gracefully
2. **Error Handling**: Return appropriate HTTP status codes
3. **Logging**: Log all incoming webhook events
4. **Monitoring**: Set up alerts for webhook failures
5. **Testing**: Use the webhook testing tool in dashboard
## Example Webhook Handler
```javascript theme={null}
const express = require('express');
const app = express();
app.post('/webhook', express.json(), (req, res) => {
const { event, data } = req.body;
switch (event) {
case 'message_status':
handleMessageStatus(data);
break;
case 'incoming_message':
handleIncomingMessage(data);
break;
default:
console.log('Unknown event type:', event);
}
res.status(200).send('OK');
});
function handleMessageStatus(data) {
console.log('Message status update:', data);
// Process message status
}
function handleIncomingMessage(data) {
console.log('Incoming message:', data);
// Process incoming message
}
app.listen(3000, () => {
console.log('Webhook server running on port 3000');
});
```
# WhatsAble API
Source: https://docs.whatsable.app/guides/whatsable/api-documentation
Send programmatic WhatsApp messages with the WhatsAble API
# WhatsAble API
> Send programmatic WhatsApp messages with ease
![WhatsAble API Hero Image]()
![WhatsAble API Hero Image]()
## Overview
WhatsAble API enables developers to programmatically send WhatsApp messages with rich media support. Our RESTful API delivers enterprise-grade reliability while maintaining a simple integration process. Whether you're building a customer support platform, marketing automation system, or notification service, WhatsAble API gives you the tools to engage your users on WhatsApp.
Send your first WhatsApp message in under 5 minutes
Complete API endpoints and parameters documentation
Send images, videos, documents, and more
Use templates for structured messages
## Key Features
Send WhatsApp messages with text, images, videos, documents, and audio files.
Use pre-defined templates for structured messages, enabling you to send consistent communications.
Seamlessly integrate with platforms like Zapier and Make.com without writing code.
Send messages to thousands of recipients with high deliverability and reliability.
## Getting Started
Sign up for a [WhatsAble account](https://dashboard.whatsable.app/register) and activate your subscription or start a free trial.
You'll need a WhatsApp-enabled phone number to send messages from your account.
Navigate to the API section in your WhatsAble dashboard and generate an API key.
Keep your API key secure and never share it publicly. It grants full access to send messages from your account.
Use the examples below to send your first WhatsApp message programmatically.
## API Reference
### Base URL
```bash Base URL theme={null}
https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0
```
```bash Legacy URL (v1) theme={null}
https://dashboard.whatsable.app/api/whatsapp/messages
```
### Authentication
All API requests require authentication using your API key in the request header:
Your WhatsAble API key
```bash Example theme={null}
curl -X POST https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0/send \
-H 'Authorization: YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"to": "+1234567890",
"text": "Hello from WhatsAble!"
}'
```
### Send Message Endpoint
Endpoint to send WhatsApp messages
#### Request Parameters
The recipient's phone number in E.164 format (e.g., +1234567890)
The message content you want to send
URL or base64-encoded file for attachments (images, videos, PDFs)
Name of the file when sending a document attachment
#### Response
Indicates if the message was sent successfully (true)
A human-readable message describing the result
Unique identifier for the message (e.g., wamid.XXXXXX)
Status of the message (e.g., "accepted")
```bash cURL theme={null}
curl -X POST https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0/send \
-H 'Authorization: YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"to": "+1234567890",
"text": "Hello, this is a test message from WhatsAble!",
"attachment": "https://example.com/image.jpg",
"filename": "image.jpg"
}'
```
```json Success Response theme={null}
{
"success": true,
"message": "Message sent successfully to +1234567890",
"details": {
"messages": [
{
"id": "wamid.XXXXXX",
"message_status": "accepted"
}
]
}
}
```
### Error Codes
```json theme={null}
{
"success": false,
"message": "Invalid phone number format",
"details": "Phone number must be in E.164 format."
}
```
Ensure phone numbers are in E.164 format (e.g., +1234567890) with country code.
```json theme={null}
{
"success": false,
"message": "API key is required"
}
```
Make sure you're including the API key in the Authorization header.
```json theme={null}
{
"success": false,
"message": "Invalid API Key"
}
```
Verify your API key is correct and active in your WhatsAble dashboard.
```json theme={null}
{
"success": false,
"message": "The number +1234567890 is not registered."
}
```
The recipient's number must be registered with WhatsApp to receive messages.
## Code Examples
```javascript JavaScript (Fetch) theme={null}
const sendWhatsAppMessage = async () => {
const apiKey = 'YOUR_API_KEY';
const endpoint = 'https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0/send';
const payload = {
to: '+1234567890',
text: 'Hello, this is a test message from WhatsAble!',
attachment: 'https://example.com/image.jpg',
filename: 'image.jpg'
};
try {
const response = await fetch(endpoint, {
method: 'POST',
headers: {
'Authorization': apiKey,
'Content-Type': 'application/json'
},
body: JSON.stringify(payload)
});
const data = await response.json();
console.log('Message sent:', data);
return data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
sendWhatsAppMessage();
```
```python Python theme={null}
import requests
import json
def send_whatsapp_message():
api_key = 'YOUR_API_KEY'
endpoint = 'https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0/send'
payload = {
'to': '+1234567890',
'text': 'Hello, this is a test message from WhatsAble!',
'attachment': 'https://example.com/image.jpg',
'filename': 'image.jpg'
}
headers = {
'Authorization': api_key,
'Content-Type': 'application/json'
}
try:
response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
data = response.json()
print('Message sent:', data)
return data
except Exception as e:
print('Error sending message:', str(e))
raise e
send_whatsapp_message()
```
```php PHP theme={null}
'+1234567890',
'text' => 'Hello, this is a test message from WhatsAble!',
'attachment' => 'https://example.com/image.jpg',
'filename' => 'image.jpg'
];
$headers = [
'Authorization: ' . $apiKey,
'Content-Type: application/json'
];
$ch = curl_init($endpoint);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($ch);
$error = curl_error($ch);
curl_close($ch);
if ($error) {
echo 'Error sending message: ' . $error;
return false;
}
$data = json_decode($response, true);
echo 'Message sent: ' . print_r($data, true);
return $data;
}
sendWhatsAppMessage();
```
## Supported Media Types
WhatsAble API supports a wide range of media types for sending rich messages via WhatsApp.
.jpeg, .jpg
image/jpeg
5MB
8-bit, RGB or RGBA
.png
image/png
5MB
8-bit, RGB or RGBA
```javascript Send Image Example theme={null}
const payload = {
to: '+1234567890',
text: 'Check out this image!',
attachment: 'https://example.com/image.jpg',
filename: 'image.jpg'
};
```
.mp4
video/mp4
16MB
H.264 video, AAC audio
.3gp
video/3gpp
16MB
H.264 video, AAC audio
.pdf
application/pdf
100MB
.doc, .docx
application/msword, application/vnd.openxmlformats-officedocument.wordprocessingml.document
100MB
.xls, .xlsx
application/vnd.ms-excel, application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
100MB
.ppt, .pptx
application/vnd.ms-powerpoint, application/vnd.openxmlformats-officedocument.presentationml.presentation
100MB
.txt
text/plain
100MB
.mp3
audio/mpeg
16MB
.aac
audio/aac
16MB
.ogg
audio/ogg
16MB
OPUS only
.amr
audio/amr
16MB
.m4a
audio/mp4
16MB
.webp
image/webp
100KB
.webp
image/webp
500KB
## Template-Based Messaging
WhatsAble intelligently selects the appropriate template based on the message content and attachment type.
WhatsAble automatically selects the appropriate template based on your content:
* **Text-only messages**: Uses templates like `standard_1_line_textonly`, `standard_2_line_textonly`, etc.
* **Image attachments**: Uses templates like `standard_image_notification_1_lines`, `standard_image_notification_2_lines`, etc.
* **Video attachments**: Uses templates like `standard_video_notification_1_lines`, `standard_video_notification_2_lines`, etc.
* **Document attachments**: Uses templates like `standard_doc_message_1_line`, `standard_doc_message_2_lines`, etc.
Template messaging ensures your messages maintain consistent formatting and follow WhatsApp guidelines.
## Rate Limits and Best Practices
WhatsAble enforces rate limits to ensure reliable message delivery. Standard accounts are limited to 50 messages per minute, while enterprise accounts have customizable limits.
Exceeding rate limits may result in temporary API access restrictions.
Always implement proper error handling to manage failed message deliveries gracefully:
```javascript theme={null}
try {
const response = await sendWhatsAppMessage();
if (!response.success) {
// Handle specific error based on response message
console.error('Message sending failed:', response.message);
}
} catch (error) {
// Handle network or server errors
console.error('API request failed:', error);
}
```
Compress images and videos before sending to improve delivery speed and reliability:
* Resize images to appropriate dimensions for WhatsApp (1080px max width recommended)
* Compress videos to reduce file size while maintaining quality
* Use CDN-hosted media when possible rather than base64 encoding
## FAQ
No, WhatsAble is not affiliated with or endorsed by WhatsApp Inc. WhatsAble uses the WhatsApp Business API to provide its services.
Yes, according to WhatsApp's policy, recipients must explicitly opt in to receive messages from businesses. Ensure you have proper consent before sending messages.
Currently, the WhatsAble API provides message acceptance status in the response. Real-time delivery and read receipts are planned for a future release.
Yes, but you need to send individual API requests for each recipient. Bulk messaging functionality with a single API call is available for enterprise customers.
## Support
Click the green chat button in the bottom right corner of the WhatsAble dashboard
Contact our team at [team@whatsable.app](mailto:team@whatsable.app)
Our support team is available Monday through Friday, 9 AM to 6 PM UTC. Enterprise customers receive 24/7 support access.
## Updates
![API v2.0.0 Release]()
![API v2.0.0 Release]()
### What's New
* **Improved Media Handling**: Support for larger file sizes and more media types
* **Enhanced Error Reporting**: More detailed error messages and status codes
* **Better Reliability**: Automatic retry mechanism for failed message delivery
* **Performance Improvements**: 50% faster message delivery times
### What's New
* Added support for sticker messages
* Improved template selection algorithm
* Fixed issues with document attachments
For a complete changelog, visit the [WhatsAble Release Notes](https://dashboard.whatsable.app/changelog) page.
API v1 is scheduled for deprecation on December 31, 2023. Please upgrade to v2.0.0 before this date.
# WhatsAble Features
Source: https://docs.whatsable.app/guides/whatsable/features
Explore the key features of WhatsAble
# WhatsAble Features
WhatsAble provides a simple yet powerful set of features for WhatsApp messaging.
## Core Features
### Message Types
* Text messages
* Media messages (images, documents, audio)
* Location sharing
* Contact sharing
### Message Management
* Message status tracking
* Delivery receipts
* Read receipts
* Message history
### Security
* End-to-end encryption
* API key authentication
* Rate limiting
* IP whitelisting
## Advanced Features
### Bulk Messaging
* Send to multiple recipients
* Custom variables
* Scheduling
* Message templates
### Integration
* REST API
* Webhooks
* SDK support
* Third-party integrations
## Best Practices
* Keep messages concise
* Respect rate limits
* Handle errors gracefully
* Monitor message status
## Next Steps
* Learn about [Integrations](/guides/whatsable/integrations)
* Check out our [API Reference](/api-reference/whatsable)
* Read our [Getting Started](/guides/whatsable/getting-started) guide
# Getting Started with WhatsAble
Source: https://docs.whatsable.app/guides/whatsable/getting-started
Learn how to get started with WhatsAble, the simple WhatsApp messaging solution
# Getting Started with WhatsAble
WhatsAble is the simplest way to send WhatsApp messages programmatically. This guide will help you get started with WhatsAble in minutes.
## Prerequisites
* A WhatsApp account
* Basic understanding of API integration
* Your WhatsAble API key
## Quick Setup
1. Sign up for a WhatsAble account
2. Get your API key from the dashboard
3. Start sending messages using our simple API
## First Message
Here's a quick example of sending your first message:
```bash theme={null}
curl -X POST https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0/send \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"to": "+1234567890",
"message": "Hello from WhatsAble!"
}'
```
## Next Steps
* Learn about [Features](/guides/whatsable/features)
* Explore [Integrations](/guides/whatsable/integrations)
* Check out our [API Reference](/api-reference/whatsable)
# WhatsAble Integrations
Source: https://docs.whatsable.app/guides/whatsable/integrations
Learn how to integrate WhatsAble with your applications
# WhatsAble Integrations
Integrate WhatsAble with your favorite tools and platforms.
## Available Integrations
### No-Code Platforms
* Zapier
* Make (formerly Integromat)
* n8n
* Pipedream
### CRM Systems
* Salesforce
* HubSpot
* Zoho CRM
* Pipedrive
### E-commerce Platforms
* Shopify
* WooCommerce
* Magento
* BigCommerce
## Custom Integration
### REST API
```javascript theme={null}
const axios = require('axios');
const sendMessage = async (to, message) => {
try {
const response = await axios.post(
'https://dashboard.whatsable.app/api/whatsapp/messages/v2.0.0/send',
{
to,
message
},
{
headers: {
'Authorization': `Bearer ${process.env.WHATSABLE_API_KEY}`,
'Content-Type': 'application/json'
}
}
);
return response.data;
} catch (error) {
console.error('Error sending message:', error);
throw error;
}
};
```
### Webhooks
Configure webhooks to receive real-time updates about your messages:
```json theme={null}
{
"event": "message.status",
"data": {
"message_id": "msg_123",
"status": "delivered",
"timestamp": "2024-03-20T10:00:00Z"
}
}
```
## Best Practices
* Use environment variables for API keys
* Implement retry logic
* Handle rate limits
* Monitor webhook delivery
## Next Steps
* Read our [Getting Started](/guides/whatsable/getting-started) guide
* Explore [Features](/guides/whatsable/features)
* Check out our [API Reference](/api-reference/whatsable)
# Make
Source: https://docs.whatsable.app/guides/whatsable/make
Learn how to automate WhatsApp messaging through Make with WhatsAble
# WhatsAble Integration with Make
![]()
WhatsAble lets you automate WhatsApp messaging through your favorite scenario automation platforms. This guide walks you through connecting WhatsAble with Make to create powerful WhatsApp messaging workflows.
## Prerequisites
Before getting started, make sure you have:
An active subscription with WhatsAble
Access to [Make](https://www.make.com/en/register/) scenario automation platform
New to WhatsAble? [Sign up here](https://dashboard.whatsable.app/signin)
## Get started with WhatsAble
To use the WhatsAble API, you'll need an active subscription:
1. Log in to your WhatsAble dashboard
2. Click the **Subscribe** button
3. Start your 7-day free trial
During your trial, you can add unlimited phone numbers to test the service. After the trial period, pricing is \$8.99 per month per phone number.
For WhatsAble to send messages through your WhatsApp account:
1. In your WhatsAble dashboard, navigate to **Verified Numbers**
2. Click **Add New Number**
3. Enter your phone number (with country code)
4. You'll receive a WhatsApp verification code
5. Enter the verification code in the WhatsAble dashboard
![WhatsAble node selection]()
**Multiple numbers?** You only need to complete the verification process for your first phone number. For additional numbers, simply add them and save—no verification required.
To connect WhatsAble with Make, you'll need your API key:
1. In your WhatsAble dashboard, go to **API Keys**
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![WhatsAble Api Keys]()
## Connect WhatsAble to Make
Now that you have WhatsAble set up, let's connect it to Make to automate your scenarios.
1. Log in to your Make account
2. Create a new scenario by clicking **+ Create a new scenario**
3. (Optional) Add a trigger module of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up a module/trigger Make]()
1. Click the **+** button to add a new module
2. Search for "WhatsAble Message" in the apps or modules library
3. Select the app with the official WhatsAble logo
![Adding the WhatsAble module]()
1. Once you click on WhatsAble module, select **Send a WhatsApp Message** from the **ACTIONS** list
2. Click **Create a connection** in the **Connection** section of WhatsAble module and you will be prompted to enter your API Key
3. Enter your WhatsAble API key that you copied earlier
4. Rename your connection name if needed
5. Click **Save** to store your credential
![Configuring WhatsAble credentials]()
Complete the required fields:
Select the recipient's phone number (In **Your verified WhatsApp number exactly as listed in the dashboard** dropdown, you'll see all phone numbers added in your WhatsAble dashboard's **Verified Numbers** menu.)
Type your message text or use variables from previous steps
Enter publicly accessible media URL for Attachment (image/video/document)
Ensure your attachment URLs is publicly accessible and match the supported file formats.
Specify a custom filename for your attachment
![Configuring message]()
1. Click **Save** to save your message configuration
2. Right click on the WhatsAble module and select **Run this module only** to verify the module is working correctly
* or click **Run once** in the bottom-left corner of the screen to test the entire scenario
3. If the test is successful, you'll see a confirmation message
4. Click **Save** icon in the bottom-left corner to save your scenario (You can also set timer intarval for the scenario)
5. Toggle the **Active** switch in the bottom-left corner with time to activate your scenario
![Testing and activating your scenario]()
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Scenario Diagram
```mermaid theme={null}
flowchart LR
A[Trigger Module] --> B[Data Transformation]
B --> C[WhatsAble Module]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Troubleshooting
Verify that your WhatsAble account is active.
Check that your phone number is properly verified.
Ensure your API key is entered correctly in Make.
Confirm that the recipient's phone number is in the correct format (including country code).
Check that the file size is under 16 MB.
Verify the file type is supported by WhatsApp.
Ensure the file path or URL is accessible.
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the chat button in the bottom right corner of the WhatsAble dashboard
For additional automation platform integrations (Zapier, n8n, etc.), please contact our support team or check our integration documentation.
# n8n
Source: https://docs.whatsable.app/guides/whatsable/n8n
Learn how to automate WhatsApp messaging through n8n with WhatsAble
# WhatsAble Integration with n8n
![]()
WhatsAble lets you automate WhatsApp messaging through your favorite workflow automation platforms. This guide walks you through connecting WhatsAble with n8n to create powerful WhatsApp messaging workflows.
## Prerequisites
Before getting started, make sure you have:
An active subscription with WhatsAble
Access to [n8n](https://app.n8n.cloud/login) workflow automation platform
New to WhatsAble? [Sign up here](https://dashboard.whatsable.app/signin)
## Get started with WhatsAble
To use the WhatsAble API, you'll need an active subscription:
1. Log in to your WhatsAble dashboard
2. Click the **Subscribe** button
3. Start your 7-day free trial
During your trial, you can add unlimited phone numbers to test the service. After the trial period, pricing is \$8.99 per month per phone number.
For WhatsAble to send messages through your WhatsApp account:
1. In your WhatsAble dashboard, navigate to **Verified Numbers**
2. Click **Add New Number**
3. Enter your phone number (with country code)
4. You'll receive a WhatsApp verification code
5. Enter the verification code in the WhatsAble dashboard
![WhatsAble node selection]()
**Multiple numbers?** You only need to complete the verification process for your first phone number. For additional numbers, simply add them and save—no verification required.
To connect WhatsAble with n8n, you'll need your API key:
1. In your WhatsAble dashboard, go to **API Keys**
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![API Key Location]()
## Connect WhatsAble to n8n
Now that you have WhatsAble set up, let's connect it to n8n to automate your workflows.
1. Log in to your n8n account
2. Create a new workflow by clicking **+ New Workflow**
3. Add a trigger node of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
The WhatsAble trigger node enables your workflow to respond automatically to incoming WhatsApp messages. This setup is optional but recommended for building reactive communication flows.
Follow these steps to add the WhatsAble trigger node to your workflow:
1. Click the **+** button in your workflow canvas to add a new node
2. Search for "WhatsAble" in the node library search bar
3. Select the node displaying the official WhatsAble logo
4. From the available trigger options, choose **On new Incoming message event**
![WhatsAble node selection showing trigger options]()
The trigger node will automatically listen for incoming messages and initiate your workflow when a new message is received.
Set up your WhatsAble API credentials to establish a secure connection:
**Webhook URL Configuration:**
1. In the WhatsAble Trigger node parameters, locate the **Webhook URLs** section at the top
2. Select **Production URL** and copy the generated URL by clicking on it
3. Store this URL securely as you'll need it for the credential setup
![Production URL selection and copy interface]()
**Credential Creation:**
1. In the **Credential to connect with** dropdown, click **+ Create new credential**
2. Select **WhatsAble Trigger API** as your connection method
3. Enter your WhatsAble API key in the **API Key** field
4. Paste the Production URL you copied earlier into the **Production URL** field
5. Assign a descriptive name to your credential (e.g., "WhatsAble Production")
6. Click **Save** to securely store your credentials
![WhatsAble credential configuration interface]()
Your API credentials are encrypted and stored securely. Never share your API key publicly or commit it to version control.
Complete the setup by testing and activating your trigger:
**Response Configuration:**
1. In the **Respond** dropdown, select your preferred response timing:
* **Immediately**: Responds as soon as the trigger fires
* **When Last Node Finishes**: Waits for the entire workflow to complete before responding
**Testing:**
1. Click **Execute step** on the WhatsAble node to run a test
2. Verify the connection is working by checking for a success confirmation
3. Review any error messages if the test fails and adjust your configuration accordingly
Once activated, your workflow will automatically process incoming messages according to your configured logic.
Remember to test your workflow thoroughly before activating it in production to ensure it behaves as expected.
1. Click the **+** button to add a new node
2. Search for "WhatsAble" in the node library
3. Select the node with the official WhatsAble logo
4. After selecting the WhatsAble node, choose 'Send message via whatsAble' from the available actions menu
![WhatsAble node selection]()
**Credential Setup:**
1. In the WhatsAble node settings, find the **Credential to connect with** dropdown
2. Select **+ Create new credential**
3. Enter your WhatsAble API key that you copied earlier
4. Name your credential (e.g., "WhatsAble Production")
5. Click **Save** to store your credential
1. In **Resource** dropdown, select **Send Message**
2. In the **Operation** dropdown, select **Send message via WhatsAble**
3. Complete the required fields:
Select the recipient's phone number (with country code) previously added in WhatsAble
Type your message text or use variables from previous nodes
Enter the URL of the file, image, or video you want to send with your message
Specify a custom filename for your attachment
1. Click **Test Step** on the WhatsAble node to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Click **Done** to return to your workflow
4. Click **Save** to save your entire workflow
5. Toggle the **Active** switch in the top-right corner to activate your workflow
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Workflow Diagram
**Sample WhatsAble n8n Workflow:**
```mermaid theme={null}
flowchart LR
A[Trigger Node] --> B[Data Transformation]
B --> C[WhatsAble Node]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Troubleshooting
**Steps to resolve:**
1. **Verify Account Active:** Verify that your WhatsAble account is active.
2. **Phone Number Verification:** Check that your phone number is properly verified.
3. **API Key in n8n:** Ensure your API key is entered correctly in n8n.
4. **Recipient Number Format:** Confirm that the recipient's phone number is in the correct format (including country code).
**Steps to resolve:**
1. **File Size Limit:** Check that the file size is under 16 MB.
2. **Supported File Type:** Verify the file type is supported by WhatsApp.
3. **Accessibility:** Ensure the file path or URL is accessible.
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the chat button in the bottom right corner of the WhatsAble dashboard
For additional automation platform integrations (Make.com, Zapier, etc.), please contact our support team or check our integration documentation.
# Webhooks
Source: https://docs.whatsable.app/guides/whatsable/webhooks
Receive real-time notifications when WhatsApp events happen in your WhatsAble account — configure, manage, and handle webhook endpoints directly from the dashboard.
Webhooks let your external server react to WhatsApp activity the moment it happens — no polling required. Register an HTTPS endpoint once and WhatsAble pushes a JSON payload to it automatically.
***
## WhatsAble Bot vs Notifier System
Before setting up a webhook, make sure you're using the right product for your use case.
| | **WhatsAble Bot (this page)** | **Notifier System** |
| --------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **How it works** | You (or a customer) sends a WhatsApp message **to WhatsAble's number** → triggers your n8n / Make / Zapier scenario | You send WhatsApp messages **from your own WhatsApp Business number** to your leads or customers |
| **Best for** | Building AI agents, personal automation triggers, developer workflows | Customer outreach, marketing, CRM notifications |
| **Webhook direction** | Inbound — WhatsAble calls your endpoint | Inbound — your automation platform receives the event |
If you want to **send** messages to leads or customers from your own WhatsApp Business number, use the [Notifier System](/guides/notifyer-system/embedding-process) instead.
***
## What are Webhooks?
A webhook is an HTTP endpoint you host that WhatsAble calls every time a relevant event occurs in your account. Instead of repeatedly asking *"did anything happen?"*, your server receives a real-time `POST` request with the full event payload the instant the event fires.
Common things you can do with WhatsAble webhooks:
* Trigger n8n, Make, or Zapier scenarios the moment someone messages your WhatsAble bot number
* Build AI agents that react to WhatsApp messages in real time
* Pipe incoming customer messages into your CRM or support desk
* Log chat history to your own database
***
## The Webhooks Dashboard
Navigate to **Operations → Webhooks** (`/operations/webhook`) in your WhatsAble dashboard to manage all your registered endpoints.
| Action | How |
| ----------------- | --------------------------------------------------------------- |
| **Add a webhook** | Click **New Webhook** in the toolbar |
| **Search** | Type in the search bar to filter endpoints by URL |
| **Copy a URL** | Click the copy icon next to any endpoint URL |
| **Delete** | Open the ⋮ menu on any row → **Delete** — requires confirmation |
The **Active Webhooks** counter in the toolbar shows how many endpoints are currently registered in your account.
### Adding a new endpoint
Click **New Webhook** in the top toolbar of the Webhooks page.
Paste the full URL of your server endpoint into the **Endpoint URL** field.
The URL must begin with `http://` or `https://`. HTTPS is strongly recommended for production.
Click **Create Webhook**. WhatsAble stores the endpoint and begins routing eligible events to it immediately.
### Deleting an endpoint
Use the search bar or scroll through the table to locate the endpoint you want to remove.
Click the ⋮ icon in the **Actions** column of that row.
Select **Delete** and confirm in the dialog that appears. Deletion is permanent and cannot be undone.
Deleting a webhook immediately stops all future event deliveries to that endpoint. Make sure nothing critical depends on the endpoint before removing it.
***
## Webhook Data Model
Every webhook you register is stored with the following fields.
Auto-incremented integer that uniquely identifies this webhook within your account. Use it to target specific webhooks in API operations.
The full endpoint URL WhatsAble POSTs events to (e.g. `https://api.example.com/whatsapp/events`). Must be a valid HTTP or HTTPS URL.
UUID of the WhatsAble account that owns this webhook. Set automatically at creation — you cannot assign a webhook to a different account.
ISO 8601 timestamp recording when the webhook was registered. Webhooks are returned in newest-first order by default.
***
## Incoming Webhook Payload
When an event fires, WhatsAble sends an HTTP `POST` to your endpoint with a `Content-Type: application/json` body.
### Incoming message payload
```json Text Message theme={null}
{
"last_messages": [
{
"type": "user",
"content": "Can I reschedule my appointment for Thursday?",
"timestamp": "2025-06-09T22:08:11.990Z",
"content_type": "text"
},
{
"type": "bot",
"content": "Of course! Let me pull up available slots for you.",
"timestamp": "2025-06-09T21:45:30.417Z",
"content_type": "text"
}
],
"conversation_paragraph": "User (10:08:11 PM): Can I reschedule my appointment for Thursday? ; Bot (9:45:30 PM): Of course! Let me pull up available slots for you.",
"phone_number": "14155552671",
"recipient_name": "Alex Martinez",
"user_id": "9232fcef-a570-4a2c-b46b-6cab53aec304",
"last_message_of_user": "Can I reschedule my appointment for Thursday?",
"last_message_of_bot": "Of course! Let me pull up available slots for you.",
"message_type": "text",
"user_last_message_time": 1749506891,
"bot_last_message_time": 1749504330,
"attachment_url": null,
"note": "",
"note_automation": "",
"labels": "appointments, rescheduling"
}
```
```json Media Message (Document) theme={null}
{
"last_messages": [
{
"type": "user",
"content": "",
"timestamp": "2025-06-09T14:05:12.000Z",
"content_type": "document",
"media_url": "https://api.insightssystem.com/vault/contract_v2.pdf"
},
{
"type": "bot",
"content": "Please send the signed contract when ready.",
"timestamp": "2025-06-09T14:03:20.000Z",
"content_type": "text"
}
],
"conversation_paragraph": "User (2:05:12 PM): [Document] ; Bot (2:03:20 PM): Please send the signed contract when ready.",
"phone_number": "14155552671",
"recipient_name": "Alex Martinez",
"user_id": "9232fcef-a570-4a2c-b46b-6cab53aec304",
"last_message_of_user": "",
"last_message_of_bot": "Please send the signed contract when ready.",
"message_type": "document",
"user_last_message_time": 1749472312,
"bot_last_message_time": 1749472200,
"attachment_url": "https://api.insightssystem.com/vault/contract_v2.pdf",
"note": "",
"note_automation": "",
"labels": "contracts"
}
```
### Payload fields
Ordered array of recent messages in the conversation, newest last.
Sender of this message — `"user"` for the customer or `"bot"` for your WhatsAble assistant.
Text body of the message. Empty string for media-only messages (image, video, document, audio).
ISO 8601 UTC timestamp of when this message was sent.
Media type of the message. One of: `text`, `image`, `audio`, `video`, `document`, `location`.
Temporary URL to the media file. Present only when `content_type` is not `text`. URLs expire after **24 hours** — download the file promptly if you need to retain it.
Human-readable plain-text transcript of the recent exchange. Useful for passing directly to an LLM or storing as a summary without parsing the full `last_messages` array.
The WhatsApp phone number of the customer who sent the message (digits only, no `+` prefix).
Display name of the customer as stored in their WhatsApp profile. May be empty if WhatsApp has not provided a name.
UUID of the WhatsAble account that received this message. Matches the `user_id` stored on the webhook registration.
Text of the customer's most recent message. For image, video, and document messages this contains the **caption** if one was provided, otherwise an empty string.
Text of the last message your system sent to this customer.
Type of the **latest** message in the conversation. Same values as `content_type` above: `text`, `image`, `audio`, `video`, `document`, `location`.
Unix timestamp (seconds) of the customer's last message. Use this to calculate response latency or enforce time-based rules.
Unix timestamp (seconds) of your system's last reply to this customer.
URL to the media file if the **latest** message contains media. `null` for text-only messages. Same 24-hour expiry applies.
Free-form text note attached to the conversation. Set manually by agents in Notifyer Chat.
Automation-related notes written by internal workflows. Available for your server to read and act on.
Comma-separated list of labels assigned to the conversation (e.g. `"sales, premium-inquiry"`). Use these to route events to different handlers in your webhook server.
***
## Internal API Reference
The WhatsAble dashboard manages webhooks through three authenticated internal endpoints. All requests require a valid **Bearer** token from the active session.
### List webhooks
```
GET /api/webhooks/get
```
Returns all webhooks registered by the authenticated user, sorted newest first.
**Authentication:** `Authorization: Bearer `
**Response:** Array of webhook objects.
```json theme={null}
[
{
"id": 42,
"created_at": "2025-06-01T10:22:33.000Z",
"webhook": "https://api.example.com/events",
"user_id": "6fb11ff2-d9b2-4560-8437-0fe58ec9f4a6"
}
]
```
***
### Create a webhook
```
POST /api/webhooks/create
```
Registers a new webhook endpoint.
**Authentication:** `Authorization: Bearer `
**Request body:**
Full HTTP or HTTPS URL of your endpoint. Must be a valid URL — invalid formats are rejected with a `400` error.
**Response:**
```json theme={null}
{
"data": {
"id": 43,
"created_at": "2025-06-09T12:00:00.000Z",
"webhook": "https://api.example.com/events",
"user_id": "6fb11ff2-d9b2-4560-8437-0fe58ec9f4a6"
}
}
```
**Error codes:**
| Status | Meaning |
| ------ | -------------------------------------------------- |
| `400` | `webhook` field missing, empty, or not a valid URL |
| `401` | No valid session token provided |
| `500` | Database error — retry after a short delay |
***
### Delete a webhook
```
DELETE /api/webhooks/delete?id={id}
```
Permanently removes a webhook. The server verifies ownership before deleting — you cannot delete another account's webhooks.
**Authentication:** `Authorization: Bearer `
**Query parameter:**
| Parameter | Type | Required | Description |
| --------- | ------ | -------- | --------------------------------- |
| `id` | number | Yes | The `id` of the webhook to delete |
**Response:**
```json theme={null}
{ "success": true }
```
**Error codes:**
| Status | Meaning |
| ------ | ----------------------------------------------------- |
| `400` | `id` query parameter not provided |
| `401` | No valid session token |
| `403` | The webhook exists but belongs to a different account |
| `404` | No webhook found with the given `id` |
| `500` | Database error |
***
## Going to Production
When you're done testing and ready to go live, follow these steps to switch from your test webhook URL to your production endpoint.
**Do not edit your existing test credential.** Editing a credential that was used for testing can break the connection. Always create a new credential for production.
In your automation tool (n8n, Make, etc.), pin the sample payload you received during testing. This keeps the data structure available to configure downstream nodes even after you swap the endpoint.
In your automation platform, switch to the **Production** URL for your trigger node and copy it.
In WhatsAble, go to **Operations → Webhooks** and click **New Webhook**. Paste the production URL and save.
In your automation tool, create a **new credential** (e.g. `WhatsAble Bot – Production`) rather than overwriting the test credential. Enter the production webhook URL and your API key, then save.
In your automation trigger node, switch the credential selection from the test credential to the new production one. Your workflow is now live.
Keep your test credential and test webhook intact — you'll want them next time you need to iterate or debug without touching the live flow.
***
## Endpoint Requirements
Your endpoint must respond with a `2xx` HTTP status code within **10 seconds**. Responses outside that window are treated as failures.
Your webhook server must:
1. Accept `HTTP POST` requests
2. Parse `application/json` request bodies
3. Respond with `200 OK` (or any `2xx`) promptly to acknowledge receipt
4. Be publicly reachable — `localhost` and private network addresses will not work
5. Use **HTTPS** in production environments
***
## Best Practices
Always verify webhook signatures and use HTTPS endpoints. HTTP may be acceptable for local development only. WhatsAble shows a reminder banner on the webhook page: *"Always verify webhook signatures and use HTTPS endpoints for secure communication."*
Return `200 OK` immediately, then process the payload in a background job or queue. Long-running synchronous handlers risk timing out before the work is done.
Network retries can cause the same event to arrive more than once. Use the `user_last_message_time` + `phone_number` combination as an idempotency key to detect and skip duplicates.
`attachment_url` and `media_url` inside `last_messages` expire after **24 hours**. Download and store media files as soon as you receive the webhook — do not rely on the URL remaining valid later.
Use the `labels` field and `message_type` to dispatch events to different handlers. For example, route `"document"` types to a contract-processing queue and messages labelled `"support"` to your helpdesk integration.
Store the raw payload for every incoming event before processing it. Logs are invaluable for debugging and replaying missed events.
***
## Example Handler
```javascript Node.js / Express theme={null}
const express = require('express');
const app = express();
app.use(express.json());
app.post('/webhook', (req, res) => {
// Acknowledge immediately
res.status(200).send('OK');
// Process asynchronously
const payload = req.body;
const { phone_number, message_type, last_message_of_user, labels } = payload;
console.log(`New ${message_type} from ${phone_number}: "${last_message_of_user}"`);
if (message_type === 'document' || message_type === 'image') {
// Download media before the 24-hour URL expires
downloadMedia(payload.attachment_url);
}
if (labels?.includes('support')) {
forwardToHelpdesk(payload);
}
});
app.listen(3000);
```
***
## Troubleshooting
This is the **most common issue** when setting up the WhatsAble bot trigger. When configuring the WhatsApp trigger node in n8n or Make, you must explicitly select **Incoming Messages** as the event type. The option can be easy to miss, especially if the interface has changed recently.
**What to check:**
1. Open the trigger node settings in your automation tool
2. Look for an event type or trigger type selector
3. Make sure **Incoming Messages** (or equivalent) is selected — not "All Events" or left blank
4. Save and re-activate the trigger
If it still doesn't fire after sending a test message, move on to the duplicate webhook check below.
Before spending more time debugging, open **Operations → Webhooks** in the WhatsAble dashboard and check how many webhooks you have registered. It's easy to accumulate duplicate entries from previous test attempts. Multiple webhooks registered to different URLs (or stale test URLs) can cause unexpected behaviour.
**Fix:** Delete any old or duplicate webhook entries, keep only the one that matches your current trigger URL, then test again.
* Confirm the endpoint is publicly accessible (not `localhost` or behind a firewall)
* Check your server logs for incoming `POST` requests
* Verify the webhook is listed and saved correctly in the dashboard
* Ensure your server returns a `2xx` response — otherwise deliveries may be dropped
`attachment_url` and `media_url` values are temporary and expire within **24 hours** of generation. If you receive a 404, the file has expired. Download media immediately on receipt and store it in your own storage.
The `DELETE` endpoint enforces ownership checks. You can only delete webhooks that belong to the currently authenticated user. Make sure you are using the correct account session token.
WhatsAble may redeliver events if your server did not respond with a `2xx` in time. Build idempotency into your handler using `phone_number` + `user_last_message_time` as a composite key.
***
## Next steps
Explore the full WhatsAble REST API for sending messages, managing contacts, and more.
Connect WhatsAble to Zapier, Make, n8n, and other automation platforms.
# Zapier
Source: https://docs.whatsable.app/guides/whatsable/zapier
Learn how to automate WhatsApp messaging through Zapier with WhatsAble
# WhatsAble Integration with Zapier
![]()
WhatsAble lets you automate WhatsApp messaging through your favorite workflow automation platforms. This guide walks you through connecting WhatsAble with Zapier to create powerful WhatsApp messaging workflows.
## Prerequisites
Before getting started, make sure you have:
An active subscription with WhatsAble
Access to [Zapier](https://zapier.com/sign-up) workflow automation platform
New to WhatsAble? [Sign up here](https://dashboard.whatsable.app/signin)
## Get started with WhatsAble
To use the WhatsAble API, you'll need an active subscription:
1. Log in to your WhatsAble dashboard
2. Click the **Subscribe** button
3. Start your 7-day free trial
During your trial, you can add unlimited phone numbers to test the service. After the trial period, pricing is \$8.99 per month per phone number.
For WhatsAble to send messages through your WhatsApp account:
1. In your WhatsAble dashboard, navigate to **Verified Numbers**
2. Click **Add New Number**
3. Enter your phone number (with country code)
4. You'll receive a WhatsApp verification code
5. Enter the verification code in the WhatsAble dashboard
![WhatsAble node selection]()
**Multiple numbers?** You only need to complete the verification process for your first phone number. For additional numbers, simply add them and save—no verification required.
To connect WhatsAble with Zapier, you'll need your API key:
1. In your WhatsAble dashboard, go to **API Keys**
2. Copy your unique API key
3. Store it securely—you'll need it for the integration
Never share your API key publicly or commit it to version control systems.
![WhatsAble Api Keys]()
## Connect WhatsAble to Zapier
Now that you have WhatsAble set up, let's connect it to Zapier to automate your workflows.
1. Log in to your Zapier account
2. Create a new Zap by clicking **+ Create** and select **Zaps**/**New Zap**
3. Add a trigger step of your choice:
* Popular triggers include Google Forms, Jotform, ClickUp, or a Schedule trigger
* Connect and configure your trigger according to your use case
![Setting up Zapier Zaps]()
1. Select the next **Action** step or click the **+** button to add a new step
2. Search for "WhatsAble" in the apps and tools library
3. Select the app with the official WhatsAble logo
![Adding the WhatsAble app]()
1. In the WhatsAble app Setup, select **Send WhatsApp Message** in the **Action event** dropdown
2. Click **Sign In** in the **Account** field and you will be prompted to enter your API Key
3. Enter your WhatsAble API key that you copied earlier
4. Click **Yes, Continue to WhatsAble** to store your credential
5. Next, click the **Continue** button in the Setup screen to proceed to the **Configure** section
![Configuring WhatsAble credentials]()
Complete the required fields:
Select the recipient's phone number (In the **Phone** dropdown, you'll see all phone numbers added in your WhatsAble dashboard's **Verified Numbers** menu.)
Type your message text or use variables from previous steps
Enter public URL of a file, image, or video to send with your message
Specify a custom filename for your attachment
![Configuring message]()
1. Click **Continue** and then click **Test step** in the **Test** to verify it's working correctly
2. If the test is successful, you'll see a confirmation message
3. Click **Publish** to save your entire Zap
4. Toggle the **Active** switch in the top-left corner to activate your Zap
## Example use cases
Send a welcome message when a new customer signs up
Update customers when their order status changes
Automatically send reminders before scheduled appointments
Send personalized messages to new leads from your form submissions
Notify customers when their support ticket status changes
## Workflow Diagram
```mermaid theme={null}
flowchart LR
A[Trigger Node] --> B[Data Transformation]
B --> C[WhatsAble App]
C --> D{Message Sent?}
D -->|Yes| E[Success Path]
D -->|No| F[Error Handling]
E --> G[Additional Actions]
F --> H[Retry Logic]
```
## Troubleshooting
Verify that your WhatsAble account is active.
Check that your phone number is properly verified.
Ensure your API key is entered correctly in Zapier.
Confirm that the recipient's phone number is in the correct format (including country code).
Check that the file size is under 16 MB.
Verify the file type is supported by WhatsApp.
Ensure the file path or URL is accessible.
## Need help?
Our support team is ready to assist you:
Contact [team@whatsable.app](mailto:team@whatsable.app)
Book a personalized walkthrough
Click the chat button in the bottom right corner of the WhatsAble dashboard
For additional automation platform integrations (Make.com, n8n, etc.), please contact our support team or check our integration documentation.
# Introduction
Source: https://docs.whatsable.app/index
Enterprise-grade WhatsApp automation solutions for business communication
WhatsApp Automation for Every Business
Automate your WhatsApp business communication with the WhatsAble family of products. From team notifications to customer engagement, we've built specialized solutions to power your WhatsApp workflows.
One Platform, Two Solutions
Choose the perfect WhatsAble solution based on your specific business requirements and communication needs.
Internal Communication
Team notifications and alerts with per-number pricing.
Enterprise Communication
Unlimited customer messaging with your business identity.
Seamless Integration
Connect with your favorite automation platforms to build powerful communication workflows without writing a single line of code.
Key Features
WhatsAble provides powerful features to transform how you engage with your customers and streamline business communication.
Create, save, and reuse approved message templates for consistent communication across all your channels.
Track delivery rates, open rates, and user engagement metrics with beautiful real-time dashboards.
Set up powerful triggers and actions to automate your entire customer communication journey.
Choose Your Solution
Compare our offerings to find the perfect WhatsAble solution that aligns with your business goals and communication needs.
| Features |
WhatsAble |
Notifyer System |
| Best For |
Internal teams |
Professional business with own brand |
| Messages |
Unlimited |
Unlimited |
| Identity |
WhatsAble |
Your business |
| Pricing |
Subscription |
Subscription
Pay-as-you-go |
# Introduction
Source: https://docs.whatsable.app/introduction
Enterprise-grade WhatsApp automation solutions for business communication
WhatsApp Automation for Every Business
Automate your WhatsApp business communication with the WhatsAble family of products. From team notifications to customer engagement, we've built specialized solutions to power your WhatsApp workflows.
One Platform, Two Solutions
Choose the perfect WhatsAble solution based on your specific business requirements and communication needs.
Internal Communication
Team notifications and alerts with per-number pricing.
Enterprise Communication
Unlimited customer messaging with your business identity.
Seamless Integration
Connect with your favorite automation platforms to build powerful communication workflows without writing a single line of code.
Key Features
WhatsAble provides powerful features to transform how you engage with your customers and streamline business communication.
Create, save, and reuse approved message templates for consistent communication across all your channels.
Track delivery rates, open rates, and user engagement metrics with beautiful real-time dashboards.
Set up powerful triggers and actions to automate your entire customer communication journey.
Choose Your Solution
Compare our offerings to find the perfect WhatsAble solution that aligns with your business goals and communication needs.
| Features |
WhatsAble |
Notifyer System |
| Best For |
Internal teams |
Professional business with own brand |
| Messages |
Unlimited |
Unlimited |
| Identity |
WhatsAble |
Your business |
| Pricing |
Subscription |
Subscription
Pay-as-you-go |
# WhatsAble Suite with n8n
Source: https://docs.whatsable.app/n8n-overview
Integrate n8n with the WhatsAble Suite (WhatsAble and Notifyer System) for powerful messaging automation
# WhatsAble Suite Integration with n8n
![]()
The WhatsAble Suite offers a comprehensive set of messaging tools that integrate seamlessly with n8n, enabling powerful automation workflows for businesses of all sizes.
## Overview
The WhatsAble Suite comprises powerful messaging platforms—WhatsAble and Notifyer System—each designed to meet different business needs while integrating perfectly with n8n's workflow automation capabilities.
This guide introduces the WhatsAble Suite and its integration with n8n, helping you select the right platform from the suite for your specific business requirements.
## The WhatsAble Suite
The WhatsAble Suite consists of complementary messaging platforms that integrate with n8n, each designed for different business needs:
WhatsAble
The WhatsAble Bot seamlessly delivers important notifications and alerts to you and your team members, ensuring everyone stays informed.
Notifyer System
Our most comprehensive solution, the Notifyer System provides complete messaging capabilities for businesses seeking to communicate with customers and leads while maintaining professional branding.
# Why Choose WhatsAble?
Reliable and secure integration with WhatsApp, backed by Meta's approval.
Send customized WhatsApp messages in real-time with powerful automation.
Flexible integration options for both developers and non-technical users.
Send alerts, confirmations, reminders, and team updates efficiently.
## Choosing the Right Platform from the Suite
Selecting the optimal platform from the WhatsAble Suite depends on your specific business requirements:
## WhatsAble Suite Comparison
| Feature |
WhatsAble |
Notifyer System |
| Target Business Size |
Small & Startups |
Enterprise |
| n8n Integration Ease |
Very Simple |
Moderate |
| Business Verification |
Not Required |
Full Official Verification |
| Message Templates |
No |
Advanced |
| Media Support |
Basic |
Advanced |
| Pricing Model |
Subscription |
Enterprise Pricing |
| Free Trial |
7 days |
Contact Sales |
## Integrating the WhatsAble Suite with n8n
Both platforms in the WhatsAble Suite integrate with n8n through a similar workflow pattern:
Create and configure your account on your chosen WhatsApp platform.
Complete the required verification steps for your WhatsApp number.
Generate an API key from your platform's dashboard.
Add the platform's node in n8n and enter your API credentials.
Design your automation workflow with triggers and actions.
Test your workflow configuration and activate it for production use.
## Common Use Cases
Send automated follow-up messages to new leads based on form submissions or website interactions.
Keep customers informed at every stage of their order from confirmation to delivery.
Reduce no-shows with automated appointment reminders and confirmations.
Route support requests to the right team members and provide instant responses to common questions.
Send timely payment reminders for invoices and subscriptions.
Gather customer feedback after purchases or service interactions.
## Sample Workflow: Order Confirmation with WhatsAble Suite
Here's how a simple order confirmation workflow might look using the WhatsAble Suite with n8n:
```mermaid theme={null}
flowchart LR
A[Order Placed Trigger] --> B[Get Order Details]
B --> C[Format Message]
C --> D{Select Suite Platform}
D -->|WhatsAble| E[WhatsAble Node]
D -->|Notifyer System| G[Notifyer System Node]
E --> H[Send Confirmation]
G --> H
H --> I[Update Order Status]
```
## Best Practices
- Keep messages concise and focused on a single call-to-action
- Personalize content with customer names and order details
- Use emojis sparingly for emphasis, not decoration
- Include clear opt-out instructions in marketing communications
- Avoid sending multiple messages in quick succession
- Add error handling for failed message delivery
- Include conditional logic for different customer segments
- Test thoroughly with sample data before activating
- Configure appropriate retry logic for temporary failures
- Document your workflow design for future reference
- Ensure you have explicit consent before messaging customers
- Follow WhatsApp's Business Policy for all communications
- Provide clear opt-out mechanisms in your messaging
- Store customer data securely and in compliance with privacy regulations
- Keep records of consent for compliance purposes
## Getting Started with the WhatsAble Suite
Ready to enhance your messaging capabilities with the WhatsAble Suite and n8n? Follow our platform-specific integration guides:
Quick setup with personal numbers - ideal for small businesses and solopreneurs looking for simple integration.
Enterprise-grade messaging solution with advanced template capabilities and robust API features.
## Need Help Choosing?
Schedule a WhatsAble Suite Demo
Not sure which platform in the WhatsAble Suite is right for your business? Our experts can help you make the right choice.
Book a Free Consultation
## FAQ
It depends on which platform in the WhatsAble Suite you choose:
- WhatsAble: Works with regular numbers - no business account required
- Notifyer System: Requires complete business API integration
The WhatsAble Suite integrates with n8n through dedicated nodes:
- Each platform has its own dedicated node in the n8n library
- API credentials from your chosen platform are required for connection
- Once connected, you can trigger messaging actions from any n8n workflow
- All platforms support dynamic variables from previous nodes in your workflow
All platforms in the WhatsAble Suite support standard media types when integrated with n8n:
- Images: JPG, PNG (up to 5MB)
- Videos: MP4, 3GP (up to 16MB)
- Documents: PDF, DOC, XLSX, etc. (up to 100MB)
- Audio: MP3, OGG, etc.
Yes, all platforms in the WhatsAble Suite support dynamic content from n8n workflows:
- WhatsAble: Use variables directly in message content with no restrictions
- Notifyer System: Offers template variables for approved templates and regular variables for non-template messages
## WhatsAble Suite Support Resources
Need help with your n8n integration with the WhatsAble Suite? We've got you covered:
Contact our dedicated support team for technical assistance with any platform in the WhatsAble Suite
Watch step-by-step integration guides for connecting n8n with the WhatsAble Suite
Get expert assistance with implementing your n8n workflows with the WhatsAble Suite
Looking for custom integration solutions or enterprise-level support? Contact our solution engineers at [team@whatsable.app](mailto:team@whatsable.app) for personalized assistance with the WhatsAble Suite.
# Get Started with WhatsAble for monday.com
Source: https://docs.whatsable.app/onboarding/get-started-with-whatsable
Connect WhatsApp Business to your monday boards—from install and Meta setup to templates, workflows, and Live Chat. Includes video walkthrough and free setup offer.
# WhatsAble + monday.com
WhatsAble connects WhatsApp Business to your monday boards. This guide takes you from zero to a working WhatsApp automation inside monday.
If you’d rather we set this up for you, [**book a free setup call**](https://tidycal.com/axelmeta/whatsapp-notifications-by-whatsable)—included for all customers, even during the free trial.
***
## Quick setup (3 steps)
Go to [**whatsable.app**](https://www.whatsable.app) and create your account
Connect your WhatsApp Business number through WhatsAble and Meta—the detailed steps are in **[Connect your WhatsApp Business number](#2-connect-your-whatsapp-business-number-with-meta-through-whatsable)** below.
Install WhatsAble from the monday marketplace, then build workflows and use **Live Chat** on your boards. Follow the **[Step-by-step walkthrough](#step-by-step-walkthrough)** from the beginning.
**Full video walkthrough:** [**Watch on YouTube**](https://youtu.be/3cc4uvtF7AY) (same embedded video above).
***
## Step-by-step walkthrough
### 1. Install WhatsAble on monday
In the [monday marketplace](https://monday.com/marketplace), click **Install WhatsAble**. This opens monday and asks for permission to install.
![monday marketplace install permission dialog for WhatsAble]()
There is a **second step** right after: click **Authorize**. Both steps are needed—if you skip authorization, the integration will not work.
Continue through the authorize flow until it completes.
![Authorize WhatsAble Notifyer integration in monday.com]()
**What you’ll see if authorization is still pending:** When you open the **WhatsAble Live Chat** tab on any board item, you may see a screen asking you to **Connect WhatsAble Notifyer**. Click **Open authorization** to finish. If a new tab does not open, click **Retry session**.
![WhatsAble successfully connected confirmation in monday.com]()
Once authorized, you’ll see a confirmation such as **“Connected successfully to monday.”**
### 2. Connect your WhatsApp Business number with Meta (through WhatsAble)
Inside WhatsAble, click [**Connect WhatsApp**](https://notifyer.whatsable.app/onboarding/whatsapp-connection) and follow the flow through **Step 2**.
You can skip or ignore prompts to **subscribe** at first—keep going until **Step 2**, where you’ll see the green **Connect your WhatsApp number** [**button**](https://notifyer.whatsable.app/onboarding/whatsapp-connection).
**If your number is not connected yet:** The **WhatsAble Live Chat** tab can show a WhatsApp setup screen with a green **Open WhatsApp connection** button. Click it to start the Meta connection flow; if nothing opens in a new tab, use **Retry session**.
![WhatsAble Connect WhatsApp step before redirect to Meta]()
When you click it, you’ll be sent to Meta to log into your Facebook Business portfolio. From there:
1. **Select your business portfolio**.
2. **Choose** your existing WhatsApp Business Account, or **create** a new one.
3. **Select (or create) a Facebook page**—you don't need to actively use it, it just needs to exist
4. **Select an ad account**.
5. **Choose how to attach a number:**
* **Option A:** Use a number WhatsApp provides for you (no number of your own needed)
* **Option B:** **Connect your existing WhatsApp Business number**—either select it if it's already linked, or enter it manually and scan the QR code.
### 3. Add a payment method (do not skip)
WhatsApp messaging from the Cloud API normally requires a **billing method on the WhatsApp side**. Many people skip this—and then sends fail.
![Meta Business settings—add payment method for WhatsApp account]()
Typical places to add payment in Meta:
* Open [**business.facebook.com**](https://business.facebook.com/), go to **Settings** (often bottom-left) → **Accounts** → **WhatsApp accounts** → select your **Phone number** → open **Summary** and scroll to **Payment settings** → **Add payment method**.
* Alternatively, explore **Billing** / **Payments** sections in Meta Business Suite or Business Settings until you locate **payment method for WhatsApp** (UI labels change over time).
If Meta **rejects your card**, contact [**team@whatsable.app**](mailto:team@whatsable.app)—we’ll help troubleshoot.
Even if you already have a payment method for **Ads**, you may still need one **explicitly tied to WhatsApp** / conversation-based billing depending on how your Meta account was set up.
![Meta Business payment menu for WhatsApp conversation-based billing]()
### 4. Create your first template
A template is the message format WhatsApp uses when you send something from monday. For example: a welcome message when a lead’s status changes to "Qualified."
To create one:
1. Go to the template area ([**click here**](https://notifyer.whatsable.app/create-template)).
2. Give your template a name.
3. Leave the category as **Marketing** (unless it’s a transactional notification, then use **“Utility”**).
4. Write your message. To insert dynamic fields like a contact’s name, click **Add variable** — for example: `Hi {{1}}, thank you for your interest in {{2}}.`
5. Add **example values** so Meta understands what the variables represent (e.g. **“Alex”** for name, **“Product Name”** for product).
6. Optionally add **buttons** — quick replies like **“Yes, I want info”** or URL buttons that can be static or dynamic per contact.
7. Click **Submit for approval**.
![Notifyer WhatsApp template creation menu]()
Meta usually approves templates in under a minute. After being approved, the template will appear in your Monday workflow.
### 5. Set up your AI agent (optional)
WhatsAble can run an AI agent beside human replies:
* Give it a **name** (for example **“Lead qualifier”**).
* Describe your **business mission** and paste **product / FAQ knowledge**.
* Define **human handoff** rules—for example *“If a customer mentions a deal over \$5 000, notify a human.”*
When handoff fires, Notifyer/WhatsAble can notify you (**Notifyer by WhatsAble** mobile apps on [**iOS**](https://apps.apple.com/es/app/notifyer-by-whatsable/id6743722183?l=en-GB) and [**Android**](https://play.google.com/store/apps/details?id=com.chatmobile.chat_mobile)).
The agent can also **follow up proactively** when a conversation goes quiet—within the rules you set.
### 6. Invite your team
You can [**add team members and control what they see**](https://notifyer.whatsable.app/role-management):
| Access type | Meaning |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **All labels** | Sees every conversation you grant them. |
| **Specific labels** | Only conversations with certain labels—useful when routing by region, product line, or role. Conversations can be **auto-assigned** by label rules according to how you configure the product. |
Access can be changed at any time.
[**Video tutorial here**](https://youtu.be/3cc4uvtF7AY)
### 7. Build your monday workflows
Inside any board, click **+** on the workflows area and compose automations.
#### Outbound: send WhatsApp when monday changes
**Example:** when a lead’s **status** becomes **Qualified**:
1. **Trigger:** Status changes to → **Qualified**.
2. **Action:** Search for **WhatsAble** → **Send WhatsApp message** (or equivalent).
3. Pick your **approved template**.
4. **Map columns:** name variable ← name column; **recipient / phone** ← phone column (field names vary by recipe).
5. **Publish.**
![monday automation workflow Publish step with WhatsAble send message]()
#### Inbound: Update monday when WhatsApp activity happens
WhatsAble gives you three inbound triggers:
| Trigger | Use case |
| ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| When you send a message to a new WhatsApp contact | You messaged someone new (e.g. a Facebook Lead Ads contact). Use this to create a new monday item. |
| When you send or receive any WhatsApp message | Use this to log every message into the activity tab of the matching monday item. Pair it with Find matching item (by phone number) to update the right record. |
| When you receive a WhatsApp message from a new number | An inbound lead messages you and isn't in monday yet. Use this to auto-create a new item. |
For "find matching item," select your board and use the phone field to match. Then choose what happens if the item is found or not found.
![monday WhatsAble inbound workflow with find matching item by phone field]()
### 8. See WhatsApp messages directly inside any monday item
This is one of the most useful parts of WhatsAble. Every WhatsApp message your team sends or receives gets logged into the Updates section of the matching monday item — so you have full conversation history right next to the lead's details.
When you open any item, you'll see entries like "Last message by Axel Meta: hi" or "Last message by: Delivery Feedback Request — Hi Joe Harris, could you please give us a feedback…" — with the exact date, time, and the team member or template that sent it. You can like, reply, and mention teammates on each message just like any other monday update.
![monday item Updates section showing WhatsAble WhatsApp message history]()
### 9. Use the Live Chat view inside monday
For active, two-way conversations, go to **My Work** in monday and expand the sidebar. You'll see **WhatsAble Live Chat** as a tab.
Click it — no extra login needed — and you can read and reply to every WhatsApp conversation right inside monday. AI replies are labeled as AI; human replies show which team member sent them.
You can also open the Live Chat as a tab on any individual item (next to Updates, Files, and Activity Log) to see only that contact's conversation.
![monday board item WhatsAble Live Chat tab next to Updates and Files]()
***
## What you can do
* Send **WhatsApp messages automatically from monday boards**
* Get notified when a contact replies
* **Sync contacts & messages** between WhatsApp and monday
* View full WhatsApp conversations inside any board item — no extra login needed
* See every WhatsApp message logged in the Updates section of each item, with full team attribution
* Run an AI agent that qualifies leads and follows up automatically
* Bulk-message contacts by uploading a CSV (broadcasting)
* Reply on the go with our iOS and Android apps
* Connect with Zapier, Make, or n8n for deeper workflows
* See message analytics and access API keys for custom integrations
***
## Helpful Resources
📖 Documentation: [docs.whatsable.app](https://docs.whatsable.app)
🎬 YouTube tutorials: [youtube.com/@TheWhatsAutomator](https://www.youtube.com/@TheWhatsAutomator)
📧 Support: [team@whatsable.app](mailto:team@whatsable.app)
📅 Free setup call: [Book a session](https://tidycal.com/axelmeta/whatsapp-notifications-by-whatsable)
***
## Need help?
Chat with us directly on [whatsable.app](https://www.whatsable.app) — click the green button in the bottom right corner.
Setup help is completely free for all customers, including during your free trial. If you'd rather have us configure your templates and workflows for you, just [book a call](https://tidycal.com/axelmeta/whatsapp-notifications-by-whatsable).
# Quickstart
Source: https://docs.whatsable.app/quickstart
Start sending automated WhatsApp messages in under 5 minutes
## Getting Started with WhatsAble
WhatsAble offers two straightforward options to integrate our communication tools into your business workflow:
### Option 1: No-Code Integration Platforms
Connect WhatsAble to your existing tools without writing a single line of code using our seamless integration with popular automation platforms:
Create powerful workflows linking WhatsAble with over 1,000 apps
Automate message sending based on triggers from 3,000+ connected applications
Leverage this open-source automation tool for custom workflow creation with WhatsAble
### Option 2: Direct API Access
For developers and businesses requiring custom solutions, our robust API provides complete control:
* RESTful API: Simple HTTP requests to send and manage WhatsApp messages
* Comprehensive Documentation: Detailed endpoints, parameters, and example requests
* Authentication: Secure API key authentication for all requests
* Webhooks: Receive real-time notifications for message delivery and responses
Our API documentation includes code examples in popular programming languages to help you integrate WhatsAble functionality directly into your applications.
Choose the option that best fits your technical capabilities and business requirements to start sending WhatsApp messages through the WhatsAble platform today.
```
## Embeds and HTML elements