DEV Community: Ivan Amato

The Power of WhatsApp Automation in Business

Ivan Amato — Tue, 03 Jun 2025 21:24:53 +0000

The Power of WhatsApp Automation in Business

WhatsApp automation can revolutionize how businesses communicate with both internal teams and customers. Here are some key applications:

Administrative Reporting: Send daily, weekly, or monthly reports to managers and executives.
Customer Order Notifications: Update customers on their order status in real-time.
Appointment Reminders: Automatically send reminders to clients about upcoming appointments.
Customer Support: Provide instant responses to common customer queries.
Internal Alerts: Notify team members about critical system events or emergencies.
Marketing Campaigns: Send personalized offers or updates to opted-in customers.

Let's explore how to implement some of these use cases using Python and SuperSimpleWhats (SSW).

Implementing SSW API in Python: Multiple Use Cases

We'll create a Python script that demonstrates three common use cases: sending admin reports, order notifications, and appointment reminders.

Step 1: Install Required Libraries

pip install requests python-dotenv

Step 2: Set Up Environment Variables

Create a .env file in your project directory:

SSW_API_KEY=your_api_key_here
SSW_DEVICE_NAME=your_device_name
ADMIN_PHONE=+1234567890

Step 3: Create the Python Script

Save this as whatsapp_automation.py:

import os
import requests
from dotenv import load_dotenv
from datetime import date, datetime, timedelta

# Load environment variables
load_dotenv()

SSW_API_KEY = os.getenv('SSW_API_KEY')
SSW_DEVICE_NAME = os.getenv('SSW_DEVICE_NAME')
ADMIN_PHONE = os.getenv('ADMIN_PHONE')

SSW_BASE_URL = "https://app.supersimplewhats.com/v1"

def send_whatsapp_message(recipient, message):
    headers = {
        "Authorization": SSW_API_KEY,
        "Content-Type": "text/plain"
    }

    response = requests.post(
        f"{SSW_BASE_URL}/messages/send/{SSW_DEVICE_NAME}/{recipient}",
        headers=headers,
        data=message
    )

    if response.status_code == 200:
        print(f"Message sent successfully to {recipient}")
    else:
        print(f"Failed to send message to {recipient}. Status code: {response.status_code}")

def generate_admin_report():
    # This is a placeholder function. In a real scenario, you would
    # gather and process your data here.
    today = date.today().strftime("%Y-%m-%d")
    return f"Daily Admin Report for {today}:\n\n" \
           f"- Total Sales: $5,678\n" \
           f"- New Customers: 12\n" \
           f"- Customer Satisfaction: 4.7/5\n" \
           f"- Pending Orders: 8"

def send_order_notification(customer_phone, order_id, status):
    message = f"Order Update:\n\n" \
              f"Your order #{order_id} has been {status}.\n" \
              f"Thank you for your business!"
    send_whatsapp_message(customer_phone, message)

def send_appointment_reminder(customer_phone, appointment_time, service):
    message = f"Appointment Reminder:\n\n" \
              f"This is a friendly reminder that you have a {service} appointment scheduled for " \
              f"{appointment_time.strftime('%Y-%m-%d at %H:%M')}.\n" \
              f"We look forward to seeing you!"
    send_whatsapp_message(customer_phone, message)

if __name__ == "__main__":
    # Send admin report
    admin_report = generate_admin_report()
    send_whatsapp_message(ADMIN_PHONE, admin_report)

    # Send order notification (example)
    customer_phone = "+9876543210"
    order_id = "ORD12345"
    order_status = "shipped"
    send_order_notification(customer_phone, order_id, order_status)

    # Send appointment reminder (example)
    appointment_customer = "+1122334455"
    appointment_time = datetime.now() + timedelta(days=1)  # Tomorrow
    appointment_service = "haircut"
    send_appointment_reminder(appointment_customer, appointment_time, appointment_service)

Step 4: Run the Script

Execute the script to send all the messages:

python whatsapp_automation.py

Expanding Your WhatsApp Automation

This script demonstrates three common use cases, but the possibilities are vast. Here are some ideas to further leverage WhatsApp automation in your business:

Inventory Alerts: Notify purchasing managers when stock levels are low.
Sales Milestones: Automatically congratulate the sales team when they hit targets.
Customer Feedback: Send follow-up messages asking for product or service reviews.
Event RSVPs: Manage event attendance by sending reminders and collecting confirmations.
Lead Nurturing: Set up a series of automated messages to guide potential customers through your sales funnel.
Employee Notifications: Send important company announcements or emergency alerts to staff.

Best Practices for WhatsApp Business Automation

Obtain Consent: Always get explicit permission from users before sending them automated messages.
Respect Frequency: Don't overwhelm recipients with too many messages.
Provide Value: Ensure each automated message serves a clear purpose and benefits the recipient.
Allow Opt-Out: Include clear instructions on how to opt out of automated messages.
Personalize: Use the recipient's name and relevant details to make messages feel more personal.
Monitor Performance: Regularly review open rates and engagement to refine your messaging strategy.

Conclusion

By leveraging the power of WhatsApp automation with SuperSimpleWhats and Python, businesses can significantly enhance their communication efficiency. From keeping administrators informed with real-time reports to providing timely updates to customers, WhatsApp automation opens up a world of possibilities for improved engagement and operational efficiency.

