WAHA

https://waha.devlike.pro/docs
Admin
WAHA is a WhatsApp API that can be installed on your own server, allowing for quick setup and...
Tokens:294,298
Snippets:1,302
Trust Score:6
Update:8 months ago
Show doc for...
Tokens:
Raw
### Docker Installation and Setup

Source: https://waha.devlike.pro/docs/integrations/python

Instructions for downloading and running the WAHA Docker container, including specific steps for ARM architecture.

```APIDOC
## Docker Installation and Setup

### Download and start image

First, run the WhatsApp API locally by downloading and starting the Docker container.

**Standard (AMD64) Architecture:**
```bash
# Download the image
docker pull devlikeapro/waha
# Run the docker container
docker run -it --rm --network=host -e WHATSAPP_HOOK_URL=http://localhost:5000/bot -e "WHATSAPP_HOOK_EVENTS=*" --name waha devlikeapro/waha
```

**ARM Architecture (Apple Silicon, M1, etc.):**
```bash
# Download the image
docker pull devlikeapro/waha:arm
# Rename it to use the standard image name
docker tag devlikeapro/waha:arm devlikeapro/waha
# Run the docker container
docker run -it --rm --network=host -e WHATSAPP_HOOK_URL=http://localhost:5000/bot -e "WHATSAPP_HOOK_EVENTS=*" --name waha devlikeapro/waha
```

After running, the last line of the logs should indicate: `WhatsApp API is running on: http://[::1]:3000`.
```

--------------------------------

### Install Dependencies

Source: https://waha.devlike.pro/docs/integrations/go

Instructions for installing the necessary Go dependencies for the WAHA API.

```APIDOC
## Install Dependencies

### Description
Installs the required GoFiber dependency for WAHA integration.

### Method
`go get`

### Endpoint
`github.com/gofiber/fiber/v2`

### Parameters
None

### Request Example
```bash
go get -u github.com/gofiber/fiber/v2
```

### Response
None
```

--------------------------------

### Install WAHA Go Dependencies

Source: https://waha.devlike.pro/docs/integrations/go

Installs the Go Fiber framework, which is commonly used for building web applications and APIs in Go. This is a prerequisite for the other examples.

```go
go get -u github.com/gofiber/fiber/v2
```

--------------------------------

### Run WAHA Docker Container

Source: https://waha.devlike.pro/docs/overview/quick-start

Starts the WAHA WhatsApp API using Docker. This command is for initial testing and not production. It maps ports and mounts a volume for sessions.

```bash
docker run -it --env-file "$(pwd)/.env" -v "$(pwd)/sessions:/app/.sessions" --rm -p 3000:3000 --name waha devlikeapro/waha
```

--------------------------------

### WAHA Docker Installation and Run

Source: https://waha.devlike.pro/docs/integrations/kotlin

Instructions to download and run the WAHA Docker container for local WhatsApp API interaction.

```APIDOC
## Docker Installation and Run

### Description
Download and start the WAHA Docker container to run the WhatsApp API locally. This exposes an HTTP API for interaction with WhatsApp Web.

### Method
`docker pull`, `docker run`

### Endpoint
N/A

### Parameters
#### Environment Variables
- **WHATSAPP_HOOK_URL** (string) - Required - The URL to send webhook notifications to.
- **WHATSAPP_HOOK_EVENTS** (string) - Optional - Comma-separated list of events to receive notifications for (e.g., `*` for all events).

### Request Example
```bash
# Download the image
docker pull devlikeapro/waha
# Run the docker container
docker run -it --rm --network=host -e WHATSAPP_HOOK_URL=http://localhost:5000/bot -e "WHATSAPP_HOOK_EVENTS=*" --name waha devlikeapro/waha
```

### Response
#### Success Response
Logs indicating the API is running, e.g., `WhatsApp API is running on: http://[::1]:3000`

#### Response Example
N/A
```

--------------------------------

### Run WAHA with Docker (Development)

Source: https://waha.devlike.pro/docs/how-to/install

This command initiates a WAHA container for development purposes. It's a quick way to get started but is not recommended for production environments due to security and reliability considerations.

```bash
docker run ... devlikeapro/waha
```

--------------------------------

### WAHA Docker Installation and Run (ARM)

Source: https://waha.devlike.pro/docs/integrations/kotlin

Instructions to download and run the WAHA Docker container on ARM-based systems (e.g., Apple Silicon).

```APIDOC
## Docker Installation and Run (ARM)

