WATI

The WATI provider enables you to deliver professional WhatsApp messages to your customers through the Comify Platform. With a single API integration, you can create seamless multi-channel communication experiences leveraging WhatsApp’s 2 billion+ user base.

​

Getting Started

Implementing the WATI WhatsApp provider requires four primary steps: creating a WATI account, setting up the WhatsApp Business API, generating a WATI API token, and configuring the WATI integration within your Comify platform.

​

Creating a WATI Account

Follow these steps to set up your WATI account:

1. Visit WATI’s official website and select “Sign Up Free”.
2. Enter all required information to create your account.
3. Complete any verification process if prompted.
4. Once verification is complete, you’ll be directed to your WATI dashboard.

​

Setting Up WhatsApp Business API with WATI

Before generating an API token, you’ll need to set up your WhatsApp Business API:

1. In your WATI dashboard, navigate to the WhatsApp connection setup section.
2. Follow the guided process to connect your business number with the WhatsApp Business API.
3. WATI will guide you through the necessary Facebook Business Manager verification steps.
4. Complete the business verification process, which may include providing business documentation.
5. Set up your WhatsApp Business profile with your business information, logo, and description.

​

Business Requirements for WhatsApp Business API

Before proceeding, ensure your business meets these requirements:

1. Valid Business Identity: Your business must be officially registered and possess a clear identity that WhatsApp can verify.
2. WhatsApp Business Policy Adherence: Ensure your business operations align with WhatsApp’s Business Policy.
3. Customer Consent: You must obtain consent from customers before reaching out to them via WhatsApp.
4. Dedicated Phone Number: A dedicated phone number that will serve as your business’s WhatsApp identity.
5. Business Website: A verifiable business website adds credibility and serves as a digital footprint.

​

Creating a WATI API Token

Follow these steps to generate and secure your WATI API token:

1. In your WATI dashboard, navigate to the API section.
2. Look for the API token generation option (typically under “Settings” or “API Documentation”).
3. The API token can be found under “API docs” in the WATI user interface.
4. Copy the generated token immediately and store it in a secure location.
5. Note: Access tokens are app and user-specific. Please do not share the token with anyone, nor post it publicly.

​

Creating a Comify API Key

Before configuring the WATI integration, you’ll need to generate a Comify API key for authentication:

1. Access your Comify account dashboard.
2. Navigate to the API Keys management section at https://cloud.comify.io/settings/api-keys.
3. Select “Generate API Key” if not already generated.
4. Provide a clear, descriptive name for your key (e.g., “WATI WhatsApp Integration”) to facilitate future management.
5. Copy and store this API key in a secure location. You’ll use this key in your application code to authenticate requests to the Comify platform.

​

Configuring WATI Integration in Comify

To establish the connection between Comify and WATI:

1. Sign in to your Comify platform dashboard.
2. Navigate to Integration Store > Add Integration > WhatsApp.
3. From the available WhatsApp service providers, select WATI.
4. Enter the WATI API token you generated earlier.
5. Configure any additional provider-specific settings according to your requirements.
6. Click Save to finalize the integration.

​

Creating WhatsApp Message Templates

After successfully configuring the WATI integration, you’ll need to create and get approval for WhatsApp message templates:

1. Navigate to the Manage Templates section in your Comify dashboard.
2. Select the WhatsApp tab from the available channel options.
3. Click Create Template to begin the design process.
4. Choose from multiple template creation methods:
   • Pre-approved Templates: Select from WhatsApp’s pre-approved template categories.
   • Custom Templates: Create your own template following WhatsApp’s guidelines.
   • AI-Assisted Design: Utilize the AI Writer feature for automated content generation that follows WhatsApp’s guidelines.
5. Add variables to personalize your templates where needed (e.g., customer name, order number).
6. Submit your template for WhatsApp approval (this may take 24-48 hours).

​

Understanding WhatsApp Message Types

WhatsApp Business API supports several types of messages:

1. Session Messages: Responses to customer-initiated conversations (24-hour window).
2. Template Messages: Pre-approved message templates for business-initiated conversations.
3. Interactive Messages: Messages with buttons, list messages, or reply buttons.
4. Media Messages: Images, documents, videos, and other rich media content.

​

Sending WhatsApp Templates

Implement the following code examples in your application to trigger WhatsApp template delivery:

const { Comify } = require('comify-node')

const comm = new Comify('COMIFY_API_KEY')

comm.triggerComm('whatsapp_template_name',{ 
  "order_id" : "123455",
  "customer" : {
    "phoneNumber" : "919876543210",  // with country code
    "customerName" : "Comify"
  }
}, 'whatsappTemplate')

