NAV
shell php java python nodejs ruby c#

Autenticação

Cada pedido realizado terá de incluir no respetivo cabeçalho do pedido http a autenticação do cliente. Tal é feito usando uma autenticação de acesso básico HTTP.

O cabeçalho da autorização é construído combinando a combinação utilizador:apiPassword e codificando-a em base64. A esta combinação antepõe-se Authorization: Basic

Por exemplo, para o utilizador username e palavra-passe apiPassword o cabeçalho resultante seria:

Authorization: Basic dXNlcm5hbWU6YXBpUGFzc3dvcmQ=

Campanhas

Mensagens programadas

Listar

GET {{DASHBOARD_HOST}}/api/rest/scheduled

curl -X GET '{{DASHBOARD_HOST}}/api/rest/scheduled' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/scheduled',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/scheduled");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/scheduled',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/scheduled"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/scheduled")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/scheduled");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

Multi GUID

{
  "result": [
    {
      "guid": "100",
      "type": "SMS",
      "sending_id": 123,
      "updated_at": "2017-09-18 10:49:12",
      "scheduled_at": "2017-11-11 10:10:10"
    },
    {
      "guid": "101",
      "type": "SMS",
      "sending_id": 123,
      "created_at": "2017-09-18 10:49:12",
      "updated_at": "2017-09-18 10:49:12",
      "scheduled_at": "2017-11-11 10:10:10"
    },
    {
      "guid": "102",
      "type": "SMS",
      "sending_id": 123,
      "created_at": "2017-09-18 10:49:12",
      "updated_at": "2017-09-18 10:49:12",
      "scheduled_at": "2017-11-11 10:10:10"
    }
  ],
  "total": 3
}

Single GUID

{
  "result": {
    "guid": "100",
    "type": "SMS",
    "content": {
        "to": "34666555444",
        "from": "SAMPLE",
        "encoding": "gsm",
        "message": "This is a test",
        "campaignId": 456,
        "sendingId": 123
    },
    "created_at": "2017-09-18 10:49:12",
    "updated_at": "2017-09-18 10:49:12",
    "scheduled_at": "2017-11-11 10:10:10"
  },
  "total": 1
}

Podem-se filtrar todos os envios programados. A lista poderá ser filtrada por tipo de envio (SMS ou MAILING) e também por GUID, relação de GUIDs ou para todos.

O conteúdo da mensagem não é mostrado na lista a não ser que seja especificado um único GUID.

Parâmetro Tipo Obrigatório Descrição
guid integer, array Não Identificador único de cada uma das mensagens Podem-se indicar diversos guids agrupados num array ou nenhum para visualizar todos.
type string Não SMS o MAILING
sendingId integer Não Identificador de envio.

Atualização

PUT {{DASHBOARD_HOST}}/api/rest/scheduled

curl -X PUT '{{DASHBOARD_HOST}}/api/rest/scheduled' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "guid": [100,101],
  "scheduleDate": "20171011093000"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/scheduled',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'PUT',
  CURLOPT_POSTFIELDS => '{
  "guid": [100,101],
  "scheduleDate": "20171011093000"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/scheduled");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("PUT");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"guid\": [100,101], \"scheduleDate\": \"20171011093000\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'put',
  url: '{{DASHBOARD_HOST}}/api/rest/scheduled',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "guid": [100,101], "scheduleDate": "20171011093000" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/scheduled"

payload = "{ \"guid\": [100,101], \"scheduleDate\": \"20171011093000\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("PUT", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/scheduled")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"guid\": [100,101], \"scheduleDate\": \"20171011093000\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/scheduled");
      client.Timeout = -1;
      var request = new RestRequest(Method.PUT);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"guid\": [100,101], \"scheduleDate\": \"20171011093000\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "result": true,
  "updated": 2
}

Atualiza a data de programação de um, vários ou todos os envios programados. Pode-se filtrar por GUID e/ou tipo de envio.

Parâmetro Tipo Obrigatório Descrição
guid integer, array Não Identificador del mensaje o mensajes. Se le puede pasar un identificador, un array de identificadores o ninguno para mostrarlos todos.
type string Não SMS o MAILING
scheduleDate string Sim Fecha de envío del mensaje en formato UTC. Si se necesita enviar mensajes programados se puede especificar la fecha de envío indicando la fecha en formato YYYYmmddHHiiss (Ej: 20130215142000 sería el 15 de febrero de 2013 a las 14:20:00). En caso de envío inmediato no se tiene que especificar este parámetro.

Eliminar

DELETE {{DASHBOARD_HOST}}/api/rest/scheduled

curl -X DELETE '{{DASHBOARD_HOST}}/api/rest/scheduled' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "guid": [100, 101]
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/scheduled',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'DELETE',
  CURLOPT_POSTFIELDS => '{
  "guid": [100, 101]
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/scheduled");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("DELETE");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"guid\": [100, 101] }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'delete',
  url: '{{DASHBOARD_HOST}}/api/rest/scheduled',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "guid": [100, 101] }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/scheduled"

payload = "{ \"guid\": [100, 101] }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/scheduled")

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

request = Net::HTTP::Delete.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"guid\": [100, 101] }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/scheduled");
      client.Timeout = -1;
      var request = new RestRequest(Method.DELETE);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"guid\": [100, 101] }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "result": true,
  "deleted": 2
}

Elimine um, vários ou todos os envios programados. Pode-se filtrar por um ou vários GUID ou nenhum.

Parámetro Tipo Obligatorio Descripción
guid integer, array Não Identificador único de cada uma das mensagens. Podem-se indicar diversos guids agrupados num array ou nenhum para deletar todos.
type string Não SMS o MAILING

Lista de campanhas

GET {{DASHBOARD_HOST}}/api/rest/campaigns

curl -X GET '{{DASHBOARD_HOST}}/api/rest/campaigns' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/campaigns',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/campaigns");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/campaigns',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/campaigns"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/campaigns")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/campaigns");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": [
    {
      "id": 1,
      "name": "My campaign",
      "type": "basic",
      "createdAt": "2018-12-27T11:31:16+00:00",
      "updatedAt": "2018-12-27T11:31:16+00:00",
      "links": {
        "self": "{{DASHBOARD_HOST}}/api/rest/campaigns/1",
        "sendings": "{{DASHBOARD_HOST}}/api/rest/campaigns/1/sendings"
      },
      "sendings": {
        "data": [
          {
            "id": 1,
            "campaignName": "My campaign",
            "status": "OPENED",
            "channel": "sms",
            "total": 2,
            "processed": 2,
            "totalSmsParts": 4,
            "cost": 0.02,
            "currency": "EUR",
            "tags": [],
            "scheduledAt": null,
            "expiresAt": null,
            "startedAt": null,
            "finishedAt": null,
            "createdAt": "2018-12-27T11:31:16+00:00",
            "updatedAt": "2018-12-27T11:31:22+00:00",
            "events": {
              "delivered": 2,
              "opened": 0,
              "opened_unique": 0,
              "clicked": 0,
              "clicked_unique": 0,
              "unsubscribed": 0,
              "hard_bounced": 0,
              "complaint": 0,
              "sent": 2,
              "soft_bounced": 0,
              "undelivered": 0,
              "rejected": 0,
              "expired": 0,
              "unsubscribed_landing": 0
            },
            "links": {
              "self": "{{DASHBOARD_HOST}}/api/rest/sendings/1",
              "eventsReport": "{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events"
            }
          }
        ]
      }
    }
  ]
}