### Description
Download and start the WAHA Docker container on ARM-based systems. This version is optimized for ARM architecture.

### Method
`docker pull`, `docker tag`, `docker run`

### Endpoint
N/A

### Parameters
#### Environment Variables
- **WHATSAPP_HOOK_URL** (string) - Required - The URL to send webhook notifications to.
- **WHATSAPP_HOOK_EVENTS** (string) - Optional - Comma-separated list of events to receive notifications for (e.g., `*` for all events).

### Request Example
```bash
# Download the image for ARM
docker pull devlikeapro/waha:arm
# Rename it to use the standard image name
docker tag devlikeapro/waha:arm devlikeapro/waha
# Run the docker container
docker run -it --rm --network=host -e WHATSAPP_HOOK_URL=http://localhost:5000/bot -e "WHATSAPP_HOOK_EVENTS=*" --name waha devlikeapro/waha
```

### Response
#### Success Response
Logs indicating the API is running, e.g., `WhatsApp API is running on: http://[::1]:3000`

#### Response Example
N/A
```

--------------------------------

### Initialize WAHA Configuration

Source: https://waha.devlike.pro/docs/overview/quick-start

Generates a .env file containing credentials for WAHA dashboard and API key. The generated credentials should be kept secure.

```bash
docker run --rm -v "$(pwd)":/app/env devlikeapro/waha init-waha /app/env
```

--------------------------------

### Download WAHA Docker Image

Source: https://waha.devlike.pro/docs/overview/quick-start

Downloads the WAHA Docker image. For WAHA Plus, it includes login and logout steps. ARM-specific images are also available and can be retagged.

```bash
docker pull devlikeapro/waha
```

```bash
docker login -u devlikeapro -p {KEY}
docker pull devlikeapro/waha-plus
docker logout
```

```bash
# Download the image
docker pull devlikeapro/waha:arm
# Rename it, so you can use devlikeapro/waha image in other place
docker tag devlikeapro/waha:arm devlikeapro/waha
```

```bash
docker login -u devlikeapro -p {KEY}
docker pull devlikeapro/waha-plus:arm
docker logout

# Rename it, so you can use devlikeapro/waha image in other place
docker tag devlikeapro/waha-plus:arm devlikeapro/waha-plus
```

--------------------------------

### Start Session (POST /api/sessions/{session}/start)

Source: https://waha.devlike.pro/docs/how-to/sessions

Starts a specified session. This is an idempotent operation, meaning calling it multiple times will only start the session if it is not already running. It requires an API key for authentication.

```curl
curl -X 'POST' \
  'http://localhost:3000/api/sessions/default/start' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json'
```

```python
import requests

url = "http://localhost:3000/api/sessions/default/start"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Content-Type": "application/json",
}

response = requests.post(url, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/sessions/default/start";
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Content-Type': 'application/json',
};