Remember, while automation can greatly streamline your processes, it's crucial to maintain a balance. Ensure that your automated messages feel personal and valuable, and always be ready to provide human interaction when necessary.

As you implement these solutions, continually gather feedback from both your team and customers to refine and improve your WhatsApp communication strategy. With the right approach, WhatsApp automation can become a powerful tool in your business communication arsenal.

Building a WhatsApp Order Notification System with Node.js and Webhooks

Ivan Amato — Mon, 26 May 2025 14:03:44 +0000

Online shoppers expect instant communication. As soon as they click "Place Order," they want to know their purchase was successful and when it's on the way.

Email confirmations are the norm, but they often get buried or delayed. SMS is better—but WhatsApp? Now you're speaking the customer's language.

In this post, we'll walk you through building a simple but powerful WhatsApp order notification system using Node.js, Express, and webhooks. You’ll learn how to receive order events from your e-commerce backend and instantly notify the customer via WhatsApp.

This tutorial is developer-focused, practical, and API-driven. Let’s get started.

Prerequisites

Here’s what you need before we dive in:

Node.js installed (v14 or later)
Basic knowledge of Express and working with APIs
A way to expose a local server to the internet (e.g., ngrok)
Access to a WhatsApp Business API (via any provider that supports message sending via REST)
Familiarity with JSON and webhooks

Optional:

Postman or curl to test your endpoint

Step 1: Setting Up a Simple Express Server

Let’s begin by creating a simple webhook listener that will receive order data and trigger a WhatsApp message.

First, initialize your Node.js project:

mkdir whatsapp-order-notifier
cd whatsapp-order-notifier
npm init -y

Install the required packages:

npm install express axios body-parser dotenv

Create a file named index.js and add the following boilerplate:

const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

app.use(bodyParser.json());

app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`);
});

Now let’s define a POST endpoint that will handle incoming order data.

app.post('/order-confirmation', async (req, res) => {
  const { customerName, phoneNumber, orderId, total } = req.body;

  if (!customerName || !phoneNumber || !orderId || !total) {
    return res.status(400).json({ message: 'Missing required fields' });
  }

  try {
    await sendWhatsAppMessage({ customerName, phoneNumber, orderId, total });
    res.status(200).json({ message: 'WhatsApp message sent!' });
  } catch (error) {
    console.error('Error sending WhatsApp message:', error.message);
    res.status(500).json({ message: 'Internal server error' });
  }
});

Step 2: Sending the WhatsApp Message

Now, let’s implement the sendWhatsAppMessage function using axios to send a POST request to your WhatsApp provider’s API.

For this example, we’ll use supersimplewhats api.

Create a new file called whatsapp.js (or place it inside your main file):

const axios = require('axios');

async function sendWhatsAppMessage({ customerName, phoneNumber, orderId, total }) {
    const message = `Hi ${customerName}, thanks for your order #${orderId}! Total: ${total}. We'll notify you when it ships.`;
    const config = {
        headers: {
            Authorization: `Bearer ${process.env.WHATSAPP_API_TOKEN}`,
            'Content-Type': 'text/plain',
        },
    };

    const url = `${process.env.WHATSAPP_API_URL}/${process.env.WHATSAPP_API_DEVICE_NAME}/${phoneNumber}`;

    const response = await axios.post(url, message, config);
    console.log('WhatsApp message sent:', response.data);

    return response.data;
}

module.exports = { sendWhatsAppMessage };

Don’t forget to import it in index.js:

const { sendWhatsAppMessage } = require('./whatsapp');

Then, in your .env file, set the API token and endpoint:

WHATSAPP_API_TOKEN=your-supersimplewhats-api-key
WHATSAPP_API_URL=https://app.supersimplewhats.com/v1/messages/send/
WHATSAPP_API_DEVICE_NAME=your-supersimplewhats-device-name

Step 3: Testing with a Mock Request

Now that your webhook is up and running, let’s test it.

First, start the server:

node index.js

Expose it using ngrok (or another tunneling tool):

ngrok http 3000

You’ll get a public URL like https://abc123.ngrok.io. This is the URL you’ll use to simulate a webhook request.

Use Postman or curl to send a test request:

curl -X POST https://abc123.ngrok.io/order-confirmation \
  -H "Content-Type: application/json" \
  -d '{
    "customerName": "Ana Silva",
    "phoneNumber": "+5511999999999",
    "orderId": "12345",
    "total": "$ 249.90"
  }'

If everything is working, your WhatsApp API provider should deliver the message to the specified number.

Wrapping Up

And there you have it — a functional WhatsApp order notification system built in under 100 lines of code.

With just Node.js, Express, and your provider's API, you've created a highly effective notification tool that gives your customers peace of mind and keeps them engaged.

Want to go further?

You can extend this project to:

Send messages for different order statuses (e.g., "Shipped", "Out for delivery")
Include tracking links or support contact info
Localize messages based on customer language
Integrate with Shopify, WooCommerce, or a headless CMS

For developers building e-commerce platforms, integrating WhatsApp notifications is a lightweight but powerful UX upgrade.

Have questions or want a GitHub starter repo? Reach out!

Happy coding!