Service Message

Send WhatsApp service messages with Messente's Omnichannel API.

Introduction

Service messages are a type of message that can be sent to users without the need for a pre-approved template. They are used to facilitate ongoing conversations with users. Service messages can include text, images, buttons, and other interactive elements, and they are designed to facilitate back-and-forth conversations with users. In order to be able to send service messages, you must first have a WhatsApp Business Account and a verified phone number connected to Messente using our embedded signup.

tip

Follow our support guides for more details on setting up your WhatsApp account and connecting it to Messente.

24-hour conversation window

The 24-hour conversation window is a period of time during which you can send service messages to a user without needing to use a template. This window is opened when a user interacts with your business, such as by replying to a message or clicking a button. The window remains open for 24 hours, allowing you to send multiple messages without needing to use a template. Each message sent within this window will extend the window by another 24 hours.

Sending a Service Message

To send a service message, you can use the Omnichannel API send message endpoint, similarly as for template WhatsApp messages. The key difference is that you do not need to specify a template, but rather provide the content of the message directly in the request body. The message can include text, images, buttons, and other interactive elements. Below are examples of how to send a service message using our public libraries.

Text Message

from pprint import pprint
from messente_api import (
    OmnimessageApi,
    Omnimessage,
    Configuration,
    ApiClient,
    WhatsApp,
    OmnimessageMessagesInner,
    WhatsAppText,
)
from messente_api.rest import ApiException


configuration = Configuration()
configuration.username = "YOUR_MESSENTE_API_USERNAME"
configuration.password = "YOUR_MESSENTE_API_PASSWORD"

api_instance = OmnimessageApi(ApiClient(configuration))

wa_text = WhatsAppText(
    body="hello, world!",
    preview_url=True, # set preview_url to False if you want to disable URL previews
)

whatsapp = WhatsApp(
    sender="<SENDER_NAME>",
    text=wa_text,
)

whatsapp_inner = OmnimessageMessagesInner(whatsapp)
omnimessage = Omnimessage(messages=[whatsapp_inner], to="<RECIPIENT_PHONE_NUMBER>")

try:
    response = api_instance.send_omnimessage(omnimessage)
    print(
        "Successfully sent Omnimessage with id: %s that consists of the following messages:"
        % response.omnimessage_id
    )
    for message in response.messages:
        pprint(message)
except ApiException as exception:
    print("Exception when sending an omnimessage: %s\n" % exception)

// npm i messente_api

const MessenteApi = require("messente_api");

const defaultClient = MessenteApi.ApiClient.instance;
const basicAuth = defaultClient.authentications["basicAuth"];
basicAuth.username = "YOUR_MESSENTE_API_USERNAME";
basicAuth.password = "YOUR_MESSENTE_API_PASSWORD";

const api = new MessenteApi.OmnimessageApi();

const text = new MessenteApi.WhatsAppText.constructFromObject({
  body: "hello, world!",
	previewUrl: true, // set to false if you do not want to generate URL preview
});

const whatsapp = MessenteApi.WhatsApp.constructFromObject({
  sender: "<SENDER_NAME>",
  text: text,
});

const omnimessage = MessenteApi.Omnimessage.constructFromObject({
  messages: [whatsapp],
  to: "<RECIPIENT_PHONE_NUMBER>",
});

api.sendOmnimessage(omnimessage, (error, data) => {
  if (error) {
    console.error(error);
  } else {
    console.log("API called successfully. Returned data: ", data);
  }
});

// composer require messente/messente-api-php

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Messente\Api\Api\OmnimessageApi;
use Messente\Api\Model\Omnimessage;
use Messente\Api\Configuration;
use Messente\Api\Model\WhatsApp;
use Messente\Api\Model\WhatsAppParameter;
use Messente\Api\Model\WhatsAppComponent;
use Messente\Api\Model\WhatsAppLanguage;
use Messente\Api\Model\WhatsAppTemplate;
use Messente\Api\Model\WhatsAppText;

$config = Configuration::getDefaultConfiguration()
    ->setUsername('YOUR_MESSENTE_API_USERNAME')
    ->setPassword('YOUR_MESSENTE_API_PASSWORD');


$apiInstance = new OmnimessageApi(
    new GuzzleHttp\Client(),
    $config
);

$omnimessage = new Omnimessage([
    'to' => '+48507315819',
]);

$text = new WhatsAppText(
    data: [
        'body' => 'hello, world!',
        'previewUrl' => true, // set to false if you do not want to include a preview URL
    ]
);

$whatsapp = new WhatsApp(
    [
        'sender' => 'WhatsappDEV',
        'text' => $text,
    ]
);

$omnimessage->setMessages([$whatsapp]);

