Forem: WhatsApp API for developers

Building WhatsApp Automation with n8n Cloud: Complete Integration Guide

WhatsApp API for developers — Wed, 03 Sep 2025 09:46:38 +0000

Learn how to integrate Whapi.Cloud with n8n Cloud using HTTP requests to build powerful WhatsApp automation workflows. This comprehensive guide covers everything from receiving webhooks and sending messages to creating groups, managing channels, and building community engagement tools directly from your n8n Cloud workflows.

Note: This guide focuses on integrating Whapi.Cloud via HTTP requests in n8n Cloud. If you're using Self-Hosted n8n, we offer a dedicated custom module for seamless integration. Learn more here → Custom Node for n8n

Prerequisites

To follow this guide, you'll need:

An active Whapi.Cloud account and your channel's API Token (available in your Whapi.Cloud dashboard). For detailed token setup instructions, refer to: Getting Started
An active n8n Cloud account with workflow creation permissions.

Ensure both accounts are properly configured before proceeding.

Step 1: Setting up Webhook in n8n

In your n8n Cloud workflow, add a new Webhook node.

Configure the node by selecting POST as the HTTP method. Copy the generated Webhook URL provided by n8n.

Navigate to your Whapi.Cloud channel settings and paste the copied URL into the webhook URL field. Enable the events you wish to receive (e.g., incoming messages, group updates, channel activities).

Your Whapi.Cloud events (new messages, group interactions, community updates) will now trigger this Webhook node in n8n.

Step 2: Receiving Messages in n8n

Ensure your Webhook node in n8n is active and configured for POST requests.
Send a test message to your connected WhatsApp number.
The Webhook node in n8n will capture the incoming message instantly.
Inspect the received JSON payload to understand its structure for further workflow automation.

Example JSON payload

You can view all examples of incoming callbacks here: Incoming webhooks format

Example JSON payload:

{
  "messages": [
    {
      "id": "p.w30M7fgwWD4XwHu.g4CA-gBgTwl0rVw",
      "from_me": false, // Please note this parameter, which allows you to understand whether the message is incoming or outgoing. In the future, we will filter webhooks based on this parameter.
      "type": "text",
      "chat_id": "919984351847@s.whatsapp.net",
      "timestamp": 1712995245,
      "source": "mobile",
      "text": {
        "body": "Hello world"
      },
      "from": "919984351847",
      "from_name": "Gerald"
    }
  ],
  "event": {
    "type": "messages",
    "event": "post"
  },
  "channel_id": "MANTIS-M72HC"
}

Step 3: Sending Messages from n8n

Add an HTTP Request node to your n8n workflow. To do this, select Core, then HTTP Request.

Configure the HTTP Request node as follows: You will need to use the correct request configuration from the Whapi.Cloud documentation. Examples and convenient documentation with examples can be found here: API Docs

HTTP Method: POST
URL: https://gate.whapi.cloud/messages/text

Information for the request can be easily obtained from our docs.

Authentication:
To authorize, you will need to select Bearer Auth in the Credential Type field. After that, enter and save your channel token from Whapi.Cloud.
In the Body section, select RAW / JSON and enter:

{
  "to": "recipient_number",
  "body": "Hello from n8n and Whapi.Cloud!"
}

Replace "recipient_number" with the recipient's WhatsApp number (international format, no +).

You can specify either the recipient's number in international format or the chat ID. It doesn't matter which one you use. For more information about what a chat ID is, see: Chat ID. What is it and how to get it?

Building a WhatsApp Bot with Message Filtering

So far, we've covered the basic setup of connecting the WhatsApp API to n8n, allowing you to receive incoming messages and send messages to any number — including groups, channels, and community members.

Now let's explore a common use case: building an automated bot in WhatsApp. In this scenario, you typically want the bot to respond only to incoming messages, and ignore outgoing ones to avoid loops.

To achieve this, you'll need to filter incoming webhooks. Let's add a Filter node to your workflow.

Your goal is to distinguish incoming messages from outgoing ones. This can be done by checking the from_me parameter in the webhook payload:

from_me = true → the message was sent by you (outgoing)
from_me = false → the message was received from the user (incoming)

By filtering for from_me = false, your bot will respond only to actual user messages and won't react to its own replies. Make sure to set the data type to Boolean when configuring the filter, as shown in the example below.

Creating WhatsApp Groups and Managing Communities via n8n

Now let's walk through how to create a new WhatsApp group and send a message to it - along the way, we'll highlight a few important details for community management.

To create a group, use the Create Group endpoint. You can find the full documentation here: 👉 https://whapi.readme.io/reference/creategroup

In n8n, add an HTTP Request node:

Set the method to POST
URL: https://gate.whapi.cloud/groups
Add your channel's Authorization Bearer Token to the headers

Now let's review the required parameters:

subject: the name of the group
participants: an array of phone numbers (as strings) to be added to the group during creation