Filtros

Parâmetro Descrição
name Filtrar por nome da campanha. É possível usar o caractere "*" como "wildcard". Exemplo: ?name=CAMPAIGN_2020_*
channel Filtrar por canal. Valores disponíveis: sms, mailing, landing, text2speech, voice-interactive. Exemplo: ?channel=sms.
beforeDate Mostrar resultados antes da data indicada. A data deve ser especificada no formato ISO 8601. Exemplo: ?beforeDate=2019-01-01T00%3A00%3A00%2B00%3A00.
afterDate Mostrar resultados após a data indicada. A data deve ser especificada no formato ISO 8601. Exemplo: ?afterDate=2019-01-01T00%3A00%3A00%2B00%3A00.

Os parâmetros devem ser codificados corretamente (urlencode) em relação ao padrão RFC 3986 para serem suportados pelo servidor.

Campos da resposta

Parâmetro Descrição
name Nome da campanha.
type Tipo de campanha. Valores possíveis: basic, automatic, trigger, testab.
sendings Listagem dos envios associadas na campanha. Para campanhas de tipo basic e automatic O número de envios será sempre 1.
sendings.*.status Status do envio. Valores possíveis:
PENDING: Envio agendado para uma data futura.
SAVED: Envio salvo. Não será enviado até que a campanha seja confirmada na plataforma.
SENDING: Envio em processamento.
PAUSED: Envio pausado.
FINISHED: Envio finalizado.
CANCELLED: Envio cancelado.
EDITING: O envio está sendo editado na plataforma.
OPENED: Os envios por API informarão esse status. Indica que o envio pode aceitar mais mensagens.
AUTOMATED: Envio automatizado aguardando que as condições de automação sejam alcançadas.
WAITING: Envio trigger aguardando que as condições de envio sejam alcançadas.
sendings.*.channel Canal do envio. Valores possíveis: sms, mailing, landing, text2speech, voice-interactive.
sendings.*.total Total de mensagens a serem enviadas.
sendings.*.processed Total de mensagens enviadas.
sendings.*.totalSmsParts Aplicável apenas aos envios de SMS. No caso de envios concatenados, será indicado o número de partes de SMS enviadas.
sendings.*.cost Custo do envio.
sendings.*.currency Código da moeda para o custo.
sendings.*.tags Tags atribuídas ao envio.
sendings.*.scheduledAt Data de programação da campanha. Nenhuma mensagem será enviada antes desta data.
sendings.*.expiresAt Data de expiração da campanha. Após essa data, nenhuma outra mensagem será enviada.
sendings.*.events Resumo dos totais de eventos produzidos no envio. Eventos:
delivered: A mensagem foi entregue ao contato.
opened: O contato abriu a mensagem. Não aplicável a sms e voz.
opened_unique: Total de aberturas únicas. Não aplicável a sms e voz.
clicked: O contato clicou em um link incluído na mensagem. Não aplicável a sms e voz.
clicked_unique: Total de cliques únicos. Não aplicável a sms e voz.
unsubscribed: O contato solicitou a baixa da lista.
hard_bounced: Total hard bounces gerado pela campanha. Aplicável apenas ao envio de emails.
complaint: O contato marcou a mensagem como indesejada.
sent: A mensagen foi enviada ao contato.
soft_bounced: Total soft bounces gerado pela campanha. Aplicável apenas ao envio de emails.
undelivered: Não foi possível entregar a mensagem ao contato.
rejected: A tentativa de enviar a mensagem foi rejeitada.
expired: A mensagem foi rejeitada devido a que a data de expiração da campanha já foi alcançada.
unsubscribed_landing: O contato solicitou a baixa usando a landing page incluída na mensagem.

Bancos de dados

Contactos

Lista de contactos

GET {{DASHBOARD_HOST}}/api/rest/contacts

curl -X GET '{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields,groups");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": [
    {
      "id": 1,
      "email": "email@example.com",
      "phone": "34666666666",
      "countryIso": "ES",
      "landline": "900222222",
      "name": "Name",
      "surname": "Last name",
      "createdAt": "2018-03-13T14:32:25+00:00",
      "updatedAt": "2018-07-04T13:57:09+00:00",
      "customFields": {
        "data": [
          {
            "key": "color",
            "type": "string",
            "value": "green"
          }
        ]
      },
      "groups": {
        "data": [
          {
            "id": 1,
            "name": "My Contact List"
          }
        ]
      }
    }
  ],
  "meta": {
    "pagination": {
      "total": 500,
      "count": 100,
      "per_page": 100,
      "current_page": 1,
      "total_pages": 5,
      "links": {
        "next": "{{DASHBOARD_HOST}}/api/rest/contacts?include=customFields%2Cgroups&page=2"
      }
    }
  }
}

Filtros

Parâmetro Descrição
limit Total de contactos a exibir num único pedido. Valor por defeito: 100. Máximo: 1000.
include Incluir os sub-recursos associados na resposta. É possível especificar vários valores separando-os por vírgulas. Valores disponíveis: customFields, groups.
email Filtrar os contactos para um e-mail especificado: email=myemail@example.com.
phone Filtrar os contactos para um telefone especificado: phone=34666666666.
landline Filtrar os contactos para um telefone fixo especificado: landline=900222222.
countryIso Filtrar os contactos para um país especificado: countryIso=ES.
externalId Filtrar os contactos para um externalId especificado: externalId=EXT1.

Mostrar um contacto

GET {{DASHBOARD_HOST}}/api/rest/contacts/<ID>

curl -X GET '{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/contacts/1?include=customFields,groups");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": {
    "id": 1,
    "email": "email@example.com",
    "phone": "34666666666",
    "countryIso": "ES",
    "landline": "900222222",
    "name": "Name",
    "surname": "Last name",
    "createdAt": "2018-03-13T14:32:25+00:00",
    "updatedAt": "2018-07-04T13:57:09+00:00",
    "customFields": {
      "data": [
        {
          "key": "color",
          "type": "string",
          "value": "green"
        }
      ]
    },
    "groups": {
      "data": [
        {
          "id": 1,
          "name": "My Contact List"
        }
      ]
    }
  }
}

Filtros

Parâmetro Descrição
include Incluir os sub-recursos associados na resposta. É possível especificar vários valores separando-os por vírgulas. Valores disponíveis: customFields, groups.

Criar um novo contacto

POST {{DASHBOARD_HOST}}/api/rest/contacts