axios.post(url, {}, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/sessions/default/start";

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Content-Type: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Python Example: Receive Message Webhook

Source: https://waha.devlike.pro/docs/integrations/python

A Python Flask example demonstrating how to set up a webhook to receive incoming WhatsApp messages.

```APIDOC
## Using Built-in HTTP API - Receive Message

### Description
This example demonstrates setting up a basic Flask webhook server to receive and process incoming WhatsApp messages.

### Install Dependencies
```bash
pip install flask
```

### Code Example (`whatsapp_echo_bot.py` or similar)
```python
from flask import Flask, request

app = Flask(__name__)

# Placeholder for message processing logic
def process_message(message_data):
    print("Received message:", message_data)
    # Add your message handling logic here
    # For example, echo the message back

@app.route("/bot", methods=["POST"])
def whatsapp_webhook():
    data = request.get_json()
    print("Webhook received:", data)
    
    # Check if the event is a message
    if data and data.get("event") == "message":
        payload = data.get("payload")
        if payload:
            process_message(payload)
            
    return "OK", 200 # Respond with OK to acknowledge receipt

if __name__ == "__main__":
    # Run the Flask app, accessible from your Docker network
    # Ensure WHATSAPP_HOOK_URL is set to http://<your-host-ip>:5000/bot
    app.run(host='0.0.0.0', port=5000)
```

**To run this:**
1. Save the code as a Python file (e.g., `app.py`).
2. Install Flask: `pip install Flask`.
3. Run the server: `flask run` or `python app.py`.
4. Ensure your `WHATSAPP_HOOK_URL` environment variable in the Docker run command points to this server (e.g., `http://<your-host-ip>:5000/bot`).
```

--------------------------------

### Start Session with Debug Logs

Source: https://waha.devlike.pro/docs/overview/changelog

Starts a session and enables debug and verbose logs for the session. Useful for troubleshooting.

```APIDOC
## Start Session with Debug Logs

### Description
Starts a session and enables debug and verbose logs for the session. Useful for troubleshooting.

### Method
POST

### Endpoint
/api/sessions/start

### Parameters
#### Request Body
- **sessionName** (string) - Required - The name of the session to start.
- **configDebug** (boolean) - Optional - Set to `true` to enable debug and verbose logs.

### Request Example
```json
{
  "sessionName": "default",
  "configDebug": true
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **message** (string) - A message indicating the session status.

#### Response Example
```json
{
  "success": true,
  "message": "Session started successfully."
}
```
```

--------------------------------

### Start Session

Source: https://waha.devlike.pro/docs/how-to/sessions

Starts a previously created or stopped WhatsApp session.

```APIDOC
## POST /api/sessions/{name}/start

### Description
Starts a previously created or stopped WhatsApp session, making it ready for use.

### Method
POST

### Endpoint
/api/sessions/{name}/start

### Parameters
#### Path Parameters
- **name** (string) - Required - The name of the session to start.

### Request Example
None

### Response
#### Success Response (200)
- **message** (string) - Confirmation message indicating the session start was initiated.

#### Response Example
{
  "message": "Session starting"
}
```

--------------------------------

### Session Management and QR Code Scanning

Source: https://waha.devlike.pro/docs/integrations/python

Steps to start a session, obtain a QR code, and scan it using your mobile WhatsApp application.

```APIDOC
## Session Management and QR Code Scanning

1.  Open the Swagger API documentation in your browser: `http://localhost:3000/`.
2.  **Start a session:**
    *   Find the `POST /api/sessions` request.
    *   Press **Try it out**.
    *   Execute the request with a session name (e.g., `default`).
3.  **Get QR Code:**
    *   Find the `GET /api/screenshot` endpoint.
    *   Execute it. This will display the QR code.
4.  **Scan QR Code:**
    *   Open your mobile WhatsApp application.
    *   Go to Settings > Linked Devices > Link a device and scan the QR code shown in the browser.
5.  **Verify Session:**
    *   Execute `GET /api/screenshot` again. It should now show a screenshot from WhatsApp Web, confirming the session is active.
```

--------------------------------

### Session Metadata Example

Source: https://waha.devlike.pro/docs/how-to/events

Illustrates how to include custom metadata when starting a session, which will then be included in subsequent webhook payloads.

```json
{
  "event": "message",
  "session": "default",
  // 'metadata' provided when you created the session
  "metadata": {
    "user.id": "123",
    "user.email": "email@example.com"
  },
  ...
}
```

--------------------------------

### WAHA Session Management and QR Code Scanning

Source: https://waha.devlike.pro/docs/integrations/kotlin

Steps to start a session, obtain a QR code, and scan it to connect your WhatsApp account to WAHA.

```APIDOC
## Session Management and QR Code Scanning

### Description
Manage your WhatsApp session by starting it via the API, obtaining a QR code, and scanning it with your mobile device. This process links your WhatsApp account to the WAHA API.

### Method
`POST`, `GET`

### Endpoint
- `POST /api/session`
- `GET /api/screenshot`

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
##### `POST /api/session`
- **session** (string) - Required - The name for the session (e.g., `default`).

### Request Example
1. **Start Session:**
   - Access Swagger UI at `http://localhost:3000/`.
   - Find `POST /api/session`, press "Try it out", and execute with `{"session": "default"}`.

2. **Get QR Code:**
   - Find `GET /api/screenshot` and execute it.

### Response
#### Success Response (200)
- **QR Code Image**: Displayed when `GET /api/screenshot` is executed after starting a session.
- **Session Status**: Confirmation of session start.

#### Response Example
N/A (QR code is displayed visually)
```

--------------------------------

### WAHA Kotlin Webhook Receiver Example

Source: https://waha.devlike.pro/docs/integrations/kotlin

Example Kotlin code using Ktor server to set up a webhook endpoint for receiving messages from WAHA.

```APIDOC
## Kotlin Webhook Receiver Example

### Description
This Kotlin code snippet demonstrates how to set up a basic Ktor server to act as a webhook endpoint, receiving and processing incoming messages from the WAHA API.

### Method
`POST`

### Endpoint
`/bot` (or the URL configured in `WHATSAPP_HOOK_URL`)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **event** (string) - The type of event received (e.g., `message`).
- **payload** (object) - Contains details of the message or event.

### Request Example
```kotlin
import io.ktor.application.*
import io.ktor.features.ContentNegotiation
import io.ktor.jackson.jackson
import io.ktor.request.*
import io.ktor.response.*
import io.ktor.routing.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*

fun main() {
    embeddedServer(Netty, port = 8080) {
        install(ContentNegotiation) { // Ensure ContentNegotiation is installed
            jackson() // Configure Jackson for JSON
        }
        routing {
            post("/bot") {
                val data = call.receive<Map<String, Any>>()
                if (data["event"] == "message") {  // Check for message event
                    processMessage(data["payload"])
                }
                call.respondText("OK")
            }
        }
    }.start(wait = true)
}

fun processMessage(payload: Any?) {
    println("Processing message: $payload")
}
```

### Response
#### Success Response (200)
- **HTTP Status**: `200 OK` indicating the webhook received the request.

#### Response Example
`OK`
```

--------------------------------

### Create Session and Postpone Start

Source: https://waha.devlike.pro/docs/how-to/sessions

Creates a new session but postpones its automatic start by setting the 'start' field to false. The session will be created in a 'STOPPED' state, allowing for manual initiation later via a separate API call.

```json
{
  "name": "default",
  "start": false
}
```

--------------------------------

### Send Buttons Reply API Call Examples

Source: https://waha.devlike.pro/docs/how-to/send-messages

Examples of how to call the Send Buttons Reply API endpoint from different programming languages and tools. These examples include setting headers for authentication and content type, and sending the request body.

```curl
curl -X 'POST' \
  'http://localhost:3000/api/send/buttons/reply' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "session": "default",
  "chatId": "12132132130@c.us",
  "replyTo": "false_12132132130@c.us_AAAAAAAAAAAAAAAAA",
  "selectedDisplayText": "No",
  "selectedButtonID": "button:id"
}'
```

```python
import requests

