Unlock your platform’s potential with CPaaS X

Introducing the next generation of CPaaS (communications platform as a service)- CPaaS X, a modular API stack to help platforms scale exponentially with reduced engineering effort and greater operational efficiency.

REDUCE OPERATIONAL LOAD

More automation opportunities

CPaaS X introduces new granular APIs for automating resource provisioning, campaign registration, and client-specific consumption reporting.

Contact an expert

REDUCE TIME-TO-MARKET

Get your clients up and running immediately

Automated client onboarding and number provisioning enables your customers to get operational and start sending traffic faster than they thought possible.

Contact an expert

LESS ENGINEERING EFFORT

A truly unified API for every channel

Reduce complexity and easily adopt new channels with a unified API stack.

Contact an expert

GO OMNICHANNEL WITH EASE

Maximum channel flexibility, minimal engineering effort

The Messages API unifies all channels, so adding new channels couldn’t be easier, but CPaaS X can also handle channel orchestration and all failover logic – ensuring that your clients can always reach their customers on the best channel, including SMS, RCS, and chat apps.

Contact an expert

We are today passing all our SMS traffic in the United States through Infobip’s shortcodes and working very closely with them on expansions of traditional products. The Infobip team is one of the most professional and experienced teams we’ve worked with

Omer Bar Joseph

General Manager, Yotpo SMS

Infobip is synonymous with innovation, making them a reliable communications platform. They go the extra mile, understand what the customer needs and deliver solutions through the right technology and channels

Hari Chinni