The easiest way to pass the participants array is by selecting "Specify Body → Using JSON" in the HTTP node. This allows you to enter the full JSON payload directly in the body. (There is also a more advanced method using a Set node to build the array dynamically, but we won't cover that here.)

You can copy a ready-to-use JSON body directly from our documentation: https://whapi.readme.io/reference/creategroup. This helps avoid issues with extra line breaks or formatting.

After sending the request, the response will include full details of the newly created group. Make sure to save the **group_id**, as you'll need it later in the to parameter when sending messages to the group.

Also note the optional field unprocessed_participants. This indicates which numbers could not be added to the group. To understand why this may happen and how to avoid it, see our guide: Why aren't participants being added to the group?

Unlock advanced WhatsApp features in n8n

With Whapi.Cloud and n8n, you can extend your automation to include:

Group Management: Add/remove participants, update group settings, manage admin roles
Channel Operations: Create and manage WhatsApp channels for broadcasting
Community Engagement: Automate responses, schedule announcements, and manage member interactions
Analytics Integration: Track message delivery, engagement rates, and community growth

Need help getting started? We will tell you exactly how to create the scenario you need or help you find a mistake. Our support team is always here to assist you: https://whapi.cloud/n8n-whatsapp-integration

Optimize your WhatsApp bot development with WhatsApp API PHP SDK

WhatsApp API for developers — Mon, 23 Dec 2024 07:31:46 +0000

Unlock the Power of WhatsApp API with the PHP SDK from Whapi.Cloud

Streamline your WhatsApp bot development with the Whapi.Cloud PHP SDK, a comprehensive toolkit designed to simplify integration and automate messaging workflows. Whether you’re sending messages, managing groups, or creating advanced customer interactions, this SDK empowers developers to build robust, scalable solutions with ease.

Why Choose the Whapi.Cloud PHP SDK?

No Number Migration Required: Use your existing number without the need to migrate.
Simple Integration: Connect any number via QR code for quick testing.
Effortless Webhook Setup: Configure webhooks for real-time messaging with just a few clicks.
Comprehensive Functionality: Send and receive text, media, files, locations, polls, and more across personal and group chats.

Getting Started

1. Obtain Your API Token

Register and log in to your Whapi.Cloud Dashboard to authorize your number and generate an API token. This token will serve as the key to unlocking the SDK’s capabilities.

2. Download the SDK

Access the PHP SDK directly from the official GitHub repository: Download Here.

3. Install the SDK

Install the SDK using Composer for easy dependency management:

composer require whapi-cloud/whatsapp-api-sdk-php

Setting Up Your Integration

Initialize the Client

To authenticate your API requests, initialize the client with your API token.

use OpenAPI\Client\Api\MessagesApi;
use OpenAPI\Client\Configuration;

// Initialize the client
$config = OpenAPI\Client\Configuration::getDefaultConfiguration()
    ->setApiKey('token', "your_token")
    ->setAccessToken("your_token");

$apiInstance = new OpenAPI\Client\Api\MessagesApi(
    new GuzzleHttp\Client(),
    $config
);

Messaging API: Key Features and Examples

Sending Text Messages

Effortlessly send text messages using the API. You can also include optional settings like typing simulation or ephemeral visibility.

$sender_text = new \OpenAPI\Client\Model\SenderText();
$sender_text->setTo('13016789891'); // Include country code
$sender_text->setBody('Your message here'); // Message content
$sender_text->setEphemeral(3600); // Message visibility time
$sender_text->setTypingTime(5.0); // Typing simulation duration

$result = $apiInstance->sendMessageText($sender_text);
print_r($result);

Retrieving Messages with Webhooks

Webhooks provide real-time updates for incoming messages, ensuring your bot stays up-to-date.

Retrieve Multiple Messages

Use the following example to retrieve a batch of messages.

$count = 100;
$offset = 0;
$result = $apiInstance->getMessages($count, $offset);
print_r($result);

Retrieve a Single Message

To fetch a specific message by its ID, use this example:

$message_id = "your_message_id";
$result = $apiInstance->getMessage($message_id);
print_r($result);

For detailed webhook setup instructions, check the Webhook Guide.

WhatsApp Groups API: Automate Group Management

Simplify and streamline the management of WhatsApp groups with Whapi.Cloud's Groups API. These features empower you to automate tasks, saving time and reducing manual effort.

Key Features for Group Management

Create, Update, or Delete Groups: Programmatically manage your WhatsApp groups with ease.
Participant Management: Add, remove, or block members as required.
Custom Group Settings: Adjust group names, avatars, and permissions effortlessly.
Generate Invitation Links: Quickly create and share group invite links for seamless onboarding.

Example: Creating a Group

Below is a practical example of how to create a new WhatsApp group using the API.

$create_group_request = [

    "subject" => "Group Name",

    "participants" => [

        "13016789891",

        "13016789892"

    ]

];

$result = $apiInstance->createGroup($create_group_request);

print_r($result);

Best Practices and Important Notes

Working with Phone Numbers

When using the Whapi.Cloud API, follow these best practices for handling phone numbers:

Always include the country code: For example, use '13016789891' for a US number.
Avoid special characters and spaces: Numbers should be entered as a continuous string of digits.

Media Requirements

Ensure your media files meet the following criteria to guarantee smooth delivery:

Publicly Accessible URLs: All media files must be hosted at a URL that is accessible without authentication.
Supported Formats: Common image formats such as JPEG and PNG are supported, along with other standard file types.

Optimizing Messaging

For a more engaging and user-friendly experience, use these options:

Ephemeral Messages: Set messages to disappear after a specific time for added privacy.
Typing Simulation: Simulate typing indicators to provide a more natural, human-like interaction.

Why Choose Whapi.Cloud?

Whapi.Cloud offers a robust and user-friendly WhatsApp API gateway, designed to make integration simple and efficient for developers. Here’s why it stands out:

Comprehensive Group Management: Easily create, manage, and automate WhatsApp groups, communities, and channels.
Interactive Messaging Features: Add dynamic elements such as buttons, media sharing, polls, and reactions to enhance communication.
Reliable Support: Access fast and knowledgeable assistance from our dedicated care team to ensure your development process runs smoothly.

Whapi.Cloud’s transparency, flexibility, and robust documentation make it an ideal solution for scaling your WhatsApp operations while maintaining control and efficiency.

Get Started Today

Take the first step toward powerful WhatsApp automation with the Whapi.Cloud PHP SDK.

Links to Get Started:

Register for your API token: Whapi.Cloud Dashboard
Download the PHP SDK: GitHub Repository

Streamline your WhatsApp bot development and start building interactive solutions today.

Begin your journey with Whapi.Cloud now!

Building Your First WhatsApp Bot in Python: A Beginner’s Guide

WhatsApp API for developers — Tue, 26 Nov 2024 10:10:50 +0000

Introduction

Creating a WhatsApp bot might initially feel overwhelming, but with clear instructions, it transforms into an accessible and manageable project. For Python developers new to API integrations, this guide simplifies the process, offering step-by-step instructions for building a basic WhatsApp bot. You'll learn everything from obtaining an API token to setting up webhooks for automated responses.

This tutorial serves as a beginner-friendly starting point, making it an excellent resource for developers looking to explore WhatsApp API capabilities and lay the groundwork for building more advanced chatbot solutions in the future.

Features of This WhatsApp Bot

This basic bot showcases how to handle incoming messages by responding with predefined text or media, such as images, depending on the message's content. It’s a valuable learning tool for developers eager to understand the fundamentals of API interactions and automated messaging workflows.

A standout feature of this bot is its ability to function effortlessly within WhatsApp Groups and Communities, making it an effective solution for automating interactions and enhancing productivity within the messenger.

Prerequisites

Before you begin, ensure you have the following:

1. Obtain Your API Token

Register on Whapi.Cloud. This platform provides an easy-to-use API gateway compatible with Python and other programming languages, enabling you to connect your app, website, or CRM with WhatsApp. That said, this system works with Groups, Channels, Statuses, and more.
Retrieve your API token by following the detailed instructions provided in Whapi.Cloud’s documentation.
Download the source code for the bot from GitHub: [GitHub Repository].
Save the token in a .env file for secure access within your bot script.

2. Set Up Your Webhook URL

A webhook is a mechanism that allows one application to deliver real-time information to another. In the case of this WhatsApp bot, the webhook URL acts as the endpoint where WhatsApp forwards incoming messages, enabling your bot to process and respond accordingly.

To enable your bot to handle messages, setting up a webhook URL is essential.

This [guide] provides detailed instructions on locating your webhook URL, recommended server configurations, and popular options for setup. If you’re working in a local environment, deploying to a live server isn’t required. Instead, you can use a tunneling tool to expose your local server and allow external requests to reach it.

Testing Locally: For local testing, use Ngrok to expose your server online temporarily, allowing you to simulate bot functions without needing to deploy on a live server.

Download and unzip Ngrok, then run: ./ngrok http PORT_NUMBER
Replace PORT_NUMBER with the port where your server is running.

Set Webhook URL in Dashboard: Copy the Ngrok-generated link as your webhook URL in the Whapi.Cloud dashboard. This directs incoming messages to your bot’s local server, allowing real-time interaction with WhatsApp.

3. Setting Up Your Bot

Follow these steps to get the bot running:

Navigate to the directory containing the bot’s files: cd /path/to/bot
Install the required dependencies: pip install -r requirements.txt
Run the bot: python index.py

If everything is done correctly, your bot is ready to go. Just write the test command “help” to the number connected to the API from another number.

Understanding the Structure of Your WhatsApp Bot

The bot is designed with simplicity in mind, making it easy for beginners to understand. The directory structure includes:

files/: Stores media files, such as images, that the bot sends.
.env: Contains configuration variables like the API token and base URL.
index.py: The main Python script where the bot’s logic resides.
requirements.txt: Lists all necessary Python packages.

Customizing and Enhancing Your WhatsApp Bot

Once the basic setup is in place, you can start expanding your bot's functionality to make it more versatile and tailored to specific needs.

Here are some ideas for extending its capabilities:

Add New Commands and Responses

Modify the index.py file to include additional commands and features. Extend the conditional logic to recognize new keywords or phrases and define unique responses. These could range from simple text and images to more complex content types.

Send a Variety of Content
Move beyond basic messages by leveraging Whapi.Cloud’s API to send a diverse range of content. Here are some options you can integrate:

Files in various formats
Shared locations
Contact cards
Stickers and polls
Product details in messages
Interactive buttons for user actions

Introduce Message Reactions

Enhance user interaction by adding message reaction features. Your bot can:

Quote incoming messages
Respond with emoji reactions
Mark messages as read
Simulate typing indicators in real-time

These additions not only make the bot more engaging but also provide a human-like experience, improving interaction quality.

Automated WhatsApp Group Management

Whapi.Cloud’s API offers extensive tools for automating WhatsApp Group management, transforming your bot into an efficient group coordination assistant. Here are some of the tasks you can automate:

Create, update, or delete groups programmatically.
Retrieve group details, such as member lists, participant numbers, and other metadata.
Manage group membership by adding or removing users, assigning admin roles, or blocking members as needed.
Adjust group settings, including the group name, avatar, and permissions.
Generate and distribute group invitation links with ease.

For detailed implementation instructions and code samples, refer to Whapi.Cloud’s comprehensive documentation. Each feature is clearly explained, complete with practical examples to help you make the most of your bot’s potential.

With these advanced capabilities, you can build a robust WhatsApp bot that goes far beyond basic message automation, delivering a solution tailored to your specific requirements.

ChatGPT Integration: Bring AI into Your WhatsApp Bot

Adding ChatGPT support is a powerful way to enhance your WhatsApp bot with AI-driven, human-like responses. In this example, we’ll keep things simple: when a user sends a message like /ai [your question], the bot replies using ChatGPT.

Step 1: Install Dependencies
To enable ChatGPT, add the following packages to your requirements.txt:

openai>=1.91.0,<2.0.0
httpx>=0.28.1,<1.0.0
httpcore>=1.0.9,<2.0.0

Install them using: pip install -r requirements.txt

Step 2: Set Your OpenAI API Key
Register at platform.openai.com, generate your secret API key, and add it to your .env file: OPENAI_API_KEY=your_api_key_here

Step 3: Implement AI Logic
Next, create a basic Flask app (index.py) that:

Receives webhook events from Whapi.Cloud
Detects messages starting with /ai
Sends the prompt to ChatGPT
Replies to the user via the WhatsApp API

This structure provides a clean, minimal foundation for integrating AI into your bot.

# Import necessary libraries for web server, HTTP requests, OpenAI API, environment variables, and .env file loading
from flask import Flask, request, jsonify  # Flask is used to create the web server and handle HTTP requests
import requests  # Used to send HTTP requests to the WhatsApp API
from openai import OpenAI  # OpenAI client for interacting with ChatGPT
import os  # For accessing environment variables
from dotenv import load_dotenv  # For loading variables from a .env file

# Load environment variables from a .env file into the environment
load_dotenv()
# Create a Flask web application instance
app = Flask(__name__)

# Retrieve required configuration values from environment variables
API_TOKEN = os.getenv("API_TOKEN")  # Token for authenticating with WhatsApp API
API_URL = os.getenv("API_URL")      # Base URL for WhatsApp API
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")  # API key for OpenAI

# Ensure all required environment variables are set, otherwise stop the program with an error
if not API_TOKEN or not API_URL or not OPENAI_API_KEY:
    raise RuntimeError("Missing required environment variables: API_TOKEN, API_URL, or OPENAI_API_KEY")

# Initialize the OpenAI client with the provided API key
openai_client = OpenAI(api_key=OPENAI_API_KEY)

# Function to send a prompt to ChatGPT and get a response
# Takes a string prompt and returns the model's reply as a string
def ask_openai(prompt):
    response = openai_client.chat.completions.create(
        model="gpt-3.5-turbo",  # Specify which OpenAI model to use
        messages=[{"role": "user", "content": prompt}]  # Provide the user's message to the model
    )
    # Extract and return the text of the model's reply
    return response.choices[0].message.content.strip()

# Function to send a text message to a WhatsApp user via the WhatsApp API
# 'to' is the recipient's chat ID, 'body' is the message text
def send_message(to, body):
    headers = {
        "Authorization": f"Bearer {API_TOKEN}",  # Add authentication token to the request
        "Content-Type": "application/json"        # Specify that we're sending JSON data
    }
    payload = {"to": to, "body": body}  # Prepare the message data
    # Send the message to the WhatsApp API endpoint
    response = requests.post(f"{API_URL}/messages/text", json=payload, headers=headers)
    print("Whapi response:", response.status_code, response.text)  # Log the API response for debugging

# Define a webhook endpoint to receive incoming WhatsApp messages
@app.route("/hook/messages", methods=["POST"])
def webhook():
    data = request.json  # Parse the incoming JSON data
    print("Incoming:", data)  # Log the incoming data for debugging

    # Loop through all received messages (could be more than one in a single webhook call)
    for msg in data.get("messages", []):
        if msg.get("from_me"):
            continue  # Skip messages sent by the bot itself

        sender = msg.get("chat_id")  # Get the sender's chat ID
        # Safely extract the message text, handling cases where 'text' might be missing
        text = (msg.get("text") or {}).get("body", "").strip()

        # If the message starts with '/ai ', treat it as a prompt for ChatGPT
        if text.lower().startswith("/ai "):
            prompt = text[4:].strip()  # Extract the user's prompt after '/ai '
            if not prompt:
                send_message(sender, "Please provide a prompt after /ai.")  # Ask user to provide a prompt
            else:
                try:
                    reply = ask_openai(prompt)  # Get response from ChatGPT
                    send_message(sender, reply)  # Send the response back to the user
                except Exception as e:
                    send_message(sender, f"Error: {e}")  # Inform user if something went wrong
        else:
            # If the message doesn't start with '/ai ', send instructions to the user
            send_message(sender, "Hi! To ask me something, type:\n/ai your question")

    # Respond to WhatsApp API to confirm receipt of the webhook
    return jsonify({"status": "received"})

# Optional: health check endpoint to verify the bot is running
@app.route("/", methods=["GET"])
def index():
    return "Bot is running"

# Function to register the webhook URL with the WhatsApp API
def register_webhook():
    if os.getenv("BOT_URL"):
        headers = {"Authorization": f"Bearer {API_TOKEN}"}
        payload = {
            "webhooks": [
                {
                    "url": os.getenv("BOT_URL"),  # The public URL where Whapi should send messages
                    "events": [{"type": "messages", "method": "post"}],  # Listen for message events
                    "mode": "method"
                }
            ]
        }
        # Register the webhook
        response = requests.patch(f"{API_URL}/settings", json=payload, headers=headers)
        print("Webhook setup:", response.status_code, response.text)  # Log the result

# If this script is run directly (not imported), start the bot
if __name__ == "__main__":
    register_webhook()  # Optionally register the webhook on startup
    port = int(os.getenv("PORT", 80))  # Use the PORT environment variable or default to 80
    app.run(host="0.0.0.0", port=port)  # Start the Flask web server, accessible from any network interface

This basic bot processes incoming messages, filters out messages from itself, and searches for messages beginning with /ai. If such a command is found, it extracts the question, sends it to ChatGPT, and responds using the WhatsApp API with an AI response. This script is ready for testing. And its useful part has already been implemented in our chatbot example on GitHub to make it easier for you to get started!

FAQs and Troubleshooting

Setting up and operating a WhatsApp bot may occasionally present challenges. Here are some common issues and steps you can take to resolve them:

The Bot Is Not Responding to Incoming Messages
1. Verify Your Testing Method
Ensure you’re testing with a phone number different from the one assigned to the bot. The bot is programmed to respond only to messages received from external sources, so messages sent from the same number will be ignored.

2. Check Your Webhook Configuration
If the bot isn’t responding to messages from other numbers, the issue might be with the webhook setup. Follow these steps to troubleshoot:

Simulate Webhook Requests: Use tools like Webhook Request Debugger to test incoming requests and verify that the webhook URL matches the one expected by the API.
Server Response Validation: Confirm that your server is returning a 200 OK response, which indicates the webhook is active and properly receiving requests.
Endpoint Testing: Use an endpoint tester to send mock callbacks to your webhook URL and ensure it is correctly configured.

3. Reach Out for Support
If you’ve tried the above steps and the issue persists, don’t hesitate to contact our technical support team. You can reach us via the chat widget on our website or email care@whapi.cloud. Our team is ready to help resolve webhook or configuration issues and get your bot running smoothly.

Conclusion

This Python-based WhatsApp bot serves as the perfect entry point for developers exploring API integration and chatbot development. By following this step-by-step guide, you’ll acquire the foundational skills needed to create more sophisticated bots that can process diverse commands, handle media interactions, and automate messaging tasks.

Whether you’re new to Python programming or looking to expand your expertise in chatbot development, this project equips you with the essential tools to master WhatsApp API integration. Start building your custom bots today and pave the way for advanced Python automation projects in the future.

Building Your First WhatsApp Bot in PHP: A Beginner's Guide to Code and Integration

WhatsApp API for developers — Wed, 06 Nov 2024 08:44:45 +0000

Building a custom WhatsApp bot might seem daunting at first, but with clear guidance, it’s a manageable and rewarding project for developers—especially those just beginning to explore API integrations. This tutorial provides a straightforward path to setting up a WhatsApp bot in PHP, covering everything from API token setup to tailored message responses.

Designed for beginners, this guide is the perfect foundation for developing more advanced bots in the future.

Features of This WhatsApp Bot

This introductory bot is programmed to respond to incoming messages with preset text and image replies, depending on the message content. It’s a practical starting point for developers wanting to learn about API-driven interactions and automated messaging.

One standout feature: this bot operates seamlessly within WhatsApp Groups and communities, enabling you to bring automation to your WhatsApp channels with ease.

Prerequisites

To get started, make sure you have the following setup:

1. Obtain Your API Token

Register on Whapi.Cloud. Whapi.Cloud provides an easy to use API gateway that is compatible with any programming language. It will allow you to integrate your website, store, app or CRM with WhatsApp without nerves.
Download the ready-to-use bot source code from GitHub: https://github.com/Whapi-Cloud/whatsapp-simple-php-bot.
Get your API Token to work with your WhatsApp. How to get the token is very detailed in this instruction.
Save this token in /config/config.php for easy access by the bot.

2. Set Up Your Webhook URL

A webhook is a tool that enables one application to send real-time data to another. For this WhatsApp bot, the webhook URL is the designated address where WhatsApp sends incoming messages for your bot to process and reply.

To allow the bot to receive messages, you’ll need to configure a webhook URL.

This guide covers where to find this link, recommended server options, and popular solutions available. If you’re testing locally, however, a live server isn’t necessary. You can set up a tunnel to allow requests to reach your local machine.

Testing Locally: For local testing, use Ngrok to expose your server online temporarily, allowing you to simulate bot functions without needing to deploy on a live server.

Download and unzip Ngrok, then run:
./ngrok http PORT_NUMBER
Replace PORT_NUMBER with the port where your server is running.

Set Webhook URL in Dashboard: Copy the Ngrok-generated link as your webhook URL in the Whapi.Cloud dashboard. This directs incoming messages to your bot’s local server, allowing real-time interaction with WhatsApp.

3. Install Composer

Composer is needed to handle dependencies for this bot. Run the following commands to install Composer:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

4. Install Dependencies

With Composer installed, navigate to the bot’s directory and run:

php composer.phar install

5. Launch the Bot

After setting everything up, start the bot with the command:

php server.php

For a video tutorial on setup, check out our YouTube guide.

Understanding the Structure of Your WhatsApp Bot

This bot is structured with clarity and detailed comments, making it beginner-friendly and easy to navigate. Below is an overview of the primary components:

Core Modules

/src/channel.php
This module contains essential functions that manage communication between the bot and users:

checkHealth(): Confirms that the bot’s channel is functioning properly.
sendMessage(): Sends text messages to specified recipients.
setWebHook(): Configures the webhook automatically (optional).
getWebHooks(): Retrieves webhook details from the API.
sendLocalJPG(): Converts images from the /images/ directory to base64 and sends them as media messages.

The code snippet demonstrating sendMessage() functionality. This feature displays the “Typing” status in your WhatsApp for 5 seconds and then sends a text message after that:

public function sendMessage($to, $body): bool {
  $ch = curl_init('https://gate.whapi.cloud/messages/text');
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'Authorization: Bearer ' . $this->token,
      'Content-Type: application/json'
  ]);
  curl_setopt($ch, CURLOPT_POST, 1);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
      'typing_time' => 5,
      'to' => $to,
      'body' => $body
  ]));
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $response = curl_exec($ch);
  $data = json_decode($response, true);
  curl_close($ch);

  return $data['sent'] ?? false;
}