curl -X POST '{{DASHBOARD_HOST}}/api/rest/contacts' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
    "email": "new.contact@example.com",
    "phone": "3466666666",
    "countryIso": "ES",
    "groupsNames": ["My contact list"],
    "customFields": [
        {
            "key": "company",
            "value": "ACME inc."
        }
    ]
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/contacts',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => '{
    "email": "new.contact@example.com",
    "phone": "3466666666",
    "countryIso": "ES",
    "groupsNames": ["My contact list"],
    "customFields": [
        {
            "key": "company",
            "value": "ACME inc."
        }
    ]
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/contacts");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'post',
  url: '{{DASHBOARD_HOST}}/api/rest/contacts',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "email": "new.contact@example.com", "phone": "3466666666", "countryIso": "ES", "groupsNames": ["My contact list"], "customFields": [ { "key": "company", "value": "ACME inc." } ] }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/contacts"

payload = "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/contacts")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/contacts");
      client.Timeout = -1;
      var request = new RestRequest(Method.POST);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response (HTTP 201)

{
  "data": {
    "id": 1,
    "email": "new.contact@example.com",
    "phone": "3466666666",
    "countryIso": "ES",
    "landline": null,
    "name": null,
    "surname": null,
    "createdAt": "2018-03-13T14:32:25+00:00",
    "updatedAt": "2018-03-13T14:32:25+00:00",
    "links": {
      "self": "{{DASHBOARD_HOST}}/api/rest/contacts/1"
    }
  }
}

Error response

{
  "error": {
    "code": 422,
    "description": "The email field is required."
  }
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
email string Obrigatório quando o phone ou landline não é especificado. E-mail do novo contacto.
phone string Obrigatório quando email ou landline não for especificado. Número de telemóvel do contacto.
landline string Obrigatório quando email ou phone não for especificado. Número de telefone fixo do contacto.
countryIso string Obrigatório quando phone ou landline não for especificado. ISO code de 2 letras del país del contacto.
groupsIds array Obrigatório de groupsNames não for especificado. Lista de grupos aos quais será adicionado o novo contacto. Para obter as ids de grupos, consultar a documentação para o endpoint correspondente.
groupsNames array Obrigatório se groupsIds não for especificado. Em alternativa, caso não disponha da lista de IDs de grupos, é possível especificar uma lista com os nomes dos grupos aos quais será adicionado o contacto.
name string Não Nome do contacto.
surname string Não Apelidos do contacto.
customFields[]key string Não Nome do campo personalizado a adicionar.
customFields[]type string Não Tipo do campo personalizado. Valores possíveis: string, date, decimal. Para utilizar um campo, o valor deverá estar no formato ISO8601. Valor por defeito: string
customFields[]value string Não Valor do campo personalizado.

Atualizar um contacto

PUT {{DASHBOARD_HOST}}/api/rest/contacts/<ID>

curl -X PUT '{{DASHBOARD_HOST}}/api/rest/contacts/1' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
    "email": "new.contact@example.com",
    "phone": "3466666666",
    "countryIso": "ES",
    "groupsNames": ["My contact list"],
    "customFields": [
        {
            "key": "company",
            "value": "ACME inc."
        }
    ]
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/contacts/1',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'PUT',
  CURLOPT_POSTFIELDS => '{
    "email": "new.contact@example.com",
    "phone": "3466666666",
    "countryIso": "ES",
    "groupsNames": ["My contact list"],
    "customFields": [
        {
            "key": "company",
            "value": "ACME inc."
        }
    ]
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/contacts/1");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("PUT");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'put',
  url: '{{DASHBOARD_HOST}}/api/rest/contacts/1',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "email": "new.contact@example.com", "phone": "3466666666", "countryIso": "ES", "groupsNames": ["My contact list"], "customFields": [ { "key": "company", "value": "ACME inc." } ] }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/contacts/1"

payload = "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("PUT", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/contacts/1")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/contacts/1");
      client.Timeout = -1;
      var request = new RestRequest(Method.PUT);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"email\": \"new.contact@example.com\", \"phone\": \"3466666666\", \"countryIso\": \"ES\", \"groupsNames\": [\"My contact list\"], \"customFields\": [ { \"key\": \"company\", \"value\": \"ACME inc.\" } ] }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response (HTTP 200)

{
  "data": {
    "id": 1,
    "email": "new.contact@example.com",
    "phone": "3466666666",
    "countryIso": "ES",
    "landline": null,
    "name": null,
    "surname": null,
    "createdAt": "2018-03-13T14:32:25+00:00",
    "updatedAt": "2018-03-13T14:32:25+00:00",
    "links": {
      "self": "{{DASHBOARD_HOST}}/api/rest/contacts/1"
    }
  }
}

Error response

{
  "error": {
    "code": 422,
    "description": "The email field is required."
  }
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
email string Obrigatório quando o phone ou landline não é especificado. E-mail do novo contacto.
phone string Obrigatório quando email ou landline não for especificado. Número de telemóvel do contacto.
landline string Obrigatório quando email ou phone não for especificado. Número de telefone fixo do contacto.
countryIso string Obrigatório quando phone ou landline não for especificado. ISO code de 2 letras del país del contacto.
groupsIds array Obrigatório de groupsNames não for especificado. Lista de grupos aos quais será adicionado o novo contacto. Para obter as ids de grupos, consultar a documentação para o endpoint correspondente.
groupsNames array Obrigatório se groupsIds não for especificado. Em alternativa, caso não disponha da lista de IDs de grupos, é possível especificar uma lista com os nomes dos grupos aos quais será adicionado o contacto.
name string Não Nome do contacto.
surname string Não Apelidos do contacto.
customFields[]key string Não Nome do campo personalizado a adicionar.
customFields[]type string Não Tipo do campo personalizado. Valores possíveis: string, date, decimal. Para utilizar um campo, o valor deverá estar no formato ISO8601. Valor por defeito: string.
customFields[]value string Não Valor do campo personalizado.

Eliminar um contacto

DELETE {{DASHBOARD_HOST}}/api/rest/contacts/<ID>

curl -X DELETE '{{DASHBOARD_HOST}}/api/rest/contacts/1' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/contacts/1',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'DELETE',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/contacts/1");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("DELETE");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'delete',
  url: '{{DASHBOARD_HOST}}/api/rest/contacts/1',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/contacts/1"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/contacts/1")

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

request = Net::HTTP::Delete.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/contacts/1");
      client.Timeout = -1;
      var request = new RestRequest(Method.DELETE);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Caso o pedido seja bem sucedido, responderá com um código HTTP 204.

Grupos

Lista de grupos

GET {{DASHBOARD_HOST}}/api/rest/groups

curl -X GET '{{DASHBOARD_HOST}}/api/rest/groups' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/groups',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/groups");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/groups',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/groups"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/groups")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/groups");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": [
    {
      "id": 1,
      "name": "My contact list"
    }
  ],
  "meta": {
    "pagination": {
      "total": 500,
      "count": 100,
      "per_page": 100,
      "current_page": 1,
      "total_pages": 5,
      "links": {
        "next": "{{DASHBOARD_HOST}}/api/rest/groups?page=2"
      }
    }
  }
}

Filtros

Parâmetro Descrição
limit Total de contactos a exibir num único pedido. Valor por defeito: 100. Máximo: 1000.