const { Comify } = require('comify-node')

const comm = new Comify('COMIFY_API_KEY')

comm.triggerComm('whatsapp_template_name',{ 
  "order_id" : "123455",
  "customer" : {
    "phoneNumber" : "919876543210",  // with country code
    "customerName" : "Comify"
  }
}, 'whatsappTemplate')

const fetch = require('node-fetch');

const apiKey = 'YOUR_COMIFY_API_KEY';
const url = 'https://commify.transify.tech/v1/comm';

const payload = {
  name: 'whatsapp_template_name',
  payload: { 
    order_id: '123455',
    customer: {
      phoneNumber: '919876543210',  // with country code
      customerName: 'Comify'
    }
  },
  type: 'whatsappTemplate'
};

fetch(url, {
  method: 'POST',
  headers: {
    'Authorization': `ApiKey ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

import requests

api_key = 'YOUR_COMIFY_API_KEY'
url = 'https://commify.transify.tech/v1/comm'

headers = {
    'Authorization': f'ApiKey {api_key}',
    'Content-Type': 'application/json'
}

payload = {
    'name': 'whatsapp_template_name',
    'payload': {
        'order_id': '123455',
        'customer': {
            'phoneNumber': '919876543210',  # with country code
            'customerName': 'Comify'
        }
    },
    'type': 'whatsappTemplate'
}

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

require 'net/http'
require 'uri'
require 'json'

api_key = 'YOUR_COMIFY_API_KEY'
url = URI.parse('https://commify.transify.tech/v1/comm')

payload = {
  name: 'whatsapp_template_name',
  payload: {
    order_id: '123455',
    customer: {
      phoneNumber: '919876543210',  # with country code
      customerName: 'Comify'
    }
  },
  type: 'whatsappTemplate'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url.request_uri)
request['Authorization'] = "ApiKey #{api_key}"
request['Content-Type'] = 'application/json'
request.body = payload.to_json

response = http.request(request)
puts response.body

<?php
$api_key = 'YOUR_COMIFY_API_KEY';
$url = 'https://commify.transify.tech/v1/comm';

$payload = [
    'name' => 'whatsapp_template_name',
    'payload' => [
        'order_id' => '123455',
        'customer' => [
            'phoneNumber' => '919876543210',  // with country code
            'customerName' => 'Comify'
        ]
    ],
    'type' => 'whatsappTemplate'
];

$ch = curl_init($url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: ApiKey ' . $api_key,
    'Content-Type: application/json'
]);

$response = curl_exec($ch);
$err = curl_error($ch);

curl_close($ch);

if ($err) {
    echo "cURL Error: " . $err;
} else {
    echo $response;
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    apiKey := "YOUR_COMIFY_API_KEY"
    url := "https://commify.transify.tech/v1/comm"

    // Create the payload structure
    type Customer struct {
        PhoneNumber  string `json:"phoneNumber"`
        CustomerName string `json:"customerName"`
    }

    type PayloadData struct {
        OrderID  string   `json:"order_id"`
        Customer Customer `json:"customer"`
    }

    type RequestPayload struct {
        Name    string      `json:"name"`
        Payload PayloadData `json:"payload"`
        Type    string      `json:"type"`
    }

    data := RequestPayload{
        Name: "whatsapp_template_name",
        Payload: PayloadData{
            OrderID: "123455",
            Customer: Customer{
                PhoneNumber:  "919876543210",  // with country code
                CustomerName: "Comify",
            },
        },
        Type: "whatsappTemplate",
    }

    payloadBytes, err := json.Marshal(data)
    if err != nil {
        fmt.Println("Error marshalling JSON:", err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Authorization", "ApiKey "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println("Response:", string(body))
}

curl -X POST 'https://commify.transify.tech/v1/comm' \
  -H 'Authorization: ApiKey YOUR_COMIFY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "whatsapp_template_name",
    "payload": { 
      "order_id": "123456",
      "customer": {
        "phoneNumber": "91xxxxxxxxxx",
        "customerName": "John"
      }
    },
    "type": "whatsappTemplate"
  }'

Upon successful API request processing, you will receive a response containing a unique requestId and confirmation message:

{
  "requestId": "016e9d9c-ea29-455c-bf2e-a703e96482fb",
  "message": "your request has been submitted"
}

Important: The API may return a success response even when there are underlying issues with your request. For comprehensive delivery monitoring and troubleshooting, we recommend reviewing the complete request logs in the Activity Feed dashboard.