Primary Logic

/src/Whapi.php
The main logic for the bot resides here, controlling how it processes and responds to incoming messages:

Message Filtering: Screens out outgoing messages, ensuring only external incoming messages are handled.
Sender and Content Parsing: Extracts the sender’s phone number and the message text.
Command-Based Responses: Uses a switch statement to define responses based on specific commands or keywords received.

This structure allows for easy customization and extension, providing a solid foundation to build upon as you add new features.

// The main cycle of the bot is to check and react to the incoming message depending on the text
switch ($receivedText) {
  case 'help':
      $channel->sendMessage($senderPhone, 'Text1'); // If the bot receives the message 'help', it will send the message 'Text1'
      break;
  case 'command':
      $channel->sendMessage($senderPhone, 'Text2');
      break;
  case 'image':
      $channel->sendLocalJPG(__DIR__ . '/../public/images/example.jpeg', $senderPhone, 'Caption'); // We encode the picture in base64, so it's easier to send a media message.
      break;
  default:
      $channel->sendMessage($senderPhone, 'Unknown command'); // On an unknown team, it's best to send navigation information to help your customer navigate
      break;
}

Customizing and Expanding Your WhatsApp Bot

With the initial setup complete, you have a strong foundation to enhance your bot with new features and customizations. Here are some ways to expand its functionality and tailor it to your needs.

