Desbloquea el potencial de tu plataforma con CPaaS X

Presentamos la nueva generación de CPaaS (Plataforma de Comunicación como Servicio). CPaaS X es un conjunto modular de APIs que ayuda a las plataformas a escalar exponencialmente con menos esfuerzos de ingeniería y una mayor eficiencia operacional.

REDUCE LA CARGA OPERACIONAL

Más oportunidades de automatización

CPaaS X presenta nuevas APIs granulares para automatizar el aprovisionamiento de recursos, el registro de campañas y los informes de consumo específicos de cada cliente.

Habla con un experto

DISMINUYE EL TIME-TO-MARKET

Pon a tus clientes en marcha al instante

El onboarding y el aprovisionamiento de números automatizados permiten que tus clientes se pongan en marcha y comiencen a enviar tráfico más rápido de lo que creían posible.

Habla con un experto

MENORES ESFUERZOS DE INGENIERÍA

Una API verdaderamente unificada para todos los canales

Reduce la complejidad e integra fácilmente nuevos canales mediante una API unificada.

Habla con un experto

CONVIÉRTETE A LA OMNICANALIDAD

Máxima flexibilidad de los canales, mínimo esfuerzo de ingeniería

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.

Habla con un experto

Actualmente, estamos pasando todo nuestro tráfico de SMS en los Estados Unidos a través de códigos cortos de Infobip y trabajando muy de cerca con ellos en la expansión de productos tradicionales. El equipo de Infobip es uno de los equipos más profesionales y experimentados con los que hemos trabajado. El equipo de Infobip es uno de los equipos más profesionales y experimentados con los que hemos trabajado.

Omer Bar Joseph

Gerente General, Yotpo SMS

Infobip es sinónimo de innovación, lo que los convierte en una plataforma de comunicación confiable. Hacen un esfuerzo adicional, entienden lo que el cliente necesita y brindan soluciones a través de la tecnología y los canales correctos.

Hari Chinni

Gerente de Tecnología, 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

Todos los beneficios de una API unificada

Aumenta tu eficiencia y gestiona tus canales de comunicación mediante una única API. Administra fácilmente la secuenciación de canales y la conmutación por error (failover) sin tener que editar el contenido.

API Unificada

Explora toda la documentación API

CPaaS X potencia todo el recorrido de las plataformas

Distribución optimizada del tráfico

Conecta diferentes canales con una sola API unificada
Permite que los clientes envíen mensajes a través de diferentes canales y deja que Infobip se encargue de la lógica de la conmutación por error

Habla con un experto

Identifica inconvenientes antes de que generen un impacto

Detección automática de tráfico fraudulento y/o generado por bots
Análisis de tráfico proactivo para la identificación temprana de problemas potenciales
Recibe alertas e información en tiempo real para actuar de inmediato

Habla con un experto

Benefíciate de la más integral solución CPaaS

Ofrece un servicio personalizado a cada cliente y reduce los gastos de gestión

CPaaS X te permite configurar cada cliente individualmente y entregar informes detallados por cliente, caso de uso o función. Elimina el ruido generado por demasiados datos y selecciona únicamente los eventos que deseas monitorear.

Explora nuevos mercados globales

Con más de 70 oficinas en todo el mundo y más de 800 conexiones directas de operadores, Infobip respaldará tu expansión geográfica; no solo a través de nuestra infraestructura, sino también a través de nuestra experiencia legal y de cumplimiento local. Selecciona el canal más popular y eficaz para cada región y ayuda a tus clientes a obtener mayor éxito en todo el mundo.