Technology Sourcing Manager, Uber

		OkHttpClient client = new OkHttpClient().newBuilder()
     .build();
 MediaType mediaType = MediaType.parse(“application/json”);
 RequestBody body = RequestBody.create(mediaType, “{\”messages\”:[{\”content\”:{\”body\”:{\”text\”:\”Text message to send\”,\”type\”:\”TEXT\”}},\”sender\”:\”senderNumber\”,\”destinations\”:[{\”to\”:\”destinationNumber\”}],\”channel\”:\”SMS\”}]}”);
 Request request = new Request.Builder()
     .url(“https://{baseUrl}/unified-api/1/messages”)
     .method(“POST”, body)
     .addHeader(“Authorization”, “{authorization}”)
     .addHeader(“Content-Type”, “application/json”)
     .addHeader(“Accept”, “application/json”)
     .build();
 Response response = client.newCall(request).execute();
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12

		{
   “messages”: [
     {
       “content”: {
         “body”: {
           “text”: “Text message to send”,
           “type”: “TEXT”
         }
       },
       “sender”: “senderNumber”,
       “destinations”: [
         {
           “to”: “destinationNumber”
         }
       ],
       “channel”: “SMS”
     }
   ]
 }
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19

		curl -L -g -X POST ‘https://{baseUrl}/unified-api/1/messages’ \
 -H ‘Authorization: {authorization}’ \
 -H ‘Content-Type: application/json’ \
 -H ‘Accept: application/json’ \
 –data-raw ‘{
   “messages”: [
     {
       “content”: {
         “body”: {
           “text”: “Text message to send”,
           “type”: “TEXT”
         }
       },
       “sender”: “senderNumber”,
       “destinations”: [
         {
           “to”: “destinationNumber”
         }
       ],
       “channel”: “SMS”
     }
   ]
 }’
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23

		var client = new RestClient(“https://{baseUrl}/unified-api/1/messages”);
 client.Timeout = -1;
 var request = new RestRequest(Method.POST);
 request.AddHeader(“Authorization”, “{authorization}”);
 request.AddHeader(“Content-Type”, “application/json”);
 request.AddHeader(“Accept”, “application/json”);
 var body = @”{“”messages””:[{“”content””:{“”body””:{“”text””:””Text message to send””,””type””:””TEXT””}},””sender””:””senderNumber””,””destinations””:[{“”to””:””destinationNumber””}],””channel””:””SMS””}]}”;
 request.AddParameter(“application/json”, body,  ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 Console.WriteLine(response.Content);
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10

		package main
 import (
     “fmt”
     “strings”
     “net/http”
     “io/ioutil”
 )
 func main() {
 <code>url := “https://%7BbaseUrl%7D/unified-api/1/messages” method := “POST” payload := strings.NewReader(`{“messages”:[{“content”:{“body”:{“text”:”Text message to send”,”type”:”TEXT”}},”sender”:”senderNumber”,”destinations”:[{“to”:”destinationNumber”}],”channel”:”SMS”}]}`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil {     fmt.Println(err)     return } req.Header.Add(“Authorization”, “{authorization}”) req.Header.Add(“Content-Type”, “application/json”) req.Header.Add(“Accept”, “application/json”) res, err := client.Do(req) if err != nil {     fmt.Println(err)     return } defer res.Body.Close() body, err := ioutil.ReadAll(res.Body) if err != nil {     fmt.Println(err)     return } fmt.Println(string(body))</code>
 }
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10

		import http.client
 import json
 conn = http.client.HTTPSConnection(“{baseUrl}”)
 payload = json.dumps({
     “messages”: [
         {
             “content”: {
                 “body”: {
                     “text”: “Text message to send”,
                     “type”: “TEXT”
                 }
             },
             “sender”: “senderNumber”,
             “destinations”: [
                 {
                     “to”: “destinationNumber”
                 }
             ],
             “channel”: “SMS”
         }
     ]
 })
 headers = {
     ‘Authorization’: ‘{authorization}’,
     ‘Content-Type’: ‘application/json’,
     ‘Accept’: ‘application/json’
 }
 conn.request(“POST”, “/unified-api/1/messages”, payload, headers)
 res = conn.getresponse()
 data = res.read()
 print(data.decode(“utf-8”))
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23
											24
											25
											26
											27
											28
											29
											30
											31

		<?php
 $curl = curl_init();
 curl_setopt_array($curl, array(
     CURLOPT_URL => ‘https://%7BbaseUrl%7D/unified-api/1/messages’,
     CURLOPT_RETURNTRANSFER => true,
     CURLOPT_ENCODING => ”,
     CURLOPT_MAXREDIRS => 10,
     CURLOPT_TIMEOUT => 0,
     CURLOPT_FOLLOWLOCATION => true,
     CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
     CURLOPT_CUSTOMREQUEST => ‘POST’,
     CURLOPT_POSTFIELDS =>‘{“messages”:[{“content”:{“body”:{“text”:”Text message to send”,”type”:”TEXT”}},”sender”:”senderNumber”,”destinations”:[{“to”:”destinationNumber”}],”channel”:”SMS”}]}’,
     CURLOPT_HTTPHEADER => array(
         ‘Authorization: {authorization}’,
         ‘Content-Type: application/json’,
         ‘Accept: application/json’
     ),
 ));
 $response = curl_exec($curl);
 curl_close($curl);
 echo $response;
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21

		var settings = {
     “url”: “https://{baseUrl}/unified-api/1/messages”,
     “method”: “POST”,
     “timeout”: 0,
     “headers”: {
         “Authorization”: “{authorization}”,
         “Content-Type”: “application/json”,
         “Accept”: “application/json”
     },
     “data”: JSON.stringify({
         “messages”: [
             {
                 “content”: {
                     “body”: {
                         “text”: “Text message to send”,
                         “type”: “TEXT”
                     }
                 },
                 “sender”: “senderNumber”,
                 “destinations”: [
                     {
                         “to”: “destinationNumber”
                     }
                 ],
                 “channel”: “SMS”
             }
         ]
     }),
 };
 $.ajax(settings).done(function (response) {
     console.log(response);
 });
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23
											24
											25
											26
											27
											28
											29
											30
											31
											32

		var https = require(‘follow-redirects’).https;
 var fs = require(‘fs’);
 var options = {
     ‘method’: ‘POST’,
     ‘hostname’: ‘{baseUrl}’,
     ‘path’: ‘/unified-api/1/messages’,
     ‘headers’: {
         ‘Authorization’: ‘{authorization}’,
         ‘Content-Type’: ‘application/json’,
         ‘Accept’: ‘application/json’
     },
     ‘maxRedirects’: 20
 };
 var req = https.request(options, function (res) {
     var chunks = [];
 <code>res.on(“data”, function (chunk) {     chunks.push(chunk); }); res.on(“end”, function (chunk) {     var body = Buffer.concat(chunks);     console.log(body.toString()); }); res.on(“error”, function (error) {     console.error(error); });</code>
 });
 var postData = JSON.stringify({
     “messages”: [
         {
             “content”: {
                 “body”: {
                     “text”: “Text message to send”,
                     “type”: “TEXT”
                 }
             },
             “sender”: “senderNumber”,
             “destinations”: [
                 {
                     “to”: “destinationNumber”
                 }
             ],
             “channel”: “SMS”
         }
     ]
 });
 req.write(postData);
 req.end();
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23
											24
											25
											26
											27
											28
											29
											30
											31
											32
											33
											34
											35
											36
											37
											38

		require “uri”
 require “json”
 require “net/http”
 url = URI(“https://{baseUrl}/unified-api/1/messages”)
 https = Net::HTTP.new(url.host, url.port)
 https.use_ssl = true
 request = Net::HTTP::Post.new(url)
 request[“Authorization”] = “{authorization}”
 request[“Content-Type”] = “application/json”
 request[“Accept”] = “application/json”
 request.body = JSON.dump({
     “messages”: [
         {
             “content”: {
                 “body”: {
                     “text”: “Text message to send”,
                     “type”: “TEXT”
                 }
             },
             “sender”: “senderNumber”,
             “destinations”: [
                 {
                     “to”: “destinationNumber”
                 }
             ],
             “channel”: “SMS”
         }
     ]
 })
 response = https.request(request)
 puts response.read_body
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23
											24
											25
											26
											27
											28
											29
											30
											31

Unify all channels with Messages API

Improve efficiency and manage all your communication channels with a single API. Easily manage channel sequencing and failover without having to edit content.

Messages API

Explore all API docs

CPaaS X enhances the entire platform journey

Identify issues before they have an impact

Automatic detection of fraudulent and bot-generated traffic
Proactive analysis of overall traffic for early identification of possible issues
Receive real-time alerts and immediately actionable insights

Contact an expert

Benefit from the most evolved CPaaS solution

Provide a bespoke service for every client and reduce management overheads

CPaaS X enables you to configure every client individually and provides granular reports per customer, use case, or resource. Cut out distracting data noise by subscribing only to the events you need.

Explore new global markets

With more than 80 offices worldwide and 800+ direct carrier connections, Infobip will support your geographic expansion, not only through infrastructure but with our local compliance and legal know-how. Provide the most popular and effective channel for every region and help your clients be more successful everywhere.