Add Custom Commands and Responses

Customize your bot’s behavior by adding commands within the /src/Whapi.php file. Expand the switch statement to recognize additional keywords or phrases and create unique responses, from text and images to other content types.

Send Varied Content

Go beyond basic text and images by implementing advanced messaging options available through Whapi.Cloud’s API. These include:

Files in multiple formats
Location sharing
Contact information cards
Stickers and polls
Product listings within messages
Interactive messages with buttons for user actions

Interactive Message Reactions

Make your bot more engaging by adding message reactions. Enable it to quote messages, respond with emoji reactions, mark messages as read, or show real-time typing indicators. These small interactions add a human-like element to your bot’s responses.

Automated WhatsApp Group Management

With Whapi.Cloud’s API, you can automate a range of group management tasks, turning your bot into a powerful tool for group coordination:

Automatically create, modify, or delete groups.
Access group information, including member details and total counts.
Manage membership by adding or removing users, assigning administrator roles, and blocking members.
Customize group settings like name, avatar, and permissions.
Generate and share group invitation links effortlessly.

For full implementation details and code examples, check out Whapi.Cloud’s detailed documentation. Each method is thoroughly explained with examples to help you unlock the full potential of your bot’s capabilities.

These enhancements make it possible to build a highly functional WhatsApp bot tailored to your unique needs, going far beyond basic message responses.

FAQs and Troubleshooting

Setting up and running a WhatsApp bot can sometimes present challenges. Here are some solutions for common issues to help keep your bot operating smoothly:

Bot Isn’t Responding to Incoming Messages

1. Confirm Your Testing Method
Make sure you’re testing from a different phone number than the one the bot uses. The bot is designed to respond only to messages from external sources, so messages from the same number won’t trigger a response.

2. Check Webhook Functionality
If the bot still isn’t responding, the webhook configuration might need attention. Here are a few steps to troubleshoot:

Simulate Webhook Requests: Use a tool like Webhook Request Debugger to simulate incoming requests and confirm that your bot’s webhook URL matches what the API expects.
Server Response Verification: Ensure your server responds with a 200 OK status, indicating that the webhook is active and receiving requests.

You can also use an endpoint tester to verify your webhook link, which sends test callbacks to simulate real incoming requests.

3. Contact Technical Support
If these steps don’t resolve the issue, reach out to our technical support team. Use the chat widget on our website or email care@whapi.cloud, and our team will assist with any webhook or bot configuration issues to get you up and running.

Conclusion

This WhatsApp bot in PHP offers an ideal entry point for beginners exploring chatbot creation and API integration. By following this guide, you’ll develop foundational skills for building more advanced bots capable of responding to various commands with text, images, and more. This project lays the groundwork for creating versatile and interactive bots that can grow in complexity as you expand your API knowledge.

Simple WhatsApp ChatBot in Node.js for Beginners

WhatsApp API for developers — Tue, 22 Oct 2024 13:27:16 +0000

Are you looking to build your first bot but don’t know where to start? Then you're in the right place! I'm excited to announce the release of a new, simple WhatsApp bot built with Node.js that’s perfect for beginners.

In this tutorial, we are excited to announce the release of a simple WhatsApp bot built with Node.js—an ideal starting point for beginner developers. If you're just venturing into bot development, this bot will help you learn how to handle commands, respond to messages, and even share images, all while keeping the complexity at bay. You’ll focus on the core functionality without being overwhelmed by unnecessary features.

Why Build a WhatsApp Bot?

WhatsApp is one of the most widely used messaging platforms in the world, and many businesses use it for customer support, notifications, and marketing. A bot can automate these tasks, saving time and effort, and enhancing user experience.

However, for someone new to development, it can be challenging to figure out where to begin with building a WhatsApp bot. That's why I've created this bot with simplicity in mind, offering only core functionality like responding to text commands and sending images.

Let’s dive into the details of this project and explore how to set up your very own WhatsApp bot!

What’s Inside This WhatsApp Bot

This bot is designed to respond to a few basic commands. When a user sends a message to the connected WhatsApp channel, the bot can:

Reply with text messages.
Send images based on commands.
Understand and talk about a team he doesn't know.

These functionalities give you a hands-on way to understand how to process messages and how to structure your own bot logic.

Prerequisites

Before we get started, there are a few things you’ll need:

Node.js – Make sure you have Node.js installed on your system. If you haven't installed it yet, you can download it from Node.js official website.
API Token from Whapi.Cloud – Whapi.Cloud provides an easy-to-use API for WhatsApp integration. You’ll need to sign up for an account and grab a token. We have described in more detail how to connect a WhatsApp account and get a token in our knowledge base here.
A Webhook – The bot relies on a webhook to receive incoming messages. If you don't know how to set it up, we'll tell you more about it below.

Project Structure Overview

Here’s a breakdown of the key files in this project:

index.js – This file verifies the WhatsApp channel, checks the API token, and sets up the webhook programmatically through the API. There’s no need to configure the webhook manually in the interface, as it's handled here automatically.
/modules/channel.ts – Contains essential functions such as:

checkHealth() – Verifies the channel’s functionality.
sendMessage() – Sends text messages.
setWebHook() – Sets the webhook for incoming messages.
getWebHooks() – Retrieves existing webhooks.
sendLocalJPG() – Converts images from the /images/ folder into Base64 and sends them as WhatsApp messages.

/endpoints/hook.ts – This is where the core bot logic lives:

It listens for incoming messages and ignores outgoing messages.
It fetches the sender's number and message text.
It filters out non-text messages.
A switch statement processes the command and sends back the appropriate response, either a text message or an image.

Step-by-Step Setup

Follow these simple steps to get your WhatsApp bot running:

1. Clone the Project

Start by cloning the repository:

git clone https://github.com/Whapi-Cloud/whatsapp-simple-node-js-bot
cd whatsapp-bot

2. Update the Config

Next, open the config.json file and add your API token and webhook URL:

{
    "webhookUrl": "YOUR-WEBHOOK-URL",
    "token": "YOUR-TOKEN",
    "port": "8080"
}

Where to Find the Webhook URL?

To set up a webhook URL, you'll need to configure a server endpoint that can handle incoming HTTP requests from our API. This allows your application to receive real-time data, such as message updates, directly from WhatsApp.

You can set up a webhook on a hosting platform, in the cloud services, or locally (using Ngrok or similar programs).

The links provided will give you instructions on how to use this option. In this article's example, we will use Ngrok.

3. Install Dependencies

Install the required dependencies by running:
npm install

4. Run the Bot

To start your bot, run the following command:
npm run start

And that’s it! Your bot is now up and running. It will respond to incoming messages based on the logic defined in /endpoints/hook.ts.

Detailed Features

Here’s a closer look at what the bot does and how it works:

Channel Health Check
Before anything else, the bot ensures that the WhatsApp channel is functioning correctly by using the checkHealth() function in /modules/channel.ts. This prevents problems from occurring later and helps you ensure that the session is working correctly and your channel is running.
Sending Messages
The bot uses the sendMessage() function to send replies to users. The bot script itself contains logic for processing various types of responses (skips outgoing messages; processes only incoming text messages; sends messages in response to the numbers that were written to it).
Webhook Setup
Instead of manually setting up the webhook in the Whapi.Cloud interface, the setWebHook() function handles this automatically via the API, streamlining the setup process.
Image Handling
The sendLocalJPG() function allows the bot to send images in response to certain commands. It converts images from the /images/ folder into Base64 format and sends them via WhatsApp.
Processing Incoming Messages
The core bot logic in /endpoints/hook.ts listens for incoming messages, processes the text, and replies accordingly. The bot handles various commands using the switch statement, which makes it easy to expand the bot's capabilities in the future.

Ready to learn more?

If you want to dive deeper into the API or expand the bot's capabilities, check out our more comprehensive chatbot on GitHub.

Conclusion

This simple WhatsApp bot built with Node.js is a great way to start learning how to develop chatbots. With the functionality to send both text and images, and clear, easy-to-understand code, this project is perfect for beginner developers.

Start your journey with WhatsApp bot development today by trying out this bot and customizing it to your needs. Be sure to also explore Whapi.Cloud’s API for additional functionality and support for more complex features.

Try it now, and happy coding!

How to register a virtual WhatsApp number

WhatsApp API for developers — Wed, 09 Oct 2024 10:52:13 +0000

What is a virtual number and why do I need it?

This article is intended for entrepreneurs, marketers and professionals who actively use WhatsApp to interact with customers, mass mailings and automate business processes. Using a personal number for these purposes can be insecure and inconvenient due to the risks of blocking and the need to buy SIM cards.

Virtual numbers make registering accounts on WhatsApp simpler, making it much easier to manage and automate. This is especially important for mass activity, as it allows for quick recovery when accounts are blocked, minimizing potential losses. This approach opens up great opportunities for safer and more convenient use of WhatsApp for commercial purposes, as even if one account is blocked, you can quickly register a new one without risking your core numbers and infrastructure.

Virtual number and its use in WhatsApp

Using a personal number for commercial purposes carries the risk of blocking and loss of privacy, and restoring the account, in case of a ban, will be difficult. Virtual numbers help to avoid this by providing access to numbers from any country and region with full messenger functionality.

To sign up for WhatsApp, you need to have the app itself on your phone, accept the terms of use and enter your phone number in international format. This number will then receive a confirmation code via SMS or call, which must be entered into the app. This process is simple on a regular smartphone, but without a physical device it becomes more complicated as you will need a method of receiving messages or calls to confirm.