url = "http://localhost:3000/api/send/buttons/reply"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Content-Type": "application/json",
}
data = {
    "session": "default",
    "chatId": "12132132130@c.us",
    "replyTo": "false_12132132130@c.us_AAAAAAAAAAAAAAAAA",
    "selectedDisplayText": "No",
    "selectedButtonID": "button:id"
}

response = requests.post(url, json=data, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/send/buttons/reply";
const data = {
    session: "default",
    chatId: "12132132130@c.us",
    replyTo: "false_12132132130@c.us_AAAAAAAAAAAAAAAAA",
    selectedDisplayText: "No",
    selectedButtonID: "button:id"
};
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Content-Type': 'application/json',
};
axios.post(url, data, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/send/buttons/reply";
$data = [
    "session" => "default",
    "chatId" => "12132132130@c.us",
    "replyTo" => "false_12132132130@c.us_AAAAAAAAAAAAAAAAA",
    "selectedDisplayText" => "No",
    "selectedButtonID" => "button:id"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Content-Type: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Add/Remove Reaction API Examples

Source: https://waha.devlike.pro/docs/how-to/send-messages

Examples of how to call the Add/Remove Reaction API using cURL, Python, Node.js (Axios), and PHP.

```curl
curl -X 'PUT' \
  'http://localhost:3000/api/reaction' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "session": "default",
  "messageId": "false_12132132130@c.us_AAAAAAAAAAAAAAAAAAAA",
  "reaction": "👍"
}'
```

```python
import requests

url = "http://localhost:3000/api/reaction"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Content-Type": "application/json",
}
data = {
    "session": "default",
    "messageId": "false_12132132130@c.us_AAAAAAAAAAAAAAAAAAAA",
    "reaction": "👍"
}

response = requests.put(url, json=data, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/reaction";
const data = {
    session: "default",
    messageId: "false_12132132130@c.us_AAAAAAAAAAAAAAAAAAAA",
    reaction: "👍"
};
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Content-Type': 'application/json',
};

axios.put(url, data, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/reaction";
$data = [
    "session" => "default",
    "messageId" => "false_12132132130@c.us_AAAAAAAAAAAAAAAAAAAA",
    "reaction" => "👍"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Content-Type: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Send Seen Message API Integration Examples

Source: https://waha.devlike.pro/docs/how-to/send-messages

Examples of how to call the Send Seen Message API using cURL, Python, Node.js (axios), and PHP.

```curl
curl -X 'POST' \
  'http://localhost:3000/api/sendSeen' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "session": "default",
  "chatId": "12132132130@c.us"
}'
```

```python
import requests

url = "http://localhost:3000/api/sendSeen"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Content-Type": "application/json",
}
data = {
    "session": "default",
    "chatId": "12132132130@c.us"
}