Mostrar um grupo

GET {{DASHBOARD_HOST}}/api/rest/groups/<ID>

curl -X GET '{{DASHBOARD_HOST}}/api/rest/groups/1' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/groups/1',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/groups/1");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/groups/1',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/groups/1"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/groups/1")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/groups/1");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": {
    "id": 1,
    "name": "My contact list"
  }
}

Criar um novo grupo

POST {{DASHBOARD_HOST}}/api/rest/groups

curl -X POST '{{DASHBOARD_HOST}}/api/rest/groups' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
    "name": "My new contact list"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/groups',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => '{
    "name": "My new contact list"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/groups");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"name\": \"My new contact list\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'post',
  url: '{{DASHBOARD_HOST}}/api/rest/groups',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "name": "My new contact list" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/groups"

payload = "{ \"name\": \"My new contact list\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/groups")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"name\": \"My new contact list\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/groups");
      client.Timeout = -1;
      var request = new RestRequest(Method.POST);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"name\": \"My new contact list\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response (HTTP 201)

{
  "data": {
    "id": 1,
    "name": "My new contact list"
  }
}

Error response

{
  "error": {
    "code": 422,
    "description": "The name field is required."
  }
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
name string Sim Nome do novo grupo.

Atualizar um grupo

PUT {{DASHBOARD_HOST}}/api/rest/groups/<ID>

curl -X PUT '{{DASHBOARD_HOST}}/api/rest/groups' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
    "name": "My new contact list"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/groups',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'PUT',
  CURLOPT_POSTFIELDS => '{
    "name": "My new contact list"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/groups");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("PUT");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"name\": \"My new contact list\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'put',
  url: '{{DASHBOARD_HOST}}/api/rest/groups',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "name": "My new contact list" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/groups"

payload = "{ \"name\": \"My new contact list\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("PUT", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/groups")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"name\": \"My new contact list\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/groups");
      client.Timeout = -1;
      var request = new RestRequest(Method.PUT);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"name\": \"My new contact list\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response (HTTP 200)

{
  "data": {
    "id": 1,
    "name": "My new contact list"
  }
}

Error response

{
  "error": {
    "code": 422,
    "description": "The name field is required."
  }
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
name string Sim Nome do novo grupo.

Eliminar um grupo

DELETE {{DASHBOARD_HOST}}/api/rest/groups/<ID>

curl -X DELETE '{{DASHBOARD_HOST}}/api/rest/groups/1' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/groups/1',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'DELETE',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/groups/1");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("DELETE");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'delete',
  url: '{{DASHBOARD_HOST}}/api/rest/groups/1',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/groups/1"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/groups/1")

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

request = Net::HTTP::Delete.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/groups/1");
      client.Timeout = -1;
      var request = new RestRequest(Method.DELETE);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Caso o pedido seja bem sucedido, responderá com um código HTTP 204.

Lista negra

Listado de contactos em lista negra

GET {{DASHBOARD_HOST}}/api/rest/v2/blacklist/{type}

curl -X GET '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": [
    {
      "type": "sms",
      "recipient": "99000000000",
      "isDefinitive": false,
      "sendingId": 123,
      "campaignName": "TEST_CAMPAIGN",
      "createdAt": "2020-01-01T00:00:00+00:00"
    }
  ],
  "meta": {
    "pagination": {
      "total": 500,
      "count": 100,
      "per_page": 100,
      "current_page": 1,
      "total_pages": 5,
      "links": {
        "next": "{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms?page=2"
      }
    }
  }
}

Parâmetros de URL

Parâmetro Descrição
type Tipo de lista negra: sms, mailing, voice.

Filtros

Parâmetro Descrição
limit Total de contatos a serem exibidos em uma única petição. Valor por defeito: 100. Máximo: 1000.
recipient Filtrar por destinatário. Exemplo: ?recipient=test%40example.com
sendingId Filtrar por sendingId. Exemplo: ?sendingId=123

Adicionar contacto na lista negra

PUT {{DASHBOARD_HOST}}/api/rest/v2/blacklist/{type}

curl -X PUT '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "recipient": "99000000000"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'PUT',
  CURLOPT_POSTFIELDS => '{
  "recipient": "99000000000"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("PUT");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"recipient\": \"99000000000\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'put',
  url: '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "recipient": "99000000000" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms"

payload = "{ \"recipient\": \"99000000000\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("PUT", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"recipient\": \"99000000000\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms");
      client.Timeout = -1;
      var request = new RestRequest(Method.PUT);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"recipient\": \"99000000000\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response (HTTP 200)

{
  "data": {
    "type": "sms",
    "recipient": "99000000000",
    "isDefinitive": false,
    "campaignName": null,
    "createdAt": "2020-01-01T00:00:00+00:00"
  }
}

Parâmetros de URL

Parâmetro Descrição
type Tipo de lista negra: sms, mailing, voice.

Parâmetros

Parâmetro Tipo Obrigatório Descrição
recipient string Sim Destinatário para adicionar à lista negra.

Eliminar contacto da lista negra

DELETE {{DASHBOARD_HOST}}/api/rest/v2/blacklist/{type}

curl -X DELETE '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "recipient": "99000000000"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'DELETE',
  CURLOPT_POSTFIELDS => '{
  "recipient": "99000000000"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("DELETE");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"recipient\": \"99000000000\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'delete',
  url: '{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "recipient": "99000000000" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms"

payload = "{ \"recipient\": \"99000000000\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms")

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

request = Net::HTTP::Delete.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"recipient\": \"99000000000\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/v2/blacklist/sms");
      client.Timeout = -1;
      var request = new RestRequest(Method.DELETE);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"recipient\": \"99000000000\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Parâmetros de URL

Parâmetro Descrição
type Tipo de lista negra: sms, mailing, voice.

Parâmetros

Parâmetro Tipo Obrigatório Descrição
recipient string Sim Destinatário a ser removido da lista negra.

Se a petição for bem-sucedida, será respondida com um código HTTP 204.

Templates e ficheiros

Encurtador urls

Criação de url curtas

POST {{DASHBOARD_HOST}}/api/rest/shortener/shorten

Request

curl -X POST '{{DASHBOARD_HOST}}/api/rest/shortener/shorten' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "urls": [
    {"longUrl": "https://example.com/test1"},
    {"longUrl": "https://example.com/test2"},
    {"longUrl": "invalidUrl"}
  ]
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/shortener/shorten',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => '{
  "urls": [
    {"longUrl": "https://example.com/test1"},
    {"longUrl": "https://example.com/test2"},
    {"longUrl": "invalidUrl"}
  ]
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/shortener/shorten");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"urls\": [ {\"longUrl\": \"https://example.com/test1\"}, {\"longUrl\": \"https://example.com/test2\"}, {\"longUrl\": \"invalidUrl\"} ] }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'post',
  url: '{{DASHBOARD_HOST}}/api/rest/shortener/shorten',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "urls": [ {"longUrl": "https://example.com/test1"}, {"longUrl": "https://example.com/test2"}, {"longUrl": "invalidUrl"} ] }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/shortener/shorten"