try {
    $result = $apiInstance->sendOmnimessage($omnimessage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling sendOmnimessage: ', $e->getMessage(), PHP_EOL;
}

package org.example;

import com.messente.ApiClient;
import com.messente.ApiException;
import com.messente.api.*;
import com.messente.auth.HttpBasicAuth;

import java.util.List;

// repositories { mavenCentral() }
// dependencies { implementation 'com.messente.api:messente-api' }

public class TextServiceMessageExample {
    public static void main(String[] args) {
        ApiClient apiClient = new ApiClient();
        OmnimessageApi apiInstance = new OmnimessageApi(apiClient);

        HttpBasicAuth basicAuth = (HttpBasicAuth) apiClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR_MESSENTE_API_USERNAME");
        basicAuth.setPassword("YOUR_MESSENTE_API_PASSWORD");

        WhatsApp whatsApp = new WhatsApp();
        whatsApp.sender("<SENDER_NAME>");

        WhatsAppText text = new WhatsAppText();
        text.setBody("hello, world!");
        text.setPreviewUrl(true); // set to false if you do not want to generate URL preview
        whatsApp.setText(text);

        OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsApp);
        whatsAppOmnimessageInner.setActualInstance(whatsApp);

        Omnimessage omnimessage = new Omnimessage();
        omnimessage.setMessages(List.of(whatsAppOmnimessageInner));
        omnimessage.setTo("<RECIPIENT_PHONE_NUMBER>");

        try {
            OmniMessageCreateSuccessResponse result = apiInstance.sendOmnimessage(omnimessage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println(e.getResponseBody());
        }
    }
}

# gem install messente_api

require 'messente_api'

MessenteApi.configure do |config|
  config.username = 'YOUR_MESSENTE_API_USERNAME'
  config.password = 'YOUR_MESSENTE_API_PASSWORD'
end

api_instance = MessenteApi::OmnimessageApi.new
omnimessage = MessenteApi::Omnimessage.new
omnimessage.to = 'RECIPIENT_PHONE_NUMBER'

wa_text = MessenteApi::WhatsAppText.new(
  body: 'hello, world!',
  preview_url: true, # set preview_url to false if you want to disable URL previews
)

omnimessage.messages = [
  MessenteApi::WhatsApp.new(
    sender: '<SENDER_NAME>',
    text: wa_text,
  )
]

begin
  result = api_instance.send_omnimessage(omnimessage)
  puts result
rescue MessenteApi::ApiError => e
  puts "Exception when calling send_omnimessage: #{e}"
  puts e.response_body
end

// PM > Install-Package com.Messente.Api

using System;
using com.Messente.Api.Api;
using com.Messente.Api.Client;
using com.Messente.Api.Model;

namespace WhatsAppTextServiceMessageExample
{
    public class WhatsAppTextServiceMessageExample
    {
        public static void Main()
        {
            Configuration conf = new Configuration
            {
                Username = "YOUR_MESSENTE_API_USERNAME",
                Password = "YOUR_MESSENTE_API_PASSWORD"
            };

            var apiInstance = new OmnimessageApi(conf);

            WhatsAppText text = new WhatsAppText(
                body: "hello, world!",
                previewUrl: true // set to false if you do not want to generate URL preview
            );

            var whatsapp = new WhatsApp(
                sender: "<SENDER_NAME>",
                text: text
            );

            OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsapp)
            {
                ActualInstance = whatsapp
            };

            var omnimessage = new Omnimessage(
                to: "<RECIPIENT_PHONE_NUMBER>",
                messages: new List<OmnimessageMessagesInner> { whatsAppOmnimessageInner }
            );

            try
            {
                var result = apiInstance.SendOmnimessage(omnimessage);
                Console.WriteLine(result.ToJson());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception when calling SendOmnimessage: " + e.Message);
            }
        }
    }
}

curl -X POST \
  'https://api.messente.com/v1/omnimessage' \
  -u MESSENTE_API_USERNAME:MESSENTE_API_PASSWORD \
  -H 'Content-Type: application/json' \
  -d '{
	"to": "<RECIPIENT_PHONE_NUMBER>",
	"messages": [{
		"channel": "whatsapp",
		"sender": "<SENDER_NAME>",
        "text": {
            "preview_url": false,
            "body": "hello, world!"
        }
	}]
}'

Image Message

from pprint import pprint
from messente_api import (
    OmnimessageApi,
    Omnimessage,
    Configuration,
    ApiClient,
    WhatsApp,
    OmnimessageMessagesInner,
    WhatsAppImage,
)
from messente_api.rest import ApiException


configuration = Configuration()
configuration.username = "YOUR_MESSENTE_API_USERNAME"
configuration.password = "YOUR_MESSENTE_API_PASSWORD"

api_instance = OmnimessageApi(ApiClient(configuration))

wa_image = WhatsAppImage(
    link="<MEDIA_URL>",  # URL link to the image file
)

whatsapp = WhatsApp(
    sender="<SENDER_NAME>",
    image=wa_image,
)

whatsapp_inner = OmnimessageMessagesInner(whatsapp)
omnimessage = Omnimessage(messages=[whatsapp_inner], to="<RECIPIENT_PHONE_NUMBER>")

