docker-compose up -d

devlikeapro/waha

Let's dive into WAHA, a very interesting tool for us software engineers. It's a "WhatsApp HTTP API," which basically means it's a way to interact with WhatsApp programmatically using simple web requests. Think of it as a bridge between your application and WhatsApp.

From a software engineer's perspective, WAHA is a fantastic solution because it abstracts away all the complexity of dealing with WhatsApp's own APIs or the challenges of browser automation. Here's why you'd find it incredibly useful

Simplifies Integration
Instead of learning and implementing a complex WhatsApp library, you can simply send standard HTTP requests (like POST or GET) to WAHA. This is a language-agnostic approach, meaning you can use it with any programming language you're comfortable with—Python, JavaScript, Java, Go, etc.

Scalability & Reliability
WAHA offers different "engines" (WEBJS, NOWEB, GOWS). This gives you options for how you want to run your WhatsApp integration. For example, the GOWS engine, written in Go, is known for its performance and lower resource usage, which is great for building scalable solutions. You can choose the engine that best fits your project's needs.

Rapid Development
You can quickly prototype and build applications that interact with WhatsApp. Need to send a notification to a user after a database event? Just send a simple API call to WAHA. No need to set up a full-blown WhatsApp Business account or deal with their potentially complex approval processes.

Flexible Use Cases
This tool is perfect for creating

Automated Bots
Answering common customer questions, providing order status updates, or sending reminders.

Notification Systems
Sending alerts for critical events, like a server going down.

Data Collection
Building simple surveys or forms through WhatsApp conversations.

Custom Integrations
Connecting WhatsApp to your existing CRM, ERP, or other internal systems.

The beauty of WAHA is its easy setup. The most straightforward way to get started is by using Docker. This avoids any dependency issues and gets you up and running in a minute.

Step 1
Install Docker

Make sure you have Docker and Docker Compose installed on your system.

Step 2
Start WAHA with Docker Compose

You can use a simple docker-compose.yml file to get everything configured. Here's a basic example

version: '3.8'

services:
  waha:
    image: devlikeapro/waha
    container_name: waha
    ports:
      - "3000:3000"
    volumes:
      - ./data:/data
    environment:
      # Use the 'GOWS' engine for better performance
      - WAHA_ENGINE=GOWS
    restart: always

Save this as docker-compose.yml and run it in your terminal

docker-compose up -d

This command will

Download the WAHA image.

Start the container.

Map port 3000 from the container to your host machine.

Create a data directory to store session information.

Use the GOWS engine.

Step 3
Connect to WhatsApp

Now, open your web browser and go to http://localhost:3000. You'll see a QR code. Just open WhatsApp on your phone, go to "Linked Devices," and scan the QR code. Once it's connected, you're ready to start using the API!

Let's look at some simple code examples to show you how you would interact with WAHA.

This Python script uses the requests library to send a message.

import requests
import json

# Your WAHA API endpoint
waha_api_url = "http://localhost:3000/api/sendText"

# The session name (default is 'default')
session_name = "default"

# The phone number you want to send the message to (including country code)
# Replace with a real number
phone_number = "1234567890"

# The message you want to send
message_text = "Hello from my application!"

# The data payload for the API request
payload = {
    "session": session_name,
    "chatId": f"{phone_number}@c.us",
    "text": message_text
}

# The headers for the request
headers = {
    'Content-Type': 'application/json'
}

try:
    response = requests.post(waha_api_url, data=json.dumps(payload), headers=headers)
    response.raise_for_status()  # Raise an exception for bad status codes
    print("Message sent successfully!")
    print(response.json())
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

Here's how you'd do the same thing with Node.js using fetch.

const WAHA_API_URL = "http://localhost:3000/api/sendText";

const payload = {
    session: "default",
    chatId: "[email protected]", // Replace with a real number
    text: "Hello from my Node.js app!"
};

fetch(WAHA_API_URL, {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
})
.then(response => {
    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
})
.then(data => {
    console.log("Message sent successfully!");
    console.log(data);
})
.catch(error => {
    console.error("An error occurred:", error);
});

WAHA is a powerful and flexible tool that simplifies a lot of the work involved in building applications that use WhatsApp. It's built by engineers, for engineers, with a clear focus on ease of use, scalability, and integration. By using a standard HTTP API, it frees you from platform-specific complexities and lets you focus on building the logic of your application.