Sometimes WhatsApp offers other signup options, but more often you'll need to accept a message or call

If you have multiple devices, you can manually register numbers on each of them, which takes time and effort. How to do this is detailed below. If you don't have a physical gadget, you can use emulators or special API methods offered by us as a WhatsApp API provider. These methods allow you to automate processes, but they have their own peculiarities and limitations that are important to consider. The details will be discussed in the following sections.

Thus, virtual numbers are convenient for anonymity and automation of registration, but their use without a physical device requires a more careful approach. In this article, we will consider where and how to get a virtual number, how to receive an SMS or call on it, as well as the pros and cons of using emulators and other options for registering accounts in WhatsApp via API.

Several ways to get a virtual number for WhatsApp

1. Official virtual number providers
Virtual number providers such as Twilio, Vonage and Voximplant offer numbers that support SMS and calling directly. They require detailed business verification including providing a lot of documents. The advantage of these providers is that they provide APIs for integration, but setting up SMS and call acceptance remains your responsibility.

Twilio, for example, offers out-of-the-box webhooks for SMS, but costs more and requires more verification. Voximplant offers more affordable numbers, but setting them up to receive messages and calls is more complicated and may require you to set up IP telephony yourself.

Many numbers provided by these services may have already been used in public services and become unavailable for registration in WhatsApp. The app will simply not allow the use of such a number while requesting another one. This complicates the process and makes it impractical to use these numbers to register in the messenger.

(More often than not, numbers from exchanges and providers fail to register in WhatsApp)

Using such services requires technical knowledge and can be labor-intensive with no guarantee of results. Therefore, they are more suitable for long-term business tasks not related to mass activity on WhatsApp.

2. VoIP exchanges
VoIP exchanges are platforms where you can purchase virtual numbers from different providers with flexible terms and conditions. Services such as DIDWW, CallHippo, VoIP.ms and TollFreeForwarding offer a wide range of numbers from different countries, allowing you to find the right one at a favorable price. However, support on these platforms is limited as they act as intermediaries. In addition, exchanges may ask for documents to verify an account or business. Often, numbers can be temporary or previously used, making it difficult to sign up for WhatsApp, and you'll need additional technical setup to receive SMS or calls anyway.

(Sometimes you will need a bit of technical knowledge to set up receiving messages or calls)

3. One-time activation services
These platforms offer temporary numbers that can be rented for quick registration in WhatsApp or other services. They are convenient because the registration process is fully automated and does not require identity verification or documents. The user receives the number in a few minutes and can immediately use it to receive SMS or calls in a convenient out-of-the-box interface without any technical settings. However, this approach carries risks: numbers can be previously used or stolen, making them unreliable for long-term use. Since such services operate in a gray zone, we will not provide links to them, but they can be easily found on the Internet.

(“Gray” services for buying cheap one-time activations)

So, you have decided on a virtual number provider that meets your requirements. But now how to organize your work if you don't want to use physical devices or need to register accounts en masse with minimal effort?

How to register many numbers in WhatsApp?

Mass activity usually requires a large number of numbers, but it is inconvenient and cumbersome to store many devices at home or in the office. Let's take a look at all the solutions for active number registration in WhatsApp.

Gadget farm
A gadget farm is a group of mobile devices used to handle multiple accounts simultaneously. Usually, these are dozens or even hundreds of smartphones or tablets that perform some tasks. Most often, the devices are physically placed on a special rack or in an enclosure, connected to power and the internet. But it is possible to use automated systems to manage farms.

You may well use several of your old phones in your work:

You can install regular WhatsApp and WhatsApp Business on each device, which allows you to already use two numbers on one phone.
In regular WhatsApp, you can connect multiple numbers in one app via the “Multi-Account” feature. To do this, go to your account settings, select “Add a new number” and follow the instructions.
Cloning apps create duplicate apps, allowing you to run multiple accounts on the same device. However, WhatsApp can recognize this and block the accounts.

(Adding a new account in WhatsApp)

Thus, even a few old phones at home can provide up to ten active WhatsApp accounts. However, these devices require constant monitoring and periodic switching on to log into the app. If you don't log into WhatsApp on your phone for 14 days, it drops all connected sessions (like Web versions or API connections). This means you'll have to put your phones on charge frequently, messing around with devices and keeping track of them, which creates more inconvenience and makes it harder to manage your gadget farm.

How to register a number in WhatsApp without a gadget?

Emulators

Using emulators for WhatsApp allows you to run the application on your computer without a phone, which is convenient for mass registration of numbers. How to choose the right one? Here are a few of the most convenient options below

BlueStacks

A popular emulator with support for a variety of applications. It is easy to install and use, but requires enough system resources. Good for running WhatsApp on PC, but can be noticeable for WhatsApp security.

Nox

A lightweight emulator optimized for games and apps. Has flexible settings and can run multiple instances of WhatsApp at the same time, which is convenient for mass usage.

Memu

An emulator with high performance and flexible customization. Features a simple interface and support for multiple Android versions.

LDPlayer

Lightweight and fast emulator with good compatibility. Supports many apps and games, but like the others, has the risk of being detected by WhatsApp.

Cloud Emulator

Cloud emulators allow you to run applications remotely, which reduces the load on local resources and improves stability. However, they require additional customization and can be more expensive.

For all the pros, there are cons to this use of emulators:

Session disconnection after 14 days: as with a session on a physical device, if you don't log into your account for two weeks, WhatsApp will disconnect connected devices (like the Web version, which could be your agents or APIs). This requires regular checking and running emulators.
Increased risk of blocking: WhatsApp monitors virtual devices and may block an account if it detects emulator usage.
Problems with updates: Emulators may not be compatible with newer versions of WhatsApp, making them more difficult to use.

Overall, emulators do not guarantee stable performance and require constant monitoring, making them not the most reliable option for mass activity.

Device-Free WhatsApp API

Mobile instances or Device-Free WhatsApp Channel from Whapi.Cloud allows you to register numbers and work with APIs without using a physical device. This is convenient for companies that need mass registration and automation. Whapi.Cloud offers extensive functionality for developers: managing and parsing groups, checking numbers for WhatsApp and more. This approach solves many of the problems faced by users of traditional VoIP numbers and emulators.

(Registering a new account via API, without using a gadget. The screenshot from the Developer Hub interface shows a repeated request to register a new number with the code already received and a successful registration response)

At the moment, the Device-Free WhatsApp API functionality is only available to some partners as part of closed beta testing. If you are interested in learning more and would like to participate in the testing, contact us for a survey and possible access to this technology.

>Sign up as a beta participant<

You can also check out the full range of Whapi.Cloud API features which includes account management, parsing of groups, channels, communities, mass checking of numbers against WhatsApp, ability to send buttons, surveys, media and more.
Learn more about Whapi.Cloud

Conclusion

Using a virtual number for WhatsApp opens up many opportunities, providing privacy and convenience of working with the messenger. With its help, you can use regional numbers to enter new markets, automate mass registration and account management. This is especially useful for companies that value flexibility and scalability. Platforms like Whapi.Cloud offer powerful APIs for automating groups, mailings, and number verification. If you're looking for a truly feature-rich solution to work effectively with WhatsApp, try our API and unlock all its capabilities.

WhatsApp Communities API: sending announcements and managing members

WhatsApp API for developers — Fri, 04 Oct 2024 14:11:55 +0000

Whapi.Cloud is an easy-to-use WhatsApp API compatible with any programming language. Knowing that managing communities in WhatsApp is time-consuming, we have implemented convenient and simple mechanisms for working with communities. Let's familiarize ourselves with them in more detail.

What are WhatsApp Communities?

Simplistically speaking, communities in WhatsApp are a super-group of several smaller individual groups. To illustrate how the community structure works, take a look at the image below:

As you can see, Communities help avoid chaos in large WhatsApp groups by offering a structure where it's easy to manage threaded discussions and send announcements to all participants at once.

You can try our Whapi.Cloud API right now: after signing up, you are given a trial channel, it is limited to five days and does not require a linked card. After that, you can continue on the free plan.
This article will have more detailed instructions on how to get started: Let's Dive into Whapi.Cloud: A Three-Step Journey

How it works?

When you create a community, WhatsApp automatically creates a special group for announcements. While this may seem a bit unexpected, two groups with the same name are actually created. One is used as the “Announcements Group” to send messages to all members of the community, and the other is used for technical communication between groups. However, this won't create any difficulties in managing the community - you can easily work with them through the API.
Let's explore an example to understand how everything functions technically.
We'll begin by covering the basics — creating a new community.

Creating a new community

To create a WhatsApp community through the API, you'll need to use the following endpoint:
POST https://gate.whapi.cloud/communities
Here is an example request to get a new community:

curl --request POST \
--url https://gate.whapi.cloud/communities \
--header 'accept: application/json' \
--header 'authorization: Bearer {YOUR_TOKEN}' \
--header 'content-type: application/json' \
--data '
{
"subject": "A new community of scientists",
"description": "This is where we bring together all our faculties to stay connected and up to date with the latest news"
}
'

After creating a community, you will get its unique identifier, which is needed to bind or unbind groups. When you request a list of groups, you will see two groups with the same name but different identifiers. Pay attention to the “announcements” string - only the second group has it. This is the group you should use to send announcements or add members.
By the way, and in our documentation you will find sample requests in all popular programming languages, which can greatly facilitate the development of your integration
And this is how the response from the system will look like, indicating the successful execution of the request:

{
"id": "120363326919215056@g.us",
"name": "A new community of scientists",
"conversationTimestamp": 1727856652,
"subject": "A new community of scientists",
"subjectOwner": "919984351847@s.whatsapp.net",
"subjectTime": 1727856652,
"size": 1,
"creation": 1727856652,
"owner": "919984351847@s.whatsapp.net",
"desc": "This is where we bring together all our faculties to stay connected and up to date with the latest news",
"descId": "9A7C840518933B604F7257DB",
"restrict": false,
"announce": false,
"isCommunity": true,
"isCommunityAnnounce": false,
"joinApprovalMode": false,
"memberAddMode": false,
"participants": [
{
"id": "919984351847@s.whatsapp.net",
"admin": "superadmin"
}
],
"author": "919984351847@s.whatsapp.net"
}

Adding Participants

Now let's understand how to add a user to a WhatsApp community.
Adding a user to a community also follows the principles of adding a participant to a separate WhatsApp group. For this, use endpoint:
POST https://gate.whapi.cloud/communities/{CommunityID}/participants
An example of the request you need to pass can be found below:

curl --request POST \
     --url https://gate.whapi.cloud/communities/120363326919215056%40g.us/participants \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --data '
{
  "participants": [
    "61371989950",
    "919984651849"
  ]
}
'

Due to WhatsApp's anti-spam policy, some contacts will not be added to the group automatically!
All group members are automatically added to the announcements group.
Removing a group from the community also removes members from the announcement group.

Receiving information about community members

It is often necessary to get general information about a community, such as the community name, description, community avatar and member details.
To do this, the following endpoint will be needed:
GET https://gate.whapi.cloud/communities/{CommunityID}
The API request will look like this:

curl --request GET \
     --url https://gate.whapi.cloud/communities/120363330016374615%40g.us \
     --header 'accept: application/json' \
     --header 'authorization: Bearer {Your_Token}'

You will receive the response in the following form:

{
  "id": "120363383016284615@g.us",
  "name": "The fans",
  "type": "group",
  "timestamp": 1726495201,
  "chat_pic": "https://pps.whatsapp.net/v/t61.24694-24/45953409_389421433863366_1005252150886406739_n.jpg?stp=dst-jpg_s96x96&ccb=11-4&oh=01_Q5AaID5KTLWAwXvRX9fgs8wo5ktRhbO6BA8_4BjhtULS9jn2&oe=670A3091&_nc_sid=5e03e0&_nc_cat=108",
  "not_spam": false,
  "last_message": {
    "id": "ASh2dw-wngBq53PmZvvVw",
    "type": "system",
    "subtype": "group_change_icon",
    "chat_id": "120363383016284615@g.us",
    "from": "919984351847",
    "from_me": true,
    "source": "system",
    "timestamp": 1727128547,
    "status": "pending"
  },
  "participants": [
    {
      "id": "306894857630",
      "rank": "admin"
    },
    {
      "id": "61393175919",
      "rank": "creator"
    },
    {
      "id": "905544751391",
      "rank": "admin"
    }
  ],
  "name_at": 1724862124,
  "description": "heavy music fans by country",
  "description_id": "6959470654CD9BE1FB509998",
  "created_at": 1724862124,
  "created_by": "61371989950"
}

It is important to remember that you cannot get information about all members of a community if you are not an administrator of that community. If you are a member, you will only see the number of administrators and the community creator.
However, you can get information about the members of groups that you are a member of as a community member.

Adding an existing WhatsApp group to a community

To connect an existing WhatsApp group to a community, you need to know the community ID as well as the ID of the group you want to connect.

To get the group ID, use the method GET https://gate.whapi.cloud/groups
To add the selected group to the community, you will need the method PUT https://gate.whapi.cloud/communities/{CommunityID}/{GroupID}

Removing a WhatsApp group from the community

Sometimes you may need to remove a group from the community. To do this, use the following method
DELETE https://gate.whapi.cloud/communities/{CommunityID}/{GroupID}

To get the identifier of the required group, use the endpoint we specified earlier in the previous paragraph.

Sending an announcement to a WhatsApp community

Of course, the main purpose of WhatsApp communities is to send announcements. Sending an announcement to a community is technically fully compliant and follows the rules for sending a message to a regular WhatsApp group. To send this message, use standard messaging methods.
Let's consider sending a simple text message as an example. We will need an endpoint as well as the group ID with the announcements parameter:
POST https://gate.whapi.cloud/messages/text
In the request it will look like this:

curl --request POST \
     --url https://gate.whapi.cloud/messages/text \
     --header 'accept: application/json' \
     --header 'authorization: Bearer your_token' \
     --header 'content-type: application/json' \
     --data '
{
  "to": "120363330016384615@g.us",
  "body": "Hello, everybody!"
}
'

Where the to parameter should contain the group ID and the body parameter should contain the text of your message. If you need to send a media file or document, just use the appropriate methods:
to send an image you will need the method
POST https://gate.whapi.cloud/messages/image

to send a document, use this method
POST https://gate.whapi.cloud/messages/document

Summary

As you can see, WhatsApp communities are a convenient and effective tool to increase interaction with your users.
With our API, managing communities becomes even easier and faster, allowing you to easily organize and structure groups for effective communication.

At the same time, using our provider opens up new possibilities in messenger automation! For example, you can:

and more.

We understand that you may have questions or need additional support. That's why our live support team is always available to help you at any stage of integration and utilization. Feel free to ask questions!

We invite you to test our API and see for yourself how easy and convenient it is to manage communities through Whapi.Cloud. Get started today and get the most out of WhatsApp's capabilities for your business!

View all Whapi.Cloud API features

Running WhatsApp bot on Node.js

WhatsApp API for developers — Mon, 01 Apr 2024 10:40:36 +0000

Bot source code and step-by-step guide for setup and launch. Key features: sending messages to private chats and groups, creating groups, sending media files and products, receiving and reading messages, server tips

For those who don't have time to read:

Source code of a powerful WhatsApp bot on GitHub

Github repository with a simple WhatsApp bot - great for beginners!

Introduction

A WhatsApp chatbot allows automatic responses to requests, sending notifications, requesting information, making communication efficient and available 24/7.

This guide for programmers is a step-by-step instruction on setting up and launching your own chatbot using the Whapi.Cloud API on Node.JS, as well as demonstrating the key functions and capabilities of the gateway and bot.

You will be able to use our source code in your project, easily modifying and supplementing the script's functionality. Based on the code, you can create your chatbot or any integration. Easily integrate it into existing workflows, continuing to use WhatsApp as usual!

A short video demonstration of the bot in action

Source Code

The script of this chatbot includes basic functions that are often used by small and medium businesses and covers most tasks:

Sending a plain message;
Sending media: image / file / video;
Sending a contact (vCard);
Sending a product;
Creating a WhatsApp group;
Sending a group invitation;
Sending a message to a WhatsApp group;
Receiving and processing incoming messages;
Responding to an unknown command (for implementing menus, instructions, or a welcome message).

GitHyb: https://github.com/Whapi-Cloud/nodejs-whatsapp-chatbot

WhatsApp API Provider

Whapi.Cloud provides an easy-to-use API gateway compatible with any programming language. This allows you to integrate your website, store, app, or CRM with WhatsApp seamlessly.

Our Cloud API is an independent development and has no restrictions for working with sending messages, groups, channels, statuses, calls, and other functionalities of your messenger. Additionally, access to the API has a fixed price, and no charges are made for sent messages. This is a key advantage of our simple and powerful API.

How to Connect to Whapi.Cloud

Another advantage of our gateway is the speed of onboarding and startup. You will not need to undergo business verification or change your number. Connect your own number and continue using WhatsApp as usual!

So, register at Whapi.Cloud. You will need a valid email address to pass email verification or a Google account.

On the Dashboard, you will find a trial channel individually allocated for you. For the first 5 days, you will have the opportunity to test all the API functionality completely free.

Navigate to the page of this channel by simply clicking on it.

Unlike other providers, we give you the opportunity to connect your existing WhatsApp or WhatsApp Business to the API. Simply scan the QR code as you do in WhatsApp Web, and you'll be ready to go in a few seconds. From Meta's perspective, this is a standard connection to WhatsApp Web, and if you do not use Whapi.Cloud for spamming, your number will continue to work in the usual manner.

Skip the third step 'Channel Settings', as we won't need them right now.

Great, now you have access to the API Token, which will be required for testing and further work with the endpoints. Save this token, as it will come in handy more than once.

Let's move to config.js and replace the token variable by inserting your current key:
token: "YOUR_CHANNEL_TOKEN"

Webhook Configuration

What is a Webhook and Why is it Needed

To receive incoming data from your messenger, such as an incoming message or incoming call or a notification that someone has joined your group, you will need to use a Webhook.

This technology will allow you to instantly receive notifications about any event in your WhatsApp and respond to it.

In simple terms, for example: Contact A sent you a message -> The chatbot script received a message from Contact A -> Checked if this message is a command it recognizes -> Executed the script command (for example, sent a welcome message or sent a product, etc.)

Thus, the two systems (our API gateway connected to WhatsApp and your chatbot) exchange information without the need for any external actions.

Technically, upon receiving a message, the system will perform a POST request with a JSON body to the configured URL of your script. The JSON body will include all the information about the incoming message, such as text, sender's number, sending time, etc., allowing you to read this information on the fly.

Let's move on to setting up this URL!

Locally or on a Server

When developing a WhatsApp bot, you might want to test it locally before deploying it to a server. The simplest way to do this is to use tools like Ngrok, which creates a secure tunnel to your localhost, allowing you to provide access to your local server from the internet.

Let's take a test chatbot link from Ngrok right now. Download Ngrok from the official website and extract it. Open the terminal and navigate to the folder where Ngrok is stored.