try:
    response = api_instance.send_omnimessage(omnimessage)
    print(
        "Successfully sent Omnimessage with id: %s that consists of the following messages:"
        % response.omnimessage_id
    )
    for message in response.messages:
        pprint(message)
except ApiException as exception:
    print("Exception when sending an omnimessage: %s\n" % exception)

// npm i messente_api

const MessenteApi = require("messente_api");

const defaultClient = MessenteApi.ApiClient.instance;
const basicAuth = defaultClient.authentications["basicAuth"];
basicAuth.username = "YOUR_MESSENTE_API_USERNAME";
basicAuth.password = "YOUR_MESSENTE_API_PASSWORD";

const api = new MessenteApi.OmnimessageApi();

const image = new MessenteApi.WhatsAppImage.constructFromObject({
  link: "<MEDIA_URL>", // URL link to the image file
});

const whatsapp = MessenteApi.WhatsApp.constructFromObject({
  sender: "<SENDER_NAME>",
  image: image,
});

const omnimessage = MessenteApi.Omnimessage.constructFromObject({
  messages: [whatsapp],
  to: "<RECIPIENT_PHONE_NUMBER>",
});

api.sendOmnimessage(omnimessage, (error, data) => {
  if (error) {
    console.error(error);
  } else {
    console.log("API called successfully. Returned data: ", data);
  }
});

// composer require messente/messente-api-php

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Messente\Api\Api\OmnimessageApi;
use Messente\Api\Model\Omnimessage;
use Messente\Api\Configuration;
use Messente\Api\Model\WhatsApp;
use Messente\Api\Model\WhatsAppImage;

$config = Configuration::getDefaultConfiguration()
    ->setUsername('YOUR_MESSENTE_API_USERNAME')
    ->setPassword('YOUR_MESSENTE_API_PASSWORD');

$apiInstance = new OmnimessageApi(
    new GuzzleHttp\Client(),
    $config
);

$omnimessage = new Omnimessage([
    'to' => '<RECIPIENT_PHONE_NUMBER>',
]);

$image = new WhatsAppImage(
    data: [
        'link' => '<MEDIA_URL>', // URL link to the image file
    ]
);

$whatsapp = new WhatsApp(
    [
        'sender' => '<SENDER_NAME>',
        'image' => $image,
    ]
);

$omnimessage->setMessages([$whatsapp]);

try {
    $result = $apiInstance->sendOmnimessage($omnimessage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling sendOmnimessage: ', $e->getMessage(), PHP_EOL;
}

package org.example;

import com.messente.ApiClient;
import com.messente.ApiException;
import com.messente.api.*;
import com.messente.auth.HttpBasicAuth;

import java.util.List;

// repositories { mavenCentral() }
// dependencies { implementation 'com.messente.api:messente-api' }

public class ImageServiceMessageExample {
    public static void main(String[] args) {
        ApiClient apiClient = new ApiClient();
        OmnimessageApi apiInstance = new OmnimessageApi(apiClient);

        HttpBasicAuth basicAuth = (HttpBasicAuth) apiClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR_MESSENTE_API_USERNAME");
        basicAuth.setPassword("YOUR_MESSENTE_API_PASSWORD");

        WhatsApp whatsApp = new WhatsApp();
        whatsApp.sender("<SENDER_NAME>");

        WhatsAppImage image = new WhatsAppImage();
        image.setLink("<MEDIA_URL>"); // URL link to the image file
        whatsApp.setImage(image);

        OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsApp);
        whatsAppOmnimessageInner.setActualInstance(whatsApp);

        Omnimessage omnimessage = new Omnimessage();
        omnimessage.setMessages(List.of(whatsAppOmnimessageInner));
        omnimessage.setTo("<RECIPIENT_PHONE_NUMBER>");

        try {
            OmniMessageCreateSuccessResponse result = apiInstance.sendOmnimessage(omnimessage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println(e.getResponseBody());
        }
    }
}

# gem install messente_api

require 'messente_api'

MessenteApi.configure do |config|
  config.username = 'YOUR_MESSENTE_API_USERNAME'
  config.password = 'YOUR_MESSENTE_API_PASSWORD'
end

api_instance = MessenteApi::OmnimessageApi.new
omnimessage = MessenteApi::Omnimessage.new
omnimessage.to = '<RECIPIENT_PHONE_NUMBER>'

wa_image = MessenteApi::WhatsAppImage.new(
  link: '<MEDIA_URL>',  # URL link to the image file
)

omnimessage.messages = [
  MessenteApi::WhatsApp.new(
    sender: '<SENDER_NAME>',
    image: wa_image,
  )
]

begin
  result = api_instance.send_omnimessage(omnimessage)
  puts result
rescue MessenteApi::ApiError => e
  puts "Exception when calling send_omnimessage: #{e}"
  puts e.response_body
end

// PM > Install-Package com.Messente.Api

using System;
using com.Messente.Api.Api;
using com.Messente.Api.Client;
using com.Messente.Api.Model;

namespace WhatsAppImageServiceMessageExample
{
    public class WhatsAppImageServiceMessageExample
    {
        public static void Main()
        {
            Configuration conf = new Configuration
            {
                Username = "YOUR_MESSENTE_API_USERNAME",
                Password = "YOUR_MESSENTE_API_PASSWORD",
            };

            var apiInstance = new OmnimessageApi(conf);

            WhatsAppImage image = new WhatsAppImage(
                link: "<MEDIA_URL>" // URL of the image file
            );

            var whatsapp = new WhatsApp(
                sender: "<SENDER_NAME>",
                image: image
            );

            OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsapp)
            {
                ActualInstance = whatsapp
            };

            var omnimessage = new Omnimessage(
                to: "<RECIPIENT_PHONE_NUMBER>",
                messages: new List<OmnimessageMessagesInner> { whatsAppOmnimessageInner }
            );

            try
            {
                var result = apiInstance.SendOmnimessage(omnimessage);
                Console.WriteLine(result.ToJson());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception when calling SendOmnimessage: " + e.Message);
            }
        }
    }
}