payload = "{ \"urls\": [ {\"longUrl\": \"https://example.com/test1\"}, {\"longUrl\": \"https://example.com/test2\"}, {\"longUrl\": \"invalidUrl\"} ] }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/shortener/shorten")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"urls\": [ {\"longUrl\": \"https://example.com/test1\"}, {\"longUrl\": \"https://example.com/test2\"}, {\"longUrl\": \"invalidUrl\"} ] }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/shortener/shorten");
      client.Timeout = -1;
      var request = new RestRequest(Method.POST);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"urls\": [ {\"longUrl\": \"https://example.com/test1\"}, {\"longUrl\": \"https://example.com/test2\"}, {\"longUrl\": \"invalidUrl\"} ] }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": [
    {
      "longUrl": "https://example.com/test1",
      "shortUrl": "https://sms.tl/dvRINN",
      "error": false
    },
    {
      "longUrl": "https://example.com/test2",
      "shortUrl": "https://sms.tl/GFA6Fm",
      "error": false
    },
    {
      "longUrl": "invalidUrl",
      "shortUrl": null,
      "error": true
    }
  ]
}

Gerador de imagem

Geração de imagens

POST {{DASHBOARD_HOST}}/api/rest/images/generate

Request

curl -X POST '{{DASHBOARD_HOST}}/api/rest/images/generate' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "images": [
    {
        "externalId": "test1",
        "extension": "jpg",
        "base64": "BASE64_ENCODED_STRING"
    },
    {
        "externalId": "test2",
        "extension": "png",
        "base64": "BASE64_ENCODED_STRING"
    }
  ]
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/images/generate',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => '{
  "images": [
    {
        "externalId": "test1",
        "extension": "jpg",
        "base64": "BASE64_ENCODED_STRING"
    },
    {
        "externalId": "test2",
        "extension": "png",
        "base64": "BASE64_ENCODED_STRING"
    }
  ]
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/images/generate");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"images\": [ { \"externalId\": \"test1\", \"extension\": \"jpg\", \"base64\": \"BASE64_ENCODED_STRING\" }, { \"externalId\": \"test2\", \"extension\": \"png\", \"base64\": \"BASE64_ENCODED_STRING\" } ] }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'post',
  url: '{{DASHBOARD_HOST}}/api/rest/images/generate',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "images": [ { "externalId": "test1", "extension": "jpg", "base64": "BASE64_ENCODED_STRING" }, { "externalId": "test2", "extension": "png", "base64": "BASE64_ENCODED_STRING" } ] }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/images/generate"

payload = "{ \"images\": [ { \"externalId\": \"test1\", \"extension\": \"jpg\", \"base64\": \"BASE64_ENCODED_STRING\" }, { \"externalId\": \"test2\", \"extension\": \"png\", \"base64\": \"BASE64_ENCODED_STRING\" } ] }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/images/generate")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"images\": [ { \"externalId\": \"test1\", \"extension\": \"jpg\", \"base64\": \"BASE64_ENCODED_STRING\" }, { \"externalId\": \"test2\", \"extension\": \"png\", \"base64\": \"BASE64_ENCODED_STRING\" } ] }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/images/generate");
      client.Timeout = -1;
      var request = new RestRequest(Method.POST);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"images\": [ { \"externalId\": \"test1\", \"extension\": \"jpg\", \"base64\": \"BASE64_ENCODED_STRING\" }, { \"externalId\": \"test2\", \"extension\": \"png\", \"base64\": \"BASE64_ENCODED_STRING\" } ] }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