Run ./ngrok http PORT_NUMBER, replacing PORT_NUMBER with the port your Express server is running on locally.
Now you should have a public URL that you can use as a URL for your webhook.

Copy this link into the config.js file:
botUrl: "https://84c7-151-33-282-113.ngrok-free.app/hook"

Attention, leave “/hook” at the end of the link! The chatbot script is currently programmed to this address!

Features of Hosting on a Server

To receive incoming webhooks, it is necessary for the public IP address / host to be accessible from the internet. Thus, the Whapi.Cloud server will be able to send a request to your server at the specified address and deliver the incoming hook.

Server configuration:

Whapi.Cloud only works with webhooks that use HTTPS;
Your endpoint must accept POST/PUT/PATCH/DELETE;

Below, in the 'Deployment' chapter, we will talk about several publicly available services where you can host your chatbot.

Configuration and Various Events

Channel and webhook settings in Whapi.Cloud offer extensive customization options that can be particularly useful in projects with individual requirements.

However, to simplify the launch process, we have included the installation of necessary settings directly in the code of our chatbot, freeing you from the need to enter them manually. This allows you to focus on development without worrying about additional configuration.

If you want to delve into customization options or need more detailed webhook setup, you can always consult the full list of options in the Whapi.Cloud Knowledge Base in the article: Detailed Webhook Settings

In the source code from GitHub, the webhook link is automatically assigned to your channel through an API method, so no further action is required on your part. Let's dive a bit deeper into webhook modes and the events about which our service can notify you.

Currently, for sending a webhook, the Method mode is selected. This method is particularly suited for detailed event handling, allowing the use of different HTTP methods for specific actions. Thus, the webhook will differentiate the sent requests and send them to different addresses, for example, https://****/hook/messages (events related to messages) or https://****/hook/statuses (events related to message statuses) or https://****/hook/groups (events related to groups).
There are two more modes for the webhook: Body (directly sends the request body to the link) and Path (fully specifies the API URL request).

The event and the way we notify the original chatbot is POST Messages. This webhook tracks any changes related to new messages, including sent messages and incoming messages.

Learn more about all the possible events (receiving information about groups, channels, calls, statuses, message changes, etc.), supported by our system, in the article: Our Webhooks (Tracked Events)

Launching and Configuring the Bot

Right now, you can test the chatbot! Make sure that the token and webhook address in config.js are correctly specified.

Launching the chatbot is done by running the command node index.js in the terminal from the project's root directory. Your bot should now be active and ready to operate.

By sending a message to the number to which the bot is linked from another phone, you should receive an automatic response. If the bot does not react, we recommend referring to the 'Troubleshooting' section for diagnostics and resolving potential issues.

Predefined Settings (Group and Product)

The config.js file contains preset values, including group and product identifiers, which your chatbot uses for sending messages. To ensure the bot operates correctly in the context of your data, it's necessary to update these parameters according to your needs.

group: '120363167596599603@g.us'
product: '6559353560856703'

The first identifier is for the group to which the chatbot will send the message. You can obtain this identifier by creating a group in WhatsApp or using an existing one. The group identifier can only be obtained through the API.