curl -X POST \
  'https://api.messente.com/v1/omnimessage' \
  -u MESSENTE_API_USERNAME:MESSENTE_API_PASSWORD \
  -H 'Content-Type: application/json' \
  -d '{
    "to": "<RECIPIENT_PHONE_NUMBER>",
    "messages": [
        {
            "channel": "whatsapp",
            "sender": "<SENDER_NAME>",
            "image": {
                "link": "<MEDIA_URL>",
                "caption": "this is an image"
            }
        }
    ]
}'

Audio Message

from pprint import pprint
from messente_api import (
    OmnimessageApi,
    Omnimessage,
    Configuration,
    ApiClient,
    WhatsApp,
    OmnimessageMessagesInner,
    WhatsAppAudio,
)
from messente_api.rest import ApiException


configuration = Configuration()
configuration.username = "YOUR_MESSENTE_API_USERNAME"
configuration.password = "YOUR_MESSENTE_API_PASSWORD"

api_instance = OmnimessageApi(ApiClient(configuration))

wa_audio = WhatsAppAudio(
    link="<MEDIA_URL>",  # URL link to the audio file
)

whatsapp = WhatsApp(
    sender="<SENDER_NAME>",
    audio=wa_audio,
)

whatsapp_inner = OmnimessageMessagesInner(whatsapp)
omnimessage = Omnimessage(messages=[whatsapp_inner], to="<RECIPIENT_PHONE_NUMBER>")

try:
    response = api_instance.send_omnimessage(omnimessage)
    print(
        "Successfully sent Omnimessage with id: %s that consists of the following messages:"
        % response.omnimessage_id
    )
    for message in response.messages:
        pprint(message)
except ApiException as exception:
    print("Exception when sending an omnimessage: %s\n" % exception)

// npm i messente_api

const MessenteApi = require("messente_api");

const defaultClient = MessenteApi.ApiClient.instance;
const basicAuth = defaultClient.authentications["basicAuth"];
basicAuth.username = "YOUR_MESSENTE_API_USERNAME";
basicAuth.password = "YOUR_MESSENTE_API_PASSWORD";

const api = new MessenteApi.OmnimessageApi();

const audio = new MessenteApi.WhatsAppAudio.constructFromObject({
  link: "<MEDIA_URL>", // URL link to the audio file
});

const whatsapp = MessenteApi.WhatsApp.constructFromObject({
  sender: "<SENDER_NAME>",
  audio: audio,
});

const omnimessage = MessenteApi.Omnimessage.constructFromObject({
  messages: [whatsapp],
  to: "<RECIPIENT_PHONE_NUMBER>",
});

api.sendOmnimessage(omnimessage, (error, data) => {
  if (error) {
    console.error(error);
  } else {
    console.log("API called successfully. Returned data: ", data);
  }
});

// composer require messente/messente-api-php

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Messente\Api\Api\OmnimessageApi;
use Messente\Api\Model\Omnimessage;
use Messente\Api\Configuration;
use Messente\Api\Model\WhatsApp;
use Messente\Api\Model\WhatsAppAudio;

$config = Configuration::getDefaultConfiguration()
    ->setUsername('YOUR_MESSENTE_API_USERNAME')
    ->setPassword('YOUR_MESSENTE_API_PASSWORD');

$apiInstance = new OmnimessageApi(
    new GuzzleHttp\Client(),
    $config
);

$omnimessage = new Omnimessage([
    'to' => '<RECIPIENT_PHONE_NUMBER>', // Replace with the recipient's phone number
]);

$audio = new WhatsAppAudio(
    data: [
        'link' => '<MEDIA_URL>', // URL link to the audio file
    ]
);

