Meta WhatsApp Business API

The Meta WhatsApp Business API provider enables you to deliver professional WhatsApp messages to your customers through the Comify Platform. As the official API from the creators of WhatsApp, it provides direct access to WhatsApp’s 2 billion+ user base with enterprise-grade reliability and features.

​

Getting Started

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

​

Creating a Meta Business Account

Follow these steps to set up your Meta Business account:

1. Visit Meta Business Suite and click “Create Account”.
2. Enter your business information and complete the registration process.
3. Verify your business email address.
4. Once verification is complete, you’ll be directed to your Meta Business dashboard.

​

Setting Up WhatsApp Business API with Meta

Before generating API access tokens, you’ll need to set up your WhatsApp Business API account:

1. In your Meta Business dashboard, navigate to “Business Settings” > “Accounts” > “WhatsApp Accounts”.
2. Click “Add” to create a new WhatsApp Business Account (WABA).
3. Follow the guided process to connect your business phone number with the WhatsApp Business API.
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 Meta can verify.
2. WhatsApp Business Policy Adherence: Ensure your business operations align with WhatsApp’s Business Policy.
3. Customer Consent: You must obtain explicit 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 Verification: Your business must complete Meta’s business verification process.
6. Payment Method: A valid payment method must be set up in your Business Manager account.

​

Creating API Access Tokens

Follow these steps to generate and secure your WhatsApp API access tokens:

1. Go to the Meta Developers Portal and create a business app if you don’t have one.
2. In your app’s dashboard, add the “WhatsApp Business API” product.
3. Navigate to “WhatsApp” > “API Setup” and follow the steps to configure your app.
4. You’ll need to generate a System User access token or a Business Integration System User access token:
   • System User Access Token: For developers accessing their own business data
   • Business Integration System User Access Token: For tech providers accessing customer data
5. Ensure your tokens have the following permissions:
   • whatsapp_business_management
   • whatsapp_business_messaging
   • business_management
6. Copy the generated token immediately and store it in a secure location.
7. Note: Access tokens are app and user-specific. Never share the token or post it publicly.

​

Creating a Comify API Key

Before configuring the Meta WhatsApp 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., “Meta 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 Meta WhatsApp Integration in Comify

To establish the connection between Comify and Meta’s WhatsApp Business API:

1. Sign in to your Comify platform dashboard.
2. Navigate to Integration Store > Add Integration > WhatsApp.
3. From the available WhatsApp service providers, select Meta.
4. Enter the WhatsApp API access token you generated earlier.
5. Provide your WhatsApp Business Account ID (found in your Meta Business Manager).
6. Configure any additional provider-specific settings according to your requirements.
7. Click Save to finalize the integration.

​

Creating WhatsApp Message Templates

After successfully configuring the Meta WhatsApp 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.
5. Authentication Templates: One-time passwords or verification codes.

​

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
$apiKey = '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 ' . $apiKey,
    'Content-Type: application/json'
]);

$response = curl_exec($ch);
curl_close($ch);

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"

    type Customer struct {
        PhoneNumber  string `json:"phoneNumber"`
        CustomerName string `json:"customerName"`
    }

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

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

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

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

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    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(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": "123455",
      "customer": {
        "phoneNumber": "919876543210",
        "customerName": "Comify"
      }
    },
    "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.