For this, use the API call 'Get Group List' (method: https://whapi.readme.io/reference/getgroups in Documentation). The group identifier looks like this: 120363194020948049@g.us

So, once you've found the group identifier you need, now copy it into config.js.

Do the same with the products from your catalog (available only in the Business version of the app). Determine the product identifier that will be sent by your chatbot. You can get a list of products using the method https://whapi.readme.io/reference/getproducts in Documentation.

Replace the preset values in config.js with your group and product identifiers. After making changes, save the file and restart the bot. It should now function using the new parameters, allowing you to fully test its operation.

Troubleshooting

Various issues can arise during the testing and operation of the WhatsApp chatbot. Here are a few typical situations and recommendations for their resolution:

The Bot Does Not Respond to Incoming Messages

Ensure you are sending messages to the number on which the bot is running from a different phone. The bot will not be able to respond to messages sent from the same number.
If the bot does not respond to messages from other numbers, check the operation of webhooks. Use services to simulate webhooks, for example, Webhook.site, to ensure which path the callback requests are coming through. Afterwards, check if the path matches the one you have configured. Also, ensure your server responds with 200Ok.

If you encounter difficulties, do not hesitate to contact our technical support for help. You can write in the web chat widget on our site or email care@whapi.cloud. We will assist you and figure out exactly what's wrong with the webhook.

The Bot Sends Messages Non-Stop

Return to the original version of the code. Our script includes a check to determine whether a message is incoming or outgoing, to prevent getting into an infinite loop of sending messages. Infinite sending may occur if there is no check for outgoing messages in the code, causing the bot to call itself, or if there is a cyclic sending of messages in the code.

The Bot Works in Some Chats, But Not in Others

Check your tariff plan on Whapi.Cloud. If you are using the trial mode or the "Sandbox" tariff, interaction is limited to a certain number of chats per month (currently up to 5 chats). In such a case, the bot will not be able to process messages in the sixth chat and subsequent ones.

It's important to remember that many issues can be prevented by carefully checking your chatbot's configuration and logic before launching. Regularly updating your code and paying attention to the details of settings can help avoid most typical errors. And our support team is always in touch and ready to assist you!

Deployment and Using Servers

To ensure your WhatsApp chatbot is available 24/7, it needs to be hosted on a reliable hosting platform. You can use your server, but in this chapter, we will consider the three most popular platforms - Firebase, AWS, and Heroku - and go through the basic steps of deploying your bot on each of them.

The choice of platform depends on your preferences, budget, and project requirements. Each of the considered platforms offers its unique features and advantages. Firebase and AWS Lambda provide powerful backend functionality without the need to manage a server, while Heroku offers simplicity in deploying applications based on Git.

Firebase

Firebase offers Cloud Functions functionality, allowing you to run your bot without worrying about server infrastructure. In our opinion, this is the most optimal option.

Create a project in Firebase Console;
Install Firebase CLI, following the instructions;
Initialize Firebase in your project directory with the command firebase init;
Deploy your bot using the command firebase deploy --only functions.

AWS (Amazon Web Services)

AWS Lambda offers the ability to run code in response to triggers from other AWS services, making it a good choice for a bot.

Register or log in to AWS Management Console;
Create a new Lambda function through the AWS console, selecting API Gateway as the trigger;
Upload your bot's code into the Lambda function;
Configure the API Gateway to interact with your bot and the outside world.

Heroku

Heroku offers an easy-to-use platform for hosting applications, which can automatically deploy code from your Git repository.

Create an account on Heroku;
Install Heroku CLI and log in;
Create a new Heroku app through the console or using the command heroku create;
Link your Git repository to Heroku and perform deployment with the commands git push heroku master;
Set the webhook URL provided by Heroku.

Expanding Functionality

After successfully launching and testing your WhatsApp chatbot, there are numerous ways to further expand its functionality to make the bot even more useful and interactive for users. Here are some common use cases:

Sending files via link.

Sending a media file via a link is very simple. The main condition is that the file itself must be directly accessible via the link (which is why Cloud services like Google Drive or Dropbox do not work as they do not provide direct file access). Use the media parameter in any of the methods that allow sending media files. Read more in our article: Endpoint for sending a media file.

Distributing leads among groups.

You will need the group creation function, as well as adding a participant to the group. Adding a participant to a group is straightforward, but there are some nuances. We described in detail in the article: "Adding a new member to a group"

CRM Integration with WhatsApp.

Technically, CRM integration is not much different from a chatbot, except that it adds an additional resource with its own API that needs to be utilized. Add functions that allow users to book services, order products, or receive up-to-date information from external sources in real time.

WhatsApp API Full Documentation

Surveys as an alternative to buttons.

Interactive buttons in WhatsApp are a very convenient tool for customer engagement. However, this feature is not available to most WhatsApp users. We advocate for making communication with users easier, so we offer you a convenient alternative - using surveys as buttons. Detailed article with NodeJS source code and how to use it.

Increasing customer engagement.

Use stories, change your number statuses, put likes and other emojis on your customers' messages, send voice messages - increase engagement in customer service.

Checking for WhatsApp availability on a number.

Check whether a given phone number exists on WhatsApp or not. Determine which phone numbers are active and which cannot receive WhatsApp messages. Integrate into your application before making a broadcast! Source code on GitHub and instructions here.

We provide comprehensive support to our clients! If you have any questions about bot operation, platform setup, or encounter technical difficulties, you can always count on our help.

We hope this guide will help you successfully launch your WhatsApp chatbot. Good luck in your endeavors!

The original article: https://whapi.cloud/setting-up-chatbot-whatsapp-nodejs

WhatsApp API March Update: Short videos, the store, views on the stories

WhatsApp API for developers — Fri, 29 Mar 2024 08:43:15 +0000

Powerful gateway optimization and acceleration, sending short video messages and catalog, stories views and a large amount of other improvements

Whapi.Cloud provides an easy to use API gateway that is compatible with any programming language. It will allow you to integrate your website, store, app or CRM with WhatsApp without nerves.
Our Cloud API is independently developed and has no restrictions to handle messaging, groups, channels, statuses, calls and other functionality of your messenger. At the same time, access to the API has a fixed price, there is no charge for sent messages. This is the key advantage of our simple and powerful API. Here we’ll talk about our March update.

Major Backend Upgrade Boosts Our WhatsApp API Performance

For the past two weeks, we’ve been rigorously testing and analyzing data from our massive backend upgrade, which has significantly enhanced the performance of our WhatsApp API gateway. Our infrastructure has been optimized for maximum performance and efficiency.

This comprehensive upgrade has not only improved channel uptime, but also allows you to process large volumes of chats and messages without any problems or delays.

We have seen an increase in the speed of processing requests by 4–8 times!

Sending short video messages

Whapi.Cloud API allow you to instantly share up to 60-second video in a new format

Video messages on WhatsApp allow you to instantly record and share up to 60-second video messages directly in the chat. Method responsible for sending PTV to your chats:

https://whapi.readme.io/reference/sendmessageshort

Sending and customization of the catalog

https://whapi.readme.io/reference/sendcatalog

Sends the store linked to the phone number.

The new API Call is responsible for generating and sending a “product” type message with a link to your store.

The method allows to customize the image, title and description of the store.

Allows you to send a store associated with any phone number, not just your own.

Information about views of stories and messages in the group

Now you can get information about who and how many times your status (stories) or a message in a group has been viewed. All you need is the message ID.

https://whapi.readme.io/reference/getmessageviewstatuses

See who’s been looking at your statuses and messages!

Example of a response to a request:

{
  "statuses": [
    {
      "id": "IXiocXvwx5tM6M1U0.Ma.g-0okBq526t1E1XA-EoRX88I",
      "code": 4,
      "status": "read",
      "recipient_id": "120363540426484704@g.us",
      "timestamp": "1710423370",
      "viewer_id": "61398176983" // The number of the contact who viewed your status
    }
  ]
}

Webhook to view status

You will now be able to receive notifications when your stories are viewed with details: which number viewed your status and when.

Make sure you have PUT statuses enabled in your channel settings.

An example of an incoming webhook when viewing a story:

{
  "statuses": [
    {
      "id": "yqJ_muc_kO8-1CcA-E8JdK1c",
      "code": 4,
      "status": "read",
      "recipient_id": "stories",
      "timestamp": "1710423471",
      "viewer_id": "61398176983" // The number of the contact who viewed your status
    }
  ],
  "event": {
    "type": "statuses",
    "event": "put"
  },
  "channel_id": "MANTIS-M72HC"
}

Channel settings: Several new features

A few of the new settings are described below

Automatic loading of profile pictures of all contacts when authorizing a number

There is a new channel setting, “media init_avatars”. Set it to true to not download all avatars of contacts immediately after the number is connected, which will reduce the amount of requests in WhatsApp and increase security, especially for new numbers. Activate this setting if you need to know about contact images immediately (e.g. you have developed a webchat service)

Offline mode for your number (affects iPhone notifications)

The “offline_mode” parameter allows the account to not be labeled as online. This solves the problem for Iphones with not receiving push notifications.

If true, the API will not send the online status to the server when you connect. This will allow you to receive push notifications to devices connected to the number. After changing the setting, you need to re-authorize the channel.

Uploading old/new messages

Parameter “full_history” — allows you to fully synchronize the history of messages in the local cache. This means that after connecting the number to the channel, you will immediately have access to the entire history of correspondence. If true, all messages will be cached after connection. If false, only new messages will be cached. After changing the setting, you need to re-authorize.

CSV channels export in partner account

We gave our partners the opportunity to export information about all channels in the project in CSV format. The exported file has information about channels at the moment of downloading: Name, ID, Phone Number, Work Period, Status, Mode. We have a very favorable approach to White Label WhatsApp API!

Fixed

Fixed getting products;
Fixed Unread parameter value calculation when getting Chats;
Fixed Total parameter value counting when getting groups;
Fixed getting messages from channel (Get newsletter messages) ;
Business version of the application is defined more accurately;
File Link Sending Without an Extension.

Remember, if you have any questions or issues along the way, our support team is always available to help. We value every user and strive to ensure that your experience with our API is as smooth and efficient as possible.

You can write to the web chat widget on our main website, or in your personal account. Or write to us by e-mail: care@whapi.cloud

Replacing interactive buttons in WhatsApp API

WhatsApp API for developers — Wed, 28 Feb 2024 17:24:07 +0000

Interactive buttons in WhatsApp are a very convenient tool for working with users.
Many observations have confirmed that it is easier for a customer to reply with one button than to type a reply in the usual way, accordingly, the conversion rate of responses can increase by 1.5 - 2 times. However, this feature is not available to every user, but only for WhatsApp business accounts that work via Meta Cloud API.

We have already told you separately in the article in detail about how our API differs from Cloud API Meta, what are the differences in general, what are the advantages of each gateway. So let's leave it to you to study it on your own and get straight to the point!

We are in favor of facilitating communication with users, so we offer you a profitable alternative - polls.
For the user, polls and interactive buttons are functionally similar. Surveys also require the user to click on the desired line, so this simplification is considered comfortable.

To work with surveys, you will need to use the POST /messages/poll method. You can find out more about it and test it here:
https://whapi.readme.io/reference/sendmessagepoll

Sending a poll

Sending a poll is quite easy, you need a few parameters in the body of the request:

to - in this parameter specify the Chat ID of the recipient (group, or personal number) to whom we send the survey. (Send only numbers, without formatting or masks).
title - here specify the full message to the conversation partner, the text of your question.
options - specify the user's response options. There can be from 2 to 12 of them.
count - this parameter affects the amount of response options from the conversation partner. For example, several or only one answer from the whole survey.

import requests

url = "https://gate.whapi.cloud/messages/poll"

payload = {
    "options": ["Eyelash extensions", "Eyebrow correction and coloring", "Massage", "I'm fine with everything!"],
    "title": "Thank you for visiting the Etteri salon! We are interested in ensuring that our beauty salon meets all your wishes. What service do you think is missing in our beauty salon?",
    "count": 1
}
headers = {
    "accept": "application/json",
    "content-type": "application/json",
    "authorization": "Bearer YPZapY69pl9j0xQpxoMqqsKMoBat1p8h"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

Tracking a user's selection in a poll

Polls are of a customized type "type": "poll". At the same time, each option that can be voted for by the client also has its own identifier. For example:

"results": [
          {
            "name": "I'm good",
            "voters": [],
            "count": 0,
            "id": "YCUAzJ4pYtRgSP+k/udEwRdvHxxuRQmNCrdTKz/K2TU="
          },
          {
            "name": "Can't complain",
            "voters": [],
            "count": 0,
            "id": "f61LjJqD6KEefNsuDQrvFXAB1iufPN3U1ykIOxD8DRc="
          }
        ]

Whereas when you vote, the webhook will receive full details of the selected option in the poll.

{
 "id": "f61LjJqD6KEefNsuDQrvFXAB1iufPN3U1ykIOxD8DRc=",
 "name": "Can't complain",
 "count": 1,
 "voters": [
    "61399176983@s.whatsapp.net"
  ]
 }

This way, you will be able to handle your customers' responses and respond appropriately. For example, responding with a pre-prepared answer.

Node.Js source code

We have prepared a simple and easy to understand source code for you to implement in your survey response integration or bot:
https://github.com/Whapi-Cloud/whatsapp-api-send-poll-example

WhatsApp bot integration with Google Sheets to send out messages [Source code + Step-by-Step Guide]

WhatsApp API for developers — Tue, 13 Feb 2024 09:39:38 +0000

We are pleased to announce the source code release of our script designed to simplify WhatsApp integration with Google Sheets for efficient mailings. This script automatically sends text messages from specified Google Sheets cells to phone numbers also specified in the table cells. After sending the message, the script records the status of each sent message back to the table. Furthermore, if a response is received from the customer, the bot will record the first message received in a separate cell, providing a convenient way to track feedback.

Google Sheets WhatsApp Sender

This source code is open source for use in your current work or can serve as a great starting point for developing your own project. We believe it will become a powerful tool in your arsenal for implementing effective communications and marketing strategies via WhatsApp, using the power of Google Sheets to organize and automate your processes.

To use the script functionality you will need:

Api-token of the channel from Whapi.Cloud service;
Link to Google SpreadSheet, with service account access;
Key.js from Google Project;
Set the Webhook address to which the bot will send responses.

Full step-by-step instructions are available in our knowledge base: https://support.whapi.cloud/help-desk/source-code/whatsapp-api-google-sheets

How to send a post to WhatsApp Channel via API

WhatsApp API for developers — Wed, 27 Dec 2023 09:40:22 +0000

Our Cloud API supports WhatsApp Channels, a brand-new feature introduced by WhatsApp. It’s a unidirectional broadcast tool where administrators can send text, photos, videos, stickers, and polls. And users receive push notifications of updates from the channel like a private message.

To work with our service, you need to have an account and connect any number to an available channel on the dashboard. In order to automate WhatsApp, you need to sync our API with your phone number. Here's how: navigate to your personal dashboard, select your channel, and get a QR code there.

To send a message to the channel you need to know the channel ID.

In order to find out the identifier use the following method: GET /newsletters

import requests

url = "https://gate.whapi.cloud/newsletters?count=100"

headers = {
    "accept": "application/json",
    "authorization": "Bearer iBNBwpo21BDCsbdvVwShV4czcXPbBmcs"
}

response = requests.get(url, headers=headers)

print(response.text)

The channel ID looks like this: 120363171744447809@newsletter

Once you know the channel ID, you can use the method to send any message. For example, a text message:

import requests

url = "https://gate.whapi.cloud/messages/text"

payload = {
    "typing_time": 0,
    "to": "120363171744447809@newsletter",
    "body": "Hello, world!"
}
headers = {
    "accept": "application/json",
    "content-type": "application/json",
    "authorization": "Bearer iBNBwpo21BDCsbdvVwShV4czcXPbBmcs"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

In the “to” parameter you insert the ID of the channel ( 120363171744447809@newsletter ) you want to send the message to. And in the “body”, the text of the message.

You can write to the web chat widget on our main website, or in your personal account. Or write to us by e-mail: care@whapi.cloud