$whatsapp = new WhatsApp(
    [
        'sender' => '<SENDER_NAME>',
        'audio' => $audio,
    ]
);

$omnimessage->setMessages([$whatsapp]);

try {
    $result = $apiInstance->sendOmnimessage($omnimessage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling sendOmnimessage: ', $e->getMessage(), PHP_EOL;
}

package org.example;

import com.messente.ApiClient;
import com.messente.ApiException;
import com.messente.api.*;
import com.messente.auth.HttpBasicAuth;

import java.util.List;

// repositories { mavenCentral() }
// dependencies { implementation 'com.messente.api:messente-api' }

public class AudioServiceMessageExample {
    public static void main(String[] args) {
        ApiClient apiClient = new ApiClient();
        OmnimessageApi apiInstance = new OmnimessageApi(apiClient);

        HttpBasicAuth basicAuth = (HttpBasicAuth) apiClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR_MESSENTE_API_USERNAME");
        basicAuth.setPassword("YOUR_MESSENTE_API_PASSWORD");

        WhatsApp whatsApp = new WhatsApp();
        whatsApp.sender("<SENDER_NAME>");

        WhatsAppAudio audio = new WhatsAppAudio();
        audio.setLink("<MEDIA_URL>"); // URL link to the audio file
        whatsApp.setAudio(audio);

        OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsApp);
        whatsAppOmnimessageInner.setActualInstance(whatsApp);

        Omnimessage omnimessage = new Omnimessage();
        omnimessage.setMessages(List.of(whatsAppOmnimessageInner));
        omnimessage.setTo("<RECIPIENT_PHONE_NUMBER>");

        try {
            OmniMessageCreateSuccessResponse result = apiInstance.sendOmnimessage(omnimessage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println(e.getResponseBody());
        }
    }
}

# gem install messente_api

require 'messente_api'

MessenteApi.configure do |config|
  config.username = 'YOUR_MESSENTE_API_USERNAME'
  config.password = 'YOUR_MESSENTE_API_PASSWORD'
end

api_instance = MessenteApi::OmnimessageApi.new
omnimessage = MessenteApi::Omnimessage.new
omnimessage.to = '<RECIPIENT_PHONE_NUMBER>'

wa_audio = MessenteApi::WhatsAppAudio.new(
  link: '<MEDIA_URL>',  # URL link to the audio file
)

omnimessage.messages = [
  MessenteApi::WhatsApp.new(
    sender: '<SENDER_NAME>',
    audio: wa_audio,
  )
]

begin
  result = api_instance.send_omnimessage(omnimessage)
  puts result
rescue MessenteApi::ApiError => e
  puts "Exception when calling send_omnimessage: #{e}"
  puts e.response_body
end

// PM > Install-Package com.Messente.Api

using System;
using com.Messente.Api.Api;
using com.Messente.Api.Client;
using com.Messente.Api.Model;

namespace WhatsAppAudioServiceMessageExample
{
    public class WhatsAppAudioServiceMessageExample
    {
        public static void Main()
        {
            Configuration conf = new Configuration
            {
                Username = "YOUR_MESSENTE_API_USERNAME",
                Password = "YOUR_MESSENTE_API_PASSWORD"
            };

            var apiInstance = new OmnimessageApi(conf);
            
            WhatsAppAudio audio = new WhatsAppAudio(
                link: "<MEDIA_URL>" // URL of the audio file
            );

            var whatsapp = new WhatsApp(
                sender: "<SENDER_NAME>",
                audio: audio
            );

            OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsapp)
            {
                ActualInstance = whatsapp
            };

            var omnimessage = new Omnimessage(
                to: "<RECIPIENT_PHONE_NUMBER>",
                messages: new List<OmnimessageMessagesInner> { whatsAppOmnimessageInner }
            );

            try
            {
                var result = apiInstance.SendOmnimessage(omnimessage);
                Console.WriteLine(result.ToJson());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception when calling SendOmnimessage: " + e.Message);
            }
        }
    }
}

curl -X POST \
  'https://api.messente.com/v1/omnimessage' \
  -u MESSENTE_API_USERNAME:MESSENTE_API_PASSWORD \
  -H 'Content-Type: application/json' \
  -d '{
    "to": "<RECIPIENT_PHONE_NUMBER>",
    "messages": [
        {
            "channel": "whatsapp",
            "sender": "<SENDER_NAME>",
            "audio": {
                "link": "<MEDIA_URL>"
            }
        }
    ]
}'

Video Message

from pprint import pprint
from messente_api import (
    OmnimessageApi,
    Omnimessage,
    Configuration,
    ApiClient,
    WhatsApp,
    OmnimessageMessagesInner,
    WhatsAppVideo,
)
from messente_api.rest import ApiException


configuration = Configuration()
configuration.username = "YOUR_MESSENTE_API_USERNAME"
configuration.password = "YOUR_MESSENTE_API_PASSWORD"

api_instance = OmnimessageApi(ApiClient(configuration))