{
  "data": [
    {
      "externalId": "test1",
      "imageUrl": "{{DASHBOARD_HOST}}/uploads/UCuh4pdOsW58ZEXX/1b4f0e9851971998e732078544c96b36c3d01cedf7caa332359d6f1d83567014.jpg",
      "error": false
    },
    {
      "externalId": "test2",
      "imageUrl": "{{DASHBOARD_HOST}}/uploads/UCuh4pdOsW58ZEXX/60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752.jpg",
      "error": false
    }
  ]
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
externalId string Sim ID externo para identificar a imagem na resposta.
extension string Sim Extensão de imagem. Extensões permitidas: jpg, png.
base64 string Sim Imagem codificada em Base64.

Eventos

Notificações de eventos

Introdução

O objetivo do serviço de notificação de estados é informar ao servidor do cliente os eventos que são gerados no serviço 360nrs. As notificações serão feitas para os envios feitos por qualquer tipo de canal. Desta forma, o cliente poderá rastrear em tempo real cada envio efetuado.

Um único envio pode provocar múltiplos eventos, pelo que um envio em massa pode gerar um número significativo de notificações ao servidor do cliente. Para evitar a saturação do servidor, os eventos a notificar são colocados em fila na 360nrs, pelo que se podem verificar atrasos na entrega de notificações se o servidor do cliente não for capaz de gerir o volume de notificações gerado.

Para ativar esta funcionalidade, o cliente deve fornecer um URL onde serão feitos os pedidos http POST para notificar um evento.

Receber nova notificação de evento

HTTP METHOD: POST Content-Type: application/x-www-form-urlencoded

Parâmetros

Parâmetro Tipo Descrição
id string Identificador alfanumérico que foi entregue no envio por API da mensagem. Se a mensagem foi enviada pela web, não terá valor.
channel string Indica a que canal pertence o envio a que a notificação se refere. Os valores possíveis são: sms, mailing, landing, text2speech.
contactId integer Identificador único do contacto.
campaignId integer Identificador da campanha. Se foi enviado por API e não se especificou campaignName no envio, terá valor 0.
formId integer Identificador único do formulário. (Para eventos de formulário)
campaignName string Nome da campanha.
event string Indica o evento que ocorreu. Os valores possíveis são: delivered, opened, clicked, unsubscribed, hard_bounced, complaint, sent, soft_bounced, undelivered, rejected, expired, unsubscribed_landing, form_opened, form_submitted, form_rejected.
extra string Parâmetro extra com informações adicionais do evento no formato JSON.
O evento "form_submitted" conterá os valores inseridos no formulário pelo usuário no seguinte formato:

{"formValues":{"param1":"value1", "param2": "value2", ...}}

O evento "clicked" contenda a url a la que se ha hecho clic:

{"url":"url_encoded"}
smtpResponse string Variável opcional definida para o canal de e-mail e os eventos delivered, hard_bounced, soft_bounced. A resposta do servidor SMTP do email destinatário é devolvida.
eventDate string Data em que aconteceu o evento.

As notificações são reintentadas em 5 ocasiões caso que o servidor do cliente responder a um código HTTP distinto a 200 OK.

O tempo de espera entre as notificações é progressivo, portanto a primeira tentativa será feita em 1 minuto, a segunda após 2 minutos desde a tentativa anterior, a terceira após 3 minutos, etc.

Relatório de eventos por envio

Reporte de eventos

GET {{DASHBOARD_HOST}}/api/rest/sendings/<sendingId>/reports/events

curl -X GET '{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events',
  headers: {
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events"

payload = {}
headers = {
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/events");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Filtros

Parámetro Descripción
beforeDate Mostrar os resultados anterores a data indicada. A data deve ser especificada no formato ISO 8601.
afterDate Mostrar os resultados posteriores a data indicada. A data deve ser especificada no formato ISO 8601.
showCustomFields Se definido para 1, mostra os campos personalizados utilizados.

Os parâmetros devem ser corretamente codificados (urlencode) em relação ao padrão RFC 3986 para ser admitido pelo servidor. Por exemplo, para consultar o relatório de eventos entre as datas 2019-01-01T00:00:00+00:00 y 2019-02-01T00:00:00+00:00:

{{DASHBOARD_HOST}}/api/rest/sendings/{sendingId}/reports/events?afterDate=2019-01-01T00%3A00%3A00%2B00%3A00&beforeDate=2019-02-01T00%3A00%3A00%2B00%3A00

Obter o relatório detalhado dos eventos gerados por uma remessa. A resposta estará no formato text/csv e conterá as seguintes colunas:

Para envios de voz: campaignName ,campaignId, sendingId, contactId, event, phone, email, landline, countryIso, callDurationSeconds, createdAt

Para o resto dos canais: campaignName, campaignId, sendingId, contactId, event, phone, email, landline, countryIso, browser, os, url, createdAt

Relatório de pressionamentos

Introdução

Retorna um relatório com os números de telefone junto com a tecla pressionada e a mensagem da locução.

Url

GET {{DASHBOARD_HOST}}/api/rest/sendings/<sendingId>/reports/keys

curl -X GET '{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys',
  headers: {
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys"

payload = {}
headers = {
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/sendings/1/reports/keys");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Filtros

Parámetro Descripción
beforeDate Mostrar os resultados anterores a data indicada. A data deve ser especificada no formato ISO 8601.
afterDate Mostrar os resultados posteriores a data indicada. A data deve ser especificada no formato ISO 8601.

Os parâmetros devem ser corretamente codificados (urlencode) em relação ao padrão RFC 3986 para ser admitido pelo servidor. Por exemplo, para consultar o relatório de eventos entre as datas 2019-01-01T00:00:00+00:00 y 2019-02-01T00:00:00+00:00:

{{DASHBOARD_HOST}}/api/rest/sendings/{sendingId}/reports/keys?afterDate=2019-01-01T00%3A00%3A00%2B00%3A00&beforeDate=2019-02-01T00%3A00%3A00%2B00%3A00

Obtenha o relatório detalhado de pressionamentos de tecla de um envio de voz interativa. A resposta estará no formato text/csv e conterá as seguintes colunas: phonenumber, key, message

OTP

Generar código


POST {{DASHBOARD_HOST}}/api/rest/otp/generate

curl -X POST '{{DASHBOARD_HOST}}/api/rest/otp/generate' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "recipient": "34666555444"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/otp/generate',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => '{
  "recipient": "34666555444"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/otp/generate");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"recipient\": \"34666555444\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'post',
  url: '{{DASHBOARD_HOST}}/api/rest/otp/generate',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "recipient": "34666555444" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/otp/generate"

payload = "{ \"recipient\": \"34666555444\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/otp/generate")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"recipient\": \"34666555444\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/otp/generate");
      client.Timeout = -1;
      var request = new RestRequest(Method.POST);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"recipient\": \"34666555444\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

HTTP Response Code 200 (OK)

{
  "data": {
    "recipient": "34666555444",
    "code": "1234",
    "attempts": 0,
    "maxAttempts": 3,
    "maxSecondsValidity": 60,
    "appId": "",
    "createdAt": "2020-01-01T12:00:00+00:00",
    "updatedAt": "2020-01-01T12:00:00+00:00",
    "expiresAt": "2020-01-01T12:01:00+00:00"
  }
}

Error response (HTTP 422)

{
  "error": {
    "code": 422,
    "description": "The recipient field must be a valid phone or email."
  }
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
recipient string Sim Número de telefone ou e-mail do usuário.
alpha boolean Não Indique se o código é alfanumérico ou numérico.
O valor padrão é false.
length integer Não Tamanho do código.
O valor mínimo é 3 e o valor máximo é 10.
O valor padrão é 4.
maxAttempts integer Não Número máximo de tentativas.
O valor mínimo é 1 e o valor máximo é 10.
O valor padrão é 3.
maxSecondsValidity integer Não Número máximo de segundos entre a criação e validação do código.
O valor mínimo é 30 e o valor máximo é 600.
O valor padrão é 60.
appId string Não O mesmo telefone ou e-mail pode ser validado ao mesmo tempo, desde que seja com um appId diferente.
O valor padrão é "".
rejectIfPendingCode boolean Não Impede a geração de um novo código OTP se existir um anterior em estado pendente.
O valor por defeito é false.

Comprobar código


POST {{DASHBOARD_HOST}}/api/rest/otp/check

curl -X POST '{{DASHBOARD_HOST}}/api/rest/otp/check' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN' \
-d '{
  "recipient": "34666555444",
  "code": "1234"
}'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/otp/check',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => '{
  "recipient": "34666555444",
  "code": "1234"
}',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/otp/check");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      String requestBody = "{ \"recipient\": \"34666555444\", \"code\": \"1234\" }";
      connection.setDoOutput(true);
      DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
      wr.writeBytes(requestBody);
      wr.flush();
      wr.close();
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'post',
  url: '{{DASHBOARD_HOST}}/api/rest/otp/check',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  },
  data: '{ "recipient": "34666555444", "code": "1234" }'
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/otp/check"

payload = "{ \"recipient\": \"34666555444\", \"code\": \"1234\" }"
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/otp/check")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"
request.body = "{ \"recipient\": \"34666555444\", \"code\": \"1234\" }"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/otp/check");
      client.Timeout = -1;
      var request = new RestRequest(Method.POST);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      request.AddParameter("application/json", "{ \"recipient\": \"34666555444\", \"code\": \"1234\" }",  ParameterType.RequestBody);
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Response

HTTP Response Code 200 (OK)

{
  "data": {
    "valid": true,
    "reason": "Valid",
    "otp": {
      "data": {
        "recipient": "34666555444",
        "code": "1234",
        "attempts": 1,
        "maxAttempts": 3,
        "maxSecondsValidity": 60,
        "appId": "",
        "createdAt": "2020-01-01T12:00:00+00:00",
        "updatedAt": "2020-01-01T12:00:00+00:00",
        "expiresAt": "2020-01-01T12:01:00+00:00"
      }
    }
  }
}
{
  "data": {
    "valid": false,
    "reason": "Expired",
    "otp": {
      "data": {
        "recipient": "34666555444",
        "code": "1234",
        "attempts": 1,
        "maxAttempts": 3,
        "maxSecondsValidity": 60,
        "appId": "",
        "createdAt": "2020-01-01T12:00:00+00:00",
        "updatedAt": "2020-01-01T12:00:00+00:00",
        "expiresAt": "2020-01-01T12:01:00+00:00"
      }
    }
  }
}

Error response (HTTP 422)

{
  "error": {
    "code": 422,
    "description": "The recipient field is required."
  }
}

Parâmetros

Parâmetro Tipo Obrigatório Descrição
recipient string Sim Número de telefone ou e-mail do usuário.
code string Sim Código a ser verificado.
caseSensitive boolean Não Diferencia maiúsculas de minúsculas na comparação de códigos.
O valor padrão é false.
appId string Não O mesmo telefone ou e-mail pode ser validado ao mesmo tempo, desde que seja com um appId diferente.
O valor padrão é "".

Respostas

Razão Válido Descrição
Valid Sim O código é válido.
Invalid code Não O código não é válido.
Maximum attempts reached Não O número de tentativas excedeu o máximo.
Expired Não O tempo de validação excedeu o máximo.

Conta

Retorna informação da conta como nome de usuário, email, fuso horário, idioma, saldo, data de criação, país e moeda.

GET {{DASHBOARD_HOST}}/api/rest/account

curl -X GET '{{DASHBOARD_HOST}}/api/rest/account' \
-H 'Content-Type: application/json' \
-H 'Authorization: Basic YOUR_AUTH_TOKEN'
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => '{{DASHBOARD_HOST}}/api/rest/account',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Content-Type: application/json',
    'Authorization: Basic YOUR_AUTH_TOKEN'
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.HttpsURLConnection;

public class App {
  public static void main(String[] args) {
    try {
      URL url = new URL("{{DASHBOARD_HOST}}/api/rest/account");
      HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Authorization", "Basic YOUR_AUTH_TOKEN");
      connection.setRequestProperty("Accept", "application/json");
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();
      while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
      }
      in.close();
      System.out.println(response.toString());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}
var axios = require('axios');
var config = {
  method: 'get',
  url: '{{DASHBOARD_HOST}}/api/rest/account',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic YOUR_AUTH_TOKEN'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "{{DASHBOARD_HOST}}/api/rest/account"

payload = {}
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic YOUR_AUTH_TOKEN'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "net/http"

url = URI("{{DASHBOARD_HOST}}/api/rest/account")

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

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic YOUR_AUTH_TOKEN"

response = https.request(request)
puts response.read_body
using System;
using RestSharp;
namespace HelloWorldApplication {
  class HelloWorld {
    static void Main(string[] args) {
      var client = new RestClient("{{DASHBOARD_HOST}}/api/rest/account");
      client.Timeout = -1;
      var request = new RestRequest(Method.GET);
      request.AddHeader("Authorization", "Basic YOUR_AUTH_TOKEN");
      request.AddHeader("Content-Type", "application/json");
      IRestResponse response = client.Execute(request);
      Console.WriteLine(response.Content);
    }
  }
}

Cobertura

Erros

Error Code HTTP Code Description
0 202 Accepted for delivery
101 500 Internal Database error
102 400 No valid recipients
103 401 Username or password unknown
104 400 Text message missing
105 400 Text message too long
106 400 Sender missing
107 400 Sender too long
108 400 No valid Datetime for send
109 400 Notification URL incorrect
110 400 Exceeded maximum parts allowed or incorrect number of parts
111 402 Not enough credits
112 401 IP address not allowed
113 400 Invalid coding
114 400 Invalid subject
115 400 Sender is not verified
116 400 Invalid replyTo
117 400 ReplyTo is not verified
118 401 Email blocked for exceeding the hard-bounced limit allowed
119 400 Invalid expiration date
120 400 Invalid GUID
121 400 Invalid scheduled date
122 500 Update error
123 500 Delete error
125 400 Invalid JSON
126 400 Empty campaign name
130 400 Invalid voice language
131 400 Invalid voice gender
132 400 Invalid voice caller
133 400 Invalid audio URL
134 400 Unsupported audio format
140 400 Template missing
141 400 Missing landing placeholder
142 400 Can't split variable placeholders
150 400 Missing billing profile
151 400 Error retrieving TPV url
152 400 Invalid VAT
153 400 Invalid method
154 400 Invalid conversion rate
155 400 Max limit reached
156 400 Min limit reached
157 400 Error generating invoice
160 400 Invalid voice interactive language
161 400 Invalid voice interactive gender
162 400 Invalid voice interactive caller
163 400 Invalid voice interactive audio URL
164 400 Unsupported voice interactive audio format
165 400 Invalid voice interactive speech type
166 400 Ivalid voice interactive menu option type
167 400 Trying to save an existing campaign
168 400 Empty speech type
169 400 Empty menu
170 400 Empty phone key
171 400 Phone Key is not a number
172 400 Phone key out of range
173 400 Empty menu options for sub menu
174 400 Empty phone prefix for call transfer
175 400 Empty phone for call transfer
176 400 Call retries value is not an integer
177 400 Call retries value out of range
178 400 Cost limit value is not an integer
179 400 Speech retries value is not an integer
180 400 Speech retries value out of range
181 400 Speech timeout seconds value is not an integer
182 400 Speech timeout seconds value out of range
183 400 Available times value is not an array
184 400 Available times day is not an integer
185 400 Available times day out of range
186 400 Available times from hour format error
187 400 Available times to hour format error
188 400 Available times from hour is greater than to hour
189 400 Missing available time object property
190 400 Call Retries is specified but its value is empty
191 400 Cost limit is specified but its value is empty
192 400 Speech Retries is specified but its value is empty
193 400 Speech timeout seconds is specified but its value is empty
194 400 Available times is specified but its value is empty
195 400 No valid contacts external IDs
196 400 Available times range is too short
422 422 Input validation error

Anexos

Conjunto de caracteres GSM

Conjunto de caracteres básico GSM

0x00 0x10 0x20 0x30 0x40 0x50 0x60 0x70
0x00 @ Δ SP 0 ¡ P ¿ p
0x01 £ _ ! 1 A Q a q
0x02 $ Φ " 2 B R b r
0x03 ¥ Γ # 3 C S c s
0x04 è Λ ¤ 4 D T d t
0x05 é Ω % 5 E U e u
0x06 ù Π & 6 F V f v
0x07 ì Ψ ' 7 G W g w
0x08 ò Σ ( 8 H X h x
0x09 Ç Θ ) 9 I Y i y
0x0A LF Ξ * : J Z j z
0x0B Ø ESC + ; K Ä k ä
0x0C ø Æ , < L Ö l ö
0x0D CR æ - = M Ñ m ñ
0x0E Å ß . > N Ü n ü
0x0F å É / ? O § o à

* Caracteres especiais

Conjunto de caracteres estendidos GSM

0x00 0x10 0x20 0x30 0x40 0x50 0x60 0x70
0x00 |
0x01
0x02
0x03
0x04 ^
0x05
0x06
0x07
0x08 {
0x09 }
0x0A FF
0x0B SS2
0x0C [
0x0D CR2 ~
0x0E ]
0x0F \

* Caracteres especiais

Conjunto de caracteres GSM-PT

Conjunto de caracteres básico GSM-PT

0x00 0x10 0x20 0x30 0x40 0x50 0x60 0x70
0x00 @ Δ SP 0 Í P ~ p
0x01 £ _ ! 1 A Q a q
0x02 $ ª " 2 B R b r
0x03 ¥ Ç # 3 C S c s
0x04 ê À º 4 D T d t
0x05 é % 5 E U e u
0x06 ú ^ & 6 F V f v
0x07 í \ ' 7 G W g w
0x08 ó ( 8 H X h x
0x09 ç Ó ) 9 I Y i y
0x0A LF | * : J Z j z
0x0B Ô ESC + ; K Ã k ã
0x0C ô Â , < L Õ l õ
0x0D CR â - = M Ú m `
0x0E Á Ê . > N Ü n ü
0x0F á É / ? O § o à

* Caracteres especiais ** Caracteres diferentes de GSM

Conjunto de caracteres estendidos GSM-PT

0x00 0x10 0x20 0x30 0x40 0x50 0x60 0x70
0x00 |
0x01 À Â
0x02 Φ
0x03 Γ
0x04 ^
0x05 ê Ω Ú ú
0x06 Π
0x07 Ψ
0x08 Σ {
0x09 ç Θ } Í í
0x0A FF
0x0B Ô SS2 Ã ã
0x0C ô [ Õ õ
0x0D CR2 ~
0x0E Á ]
0x0F á Ê \ Ó ó â

* Caracteres especiais ** Caracteres diferentes de GSM

Restrições de Envio por País


Muitos países possuem regulamentos destinados a proteger os utilizadores de comunicações indesejadas, tanto por SMS como por chamadas de voz. Para garantir que as suas campanhas chegam ao destino corretamente e evitar bloqueios ou penalizações, é essencial cumprir estas regras.

Cada país define as suas próprias condições e restrições em relação às comunicações comerciais, pelo que é importante compreender e respeitar as especificidades de cada um. É importante relembrar que estas condições e restrições estão sujeitas à legislação em vigor de cada país e podem sofrer alterações. A {{NAME}} não se responsabiliza pelo incumprimento destas políticas; a responsabilidade é do cliente.

Abaixo encontrará as restrições para os principais países para que possa operar de forma segura e eficaz. Caso tenha alguma dúvida ou se o país destinatário não estiver listado abaixo, recomendamos que contacte a nossa equipa de atendimento ao cliente.

Considerações Preliminares

🇫🇷 França

As mensagens SMS comerciais ou promocionais enviadas para França devem obedecer a determinadas regulamentações legais, descritas abaixo. As mensagens transacionais, no entanto, não estão sujeitas a estas restrições.

Conteúdo Proibido

O envio de mensagens relacionadas com política, religião, jogo ou promoções não solicitadas é estritamente proibido.

Restrições de Horário

As mensagens SMS de marketing só podem ser enviadas de segunda-feira a sábado, entre as 8h e as 22h. Quaisquer mensagens enviadas fora deste horário serão automaticamente bloqueadas e agendadas para reenvio no próximo horário permitido. Ou seja, se tentar enviar uma SMS no domingo às 14h00, esta só será enviada na segunda-feira às 8h00.

Condições do Remetente

Contacte {{SUPPORT_EMAIL}} para obter mais informações e validar o seu remetente.

Cancelar subscrição do destinatário

É obrigatório adicionar STOP au [STOP_CODE] como instrução de cancelamento no final das suas mensagens SMS de marketing para França.

🇪🇸 Espanha

As mensagens SMS enviadas para Espanha têm determinadas condições legais. Qualquer SMS identificado como conteúdo de marketing estará sujeito às condições listadas nas secções abaixo.

Conteúdo Proibido

O envio de mensagens relacionadas com temas políticos ou religiosos, jogos de azar ou promoções não solicitadas é estritamente proibido.

🇬🇧 Reino Unido

As mensagens SMS enviadas para o Reino Unido estão limitadas a determinadas condições regulamentares. Qualquer mensagem SMS identificada como conteúdo de marketing estará sujeita às condições listadas abaixo.

Conteúdo Proibido

O envio de mensagens relacionadas com temas políticos ou religiosos ou promoções não solicitadas é estritamente proibido.

Se enviar conteúdo para adultos ou para jogos de azar, certifique-se de que a idade do destinatário foi verificada em conformidade com as Diretrizes da PSA e da Ofcom.

🇺🇸 Estados Unidos

As mensagens SMS comerciais ou promocionais enviadas para os Estados Unidos devem obedecer a determinadas regulamentações legais, descritas abaixo. As mensagens transacionais, no entanto, não estão sujeitas a estas restrições.

Conteúdo Restrito

O uso de encurtadores de URL públicos, como bit.ly ou tinyurl, não é permitido. No entanto, é permitido o uso de domínios personalizados nestes serviços. Portanto, pode utilizar o encurtador de URL próprio da {{NAME}}.

Além disso, é estritamente proibido o envio de mensagens com conteúdo sexualmente explícito ou pornográfico, material abusivo ou de assédio, informações relacionadas com armas de fogo, incluindo fogos de artifício, ou referências a álcool, tabaco ou drogas ilícitas. É também proibido o envio de mensagens sobre jogo, oportunidades de investimento, envio ou receção repetida de códigos de acesso único (OTPs) em nome de outros fornecedores, atividades consideradas de elevado risco financeiro, empréstimos ou perdão de empréstimos, serviços de recuperação de crédito, cobrança de dívidas ou questões fiscais. Da mesma forma, o conteúdo ligado a criptomoedas, incluindo aqueles relacionados com OTPs, consultas imobiliárias não solicitadas, como WeBuyHomes, ou promoções associadas a marketing multinível, não é permitido.

Condições do Remetente

Contacte {{SUPPORT_EMAIL}} para obter mais informações e validar o seu remetente.

🇨🇴 Colômbia

Restrições de Horário

As mensagens SMS de marketing só podem ser enviadas de segunda a sexta-feira, das 7h às 19h, e aos sábados, das 8h às 15h. O envio de mensagens promocionais não é permitido aos domingos e feriados. Quaisquer mensagens enviadas fora deste horário serão automaticamente bloqueadas e agendadas para reencaminhamento no próximo horário permitido. Isto significa que, se tentar enviar uma mensagem SMS no domingo às 14h00, esta só será enviada às 8h00 de segunda-feira.

Conteúdo Restrito

O conteúdo promocional em SMS pode, em alguns casos, exigir um registo prévio antes do envio. Além disso, a plataforma {{NAME}} pode adicionar automaticamente o nome do remetente ao início da mensagem ou incluir um URL no final, dependendo das condições do canal ou do país de destino.

Conteúdo Proibido

O envio de mensagens relacionadas com temas políticos ou religiosos, jogo ou promoções não solicitadas é estritamente proibido.

🇮🇪 Irlanda

Antes de enviar qualquer tráfego de marketing, é necessário o consentimento expresso (opt-in) dos utilizadores de dispositivos móveis.

Conteúdo Restrito

O envio de mensagens relacionadas com política, religião, jogo ou promoções não solicitadas é estritamente proibido.

Termos do Remetente

Contacte {{SUPPORT_EMAIL}} para obter mais informações e validar o seu remetente.