response = requests.post(url, json=data, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/sendSeen";
const data = {
    session: "default",
    chatId: "12132132130@c.us"
};
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Content-Type': 'application/json',
};
axios.post(url, data, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/sendSeen";
$data = [
    "session" => "default",
    "chatId" => "12132132130@c.us"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Content-Type: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Webhook Payload Example (NOWEB Engine)

Source: https://waha.devlike.pro/docs/overview/changelog

This is an example of a webhook payload received from the NOWEB engine, indicating a 'message' event. It includes session information and the event payload.

```json
{
  "event": "message",
  "session": "default",
  "engine": "WEBJS",
  "payload": {}
}
```

--------------------------------

### Build and Run WAHA Echo Bot (Kotlin/Gradle)

Source: https://waha.devlike.pro/docs/integrations/kotlin

Commands to clone the WAHA Kotlin examples repository, build the project using Gradle, and then run the application. This sets up the echo bot that responds to messages.

```bash
# Clone the git repository with example
git clone https://github.com/devlikeapro/waha-kotlin.git

# Build and run the app
./gradlew build
./gradlew run
```

--------------------------------

### Get All Messages with cURL

Source: https://waha.devlike.pro/docs/how-to/receive-messages

An example using cURL to fetch messages, demonstrating the required parameters such as chatId, limit, and session. This method is suitable for initial setup or specific data retrieval needs, though event-driven approaches are preferred for ongoing updates.

```Shell
curl -X 'GET' \
  'http://localhost:3000/api/messages?chatId=11111111111%40c.us&limit=1000&session=default' \
  -H 'Accept: application/json'
```

--------------------------------

### Create Session API Call Examples

Source: https://waha.devlike.pro/docs/how-to/sessions

Demonstrates how to create a new session using the WAHA API from various programming languages and tools. These examples show the necessary HTTP method, endpoint, headers, and JSON payload for a successful request.

```curl
curl -X 'POST' \
  'http://localhost:3000/api/sessions' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{ \
  "name": "default", \
  "config": { \
    "webhooks": [ \
      { \
        "url": "https://webhook.site/11111111-1111-1111-1111-11111111", \
        "events": [ \
          "message" \
        ] \
      } \
    ] \
  }' \
}
```

```python
import requests

url = "http://localhost:3000/api/sessions"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Content-Type": "application/json",
}
data = {
    "name": "default",
    "config": {
        "webhooks": [
            {
                "url": "https://webhook.site/11111111-1111-1111-1111-11111111",
                "events": [
                    "message"
                ]
            }
        ]
    }
}

response = requests.post(url, json=data, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/sessions";
const data = {
    name: "default",
    config: {
        webhooks: [
            {
                url: "https://webhook.site/11111111-1111-1111-1111-11111111",
                events: [
                    "message"
                ]
            }
        ]
    }
};
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Content-Type': 'application/json',
};
axios.post(url, data, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/sessions";
$data = [
    "name" => "default",
    "config" => [
        "webhooks" => [
            [
                "url" => "https://webhook.site/11111111-1111-1111-1111-11111111",
                "events" => [
                    "message"
                ]
            ]
        ]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Content-Type: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Get Screenshot using cURL (Binary and Base64)

Source: https://waha.devlike.pro/docs/how-to/sessions

Examples of using cURL to get a session screenshot. One fetches the binary image and saves it, while the other requests Base64 data by setting the appropriate Accept header.

```shell
# Get binary image
curl -X 'GET' \
  'http://localhost:3000/api/screenshot?session=default' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: image/png' \
  --output screenshot.png

# Get base64 image
curl -X 'GET' \
  'http://localhost:3000/api/screenshot?session=default' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json' \

```

--------------------------------

### Get Server Status

Source: https://waha.devlike.pro/docs/how-to/observability

Retrieves the server's start timestamp and uptime.

```APIDOC
## GET /api/server/status

### Description
Returns the server status, start timestamp, and uptime.

### Method
GET

### Endpoint
/api/server/status

### Response
#### Success Response (200)
- **startTimestamp** (integer) - The timestamp when the server started (in milliseconds).
- **uptime** (integer) - The current uptime of the server (in milliseconds).

#### Response Example
```json
{
  "startTimestamp": 1723788847247,
  "uptime": 3600000
}
```
```

--------------------------------

### Get Server Version

Source: https://waha.devlike.pro/docs/how-to/observability

Retrieves the version of the installed WAHA Docker image.

```APIDOC
## GET /api/server/version

### Description
Returns the version of the installed docker image.

### Method
GET

### Endpoint
/api/server/version

### Response
#### Success Response (200)
- **version** (string) - The current version of the WAHA image.
- **engine** (string) - The engine used by WAHA.
- **tier** (string) - The tier of the WAHA service.
- **browser** (string) - The path to the browser executable.

#### Response Example
```json
{
  "version": "2024.2.3",
  "engine": "NOWEB",
  "tier": "PLUS",
  "browser": "/usr/bin/google-chrome-stable"
}
```
```

--------------------------------

### Get WAHA Server Status

Source: https://waha.devlike.pro/docs/how-to/observability

Obtain the current status of the WAHA server, including its start timestamp and uptime in milliseconds.

```http
GET /api/server/status
```

```json
{
  "startTimestamp": 1723788847247,
  "uptime": 3600000
}
```

--------------------------------

### Run WAHA WhatsApp API Docker Container (ARM)

Source: https://waha.devlike.pro/docs/integrations/kotlin

Specific commands for downloading and running the WAHA WhatsApp API Docker container on ARM architecture (e.g., Apple Silicon). It includes pulling the ARM image, tagging it, and then running it.

```bash
# Download the image
docker pull devlikeapro/waha:arm
# Rename it, so you can use devlikeapro/waha image in other place
docker tag devlikeapro/waha:arm devlikeapro/waha
# Run the docker container
docker run -it --rm --network=host -e WHATSAPP_HOOK_URL=http://localhost:5000/bot -e "WHATSAPP_HOOK_EVENTS=*" --name waha devlikeapro/waha

# It prints logs and the last line must be
# WhatsApp API is running on: http://[::1]:3000
```

--------------------------------

### Get WAHA Server Version

Source: https://waha.devlike.pro/docs/how-to/observability

Retrieve the version information of the installed WAHA docker image, including the engine, tier, and browser path.

```http
GET /api/server/version
```

```json
{
  "version": "2024.2.3",
  "engine": "NOWEB",
  "tier": "PLUS",
  "browser": "/usr/bin/google-chrome-stable"
}
```

--------------------------------

### Run WAHA WhatsApp API Docker Container

Source: https://waha.devlike.pro/docs/integrations/kotlin

Commands to download and run the WAHA WhatsApp API Docker container. This is a prerequisite for interacting with the API. It exposes an HTTP API for communication.

```bash
# Download the image
docker pull devlikeapro/waha
# Run the docker container
docker run -it --rm --network=host -e WHATSAPP_HOOK_URL=http://localhost:5000/bot -e "WHATSAPP_HOOK_EVENTS=*" --name waha devlikeapro/waha

# It prints logs and the last line must be
# WhatsApp API is running on: http://[::1]:3000
```

--------------------------------

### POST /api/startTyping

Source: https://waha.devlike.pro/docs/how-to/engines

Starts the typing indicator. This endpoint allows users to indicate that they are typing a message.

```APIDOC
## POST /api/startTyping

### Description
Starts the typing indicator.

### Method
POST

### Endpoint
/api/startTyping

### Parameters
#### Request Body
- **recipient** (string) - Required - The recipient's phone number or chat ID.

### Request Example
```json
{
  "recipient": "1234567890@c.us"
}
```

### Response
#### Success Response (200)
- **status** (string) - "success"

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Run WAHA Dashboard with Docker

Source: https://waha.devlike.pro/docs/how-to/dashboard

This command starts the WAHA service and exposes the dashboard on port 3000. It's the basic command to get the dashboard up and running.

```docker
docker run -it -p 3000:3000 devlikeapro/waha-plus
```

--------------------------------

### Convert Video using FFmpeg Command Line

Source: https://waha.devlike.pro/docs/how-to/status

This command-line example shows how to convert a video file to the mp4 format using `ffmpeg`, ensuring compatibility with the WhatsApp Media API. The `-map 0 -movflags +faststart` options are crucial for thumbnail generation.

```bash
ffmpeg -i input_video.avi -c:v libx264 -map 0 -movflags +faststart output_video.mp4
```

--------------------------------

### POST /api/sendText

Source: https://waha.devlike.pro/docs/overview/quick-start

This endpoint allows you to send text messages to WhatsApp users. You need to provide the recipient's chat ID, the message text, and optionally a session name.

```APIDOC
## POST /api/sendText

### Description
Sends a text message to a specified WhatsApp chat.

### Method
POST

### Endpoint
`/api/sendText`

### Parameters
#### Header Parameters
- **X-Api-Key** (string) - Required - Your API key for authentication.
- **Accept** (string) - Optional - `application/json`
- **Content-Type** (string) - Optional - `application/json`

#### Request Body
- **chatId** (string) - Required - The recipient's chat ID (e.g., `123123@c.us`).
- **text** (string) - Required - The content of the message to be sent.
- **session** (string) - Optional - The session name to use (defaults to `default`).

### Request Example
```json
{
  "chatId": "123123@c.us",
  "text": "Hi there!",
  "session": "default"
}
```

### Response
#### Success Response (200)
- **message** (string) - Description of the success status.
- **key** (object) - Information about the sent message.
  - **remoteJid** (string) - The recipient's JID.
  - **fromMe** (boolean) - Indicates if the message was sent from the current user.
  - **id** (string) - The unique ID of the message.
  - **participant** (string) - The participant in a group chat (if applicable).
- **status** (string) - The status of the message (e.g., `SERVER_ACK`).

#### Response Example
```json
{
  "message": "Message sent successfully",
  "key": {
    "remoteJid": "123123@c.us",
    "fromMe": true,
    "id": "some_message_id",
    "participant": null
  },
  "status": "SERVER_ACK"
}
```
```

--------------------------------

### Create a New Session with Apps using API

Source: https://waha.devlike.pro/docs/how-to/sessions

Initiate a new session and associate apps with it by sending a POST request to the `/api/sessions` endpoint. The request body should include the session's name and an array of app configurations.

```http
POST /api/sessions
```

--------------------------------

### Make Authenticated API Request (Sessions)

Source: https://waha.devlike.pro/docs/how-to/security

Demonstrates how to make a GET request to the WAHA API sessions endpoint, including the required 'X-Api-Key' header for authentication. Examples are provided for cURL, Python, Node.js, and PHP.

```curl
curl -X 'GET' \
  'http://localhost:3000/api/sessions' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json'
```

```python
import requests

headers = {
  'X-Api-Key': 'yoursecretkey',
  'Content-type': 'application/json',
}
response = requests.get("http://localhost:3000/api/sessions", headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/sessions";
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Content-Type': 'application/json',
};

axios.get(url, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/sessions";

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Content-Type: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Get Session Me Information (cURL, Python, JavaScript, PHP)

Source: https://waha.devlike.pro/docs/how-to/sessions

Fetches information about the authenticated user associated with a given session. This endpoint returns user details if the session is valid, or null if it's stopped or not authenticated. Examples are provided for cURL, Python, Node.js with axios, and PHP.

```curl
curl -X 'GET' \
  'http://localhost:3000/api/sessions/default/me' \
  -H 'X-Api-Key: yoursecretkey' \
  -H 'Accept: application/json'
```

```python
import requests

url = "http://localhost:3000/api/sessions/default/me"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Accept": "application/json",
}

response = requests.get(url, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const url = "http://localhost:3000/api/sessions/default/me";
const headers = {
    'X-Api-Key': 'yoursecretkey',
    'Accept': 'application/json',
};

axios.get(url, { headers })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
```

```php
<?php
$url = "http://localhost:3000/api/sessions/default/me";

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Accept: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

--------------------------------

### Receive Message Webhook

Source: https://waha.devlike.pro/docs/integrations/go

Sets up a webhook endpoint to receive messages and other events from WAHA.

```APIDOC
## POST /bot

### Description
This endpoint acts as a webhook to receive incoming messages and events from WAHA. It processes messages and can be extended to handle other event types.

### Method
`POST`

### Endpoint
`/bot` (Listens on port 3000)

### Parameters
#### Request Body
- **event** (string) - Required - The type of event received (e.g., "message").
- **payload** (object) - Required - The data associated with the event. For messages, this contains the message details.

### Request Example
```json
{
  "event": "message",
  "payload": {
    "from": "sender@example.com",
    "text": "Hello WAHA!"
  }
}
```

### Response
#### Success Response (200)
Returns `OK` to acknowledge receipt of the webhook.

#### Response Example
`OK`
```

--------------------------------

### Set up WAHA WhatsApp Download Files Bot

Source: https://waha.devlike.pro/docs/integrations/python

Python Flask code for a WhatsApp bot that downloads files sent via WhatsApp. This bot requires the WAHA Plus version and a Flask setup. It logs the path of downloaded files.

```python
# Clone the git repository with example
git clone https://github.com/devlikeapro/waha.git
# Open python example folder
cd waha/examples/python
# Install requirements
python -mpip install -r requirements.txt
# Run the bot
FLASK_APP=whatsapp_download_files_bot.py flask run
```

--------------------------------

### JavaScript WebSocket Client Example

Source: https://waha.devlike.pro/docs/how-to/events

Provides a JavaScript example for establishing a WebSocket connection, handling incoming messages, errors, and connection events. It includes configuration for API key, URL, session, and events.

```javascript
// Configuration
const apiKey = '123'; // Replace with your API key
const baseUrl = 'ws://localhost:3000/ws';
const session = '*'; // Use '*' to listen to all sessions
const events = ['session.status', 'message']; // List of events to listen to

// Construct the WebSocket URL with query parameters
const queryParams = new URLSearchParams({
    'x-api-key': apiKey,
    session,
    ...events.reduce((acc, event) => ({ ...acc, events: event }), {})
});
const wsUrl = `${baseUrl}?${queryParams.toString()}`;

// Initialize WebSocket connection
const socket = new WebSocket(wsUrl);

// Handle incoming messages
socket.onmessage = (event) => {
    console.log('Received:', event.data);
};

// Handle errors
socket.onerror = (error) => {
    console.error('WebSocket Error:', error);
};

// Handle connection open
socket.onopen = () => {
    console.log('WebSocket connection established:', wsUrl);
};

// Handle connection close
socket.onclose = () => {
    console.log('WebSocket connection closed');
};
```

--------------------------------

### Connect to WebSocket Server using websocat

Source: https://waha.devlike.pro/docs/how-to/events

Demonstrates various ways to connect to a WebSocket server using the `websocat` command-line tool. It covers secure connections, API key usage, and filtering events and sessions.

```bash
# Listen all sessions and events
# -E to end the connection when the server closes it
websocat -E ws://localhost:3000/ws

# Use secure (SSL/HTTPS) connection - add wss://
websocat -E wss://localhost:3000/ws

# Add your API key
websocat -E ws://localhost:3000/ws?x-api-key=123

# Listen all sessions and events
websocat -E ws://localhost:3000/ws?session=*&events=*

# Listen certain events
websocat -E ws://localhost:3000/ws?session=*&events=session.status&events=message

# If you want to see the logs and ping the server every 10 seconds
websocat -v --ping-interval=10 -E ws://localhost:3000/ws

# Listen certain session
websocat -E ws://localhost:3000/ws?session=default&events=session.status

# With API Key
websocat -E ws://localhost:3000/ws?x-api-key=123
```

--------------------------------

### Get Screenshot as Base64 Image (Python, JavaScript, PHP)

Source: https://waha.devlike.pro/docs/how-to/sessions

Retrieves a screenshot from the specified URL and returns it as a base64 encoded JSON string. Examples are provided for Python using requests, Node.js with axios, and PHP with cURL. The JSON response containing the base64 image data is printed to the console or echoed.

```python
import requests

url = "http://localhost:3000/api/screenshot?session=default"
headers = {
    "X-Api-Key": "yoursecretkey",
    "Accept": "application/json",
}

response = requests.get(url, headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');

const getBase64Image = async () => {
    const url = "http://localhost:3000/api/screenshot?session=default";
    const headers = {
        'X-Api-Key': 'yoursecretkey',
        'Accept': 'application/json',
    };
    
    const response = await axios.get(url, { headers });
    console.log(response.data);
};

getBase64Image().catch(console.error);
```

```php
<?php
$url = "http://localhost:3000/api/screenshot?session=default";

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: yoursecretkey',
    'Accept: application/json',
]);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```
Tokens:
Raw