wa_video = WhatsAppVideo(
    link="<MEDIA_URL>",  # URL link to the video file
)

whatsapp = WhatsApp(
    sender="<SENDER_NAME>",
    video=wa_video,
)

whatsapp_inner = OmnimessageMessagesInner(whatsapp)
omnimessage = Omnimessage(messages=[whatsapp_inner], to="<RECIPIENT_PHONE_NUMBER>")

try:
    response = api_instance.send_omnimessage(omnimessage)
    print(
        "Successfully sent Omnimessage with id: %s that consists of the following messages:"
        % response.omnimessage_id
    )
    for message in response.messages:
        pprint(message)
except ApiException as exception:
    print("Exception when sending an omnimessage: %s\n" % exception)

// npm i messente_api

const MessenteApi = require("messente_api");

const defaultClient = MessenteApi.ApiClient.instance;
const basicAuth = defaultClient.authentications["basicAuth"];
basicAuth.username = "YOUR_MESSENTE_API_USERNAME";
basicAuth.password = "YOUR_MESSENTE_API_PASSWORD";

const api = new MessenteApi.OmnimessageApi();

const video = new MessenteApi.WhatsAppVideo.constructFromObject({
  link: "<MEDIA_URL>", // URL link to the video file
});

const whatsapp = MessenteApi.WhatsApp.constructFromObject({
  sender: "<SENDER_NAME>",
  video: video,
});

const omnimessage = MessenteApi.Omnimessage.constructFromObject({
  messages: [whatsapp],
  to: "<RECIPIENT_PHONE_NUMBER>",
});

api.sendOmnimessage(omnimessage, (error, data) => {
  if (error) {
    console.error(error);
  } else {
    console.log("API called successfully. Returned data: ", data);
  }
});

// composer require messente/messente-api-php

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Messente\Api\Api\OmnimessageApi;
use Messente\Api\Model\Omnimessage;
use Messente\Api\Configuration;
use Messente\Api\Model\WhatsApp;
use Messente\Api\Model\WhatsAppVideo;

$config = Configuration::getDefaultConfiguration()
    ->setUsername('YOUR_MESSENTE_API_USERNAME')
    ->setPassword('YOUR_MESSENTE_API_PASSWORD');

$apiInstance = new OmnimessageApi(
    new GuzzleHttp\Client(),
    $config
);

$omnimessage = new Omnimessage([
    'to' => '<RECIPIENT_PHONE_NUMBER>',
]);

$video = new WhatsAppVideo(
    data: [
        'link' => '<MEDIA_URL>', // URL link to the video file
    ]
);

$whatsapp = new WhatsApp(
    [
        'sender' => '<SENDER_NAME>',
        'video' => $video,
    ]
);

$omnimessage->setMessages([$whatsapp]);

try {
    $result = $apiInstance->sendOmnimessage($omnimessage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling sendOmnimessage: ', $e->getMessage(), PHP_EOL;
}

package org.example;

import com.messente.ApiClient;
import com.messente.ApiException;
import com.messente.api.*;
import com.messente.auth.HttpBasicAuth;

import java.util.List;

// repositories { mavenCentral() }
// dependencies { implementation 'com.messente.api:messente-api' }

public class VideoServiceMessageExample {
    public static void main(String[] args) {
        ApiClient apiClient = new ApiClient();
        OmnimessageApi apiInstance = new OmnimessageApi(apiClient);

        HttpBasicAuth basicAuth = (HttpBasicAuth) apiClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR_MESSENTE_API_USERNAME");
        basicAuth.setPassword("YOUR_MESSENTE_API_PASSWORD");

        WhatsApp whatsApp = new WhatsApp();
        whatsApp.sender("<SENDER_NAME>");

        WhatsAppVideo video = new WhatsAppVideo();
        video.setLink("<MEDIA_URL>"); // URL link to the video file
        whatsApp.setVideo(video);

        OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsApp);
        whatsAppOmnimessageInner.setActualInstance(whatsApp);

        Omnimessage omnimessage = new Omnimessage();
        omnimessage.setMessages(List.of(whatsAppOmnimessageInner));
        omnimessage.setTo("<RECIPIENT_PHONE_NUMBER>");

        try {
            OmniMessageCreateSuccessResponse result = apiInstance.sendOmnimessage(omnimessage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println(e.getResponseBody());
        }
    }
}

# gem install messente_api

require 'messente_api'

MessenteApi.configure do |config|
  config.username = 'YOUR_MESSENTE_API_USERNAME'
  config.password = 'YOUR_MESSENTE_API_PASSWORD'
end

api_instance = MessenteApi::OmnimessageApi.new
omnimessage = MessenteApi::Omnimessage.new
omnimessage.to = '<RECIPIENT_PHONE_NUMBER>'

wa_video = MessenteApi::WhatsAppVideo.new(
  link: '<MEDIA_URL>',  # URL link to the video file
)

omnimessage.messages = [
  MessenteApi::WhatsApp.new(
    sender: '<SENDER_NAME>',
    video: wa_video,
  )
]

begin
  result = api_instance.send_omnimessage(omnimessage)
  puts result
rescue MessenteApi::ApiError => e
  puts "Exception when calling send_omnimessage: #{e}"
  puts e.response_body
end

// PM > Install-Package com.Messente.Api

using System;
using com.Messente.Api.Api;
using com.Messente.Api.Client;
using com.Messente.Api.Model;

namespace WhatsAppVideoServiceMessageExample
{
    public class WhatsAppVideoServiceMessageExample
    {
        public static void Main()
        {
            Configuration conf = new Configuration
            {
                Username = "YOUR_MESSENTE_API_USERNAME",
                Password = "YOUR_MESSENTE_API_PASSWORD"
            };

            var apiInstance = new OmnimessageApi(conf);

            WhatsAppVideo video = new WhatsAppVideo(
                link: "<MEDIA_URL>" // URL of the video file
            );

            var whatsapp = new WhatsApp(
                sender: "<SENDER_NAME>",
                video: video
            );

            OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsapp)
            {
                ActualInstance = whatsapp
            };

            var omnimessage = new Omnimessage(
                to: "<RECIPIENT_PHONE_NUMBER>",
                messages: new List<OmnimessageMessagesInner> { whatsAppOmnimessageInner }
            );

            try
            {
                var result = apiInstance.SendOmnimessage(omnimessage);
                Console.WriteLine(result.ToJson());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception when calling SendOmnimessage: " + e.Message);
            }
        }
    }
}

curl -X POST \
  'https://api.messente.com/v1/omnimessage' \
  -u MESSENTE_API_USERNAME:MESSENTE_API_PASSWORD \
  -H 'Content-Type: application/json' \
  -d '{
    "to": "<RECIPIENT_PHONE_NUMBER>",
    "messages": [
        {
            "channel": "whatsapp",
            "sender": "<SENDER_NAME>",
            "video": {
                "link": "<MEDIA_URL>",
                "caption": "This is a video"
            }
        }
    ]
}'

Document Message

from pprint import pprint
from messente_api import (
    OmnimessageApi,
    Omnimessage,
    Configuration,
    ApiClient,
    WhatsApp,
    OmnimessageMessagesInner,
    WhatsAppDocument,
)
from messente_api.rest import ApiException

configuration = Configuration()
configuration.username = "YOUR_MESSENTE_API_USERNAME"
configuration.password = "YOUR_MESSENTE_API_PASSWORD"

api_instance = OmnimessageApi(ApiClient(configuration))

wa_document = WhatsAppDocument(
    link="<MEDIA_URL>",  # URL link to the document file
)

whatsapp = WhatsApp(
    sender="<SENDER_NAME>",
    document=wa_document,
)

whatsapp_inner = OmnimessageMessagesInner(whatsapp)
omnimessage = Omnimessage(messages=[whatsapp_inner], to="<RECIPIENT_PHONE_NUMBER>")

try:
    response = api_instance.send_omnimessage(omnimessage)
    print(
        "Successfully sent Omnimessage with id: %s that consists of the following messages:"
        % response.omnimessage_id
    )
    for message in response.messages:
        pprint(message)
except ApiException as exception:
    print("Exception when sending an omnimessage: %s\n" % exception)

// npm i messente_api

const MessenteApi = require("messente_api");

const defaultClient = MessenteApi.ApiClient.instance;
const basicAuth = defaultClient.authentications["basicAuth"];
basicAuth.username = "YOUR_MESSENTE_API_USERNAME";
basicAuth.password = "YOUR_MESSENTE_API_PASSWORD";

const api = new MessenteApi.OmnimessageApi();

const document = new MessenteApi.WhatsAppDocument.constructFromObject({
  link: "<MEDIA_URL>", // URL link to the document file
});

const whatsapp = MessenteApi.WhatsApp.constructFromObject({
  sender: "<SENDER_NAME>",
  document: document,
});

const omnimessage = MessenteApi.Omnimessage.constructFromObject({
  messages: [whatsapp],
  to: "<RECIPIENT_PHONE_NUMBER>",
});

api.sendOmnimessage(omnimessage, (error, data) => {
  if (error) {
    console.error(error);
  } else {
    console.log("API called successfully. Returned data: ", data);
  }
});

// composer require messente/messente-api-php

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Messente\Api\Api\OmnimessageApi;
use Messente\Api\Model\Omnimessage;
use Messente\Api\Configuration;
use Messente\Api\Model\WhatsApp;
use Messente\Api\Model\WhatsAppDocument;

$config = Configuration::getDefaultConfiguration()
    ->setUsername('YOUR_MESSENTE_API_USERNAME')
    ->setPassword('YOUR_MESSENTE_API_PASSWORD');

$apiInstance = new OmnimessageApi(
    new GuzzleHttp\Client(),
    $config
);

$omnimessage = new Omnimessage([
    'to' => '<RECIPIENT_PHONE_NUMBER>',
]);

$document = new WhatsAppDocument(
    data: [
        'link' => '<MEDIA_URL>', // URL link to the document file
    ]
);

$whatsapp = new WhatsApp(
    [
        'sender' => '<SENDER_NAME>',
        'document' => $document,
    ]
);

$omnimessage->setMessages([$whatsapp]);

try {
    $result = $apiInstance->sendOmnimessage($omnimessage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling sendOmnimessage: ', $e->getMessage(), PHP_EOL;
}

package org.example;

import com.messente.ApiClient;
import com.messente.ApiException;
import com.messente.api.*;
import com.messente.auth.HttpBasicAuth;

import java.util.List;

// repositories { mavenCentral() }
// dependencies { implementation 'com.messente.api:messente-api' }

public class DocumentServiceMessageExample {
    public static void main(String[] args) {
        ApiClient apiClient = new ApiClient();
        OmnimessageApi apiInstance = new OmnimessageApi(apiClient);

        HttpBasicAuth basicAuth = (HttpBasicAuth) apiClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR_MESSENTE_API_USERNAME");
        basicAuth.setPassword("YOUR_MESSENTE_API_PASSWORD");

        WhatsApp whatsApp = new WhatsApp();
        whatsApp.sender("<SENDER_NAME>");

        WhatsAppDocument document = new WhatsAppDocument();
        document.setLink("<MEDIA_URL>"); // URL link to the document file
        whatsApp.setDocument(document);

        OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsApp);
        whatsAppOmnimessageInner.setActualInstance(whatsApp);

        Omnimessage omnimessage = new Omnimessage();
        omnimessage.setMessages(List.of(whatsAppOmnimessageInner));
        omnimessage.setTo("<RECIPIENT_PHONE_NUMBER>");

        try {
            OmniMessageCreateSuccessResponse result = apiInstance.sendOmnimessage(omnimessage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println(e.getResponseBody());
        }
    }
}

# gem install messente_api

require 'messente_api'

MessenteApi.configure do |config|
  config.username = 'YOUR_MESSENTE_API_USERNAME'
  config.password = 'YOUR_MESSENTE_API_PASSWORD'
end

api_instance = MessenteApi::OmnimessageApi.new
omnimessage = MessenteApi::Omnimessage.new
omnimessage.to = '<RECIPIENT_PHONE_NUMBER>'

wa_document = MessenteApi::WhatsAppDocument.new(
  link: '<MEDIA_URL>',  # URL link to the document file
)

omnimessage.messages = [
  MessenteApi::WhatsApp.new(
    sender: '<SENDER_NAME>',
    document: wa_document,
  )
]

begin
  result = api_instance.send_omnimessage(omnimessage)
  puts result
rescue MessenteApi::ApiError => e
  puts "Exception when calling send_omnimessage: #{e}"
  puts e.response_body
end

// PM > Install-Package com.Messente.Api

using System;
using com.Messente.Api.Api;
using com.Messente.Api.Client;
using com.Messente.Api.Model;

namespace WhatsAppDocumentServiceMessageExample
{
    public class WhatsAppDocumentServiceMessageExample
    {
        public static void Main()
        {
            Configuration conf = new Configuration
            {
                Username = "YOUR_MESSENTE_API_USERNAME",
                Password = "YOUR_MESSENTE_API_PASSWORD",
            };

            var apiInstance = new OmnimessageApi(conf);

            WhatsAppDocument document = new WhatsAppDocument(
                link: "<MEDIA_URL>" // URL of the document file
            );

            var whatsapp = new WhatsApp(
                sender: "<SENDER_NAME>",
                document: document
            );

            OmnimessageMessagesInner whatsAppOmnimessageInner = new OmnimessageMessagesInner(whatsapp)
            {
                ActualInstance = whatsapp
            };

            var omnimessage = new Omnimessage(
                to: "<RECIPIENT_PHONE_NUMBER>",
                messages: new List<OmnimessageMessagesInner> { whatsAppOmnimessageInner }
            );

            try
            {
                var result = apiInstance.SendOmnimessage(omnimessage);
                Console.WriteLine(result.ToJson());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception when calling SendOmnimessage: " + e.Message);
            }
        }
    }
}

curl -X POST \
  'https://api.messente.com/v1/omnimessage' \
  -u MESSENTE_API_USERNAME:MESSENTE_API_PASSWORD \
  -H 'Content-Type: application/json' \
  -d '{
    "to": "<RECIPIENT_PHONE_NUMBER>",
    "messages": [
        {
            "channel": "whatsapp",
            "sender": "<SENDER_NAME>",
            "document": {
                "link": "<MEDIA_URL>",
                "caption": "this is a document"
            }
        }
    ]
}'

Introduction

Sending a Service Message​

Text Message​

Image Message​

Audio Message​

Video Message​

Document Message​