Esta documentação detalha os endpoints disponíveis na API da Xmailer, permitindo que você integre facilmente os serviços de envio de e-mails em suas aplicações. Aqui, você encontrará informações sobre os parâmetros necessários, formatos de requisição e códigos de resposta, além de exemplos práticos para diversas linguagens, como PHP, Java e Ruby.
A partir dessa URL base, você pode acessar diferentes funcionalidades adicionando caminhos específicos, como /check para verificar o status de seu domínio ou /consolidate para obter relatório de dados consolidado.
Atenção
Atualmente, não oferecemos um ambiente de sandbox. No entanto, você pode testar a integração diretamente em nosso ambiente de produção com segurança. Recomendamos que faça testes iniciais com um número reduzido de envios para garantir que tudo esteja funcionando perfeitamente.
Códigos HTTP das respostas
Nossa API utiliza códigos de status HTTP padrão para indicar o resultado das requisições. Respostas com status 200 indicam que a requisição foi processada corretamente, mas com diferentes códigos internos para indicar o sucesso ou falha de cada operação. Os códigos 200 podem representar tanto o sucesso quanto falhas, dependendo do código específico retornado. Não há erros 400 ou 500 na nossa API, todos os erros são tratados com diferentes status dentro do código 200.
Código
Descrição
Solução
200
MSG ENVIADA - A mensagem foi enviada com sucesso.
HTTP 200 – OK
Nenhuma ação necessária.
204
ERRO DE ENVIO - Falha na conexão SMTP.
HTTP 502 – Bad Gateway
Verifique as configurações do SMTP e tente novamente.
208
FALTAM PARÂMETROS - Um ou mais parâmetros obrigatórios estão ausentes.
HTTP 400 – Bad Request
Verifique se todos os parâmetros obrigatórios foram enviados corretamente.
207
ERRO: FALHA DE AUTENTICAÇÃO - Credenciais inválidas.
HTTP 401 – Unauthorized
Verifique usuário e senha SMTP informados.
211
ERRO: ENCODING INVÁLIDO - O parâmetro mensagemEncoding foi informado incorretamente.
HTTP 422 – Unprocessable Entity
Utilize base64 ou quoted-printable.
212
ERRO: TIPO INVÁLIDO - O parâmetro mensagemTipo foi informado incorretamente.
HTTP 422 – Unprocessable Entity
Utilize html ou text.
215
ERRO: TAMANHO EXCEDIDO - O e-mail ou anexo ultrapassou o limite permitido.
HTTP 413 – Payload Too Large
Reduza o tamanho do e-mail ou dos anexos.
221
ERRO: LIMITE DE CONTATOS EXCEDIDO - O número de destinatários ultrapassou o máximo permitido.
HTTP 413 – Payload Too Large
Reduza a quantidade de destinatários para até 100.
222
ERRO: LIMITE DE CONTATOS EXCEDIDO - O número de contatos no campo emailDestinoCopia ultrapassou o permitido.
HTTP 413 – Payload Too Large
Reduza o número de destinatários no campo CC.
223
ERRO: LIMITE DE CONTATOS EXCEDIDO - O número de contatos no campo emailDestinoCopiaOculta ultrapassou o permitido.
HTTP 413 – Payload Too Large
Reduza o número de destinatários no campo BCC.
227
ERRO: FORMATO INCORRETO - O campo emailDestino não está no formato correto.
HTTP 400 – Bad Request
Certifique-se de que ele seja um array.
228
ERRO: FORMATO INCORRETO - O campo emailDestinoCopia não está no formato correto.
HTTP 400 – Bad Request
Certifique-se de que ele seja um array.
229
ERRO: FORMATO INCORRETO - O campo emailDestinoCopiaOculta não está no formato correto.
HTTP 400 – Bad Request
Certifique-se de que ele seja um array.
Exemplo de resposta para HTTP 502:
HTTP/1.1 502 Bad Gateway
Content-Type: application/json
Nossa API permite até 10 chamadas simultâneas por segundo. É importante respeitar esse limite para garantir o desempenho ideal e evitar qualquer impacto no funcionamento da API.
Em alguns endpoints, podemos impor limites adicionais para proteger a qualidade do serviço e evitar sobrecarga nos nossos sistemas. Caso o número de requisições ultrapasse o limite permitido, as chamadas podem ser temporariamente restringidas.
Recomendamos que você controle o ritmo de envio das requisições para garantir que tudo funcione corretamente e de forma eficiente.
Importante
Também é possível usar o protocolo HTTP caso prefira. No entanto, é importante garantir que as chamadas da API sejam feitas utilizando o método POST, pois é o método correto para enviar dados e interagir com nossos endpoints.
Autenticação
Para realizar determinadas requisições à nossa API, é necessário fornecer as credenciais de autenticação no corpo da requisição, utilizando os parâmetros usuario_smtp e senha_smtp. Essas credenciais correspondem ao usuário e senha fornecidos durante a abertura de sua conta e são as mesmas utilizadas para autenticação SMTP.
Senha associada ao usuario_smtp, usada para autenticação no servidor SMTP da Xmailer.
É importante garantir que esses dados estejam corretos em todas as requisições, já que qualquer falha de autenticação impedirá o envio de e-mails. Para mais informações sobre a configuração e utilização da API, consulte a documentação completa.
Além disso, algumas requisições exigem o uso de um token de autenticação. Esse token deve ser incluído no cabeçalho da requisição no seguinte formato:
<?php
// Defina o endpoint para checar o status do domínio
$url = "https://api.xmailer.com.br/domain/check/";
// Seu token de autenticação (substitua pelo real)
$token = "SEU_TOKEN_AQUI";
// Domínio a ser consultado
$data = [
"dominio" => "seudominio.com.br"
];
// Inicializa o cURL
$ch = curl_init($url);
// Configuração dos headers com autenticação Bearer
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer $token",
"Content-Type: application/json"
]);
// Configuração da requisição
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
// Executa a requisição
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
// Exibe a resposta
echo "HTTP Code: " . $httpCode . "\n";
echo "Resposta:\n";
echo $response;
?>
Certifique-se de enviar esses dados via método POST, codificados em JSON, e incluir o cabeçalho Content-Type: application/json. Sem credenciais válidas ou um token apropriado, as requisições para os endpoints protegidos serão recusadas.
Envio de emails
Este recurso permite que você integre facilmente seu sistema ao nosso SMTP dedicado, garantindo envios de e-mails rápidos e confiáveis. A seguir, você encontrará tudo o que precisa saber para começar.
Formato: Envie os dados via POST, codificados em JSON.
Header: Inclua Content-Type: application/json em todas as requisições.
Limite de Tamanho: O total da mensagem (incluindo anexos e cabeçalhos) não deve exceder 50 MB.
Exemplo de Chamada e Resposta
Exemplo de Requisição
{
"host_smtp": "smtpxxxxxxxx.xmailer.com.br",
"usuario_smtp": "apitestexxxxxx@xmailer.com.br",
"senha_smtp": "xxxxxxxxxxxxxxxx",
"emailRemetente": "teste@xmailer.com.br",
"nomeRemetente": "xmailer",
"emailDestino": ["teste@xmailer.com.br", "postmaster@xmailer.com.br"],
"assunto": "Teste da API JSON em Produção",
"mensagemAnexos": {
"file1": {
"name": "pixel.jpg",
"type": "image/jpeg",
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/..."
}
},
"mensagem": "Mensagem de teste da API - Testando envio em HTML",
"mensagemTipo": "html",
"mensagemEncoding": "base64",
"mensagemAlt": "Mensagem de teste da API JSON"
}
Relatórios: Mensagens enviadas com sucesso são registradas automaticamente no painel de relatórios, com atualização a cada 10 minutos.
Suporte: Em caso de erros persistentes, como falhas de conexão SMTP (código 204), entre em contato com nossa equipe de suporte.
Pronto para começar? Integre agora e aproveite a potência do nosso SMTP dedicado!
Exemplos de código
Código copiado para a área de transferência
// Inicializa a sessão cURL
$curl = curl_init();
// Define as opções cURL usando um array associativo
curl_setopt_array($curl, array(
// URL da API Xmailer para envio de email
CURLOPT_URL =>'https://api.xmailer.com.br/send/',
// Faz com que o cURL retorne a resposta como string
CURLOPT_RETURNTRANSFER =>true,
// Define a codificação de resposta para ser aceita
CURLOPT_ENCODING =>'',
// Define o número máximo de redirecionamentos
CURLOPT_MAXREDIRS =>10,
// Define o tempo máximo de espera da requisição
CURLOPT_TIMEOUT =>0,
// Permite o cURL seguir redirecionamentos automaticamente
CURLOPT_FOLLOWLOCATION =>true,
// Define a versão do protocolo HTTP a ser usado
CURLOPT_HTTP_VERSION =>CURL_HTTP_VERSION_1_1,
// Define o método da requisição como POST
CURLOPT_CUSTOMREQUEST =>'POST',
// Define os dados do corpo da requisição em formato JSON
CURLOPT_POSTFIELDS =>'{
"host_smtp": "HOST-SMTP", // Substitua por seu host SMTP
"usuario_smtp": "USUARIO-SMTP", // Substitua pelo usuário SMTP
"senha_smtp": "SENHA-SMTP", // Substitua pela senha SMTP
"emailRemetente": "EMAIL-REMETENTE", // Email do remetente
"nomeRemetente": "NOME-REMETENTE", // Nome do remetente
"emailDestino": ["destinatario1@dominio.com.br","destinatario2@dominio.com.br"], // Emails dos destinatários
"assunto": "Teste de envio com anexo via API JSON", // Assunto do email
"mensagemAnexos": {
"file1": {
"name": "anexoexemplo.pdf", // Nome do arquivo
"type": "application/pdf", // Tipo MIME do arquivo
"content": "UEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AoytOgAAAAAAAP//Z" // Conteúdo do arquivo codificado em base64
}
},
"mensagem": "Mensagem de teste da API com anexo. Atenção, o arquivo codificado acima não funciona, é apenas um exemplo.", // Corpo da mensagem em HTML
"mensagemTipo": "html", // Tipo de mensagem (HTML)
"mensagemEncoding": "base64", // Codificação do arquivo anexo (base64)
"mensagemAlt": "Mensagem de teste da API com anexo. >Atenção, o arquivo codificado acima não funciona, é apenas um exemplo." // Texto alternativo para clientes de email sem suporte a HTML
}',
// Define o cabeçalho da requisição, informando que o corpo está em JSON
CURLOPT_HTTPHEADER => array(
'Content-Type: application/json'
),
));
// Executa a requisição cURL e armazena a resposta
$response = curl_exec($curl);
// Fecha a sessão cURL
curl_close($curl);
// Exibe a resposta recebida da API
echo $response;
import requests
from requests.structures import CaseInsensitiveDict
# URL do endpoint da API para envio de emails
url = "https://api.xmailer.com.br/send/"
# Criando um dicionário de cabeçalhos para a requisição HTTP
headers = CaseInsensitiveDict()
headers["Content-Type"] = "application/json" # Definindo o tipo de conteúdo como JSON
# Dados para a requisição POST - Incluindo detalhes do SMTP, remetente, destinatário, anexos e mensagem
data = """
{
"host_smtp": "HOST-SMTP", # Endereço do servidor SMTP
"usuario_smtp": "USUARIO-SMTP", # Usuário de autenticação SMTP
"senha_smtp": "SENHA-SMTP", # Senha de autenticação SMTP
"emailRemetente": "EMAIL-REMETENTE", # Email do remetente
"nomeRemetente": "NOME-REMETENTE", # Nome do remetente
"emailDestino": ["dev@xmailer.com.br", "postmaster@xmailer.com.br"], # Lista de emails destinatários
"assunto": "Teste da API JSON com anexo", # Assunto do email
"mensagemAnexos": {
"file1": {
"name": "pixel.jpg", # Nome do primeiro anexo
"type": "image/jpeg", # Tipo do arquivo (MIME type)
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQY..." # Conteúdo do arquivo codificado em base64
},
"file2": {
"name": "pixel2.jpg", # Nome do segundo anexo
"type": "image/jpeg", # Tipo do arquivo (MIME type)
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQY..." # Conteúdo do arquivo codificado em base64
}
},
"mensagem": "Mensagem de teste da API com anexos. Testando anexos de html no envio da api", # Corpo da mensagem em HTML
"mensagemTipo": "html", # Tipo da mensagem (HTML)
"mensagemEncoding": "quoted-printable", # Encoding da mensagem
"mensagemAlt": "mensagem de teste da API JSON com anexos" # Versão alternativa da mensagem
}
"""
# Fazendo a requisição POST para o endpoint com os cabeçalhos e os dados JSON
resp = requests.post(url, headers=headers, data=data)
# Verificando o status da resposta e exibindo o código de status HTTP
print(resp.status_code)
# Se a resposta for bem-sucedida (status code 200), pode-se processar o conteúdo da resposta
if resp.status_code == 200:
print("Requisição bem-sucedida!")
print(resp.json()) # Exibe a resposta JSON da API
else:
print(f"Erro na requisição: {resp.text}") # Exibe o erro caso a requisição falhe
# Enviar um e-mail com anexos usando a API Xmailer com cURL
curl --location 'https://api.xmailer.com.br/send/' \ # Endpoint da API para envio de e-mails
--header 'Content-Type: application/json' \ # Define o cabeçalho para indicar que o corpo da requisição é em JSON
--data-raw '{
"host_smtp": "HOST-SMTP", # Substitua pelo host SMTP do serviço de e-mail
"usuario_smtp": "USUARIO-SMTP", # Substitua pelo seu usuário SMTP para autenticação
"senha_smtp": "SENHA-SMTP", # Substitua pela senha SMTP para autenticação
"emailRemetente": "EMAIL-REMETENTE", # Substitua pelo e-mail do remetente
"nomeRemetente": "NOME-REMETENTE", # Substitua pelo nome do remetente
"emailDestino": ["dev@xmailer.com.br", "postmaster@xmailer.com.br"], # Lista de destinatários
"assunto": "Teste da API JSON com anexo", # Assunto do e-mail
"mensagemAnexos": { # Início da definição dos anexos
"file1": {
"name": "pixel.jpg", # Nome do arquivo no e-mail
"type": "image/jpeg", # Tipo MIME do arquivo (neste caso, imagem JPEG)
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAAUABQDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAb/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAf/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCNVJaAAAAAAAAH/9k="
},
"file2": {
"name": "pixel2.jpg", # Nome do segundo arquivo no e-mail
"type": "image/jpeg", # Tipo MIME do segundo arquivo (imagem JPEG)
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAAUABQDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAP/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AoytOgAAAAAAAP//Z"
}
},
"mensagem": "Mensagem de teste da API com anexos. Testando anexos de html no envio da api", # Corpo da mensagem em HTML
"mensagemTipo": "html", # Define que o tipo da mensagem é HTML
"mensagemEncoding": "quoted-printable", # Codificação da mensagem para garantir a integridade dos caracteres especiais
"mensagemAlt": "mensagem de teste da API JSON com anexos" # Texto alternativo caso o HTML não seja renderizado corretamente
}'
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
// URL do endpoint da API
private static readonly string apiUrl = "https://api.xmailer.com.br/send/";
// Método principal assíncrono
static async Task Main(string[] args)
{
// Cria a instância do HttpClient
using (var client = new HttpClient())
{
// Cria a requisição HTTP com o método POST para a URL do endpoint
var request = new HttpRequestMessage(HttpMethod.Post, apiUrl);
// Dados do corpo da requisição, incluindo as informações do e-mail e anexos
var jsonContent = "{\r\n" +
" \"host_smtp\": \"HOST-SMTP\",\r\n" +
" \"usuario_smtp\": \"USUARIO-SMTP\",\r\n" +
" \"senha_smtp\": \"SENHA-SMTP\",\r\n" +
" \"emailRemetente\": \"EMAIL-REMETENTE\",\r\n" +
" \"nomeRemetente\": \"NOME-REMETENTE\",\r\n" +
" \"emailDestino\": [\"dev@xmailer.com.br\",\"postmaster@xmailer.com.br\"],\r\n" +
" \"assunto\": \"Teste da API JSON com anexo\",\r\n" +
" \"mensagemAnexos\": {\r\n" +
" \"file1\": {\r\n" +
" \"name\": \"pixel.jpg\",\r\n" +
" \"type\": \"image/jpeg\",\r\n" +
" \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAAUABQDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAb/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAf/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCNVJaAAAAAAAAH/9k=\"\r\n" +
" },\r\n" +
" \"file2\": {\r\n" +
" \"name\": \"pixel2.jpg\",\r\n" +
" \"type\": \"image/jpeg\",\r\n" +
" \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAAUABQDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAP/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AoytOgAAAAAAAP//Z\"\r\n" +
" },\r\n" +
" \"mensagem\": \" Mensagem de teste da API com anexos. Testando anexos de html no envio da api\",\r\n" +
" \"mensagemTipo\": \"html\",\r\n" +
" \"mensagemEncoding\": \"quoted-printable\",\r\n" +
" \"mensagemAlt\": \"mensagem de teste da API JSON com anexos\"\r\n" +
" }";
// Define o conteúdo da requisição como JSON
var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
// Adiciona o conteúdo ao corpo da requisição
request.Content = content;
try
{
// Envia a requisição HTTP de forma assíncrona
var response = await client.SendAsync(request);
// Garante que a resposta tenha sido bem-sucedida (código de status 2xx)
response.EnsureSuccessStatusCode();
// Exibe o conteúdo da resposta da API
Console.WriteLine("Resposta da API:");
string responseContent = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseContent);
}
catch (HttpRequestException ex)
{
// Trata erros de requisição HTTP (como problemas de conexão ou falhas no servidor)
Console.WriteLine($"Erro ao fazer a requisição: {ex.Message}");
}
catch (Exception ex)
{
// Trata outros tipos de exceção
Console.WriteLine($"Erro inesperado: {ex.Message}");
}
}
}
}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class XmailerSendEmail
public static void main(String[] args) {
// Definindo a URL do endpoint da API
String apiUrl = "https://api.xmailer.com.br/send/";
// Dados do email a ser enviado em formato JSON
String data = "{\n" +
" \"host_smtp\": \"HOST-SMTP\",\n" +
" \"usuario_smtp\": \"USUARIO-SMTP\",\n" +
" \"senha_smtp\": \"SENHA-SMTP\",\n" +
" \"emailRemetente\": \"EMAIL-REMETENTE\",\n" +
" \"nomeRemetente\": \"NOME-REMETENTE\",\n" +
" \"emailDestino\": [\"dev@xmailer.com.br\", \"postmaster@xmailer.com.br\"],\n" +
" \"assunto\": \"Teste da API JSON com anexo\",\n" +
" \"mensagemAnexos\": {\n" +
Sucesso
" \"file1\": {\n" +
" \"name\": \"pixel.jpg\",\n" +
" \"type\": \"image/jpeg\",\n" +
" \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAAUABQDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAb/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAf/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCNVJaAAAAAAAAH/9k=\"\n" +
" },\n" +
" \"file2\": {\n" +
" \"name\": \"pixel2.jpg\",\n" +
" \"type\": \"image/jpeg\",\n" +
" \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAAUABQDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAP/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AoytOgAAAAAAAP//Z\"\n" +
" },\n" +
" \"mensagem\": \" Mensagem de teste da API com anexos. Testando anexos de html no envio da api\",\n" +
" \"mensagemTipo\": \"html\",\n" +
" \"mensagemEncoding\": \"quoted-printable\",\n" +
" \"mensagemAlt\": \"mensagem de teste da API JSON com anexos\"\n" +
"}";
try {
// Criando a URL e a conexão HTTP
URL url = new URL(apiUrl);
HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();
// Configurando a requisição HTTP
httpConnection.setRequestMethod("POST");
httpConnection.setDoOutput(true); // Para permitir enviar dados no corpo da requisição
httpConnection.setRequestProperty("Content-Type", "application/json");
// Convertendo os dados para bytes e enviando no corpo da requisição
byte[] out = data.getBytes(StandardCharsets.UTF_8);
try (OutputStream os = httpConnection.getOutputStream()) {
os.write(out); // Escreve os dados JSON no corpo da requisição
}
// Verificando o código de status da resposta
int statusCode = httpConnection.getResponseCode();
System.out.println("Código de Status: " + statusCode);
// Lendo a resposta da API
try (BufferedReader in = new BufferedReader(new InputStreamReader(httpConnection.getInputStream()))) {
String inputLine;
StringBuilder response = new StringBuilder();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
// Exibe a resposta da API
System.out.println("Resposta da API:\n" + response.toString());
} catch (IOException e) {
System.out.println("Erro ao ler a resposta da API: " + e.getMessage());
}
// Fechando a conexão HTTP
httpConnection.disconnect();
} catch (IOException e) {
// Exibindo erro caso a requisição falhe
System.out.println("Erro na requisição HTTP: " + e.getMessage());
}
}
}
// URL do endpoint da API para envio de e-mail
const url = 'https://api.xmailer.com.br/send/';
// Definição dos dados que serão enviados na requisição (e-mail, anexos, etc)
const data = JSON.stringify({
"host_smtp": "HOST-SMTP", // Host do servidor SMTP
"usuario_smtp": "USUARIO-SMTP", // Usuário SMTP
"senha_smtp": "SENHA-SMTP", // Senha SMTP
"emailRemetente": "EMAIL-REMETENTE", // E-mail do remetente
"nomeRemetente": "NOME-REMETENTE", // Nome do remetente
"emailDestino": ["dev@xmailer.com.br", "postmaster@xmailer.com.br"], // Destinatários do e-mail
"assunto": "Teste da API JSON com anexo", // Assunto do e-mail
"mensagemAnexos": {
"file1": {
"name": "pixel.jpg",
"type": "image/jpeg",
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD..." // Exemplo de conteúdo codificado em base64
},
"file2": {
"name": "pixel2.jpg",
"type": "image/jpeg",
"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD..." // Outro exemplo de conteúdo codificado em base64
}
},
"mensagem": "Mensagem de teste da API com anexos. Testando anexos de html no envio da api", // Corpo da mensagem em HTML
"mensagemTipo": "html", // Tipo de conteúdo da mensagem (html ou texto)
"mensagemEncoding": "quoted-printable", // Codificação da mensagem
"mensagemAlt": "mensagem de teste da API JSON com anexos" // Texto alternativo da mensagem
});
// Função assíncrona para enviar a requisição POST para a API
async function sendEmail() {
try {
// Envia a requisição usando o fetch API
const response = await fetch(url, {
method: 'POST', // Definindo o método HTTP como POST
headers: {
'Content-Type': 'application/json', // Definindo o tipo de conteúdo como JSON
},
body: data, // Envia os dados convertidos para JSON
});
// Verifica se a resposta foi bem-sucedida (código 2xx)
if (!response.ok) {
throw new Error(`Erro na requisição: ${response.status} - ${response.statusText}`);
}
// Lê a resposta da API como texto
const text = await response.text();
// Exibe a resposta no console (pode ser JSON ou erro da API)
console.log("Resposta da API:", text);
} catch (error) {
// Trata qualquer erro que ocorra durante a requisição
console.error("Erro ao enviar o e-mail:", error);
}
}
// Chama a função para enviar o e-mail
sendEmail();
# Importa a biblioteca HTTParty para fazer requisições HTTP
require 'httparty'
# Define a URL da API como uma constante para fácil manutenção
API_URL = 'https://api.xmailer.com.br/send/'
# Define os cabeçalhos da requisição (headers)
headers = {
'Content-Type' => 'application/json' # Indica que o corpo da requisição é JSON
}
# Cria o corpo da requisição como um hash Ruby
# Este hash será automaticamente convertido para JSON pela biblioteca HTTParty
body = {
# Configurações do servidor SMTP
'host_smtp' => 'HOST-SMTP', # Endereço do servidor SMTP
'usuario_smtp' => 'USUARIO-SMTP', # Usuário para autenticação SMTP
'senha_smtp' => 'SENHA-SMTP', # Senha para autenticação SMTP
# Informações do remetente
'emailRemetente' => 'EMAIL-REMETENTE', # Email do remetente
'nomeRemetente' => 'NOME-REMETENTE', # Nome do remetente
# Destinatários (array de emails)
'emailDestino' => [
'destinatario1@dominio.com.br',
'destinatario2@dominio.com.br'
],
# Assunto do email
'assunto' => 'Teste de envio com anexo via API JSON',
# Anexos da mensagem
# Aqui definimos um arquivo de exemplo em base64
'mensagemAnexos' => {
'file1' =>{
'name' =>'anexoexemplo.pdf', # Nome do arquivo
'type' =>'application/pdf', # Tipo MIME do arquivo
'content' =>'UEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AoytOgAAAAAAAP//Z' # Conteúdo em base64
}
},
# Conteúdo principal do email
'mensagem' => 'Mensagem de teste da API com anexo. Atenção, o arquivo codificado acima não funciona, é apenas um exemplo.',
# Tipo de formatação da mensagem
'mensagemTipo' => 'html', # Define que a mensagem é em formato HTML
# Codificação da mensagem
'mensagemEncoding' => 'base64', # Define a codificação como base64
# Versão alternativa da mensagem em texto puro
'mensagemAlt' => 'Mensagem de teste da API com anexo. >Atenção, o arquivo codificado acima não funciona, é apenas um exemplo.'
}
# Faz a requisição POST para a API
# O HTTParty converte automaticamente o hash para JSON
response = HTTParty.post(
API_URL,
headers: headers, # Passa os cabeçalhos definidos
body: body.to_json, # Converte o hash para JSON e envia no corpo
timeout: 0, # Sem timeout (equivalente ao CURLOPT_TIMEOUT => 0)
follow_redirects: true # Segue redirecionamentos automaticamente
)
# Exibe a resposta da API
puts response.body
// Importa a biblioteca axios para fazer requisições HTTP
const axios = require('axios');
// Define a URL da API
const apiUrl = 'https://api.xmailer.com.br/send/';
// Define os cabeçalhos da requisição
const headers = {
'Content-Type': 'application/json'
};
// Define o corpo da requisição como um objeto JavaScript
const data = {
// Configurações do servidor SMTP
host_smtp: 'HOST-SMTP', // Endereço do servidor SMTP
usuario_smtp: 'USUARIO-SMTP', // Usuário para autenticação SMTP
senha_smtp: 'SENHA-SMTP', // Senha para autenticação SMTP
// Informações do remetente
emailRemetente: 'EMAIL-REMETENTE', // Email do remetente
nomeRemetente: 'NOME-REMETENTE', // Nome do remetente
// Lista de destinatários
emailDestino: [
'destinatario1@dominio.com.br',
'destinatario2@dominio.com.br'
],
// Assunto do email
assunto: 'Teste de envio com anexo via API JSON',
// Anexos da mensagem (objeto com arquivo codificado em base64)
mensagemAnexos: {
file1: {
name: 'anexoexemplo.pdf', // Nome do arquivo
type: 'application/pdf', // Tipo MIME do arquivo
content: 'UEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AoytOgAAAAAAAP//Z' // Conteúdo em base64
}
},
// Conteúdo principal do email em HTML
mensagem: 'Mensagem de teste da API com anexo. Atenção, o arquivo codificado acima não funciona, é apenas um exemplo.',
// Tipo e codificação da mensagem
mensagemTipo: 'html', // Define o formato como HTML
mensagemEncoding: 'base64', // Define a codificação como base64
// Versão alternativa em texto puro
mensagemAlt: 'Mensagem de teste da API com anexo. > Atenção, o arquivo codificado acima não funciona, é apenas um exemplo.'
};
// Faz a requisição POST usando axios
axios.post(apiUrl, data, {
headers: headers, // Passa os cabeçalhos
maxRedirects: 10, // Equivalente a CURLOPT_MAXREDIRS
timeout: 0, // Sem timeout (equivalente a CURLOPT_TIMEOUT => 0)
httpAgent: new (require('http').Agent)({ keepAlive: true }), // Mantém a conexão viva
})
.then(response => {
// Exibe a resposta da API
console.log(response.data);
})
.catch(error => {
// Trata possíveis erros na requisição
console.error('Erro na requisição:', error.message);
});
Relatório de emails
É através desta API que você irá integrar seu sistema ao nosso para obter relatórios detalhados e consolidados dos envios realizados através de nosso SMTP dedicado. A seguir, você encontrará tudo o que precisa para começar.
Abaixo estão os parâmetros aceitos pela API de relatório:
Parâmetro
Descrição
Obrigatório
usuario_smtp
Usuário para autenticação (fornecido na abertura da conta, mesmo utilizado para autenticação SMTP)
Sim
senha_smtp
Senha para autenticação (mesma utilizada na autenticação SMTP)
Sim
dataini
Data de início da consulta (formato: YYYY-MM-DD)
Sim
horaini
Hora de início da consulta (formato: HH:MM)
Sim
datafim
Data de fim da consulta (formato: YYYY-MM-DD)
Sim
horafim
Hora de fim da consulta (formato: HH:MM)
Sim
status
Status dos envios a serem consultados (erro ou sucesso - ex.: se passar sucesso, retorna apenas e-mails entregues)
Não
emaildestino
E-mail para onde a mensagem foi enviada (filtro por destinatário específico)
Não
remetente
E-mail utilizado como remetente do envio (filtro por remetente específico)
Não
idMensagem
ID de uma mensagem enviada (filtro por mensagem específica)
Não
Requisitos Técnicos
Os dados devem ser enviados via POST, codificados em JSON. Não esqueça de incluir o cabeçalho Content-Type: application/json.
Os relatórios de envios são atualizados aproximadamente a cada 10 minutos. Caso realize um envio e não o veja imediatamente no painel, aguarde a próxima atualização.
<?php
// Defina a URL da API do Xmailer para obter relatórios
$url = "https://api.xmailer.com.br/report/";
// Inicializa a sessão cURL com a URL da API
$curl = curl_init($url);
// Define a URL para a requisição
curl_setopt($curl, CURLOPT_URL, $url);
// Define o método de requisição como POST
curl_setopt($curl, CURLOPT_POST, true);
// Faz com que o cURL retorne a resposta como uma string
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
// Define os cabeçalhos HTTP para a requisição
$headers = array(
"Authorization: Content-Type: application/json", // Cabeçalho de autorização (se necessário)
"Content-Type: application/json", // Especifica que o corpo da requisição está em JSON
);
// Define os cabeçalhos para a requisição cURL
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
// Dados que serão enviados no corpo da requisição, em formato JSON.
// O JSON contém informações sobre o usuário, a senha e o intervalo de tempo para o relatório.
$data = '{"usuario_smtp": "USUARIO-SMTP", "senha_smtp": "SENHA-SMTP", "dataini": "2022-09-27", "horaini": "00:01", "datafim": "2022-09-27", "horafim": "23:59"}';
// Define os dados do corpo da requisição POST
curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
// Configurações para debug (apenas para desenvolvimento)
// Desativa a verificação do host e do peer SSL (útil para evitar erros de certificado durante o desenvolvimento)
// **Nunca use isso em produção, pois pode causar falhas de segurança**.
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, false);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
// Executa a requisição cURL e armazena a resposta
$resp = curl_exec($curl);
// Fecha a sessão cURL
curl_close($curl);
// Exibe a resposta para depuração (ideal para testar o que a API retorna)
var_dump($resp);
?>
import requests
from requests.structures import CaseInsensitiveDict
# URL do endpoint da API Xmailer para consultar relatórios
url = "https://api.xmailer.com.br/report/"
# Criando um dicionário para os cabeçalhos HTTP da requisição
headers = CaseInsensitiveDict()
headers["Authorization"] = "Content-Type: application/json" # Cabeçalho de autorização, que deve ser ajustado conforme necessário
headers["Content-Type"] = "application/json" # Cabeçalho que define o tipo de conteúdo como JSON
# Dados para a requisição POST - Contém informações sobre o período de consulta do relatório
data = '{"usuario_smtp": "USUARIO-SMTP", "senha_smtp": "SENHA-SMTP", "dataini": "2022-09-27", "horaini": "00:01", "datafim": "2022-09-27", "horafim": "23:59"}'
# Fazendo a requisição POST para o endpoint com os cabeçalhos e os dados JSON
resp = requests.post(url, headers=headers, data=data)
# Verificando o código de status da resposta e exibindo o código de status HTTP
print(resp.status_code)
# Se a requisição for bem-sucedida (código 200), pode-se processar a resposta
if resp.status_code == 200:
print("Requisição bem-sucedida!") # Caso a resposta tenha sido bem-sucedida
print(resp.json()) # Exibe a resposta JSON da API, que pode conter o relatório solicitado
else:
# Caso ocorra um erro, exibe o erro com base no código de status
print(f"Erro na requisição: {resp.text}")
#!/bin/bash
# URL do endpoint da API de relatórios
API_URL="https://api.xmailer.com.br/report/"
# Definindo as credenciais e parâmetros para a consulta de relatórios
USUARIO_SMTP="USUARIO-SMTP" # Substitua pelo seu usuário SMTP
SENHA_SMTP="SENHA-SMTP" # Substitua pela sua senha SMTP
DATA_INICIO="2022-09-27" # Data de início para o relatório (formato: AAAA-MM-DD)
HORA_INICIO="00:01" # Hora de início para o relatório (formato: HH:MM)
DATA_FIM="2022-09-27" # Data de fim para o relatório (formato: AAAA-MM-DD)
HORA_FIM="23:59" # Hora de fim para o relatório (formato: HH:MM)
# Criando o corpo JSON dinamicamente
JSON_DATA=$(cat <<EOF
{
"usuario_smtp": "$USUARIO_SMTP",
"senha_smtp": "$SENHA_SMTP",
"dataini": "$DATA_INICIO",
"horaini": "$HORA_INICIO",
"datafim": "$DATA_FIM",
"horafim": "$HORA_FIM"
}
EOF
)
# Enviando a requisição POST para a API
curl -X POST "$API_URL" \
-H "Authorization: Content-Type: application/json" \ # Cabeçalho de autorização e tipo de conteúdo
-H "Content-Type: application/json" \ # Define o tipo de conteúdo como JSON
-d "$JSON_DATA" # Envia o corpo da requisição em formato JSON
using System;
using System.IO;
using System.Net;
using System.Text;
class Program
{
static void Main()
{
// URL do endpoint da API
var url = "https://api.xmailer.com.br/report/";
try
{
// Criação da requisição HTTP POST
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
httpRequest.Method = "POST";
// Definindo os cabeçalhos da requisição
httpRequest.Headers["Authorization"] = "Bearer SEU_TOKEN_AQUI"; // Cabeçalho de Autorização (caso necessário)
httpRequest.ContentType = "application/json"; // Especificando que o conteúdo é JSON
// Dados da requisição (parâmetros de consulta para o relatório)
var data = "{\"usuario_smtp\": \"USUARIO-SMTP\", \"senha_smtp\": \"SENHA-SMTP\", " +
"\"dataini\": \"2022-09-27\", \"horaini\": \"00:01\", \"datafim\": \"2022-09-27\", \"horafim\": \"23:59\"}";
// Escrevendo os dados no corpo da requisição
using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream(), Encoding.UTF8))
{
streamWriter.Write(data); // Envia os dados JSON como corpo da requisição
}
// Obtenção da resposta HTTP
using (var httpResponse = (HttpWebResponse)httpRequest.GetResponse())
{
// Verificando se a resposta HTTP foi bem-sucedida
if (httpResponse.StatusCode == HttpStatusCode.OK)
{
// Lê o conteúdo da resposta
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
Console.WriteLine("Resposta da API:\n" + result); // Exibe a resposta da API
}
}
else
{
Console.WriteLine($"Erro na requisição. Código de status HTTP: {httpResponse.StatusCode}");
}
}
}
catch (WebException webEx)
{
// Captura falhas de requisição, como erros de rede ou de resposta HTTP
using (var streamReader = new StreamReader(webEx.Response.GetResponseStream()))
{
var errorResponse = streamReader.ReadToEnd();
Console.WriteLine($"Erro na requisição: {errorResponse}");
}
}
catch (Exception ex)
{
// Captura outros tipos de exceções, como problemas gerais
Console.WriteLine($"Erro inesperado: {ex.Message}");
}
}
}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class Xmailer Report {
public static void main(String[] args) {
// URL do endpoint da API para solicitar o relatório
String apiUrl = "https://api.xmailer.com.br/report/";
// Dados a serem enviados no corpo da requisição (em formato JSON)
String data = "{\n" +
" \"usuario_smtp\": \"USUARIO-SMTP\",\n" +
" \"senha_smtp\": \"SENHA-SMTP\",\n" +
" \"dataini\": \"2022-09-27\",\n" +
" \"horaini\": \"00:01\",\n" +
" \"datafim\": \"2022-09-27\",\n" +
" \"horafim\": \"23:59\"\n" +
"}";
try {
// Criando a URL do endpoint e abrindo a conexão HTTP
URL url = new URL(apiUrl);
HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();
// Configuração da requisição HTTP
httpConnection.setRequestMethod("POST");
httpConnection.setDoOutput(true); // Habilita o envio de dados no corpo da requisição
httpConnection.setRequestProperty("Authorization", "Bearer YOUR_AUTH_TOKEN"); // Cabeçalho de autenticação (substitua YOUR_AUTH_TOKEN)
httpConnection.setRequestProperty("Content-Type", "application/json");
// Convertendo os dados JSON para um array de bytes
byte[] out = data.getBytes(StandardCharsets.UTF_8);
// Enviando os dados no corpo da requisição
try (OutputStream os = httpConnection.getOutputStream()) {
os.write(out); // Escreve os dados JSON no corpo da requisição
}
// Verificando o código de status HTTP da resposta
int statusCode = httpConnection.getResponseCode();
System.out.println("Código de Status: " + statusCode);
// Lendo a resposta da API
StringBuilder response = new StringBuilder();
try (BufferedReader in = new BufferedReader(new InputStreamReader(httpConnection.getInputStream()))) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
} catch (IOException e) {
System.out.println("Erro ao ler a resposta da API: " + e.getMessage());
}
// Exibindo a resposta da API (caso o código de status seja 200)
if (statusCode == HttpURLConnection.HTTP_OK) {
System.out.println("Resposta da API:\n" + response.toString());
} else {
System.out.println("Erro: " + httpConnection.getResponseMessage());
}
// Fechando a conexão HTTP
httpConnection.disconnect();
} catch (IOException e) {
// Exibindo erro caso a requisição falhe
System.out.println("Erro na requisição HTTP: " + e.getMessage());
}
}
}
// URL do endpoint da API para gerar relatórios
var url = "https://api.xmailer.com.br/report/";
// Criação de um novo objeto XMLHttpRequest para realizar a requisição
var xhr = new XMLHttpRequest();
// Configuração do método da requisição (POST) e URL do endpoint
xhr.open("POST", url);
// Definindo os cabeçalhos da requisição
// "Content-Type" define o tipo de dados que estamos enviando (JSON)
xhr.setRequestHeader("Content-Type", "application/json");
// Se a API exigir autenticação, é necessário incluir o cabeçalho de "Authorization" com o token correto
// Exemplo: "Authorization", "Bearer SEU_TOKEN_AQUI" (substitua SEU_TOKEN_AQUI pelo seu token de autenticação)
xhr.setRequestHeader("Authorization", "Bearer SEU_TOKEN_AQUI"); // Substitua "SEU_TOKEN_AQUI" pelo seu token real
// Função que será chamada sempre que o estado da requisição mudar
xhr.onreadystatechange = function () {
// Verifica se a requisição foi concluída (readyState 4 significa "done")
if (xhr.readyState === 4) {
// Exibe o código de status HTTP da resposta
console.log("Código de status:", xhr.status);
// Exibe o conteúdo da resposta da API
console.log("Resposta:", xhr.responseText);
// Verifica se a requisição foi bem-sucedida (status HTTP 2xx)
if (xhr.status >= 200 && xhr.status < 300) {
console.log("Relatório gerado com sucesso!");
} else {
console.error("Erro ao gerar o relatório. Código de status:", xhr.status);
}
}
};
// Dados para a consulta de relatório
var data = JSON.stringify({
"usuario_smtp": "USUARIO-SMTP", // Substitua pelo seu usuário SMTP
"senha_smtp": "SENHA-SMTP", // Substitua pela sua senha SMTP
"dataini": "2022-09-27", // Data inicial para a consulta (formato YYYY-MM-DD)
"horaini": "00:01", // Hora inicial para a consulta (formato HH:MM)
"datafim": "2022-09-27", // Data final para a consulta (formato YYYY-MM-DD)
"horafim": "23:59" // Hora final para a consulta (formato HH:MM)
});
// Envia a requisição com os dados no formato JSON
xhr.send(data);
# Importa a biblioteca HTTParty para fazer requisições HTTP
require 'httparty'
# Define a URL da API como uma constante
API_URL = 'https://api.xmailer.com.br/report/'
# Define os cabeçalhos da requisição
headers = {
# No PHP, "Authorization: Content-Type: application/json" parece ser um erro
# Corrigimos aqui usando apenas o Content-Type correto
'Content-Type' => 'application/json'
}
# Cria o corpo da requisição como um hash Ruby
# Este hash será convertido automaticamente para JSON
body = {
'usuario_smtp' => 'USUARIO-SMTP', # Usuário para autenticação SMTP
'senha_smtp' => 'SENHA-SMTP', # Senha para autenticação SMTP
'dataini' => '2022-09-27', # Data inicial do relatório
'horaini' => '00:01', # Hora inicial do relatório
'datafim' => '2022-09-27', # Data final do relatório
'horafim' => '23:59' # Hora final do relatório
}
# Faz a requisição POST para a API
response = HTTParty.post(
API_URL,
headers: headers, # Passa os cabeçalhos definidos
body: body.to_json, # Converte o hash para JSON e envia no corpo
# Equivalente ao CURLOPT_SSL_VERIFYHOST e CURLOPT_SSL_VERIFYPEER como false
# Usado apenas para debug, não recomendado em produção
verify: false
)
# Exibe a resposta da API
# Similar ao var_dump do PHP, usamos inspect para uma saída detalhada
puts response.body.inspect
// Importa a biblioteca axios para fazer requisições HTTP
const axios = require('axios');
// Define a URL da API
const apiUrl = 'https://api.xmailer.com.br/report/';
// Define os cabeçalhos da requisição
const headers = {
// No PHP, "Authorization: Content-Type: application/json" parece ser um erro
// Corrigimos aqui usando apenas o Content-Type correto
'Content-Type': 'application/json'
};
// Define o corpo da requisição como um objeto JavaScript
const data = {
usuario_smtp: 'USUARIO-SMTP', // Usuário para autenticação SMTP
senha_smtp: 'SENHA-SMTP', // Senha para autenticação SMTP
dataini: '2022-09-27', // Data inicial do relatório
horaini: '00:01', // Hora inicial do relatório
datafim: '2022-09-27', // Data final do relatório
horafim: '23:59' // Hora final do relatório
};
// Faz a requisição POST usando axios
axios.post(apiUrl, data, {
headers: headers, // Passa os cabeçalhos
// Equivalente a CURLOPT_SSL_VERIFYHOST e CURLOPT_SSL_VERIFYPEER como false
// Usado apenas para debug, não recomendado em produção
httpsAgent: new (require('https').Agent)({
rejectUnauthorized: false
})
})
.then(response => {
// Exibe a resposta da API (equivalente ao var_dump do PHP)
console.log(response.data);
})
.catch(error => {
// Trata possíveis erros na requisição
console.error('Erro na requisição:', error.message);
});
Relatório de emails consolidado
É através desta API que você irá integrar seu sistema ao nosso para obter o relatório consolidado dos envios realizados através de nosso SMTP dedicado. A seguir, você encontrará tudo o que precisa para consultar os dados consolidados dos seus envios.
<?php
// Definição do endpoint da API
$url = "https://api.xmailer.com.br/consolidate/";
// Dados de autenticação e parâmetros de consulta
$data = [
"usuario_smtp" => "smtp1@seudominio.com.br", // Usuário SMTP para autenticação
"senha_smtp" => "xxxxxxxx", // Senha SMTP para autenticação
"dataini" => "2023-02-01", // Data de início da consulta (AAAA-MM-DD)
"horaini" => "00:01", // Hora de início da consulta (HH:MM)
"datafim" => "2023-08-30", // Data de fim da consulta (AAAA-MM-DD)
"horafim" => "23:59" // Hora de fim da consulta (HH:MM)
];
// Configuração da requisição cURL
$options = [
CURLOPT_URL => $url, // URL do endpoint
CURLOPT_RETURNTRANSFER => true, // Retorna a resposta como string
CURLOPT_POST => true, // Método POST
CURLOPT_HTTPHEADER => ["Content-Type: application/json"], // Define o cabeçalho da requisição
CURLOPT_POSTFIELDS => json_encode($data), // Converte os dados para JSON antes de enviar
CURLOPT_TIMEOUT => 30, // Tempo limite da requisição em segundos
CURLOPT_SSL_VERIFYPEER => false // Desativar verificação SSL caso necessário
];
// Inicializa o cURL e executa a requisição
$ch = curl_init();
curl_setopt_array($ch, $options);
$response = curl_exec($ch); // Executa a requisição e armazena a resposta
$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Obtém o código de status HTTP
// Verifica se houve erro na requisição
if (curl_errno($ch)) {
echo "Erro na requisição: " . curl_error($ch); // Exibe mensagem de erro se houver falha no cURL
} elseif ($statusCode !== 200) {
echo "Erro na requisição. Código de status HTTP: " . $statusCode; // Exibe erro baseado no código de status
} else {
// Exibe a resposta formatada em JSON
echo "Resposta da API:\n";
echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
}
// Fecha a conexão cURL
curl_close($ch);
?>
import requests
import json
# Definição do endpoint da API
url = "https://api.xmailer.com.br/consolidate/"
# Dados de autenticação e parâmetros de consulta
data = {
"usuario_smtp": "smtp1@seudominio.com.br", # Usuário SMTP para autenticação
"senha_smtp": "xxxxxxxx", # Senha SMTP para autenticação
"dataini": "2023-02-01", # Data de início da consulta (AAAA-MM-DD)
"horaini": "00:01", # Hora de início da consulta (HH:MM)
"datafim": "2023-08-30", # Data de fim da consulta (AAAA-MM-DD)
"horafim": "23:59" # Hora de fim da consulta (HH:MM)
}
# Cabeçalhos para a requisição (informando que estamos enviando dados em JSON)
headers = {
"Content-Type": "application/json"
}
# Fazendo a requisição POST para a API
try:
# Realiza a requisição POST, enviando os dados no formato JSON
response = requests.post(url, headers=headers, json=data, timeout=30)
# Verifica o código de status da resposta
if response.status_code != 200:
print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
else:
# Exibe a resposta formatada em JSON
print("Resposta da API:")
# Decodifica a resposta JSON e exibe de forma legível
decoded_response = response.json()
print(json.dumps(decoded_response, indent=4, ensure_ascii=False))
except requests.exceptions.RequestException as e:
# Captura qualquer erro relacionado à requisição (erros de rede, tempo limite, etc)
print(f"Erro na requisição: {e}")
# Definição da URL do endpoint da API
URL="https://api.xmailer.com.br/consolidate/"
# Dados de autenticação e parâmetros de consulta
USUARIO_SMTP="smtp1@seudominio.com.br"
SENHA_SMTP="xxxxxxxx"
DATANAI="2023-02-01"
HORANAI="00:01"
DATAFIM="2023-08-30"
HORAFIM="23:59"
# Montagem do JSON com os dados
DATA_JSON=$(cat <<EOF
{
"usuario_smtp": "$USUARIO_SMTP",
"senha_smtp": "$SENHA_SMTP",
"dataini": "$DATANAI",
"horaini": "$HORANAI",
"datafim": "$DATAFIM",
"horafim": "$HORAFIM"
}
EOF
)
# Requisição cURL
curl -X POST "$URL" \ # Método POST para enviar os dados
-H "Content-Type: application/json" \ # Define o cabeçalho Content-Type como JSON
-d "$DATA_JSON" \ # Envia os dados no corpo da requisição
--timeout 30 \ # Define o tempo máximo de espera para 30 segundos
--insecure \ # Desativa a verificação SSL (substituir por --ssl-verify para uma conexão segura)
-v # Ativa a opção verbose para exibir o processo de requisição detalhadamente (opcional)
# O `curl` exibirá a resposta diretamente no terminal.
# Se houver erro, ele também será exibido.
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
// Definição do endpoint da API
private static string url = "https://api.xmailer.com.br/consolidate/";
static async Task Main(string[] args)
{
// Dados de autenticação e parâmetros de consulta
var data = new
{
usuario_smtp = "smtp1@seudominio.com.br", // Usuário SMTP para autenticação
senha_smtp = "xxxxxxxx", // Senha SMTP para autenticação
dataini = "2023-02-01", // Data de início da consulta (AAAA-MM-DD)
horaini = "00:01", // Hora de início da consulta (HH:MM)
datafim = "2023-08-30", // Data de fim da consulta (AAAA-MM-DD)
horafim = "23:59" // Hora de fim da consulta (HH:MM)
};
// Inicializa o HttpClient
using (var client = new HttpClient())
{
// Configura o cabeçalho da requisição para JSON
client.DefaultRequestHeaders.Add("Content-Type", "application/json");
// Serializa os dados para JSON
var jsonData = JsonConvert.SerializeObject(data);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
try
{
// Envia a requisição POST
HttpResponseMessage response = await client.PostAsync(url, content);
// Obtém o código de status HTTP
int statusCode = (int)response.StatusCode;
Console.WriteLine($"Código de status: {statusCode}");
// Verifica se a requisição foi bem-sucedida (código 2xx)
if (response.IsSuccessStatusCode)
{
// Lê a resposta como string
string responseBody = await response.Content.ReadAsStringAsync();
// Tenta desserializar a resposta JSON
var decodedResponse = JsonConvert.DeserializeObject(responseBody);
// Exibe a resposta formatada em JSON
Console.WriteLine("Resposta da API:");
string formattedResponse = JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
Console.WriteLine(formattedResponse);
}
else
{
// Exibe erro caso o código de status seja maior ou igual a 400
Console.WriteLine($"Erro na requisição. Código de status HTTP: {statusCode}");
}
}
catch (Exception ex)
{
// Exibe qualquer erro durante a requisição
Console.WriteLine($"Erro ao processar a requisição: {ex.Message}");
}
}
}
}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class XmailerConsolidate {
public static void main(String[] args) {
// Definindo o endpoint da API
String url = "https://api.xmailer.com.br/consolidate/";
// Dados de autenticação e parâmetros de consulta
String usuarioSmtp = "smtp1@seudominio.com.br"; // Usuário SMTP para autenticação
String senhaSmtp = "xxxxxxxx"; // Senha SMTP para autenticação
String dataInicio = "2023-02-01"; // Data de início da consulta (AAAA-MM-DD)
String horaInicio = "00:01"; // Hora de início da consulta (HH:MM)
String dataFim = "2023-08-30"; // Data de fim da consulta (AAAA-MM-DD)
String horaFim = "23:59"; // Hora de fim da consulta (HH:MM)
// Criando o JSON de entrada
String jsonInputString = "{"
+ "\"usuario_smtp\": \"" + usuarioSmtp + "\","
+ "\"senha_smtp\": \"" + senhaSmtp + "\","
+ "\"dataini\": \"" + dataInicio + "\","
+ "\"horaini\": \"" + horaInicio + "\","
+ "\"datafim\": \"" + dataFim + "\","
+ "\"horafim\": \"" + horaFim + "\""
+ "}";
try {
// Criando a URL e a conexão HTTP
URL urlObj = new URL(url);
HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
connection.setRequestMethod("POST");
// Definindo os cabeçalhos da requisição
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true); // Permite que dados sejam enviados no corpo da requisição
// Enviando os dados JSON no corpo da requisição
try (OutputStream os = connection.getOutputStream()) {
byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
os.write(input, 0, input.length); // Escreve os dados no corpo da requisição
}
// Obtendo o código de status da resposta
int statusCode = connection.getResponseCode();
// Lendo a resposta da API
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
// Verificando o código de status e exibindo a resposta
if (statusCode == HttpURLConnection.HTTP_OK) {
// Se o código de status for 200 (OK), exibe a resposta formatada
System.out.println("Resposta da API: ");
System.out.println(response.toString());
} else {
// Se o código de status for diferente de 200, exibe o erro
System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
}
}
} catch (IOException e) {
// Caso ocorra um erro durante a requisição, exibe a mensagem de erro
System.out.println("Erro na requisição: " + e.getMessage());
}
}
}
// Importa o módulo https nativo do Node.js para realizar requisições HTTPS
const https = require('https');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/consolidate/";
// Dados de autenticação e parâmetros de consulta
const data = JSON.stringify({
"usuario_smtp": "smtp1@seudominio.com.br", // Usuário SMTP para autenticação
"senha_smtp": "xxxxxxxx", // Senha SMTP para autenticação
"dataini": "2023-02-01", // Data de início da consulta (AAAA-MM-DD)
"horaini": "00:01", // Hora de início da consulta (HH:MM)
"datafim": "2023-08-30", // Data de fim da consulta (AAAA-MM-DD)
"horafim": "23:59" // Hora de fim da consulta (HH:MM)
});
// Configuração da requisição HTTP
const options = {
hostname: 'api.xmailer.com.br', // Nome do servidor (domínio) para onde vamos enviar a requisição
path: '/consolidate/', // Caminho (endpoint) específico da API
method: 'POST', // Método HTTP a ser utilizado (POST)
headers: {
'Content-Type': 'application/json', // Tipo de conteúdo que estamos enviando, que é JSON
'Content-Length': data.length // Comprimento do conteúdo (tamanho dos dados em bytes)
}
};
// Realizando a requisição HTTP
const req = https.request(options, (res) => {
// Variável para armazenar os dados da resposta
let responseData = '';
// A cada pedaço de dados recebido, adicionamos ao responseData
res.on('data', (chunk) => {
responseData += chunk;
});
// Quando a resposta for completamente recebida
res.on('end', () => {
try {
// Tentamos converter a resposta da API para um objeto JSON
const parsedResponse = JSON.parse(responseData);
// Verifica se o código de status HTTP foi 200 (OK)
if (res.statusCode === 200) {
// Exibe a resposta formatada em JSON (bem indentado)
console.log("Resposta da API:");
console.log(JSON.stringify(parsedResponse, null, 2)); // JSON.stringify com indentação de 2 espaços
} else {
// Exibe mensagem de erro caso o código de status não seja 200
console.log(`Erro na requisição. Código de status HTTP: ${res.statusCode}`);
}
} catch (error) {
// Caso haja erro ao processar a resposta (por exemplo, se não for um JSON válido)
console.log("Erro ao processar a resposta JSON:", error.message);
}
});
});
// Em caso de erro na requisição (como problemas de rede ou no servidor)
req.on('error', (error) => {
console.error("Erro na requisição:", error.message);
});
// Envia os dados no corpo da requisição POST
req.write(data);
// Finaliza a requisição
req.end();
require 'net/http'
require 'json'
require 'uri'
# Definição do endpoint da API
url = URI("https://api.xmailer.com.br/consolidate/")
# Dados de autenticação e parâmetros de consulta
data = {
"usuario_smtp" => "smtp1@seudominio.com.br", # Usuário SMTP para autenticação
"senha_smtp" => "xxxxxxxx", # Senha SMTP para autenticação
"dataini" => "2023-02-01", # Data de início da consulta (AAAA-MM-DD)
"horaini" => "00:01", # Hora de início da consulta (HH:MM)
"datafim" => "2023-08-30", # Data de fim da consulta (AAAA-MM-DD)
"horafim" => "23:59" # Hora de fim da consulta (HH:MM)
}
# Configuração da requisição HTTP
http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json # Converte os dados para JSON antes de enviar
# Envia a requisição e obtém a resposta
response = http.request(request)
# Verifica o status da resposta
if response.code.to_i != 200
# Se o código de status não for 200, houve um erro
puts "Erro na requisição. Código de status HTTP: #{response.code}"
else
# Caso a resposta seja bem-sucedida, decodifica e exibe o JSON
begin
decoded_response = JSON.parse(response.body)
puts "Resposta da API:"
puts JSON.pretty_generate(decoded_response) # Exibe a resposta formatada
rescue JSON::ParserError
# Caso não consiga processar o JSON, exibe um erro
puts "Erro ao processar a resposta JSON."
end
end
const axios = require('axios');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/consolidate/";
// Dados de autenticação e parâmetros de consulta
const data = {
"usuario_smtp": "smtp1@seudominio.com.br", // Usuário SMTP para autenticação
"senha_smtp": "xxxxxxxx", // Senha SMTP para autenticação
"dataini": "2023-02-01", // Data de início da consulta (AAAA-MM-DD)
"horaini": "00:01", // Hora de início da consulta (HH:MM)
"datafim": "2023-08-30", // Data de fim da consulta (AAAA-MM-DD)
"horafim": "23:59" // Hora de fim da consulta (HH:MM)
};
// Configuração da requisição
const config = {
headers: {
'Content-Type': 'application/json' // Define o cabeçalho da requisição como JSON
}
};
// Envia a requisição POST
axios.post(url, data, config)
.then((response) => {
// Se a resposta for bem-sucedida, exibe a resposta formatada
console.log("Resposta da API:");
console.log(JSON.stringify(response.data, null, 2)); // Exibe a resposta formatada
})
.catch((error) => {
// Caso ocorra erro na requisição
if (error.response) {
// A requisição foi feita e o servidor respondeu com um status de erro
console.log("Erro na requisição. Código de status HTTP: " + error.response.status);
console.log("Resposta do servidor:", error.response.data);
} else if (error.request) {
// A requisição foi feita, mas não houve resposta
console.log("Erro na requisição. Sem resposta do servidor:", error.request);
} else {
// Erro ao configurar a requisição
console.log("Erro ao configurar a requisição:", error.message);
}
});
Adição de domínios
Integre seu sistema à nossa plataforma de maneira eficiente com esta API, projetada para facilitar a adição de novos domínios à sua conta Xmailer. Este recurso permite que você expanda os domínios remetentes associados ao seu plano, garantindo flexibilidade e controle total sobre seus envios de e-mail. Confira abaixo todos os detalhes necessários para começar.
Os parâmetros a seguir são essenciais para que a API processe corretamente a adição de um domínio. Certifique-se de fornecer informações precisas para evitar erros:
Parâmetro
Descrição
Obrigatório
token_auth:
Token de autenticação exclusivo, gerado no seu painel de cliente Xmailer, acessível no menu "API". Este token valida sua identidade e autoriza a operação.
Sim
dominio:
O domínio completo que você deseja adicionar (ex.: "seudominio.com.br"). Este será o domínio remetente utilizado em seus envios de e-mail. Deve incluir o TLD (ex.: .com, .net.br) e seguir padrões válidos de nomenclatura de domínio.
Sim
Requisitos Técnicos
Os dados devem ser enviados via POST, codificados em JSON. Não esqueça de incluir o cabeçalho Content-Type: application/json.
Exemplo de Chamada e Resposta
Substitua os valores pelos dados específicos da sua conta:
Ao enviar os parâmetros corretamente, você receberá uma confirmação como esta:
{
"0": {
"status": "DOMÍNIO ADICIONADO COM SUCESSO - AGUARDE DADOS DE VALIDAÇÃO",
"codigo": "200"
}
}
Próximos Passos
Após adicionar o domínio, você receberá um e-mail com instruções detalhadas para validar o cadastro. Siga os passos indicados para ativar seu domínio e começar a utilizá-lo.
Exemplos de código
Código copiado para a área de transferência
<?php
// Definição do endpoint da API
$url = "https://api.xmailer.com.br/domain/add/";
// Dados de autenticação e domínio a ser adicionado
$data = [
"token_auth" => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
"dominio" => "dominioaseradicionado.net.br" // Domínio a ser adicionado para envios
];
// Configuração da requisição cURL
$options = [
CURLOPT_URL => $url, // URL do endpoint da API
CURLOPT_RETURNTRANSFER => true, // Retorna a resposta como string
CURLOPT_POST => true, // Método POST
CURLOPT_HTTPHEADER => ["Content-Type: application/json"], // Define o cabeçalho da requisição
CURLOPT_POSTFIELDS => json_encode($data), // Converte os dados para JSON antes de enviar
CURLOPT_TIMEOUT => 30, // Tempo limite da requisição em segundos
CURLOPT_SSL_VERIFYPEER => true // Mantém a verificação SSL ativada para segurança
];
// Inicializa o cURL
$ch = curl_init();
curl_setopt_array($ch, $options);
$response = curl_exec($ch); // Executa a requisição e captura a resposta
$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Obtém o código de status HTTP
// Verifica se houve erro na requisição
if (curl_errno($ch)) {
echo "Erro na requisição: " . curl_error($ch);
} elseif ($statusCode >= 400) {
echo "Erro na requisição. Código de status HTTP: " . $statusCode;
} else {
// Decodifica e exibe a resposta formatada em JSON
$decodedResponse = json_decode($response, true);
if (json_last_error() === JSON_ERROR_NONE) {
echo "Resposta da API:\n";
echo json_encode($decodedResponse, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
} else {
echo "Erro ao processar a resposta JSON.";
}
}
// Fecha a conexão cURL
curl_close($ch);
?>
import requests
import json
# Definição do endpoint da API
url = "https://api.xmailer.com.br/domain/add/"
# Dados de autenticação e domínio a ser adicionado
data = {
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", # Token de autenticação obtido no painel do cliente
"dominio": "dominioaseradicionado.net.br" # Domínio a ser adicionado para envios
}
# Cabeçalhos para a requisição (informando que estamos enviando dados em JSON)
headers = {
"Content-Type": "application/json"
}
# Fazendo a requisição POST para a API
try:
response = requests.post(url, headers=headers, json=data, timeout=30)
# Verifica o código de status da resposta
if response.status_code >= 400:
print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
else:
# Decodifica e exibe a resposta formatada em JSON
try:
decoded_response = response.json() # Decodifica a resposta JSON
print("Resposta da API:")
print(json.dumps(decoded_response, indent=4, ensure_ascii=False)) # Exibe a resposta formatada
except json.JSONDecodeError:
print("Erro ao processar a resposta JSON.")
except requests.exceptions.RequestException as e:
# Captura qualquer erro relacionado à requisição
print(f"Erro na requisição: {e}")
# Definição da URL do endpoint da API
URL="https://api.xmailer.com.br/domain/add/"
# Token de autenticação e domínio a ser adicionado
TOKEN_AUTH="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # Substitua com seu token de autenticação
DOMINIO="dominioaseradicionado.net.br" # Substitua com o domínio a ser adicionado
# Dados a serem enviados no corpo da requisição em formato JSON
DATA="{\"token_auth\":\"$TOKEN_AUTH\", \"dominio\":\"$DOMINIO\"}"
# Requisição cURL
curl -X POST "$URL" \ # Método POST
-H "Content-Type: application/json" \ # Define o cabeçalho Content-Type
-d "$DATA" \ # Dados JSON enviados no corpo da requisição
--timeout 30 \ # Define o tempo limite da requisição (30 segundos)
--ssl-verify # Verifica o SSL da conexão (padrão de segurança)
# A resposta será exibida diretamente no terminal, incluindo erros se houver
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
// Definição do endpoint da API
private static string url = "https://api.xmailer.com.br/domain/add/";
static async Task Main(string[] args)
{
// Dados de autenticação e domínio a ser adicionado
var data = new
{
token_auth = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
dominio = "dominioaseradicionado.net.br" // Domínio a ser adicionado para envios
};
// Inicializa o HttpClient
using (var client = new HttpClient())
{
// Configura o cabeçalho da requisição para JSON
client.DefaultRequestHeaders.Add("Content-Type", "application/json");
// Serializa o objeto para JSON
var jsonData = JsonConvert.SerializeObject(data);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
try
{
// Envia a requisição POST
HttpResponseMessage response = await client.PostAsync(url, content);
// Obtém o código de status HTTP
int statusCode = (int)response.StatusCode;
Console.WriteLine($"Código de status: {statusCode}");
// Verifica se a requisição foi bem-sucedida
if (response.IsSuccessStatusCode)
{
// Lê a resposta como string
string responseBody = await response.Content.ReadAsStringAsync();
// Tenta desserializar a resposta JSON
var decodedResponse = JsonConvert.DeserializeObject(responseBody);
// Exibe a resposta formatada
Console.WriteLine("Resposta da API:");
string formattedResponse = JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
Console.WriteLine(formattedResponse);
}
else
{
// Exibe erro caso o código de status seja maior ou igual a 400
Console.WriteLine($"Erro na requisição. Código de status: {statusCode}");
}
}
catch (Exception ex)
{
// Exibe qualquer erro durante a requisição
Console.WriteLine($"Erro ao processar a requisição: {ex.Message}");
}
}
}
}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class XmailerApiExample {
public static void main(String[] args) {
// Definindo a URL do endpoint da API
String url = "https://api.xmailer.com.br/domain/add/";
// Dados de autenticação e domínio a ser adicionado (substitua com seus dados reais)
String tokenAuth = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // Token de autenticação
String dominio = "dominioaseradicionado.net.br"; // Domínio a ser adicionado
// JSON com os dados para envio
String jsonInputString = "{"
+ "\"token_auth\": \"" + tokenAuth + "\","
+ "\"dominio\": \"" + dominio + "\""
+ "}";
try {
// Criando um objeto URL a partir do endpoint da API
URL urlObj = new URL(url);
// Abrindo uma conexão HTTP com o método POST
HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
connection.setRequestMethod("POST");
// Definindo os cabeçalhos da requisição
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true); // Permitindo que o corpo da requisição seja enviado
// Enviando os dados (JSON) para o corpo da requisição
try (OutputStream os = connection.getOutputStream()) {
byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
os.write(input, 0, input.length); // Escreve os dados no corpo da requisição
}
// Obtendo o código de resposta HTTP
int statusCode = connection.getResponseCode();
// Lendo a resposta da API
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
// Verificando o código de status e exibindo a resposta
if (statusCode >= 200 && statusCode < 300) {
// Se o código de status for 2xx, a requisição foi bem-sucedida
System.out.println("Resposta da API: ");
System.out.println(response.toString());
} else {
// Se o código de status for maior ou igual a 400, ocorreu um erro
System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
}
}
} catch (IOException e) {
// Caso ocorra algum erro na requisição, exibe a mensagem de erro
System.out.println("Erro na requisição: " + e.getMessage());
}
}
}
const https = require('https');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/domain/add/";
// Dados de autenticação e domínio a ser adicionado
const data = JSON.stringify({
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
"dominio": "dominioaseradicionado.net.br" // Domínio a ser adicionado para envios
});
// Configuração da requisição
const options = {
hostname: 'api.xmailer.com.br',
path: '/domain/add/',
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': data.length
}
};
// Realizando a requisição HTTP
const req = https.request(options, (res) => {
let responseData = '';
// Quando os dados forem recebidos
res.on('data', (chunk) => {
responseData += chunk;
});
// Quando a resposta estiver completa
res.on('end', () => {
try {
// Converte a resposta para JSON e exibe
const parsedResponse = JSON.parse(responseData);
console.log("Resposta da API:");
console.log(JSON.stringify(parsedResponse, null, 2));
} catch (error) {
console.log("Erro ao processar a resposta JSON:", error.message);
}
});
});
// Em caso de erro na requisição
req.on('error', (error) => {
console.error("Erro na requisição:", error.message);
});
// Envia os dados no corpo da requisição
req.write(data);
// Finaliza a requisição
req.end();
require 'net/http'
require 'json'
require 'uri'
# Definição da URL do endpoint da API
url = URI.parse("https://api.xmailer.com.br/domain/add/")
# Dados de autenticação e domínio a ser adicionado
data = {
"token_auth" => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", # Token de autenticação obtido no painel do cliente
"dominio" => "dominioaseradicionado.net.br" # Domínio a ser adicionado
}
# Configura a requisição HTTP
http = Net::HTTP.new(url.host, url.port)
# Cria o objeto de requisição POST
request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json # Converte os dados para JSON e coloca no corpo da requisição
# Configura o tempo de timeout
http.read_timeout = 30 # Tempo limite para a requisição em segundos
begin
# Envia a requisição para o servidor
response = http.request(request)
# Verifica o código de status da resposta HTTP
if response.code.to_i >= 400
puts "Erro na requisição. Código de status HTTP: #{response.code}"
else
# Decodifica a resposta JSON
parsed_response = JSON.parse(response.body)
# Verifica se a resposta foi decodificada corretamente
if parsed_response.is_a?(Hash)
puts "Resposta da API:"
puts JSON.pretty_generate(parsed_response) # Exibe a resposta formatada em JSON
else
puts "Erro ao processar a resposta JSON."
end
end
rescue StandardError => e
# Captura erros como problemas de conexão ou tempo limite
puts "Erro na requisição: #{e.message}"
end
const axios = require('axios');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/domain/add/";
// Dados de autenticação e domínio a ser adicionado
const data = {
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
"dominio": "dominioaseradicionado.net.br" // Domínio a ser adicionado para envios
};
// Configuração da requisição
const config = {
headers: {
'Content-Type': 'application/json' // Define o cabeçalho da requisição como JSON
}
};
// Envia a requisição POST
axios.post(url, data, config)
.then((response) => {
// Se a resposta for bem-sucedida, exibe a resposta formatada
console.log("Resposta da API:");
console.log(JSON.stringify(response.data, null, 2)); // Exibe a resposta formatada
})
.catch((error) => {
// Caso ocorra erro na requisição
if (error.response) {
// A requisição foi feita e o servidor respondeu com um status de erro
console.log("Erro na requisição. Código de status HTTP: " + error.response.status);
console.log("Resposta do servidor:", error.response.data);
} else if (error.request) {
// A requisição foi feita, mas não houve resposta
console.log("Erro na requisição. Sem resposta do servidor:", error.request);
} else {
// Erro ao configurar a requisição
console.log("Erro ao configurar a requisição:", error.message);
}
});
Checar status de domínio
Integre seu sistema à nossa API para consultar o status de um domínio cadastrado em sua conta de maneira prática e confiável. Essa funcionalidade permite verificar rapidamente se um domínio está validado e pronto para envios.
Os parâmetros a seguir são essenciais para que a API processe corretamente a consulta do domínio. Certifique-se de fornecer informações precisas para evitar erros:
Parâmetro
Descrição
Obrigatório
token_auth:
token de autenticação exclusivo, encontrado no painel de cliente, na aba "API".
Sim
dominio:
O domínio que deseja verificar (exemplo: "seudominio.com.br").
Sim
Requisitos Técnicos
Os dados devem ser enviados via POST, codificados em JSON. Não esqueça de incluir o cabeçalho Content-Type: application/json.
Exemplo de Chamada e Resposta
Substitua os valores pelos dados específicos da sua conta:
A resposta indicará se o domínio está validado e apto para envios. Se ele ainda não estiver liberado, confira o e-mail com as instruções de validação enviadas anteriormente e siga os passos indicados.
Exemplos de código
Código copiado para a área de transferência
<?php
// Definição do endpoint da API
$url = "https://api.xmailer.com.br/domain/check/";
// Dados de autenticação e domínio a ser checado
$data = [
"token_auth" => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
"dominio" => "dominioaserchecado.net.br" // Domínio a ser verificado
];
// Configuração da requisição cURL
$options = [
CURLOPT_URL => $url, // Define a URL do endpoint da API
CURLOPT_RETURNTRANSFER => true, // Retorna a resposta como string em vez de exibi-la diretamente
CURLOPT_POST => true, // Define o método da requisição como POST
CURLOPT_HTTPHEADER => ["Content-Type: application/json"], // Define o cabeçalho da requisição como JSON
CURLOPT_POSTFIELDS => json_encode($data), // Converte os dados para JSON antes de enviar
CURLOPT_TIMEOUT => 30, // Define o tempo limite da requisição em segundos
CURLOPT_SSL_VERIFYPEER => true // Mantém a verificação SSL ativada para segurança
];
// Inicializa o cURL
$ch = curl_init();
curl_setopt_array($ch, $options);
$response = curl_exec($ch); // Executa a requisição e captura a resposta
$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Obtém o código de status HTTP da resposta
// Verifica se houve erro na requisição
if (curl_errno($ch)) {
// Exibe o erro ocorrido na requisição
echo "Erro na requisição: " . curl_error($ch);
} elseif ($statusCode >= 400) {
// Exibe o código de status HTTP caso ocorra erro
echo "Erro na requisição. Código de status HTTP: " . $statusCode;
} else {
// Decodifica a resposta JSON para um array associativo
$decodedResponse = json_decode($response, true);
// Verifica se a resposta foi decodificada corretamente
if (json_last_error() === JSON_ERROR_NONE) {
echo "Resposta da API:\n";
// Exibe a resposta formatada em JSON de forma legível
echo json_encode($decodedResponse, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
} else {
// Mensagem de erro caso a resposta JSON não possa ser processada
echo "Erro ao processar a resposta JSON.";
}
}
// Fecha a conexão cURL
curl_close($ch);
?>
import requests
import json
# Definição do endpoint da API
url = "https://api.xmailer.com.br/domain/check/"
# Dados de autenticação e domínio a ser checado
data = {
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", # Token de autenticação obtido no painel do cliente
"dominio": "dominioaserchecado.net.br" # Domínio a ser verificado
}
# Cabeçalhos para a requisição (informando que estamos enviando dados em JSON)
headers = {
"Content-Type": "application/json"
}
# Fazendo a requisição POST para a API
try:
# Realiza a requisição POST, enviando os dados no formato JSON
response = requests.post(url, headers=headers, json=data, timeout=30)
# Verifica o código de status da resposta
if response.status_code >= 400:
print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
else:
# Decodifica e exibe a resposta formatada em JSON
try:
decoded_response = response.json() # Decodifica a resposta JSON
print("Resposta da API:")
# Exibe a resposta formatada
print(json.dumps(decoded_response, indent=4, ensure_ascii=False))
except json.JSONDecodeError:
print("Erro ao processar a resposta JSON.")
except requests.exceptions.RequestException as e:
# Captura qualquer erro relacionado à requisição
print(f"Erro na requisição: {e}")
# Definição da URL do endpoint da API
URL="https://api.xmailer.com.br/domain/check/"
# Token de autenticação e domínio a ser verificado
TOKEN_AUTH="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # Substitua com seu token de autenticação
DOMINIO="dominioaserchecado.net.br" # Substitua com o domínio a ser verificado
# Dados a serem enviados no corpo da requisição em formato JSON
DATA="{\"token_auth\":\"$TOKEN_AUTH\", \"dominio\":\"$DOMINIO\"}"
# Requisição cURL
curl -X POST "$URL" \ # Método POST
-H "Content-Type: application/json" \ # Define o cabeçalho Content-Type
-d "$DATA" \ # Dados JSON enviados no corpo da requisição
--timeout 30 \ # Define o tempo limite da requisição (30 segundos)
--ssl-verify # Verifica o SSL da conexão (padrão de segurança)
# A resposta será exibida diretamente no terminal, incluindo erros se houver
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
// Definição do endpoint da API
private static string url = "https://api.xmailer.com.br/domain/check/";
static async Task Main(string[] args)
{
// Dados de autenticação e domínio a ser checado
var data = new
{
token_auth = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
dominio = "dominioaserchecado.net.br" // Domínio a ser verificado
};
// Inicializa o HttpClient
using (var client = new HttpClient())
{
// Configura o cabeçalho da requisição para JSON
client.DefaultRequestHeaders.Add("Content-Type", "application/json");
// Serializa o objeto de dados para JSON
var jsonData = JsonConvert.SerializeObject(data);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
try
{
// Envia a requisição POST
HttpResponseMessage response = await client.PostAsync(url, content);
// Obtém o código de status HTTP
int statusCode = (int)response.StatusCode;
Console.WriteLine($"Código de status: {statusCode}");
// Verifica se a requisição foi bem-sucedida
if (response.IsSuccessStatusCode)
{
// Lê a resposta como string
string responseBody = await response.Content.ReadAsStringAsync();
// Tenta desserializar a resposta JSON
var decodedResponse = JsonConvert.DeserializeObject(responseBody);
// Exibe a resposta formatada
Console.WriteLine("Resposta da API:");
string formattedResponse = JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
Console.WriteLine(formattedResponse);
}
else
{
// Exibe erro caso o código de status seja maior ou igual a 400
Console.WriteLine($"Erro na requisição. Código de status: {statusCode}");
}
}
catch (Exception ex)
{
// Exibe qualquer erro durante a requisição
Console.WriteLine($"Erro ao processar a requisição: {ex.Message}");
}
}
}
}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class XmailerDomainCheck {
public static void main(String[] args) {
// Definindo a URL do endpoint da API
String url = "https://api.xmailer.com.br/domain/check/";
// Dados de autenticação e domínio a ser verificado
String tokenAuth = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // Substitua pelo seu token de autenticação
String dominio = "dominioaserchecado.net.br"; // Substitua pelo domínio a ser verificado
// Montando o JSON com os dados para enviar
String jsonInputString = "{"
+ "\"token_auth\": \"" + tokenAuth + "\","
+ "\"dominio\": \"" + dominio + "\""
+ "}";
try {
// Criando um objeto URL a partir da URL do endpoint
URL urlObj = new URL(url);
// Abrindo uma conexão HTTP com o método POST
HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
connection.setRequestMethod("POST");
// Definindo os cabeçalhos da requisição
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true); // Permitindo que dados sejam enviados no corpo da requisição
// Enviando os dados JSON para o corpo da requisição
try (OutputStream os = connection.getOutputStream()) {
byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
os.write(input, 0, input.length); // Escreve os dados no corpo da requisição
}
// Obtendo o código de resposta HTTP
int statusCode = connection.getResponseCode();
// Lendo a resposta da API
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
// Verificando o código de status e exibindo a resposta
if (statusCode >= 200 && statusCode < 300) {
// Se o código de status for entre 200 e 299, a requisição foi bem-sucedida
System.out.println("Resposta da API: ");
System.out.println(response.toString());
} else {
// Se o código de status for maior ou igual a 400, ocorreu um erro
System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
}
}
} catch (IOException e) {
// Caso ocorra algum erro na requisição, exibe a mensagem de erro
System.out.println("Erro na requisição: " + e.getMessage());
}
}
}
// Importa o módulo https nativo do Node.js para realizar requisições HTTPS
const https = require('https');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/domain/check/";
// Dados de autenticação e domínio a ser checado
// Estamos preparando os dados para enviar na requisição como um JSON
const data = JSON.stringify({
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
"dominio": "dominioaserchecado.net.br" // Domínio a ser verificado
});
// Configuração da requisição HTTP
const options = {
hostname: 'api.xmailer.com.br', // Nome do servidor (domínio) para onde vamos enviar a requisição
path: '/domain/check/', // Caminho (endpoint) específico da API
method: 'POST', // Método HTTP a ser utilizado (POST)
headers: {
'Content-Type': 'application/json', // Tipo de conteúdo que estamos enviando, que é JSON
'Content-Length': data.length // Comprimento do conteúdo (tamanho dos dados em bytes)
}
};
// Realizando a requisição HTTP
const req = https.request(options, (res) > {
// Variável para armazenar os dados da resposta
let responseData = '';
// A cada pedaço de dados recebido, adicionamos ao responseData
res.on('data', (chunk) => {
responseData += chunk;
});
// Quando a resposta for completamente recebida
res.on('end', () => {
try {
// Tentamos converter a resposta da API para um objeto JSON
const parsedResponse = JSON.parse(responseData);
// Exibe a resposta formatada em JSON (bem indentado)
console.log("Resposta da API:");
console.log(JSON.stringify(parsedResponse, null, 2)); // JSON.stringify com indentação de 2 espaços
} catch (error) {
// Caso haja erro ao processar a resposta (por exemplo, se não for um JSON válido)
console.log("Erro ao processar a resposta JSON:", error.message);
}
});
});
// Em caso de erro na requisição (como problemas de rede ou no servidor)
req.on('error', (error) => {
console.error("Erro na requisição:", error.message);
});
// Envia os dados no corpo da requisição POST
req.write(data);
// Finaliza a requisição
req.end();
require 'net/http'
require 'json'
require 'uri'
# Definição do endpoint da API
url = URI.parse("https://api.xmailer.com.br/domain/check/")
# Dados de autenticação e domínio a ser checado
data = {
"token_auth" => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", # Token de autenticação obtido no painel do cliente
"dominio" => "dominioaserchecado.net.br" # Domínio a ser verificado
}
# Configura a requisição HTTP
http = Net::HTTP.new(url.host, url.port)
# Cria o objeto de requisição POST
request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json # Converte os dados para JSON e coloca no corpo da requisição
# Configura o tempo de timeout
http.read_timeout = 30 # Tempo limite para a requisição em segundos
begin
# Envia a requisição para o servidor
response = http.request(request)
# Verifica o código de status da resposta HTTP
if response.code.to_i >= 400
puts "Erro na requisição. Código de status HTTP: #{response.code}"
else
# Decodifica a resposta JSON
parsed_response = JSON.parse(response.body)
# Verifica se a resposta foi decodificada corretamente
if parsed_response.is_a?(Hash)
puts "Resposta da API:"
puts JSON.pretty_generate(parsed_response) # Exibe a resposta formatada em JSON
else
puts "Erro ao processar a resposta JSON."
end
end
rescue StandardError => e
# Captura erros como problemas de conexão ou tempo limite
puts "Erro na requisição: #{e.message}"
end
const axios = require('axios');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/domain/check/";
// Dados de autenticação e domínio a ser checado
const data = {
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Token de autenticação obtido no painel do cliente
"dominio": "dominioaserchecado.net.br" // Domínio a ser verificado
};
// Configuração da requisição
const config = {
headers: {
'Content-Type': 'application/json' // Define o cabeçalho da requisição como JSON
}
};
// Envia a requisição POST
axios.post(url, data, config)
.then((response) => {
// Se a resposta for bem-sucedida, exibe a resposta formatada
console.log("Resposta da API:");
console.log(JSON.stringify(response.data, null, 2)); // Exibe a resposta formatada
})
.catch((error) => {
// Caso ocorra erro na requisição
if (error.response) {
// A requisição foi feita e o servidor respondeu com um status de erro
console.log("Erro na requisição. Código de status HTTP: " + error.response.status);
console.log("Resposta do servidor:", error.response.data);
} else if (error.request) {
// A requisição foi feita, mas não houve resposta
console.log("Erro na requisição. Sem resposta do servidor:", error.request);
} else {
// Erro ao configurar a requisição
console.log("Erro ao configurar a requisição:", error.message);
}
});
Listar domínios
Utilize esta API para integrar seu sistema e obter uma lista completa de todos os domínios associados à sua conta, incluindo seus respectivos status de validação e liberação para envios.
Os parâmetros a seguir são essenciais para que a API processe corretamente a listagem de um domínio. Certifique-se de fornecer informações precisas para evitar erros:
Parâmetro
Descrição
Obrigatório
token_auth:
token de autenticação exclusivo, encontrado no painel de cliente, na aba "API".
Sim
Requisitos Técnicos
Os dados devem ser enviados via POST, codificados em JSON. Não esqueça de incluir o cabeçalho Content-Type: application/json.
Exemplo de Chamada e Resposta
Substitua os valores pelos dados específicos da sua conta:
Ao enviar os parâmetros corretamente, você receberá uma confirmação como esta:
{
"dominio": "dominioteste1.com.br",
"validado": "validado",
"liberado para envios": "liberado para envios",
"dominios_adicionais": [
{
"dominio": "dominioteste2.net.br",
"validado": "não validado",
"liberado para envios": "não liberado"
},
{
"dominio": "dominioteste3.net.br",
"validado": "não validado",
"liberado para envios": "não liberado"
}
]
}
Exemplos de código
Código copiado para a área de transferência
<?php
// Definição do endpoint da API para listar domínios
$url = "https://api.xmailer.com.br/domain/list/";
// Dados de autenticação (substitua pelo seu token real)
$data = [
"token_auth" => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // Token obtido no painel do cliente
];
// Configuração da requisição cURL
$options = [
CURLOPT_URL => $url, // Define a URL do endpoint da API
CURLOPT_RETURNTRANSFER => true, // Retorna a resposta como string
CURLOPT_POST => true, // Define o método da requisição como POST
CURLOPT_HTTPHEADER => ["Content-Type: application/json"], // Define o cabeçalho da requisição como JSON
CURLOPT_POSTFIELDS => json_encode($data), // Converte os dados para JSON antes de enviar
CURLOPT_TIMEOUT => 30, // Tempo limite da requisição em segundos
CURLOPT_SSL_VERIFYPEER => true // Mantém a verificação SSL ativada para segurança
];
// Inicializa o cURL
$ch = curl_init();
curl_setopt_array($ch, $options);
$response = curl_exec($ch); // Executa a requisição e captura a resposta
$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Obtém o código de status HTTP da resposta
// Verifica se houve erro na requisição
if (curl_errno($ch)) {
echo "Erro na requisição: " . curl_error($ch); // Exibe a mensagem de erro do cURL
} elseif ($statusCode >= 400) {
echo "Erro na requisição. Código de status HTTP: " . $statusCode; // Exibe o código de erro HTTP
} else {
// Decodifica a resposta JSON para um array associativo
$decodedResponse = json_decode($response, true);
// Verifica se a resposta foi decodificada corretamente
if (json_last_error() === JSON_ERROR_NONE) {
echo "Resposta da API:\n";
echo json_encode($decodedResponse, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE); // Exibe a resposta formatada
} else {
echo "Erro ao processar a resposta JSON."; // Mensagem de erro caso a resposta JSON seja inválida
}
}
// Fecha a conexão cURL para liberar recursos
curl_close($ch);
?>
import requests
import json
# Definição do endpoint da API para listar domínios
url = "https://api.xmailer.com.br/domain/list/"
# Dados de autenticação (substitua pelo seu token real)
data = {
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # Token obtido no painel do cliente
}
# Cabeçalhos para a requisição (informando que estamos enviando dados em JSON)
headers = {
"Content-Type": "application/json"
}
# Fazendo a requisição POST para a API
try:
# Realiza a requisição POST, enviando os dados no formato JSON
response = requests.post(url, headers=headers, json=data, timeout=30)
# Verifica o código de status da resposta
if response.status_code >= 400:
print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
else:
# Decodifica e exibe a resposta formatada em JSON
try:
decoded_response = response.json() # Decodifica a resposta JSON
print("Resposta da API:")
# Exibe a resposta formatada
print(json.dumps(decoded_response, indent=4, ensure_ascii=False))
except json.JSONDecodeError:
print("Erro ao processar a resposta JSON.")
except requests.exceptions.RequestException as e:
# Captura qualquer erro relacionado à requisição (erros de rede, tempo limite, etc)
print(f"Erro na requisição: {e}")
# Definição da URL do endpoint da API
URL="https://api.xmailer.com.br/domain/list/"
# Token de autenticação (substitua com seu token real)
TOKEN_AUTH="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
# Dados a serem enviados no corpo da requisição em formato JSON
DATA="{\"token_auth\":\"$TOKEN_AUTH\"}"
# Requisição cURL
curl -X POST "$URL" \ # Método POST para enviar dados
-H "Content-Type: application/json" \ # Define o cabeçalho Content-Type como JSON
-d "$DATA" \ # Envia os dados no corpo da requisição
--timeout 30 \ # Define o tempo máximo de espera (30 segundos)
--ssl-verify # Mantém a verificação SSL ativada para segurança
# A resposta será exibida diretamente no terminal, incluindo erros se houver
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
// Definição do endpoint da API para listar domínios
private static string url = "https://api.xmailer.com.br/domain/list/";
static async Task Main(string[] args)
{
// Dados de autenticação (substitua pelo seu token real)
var data = new
{
token_auth = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // Token obtido no painel do cliente
};
// Inicializa o HttpClient
using (var client = new HttpClient())
{
// Configura o cabeçalho da requisição para JSON
client.DefaultRequestHeaders.Add("Content-Type", "application/json");
// Serializa o objeto de dados para JSON
var jsonData = JsonConvert.SerializeObject(data);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
try
{
// Envia a requisição POST
HttpResponseMessage response = await client.PostAsync(url, content);
// Obtém o código de status HTTP
int statusCode = (int)response.StatusCode;
Console.WriteLine($"Código de status: {statusCode}");
// Verifica se a requisição foi bem-sucedida (código 2xx)
if (response.IsSuccessStatusCode)
{
// Lê a resposta como string
string responseBody = await response.Content.ReadAsStringAsync();
// Tenta desserializar a resposta JSON
var decodedResponse = JsonConvert.DeserializeObject(responseBody);
// Exibe a resposta formatada em JSON
Console.WriteLine("Resposta da API:");
string formattedResponse = JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
Console.WriteLine(formattedResponse);
}
else
{
// Exibe erro caso o código de status seja maior ou igual a 400
Console.WriteLine($"Erro na requisição. Código de status HTTP: {statusCode}");
}
}
catch (Exception ex)
{
// Exibe qualquer erro durante a requisição
Console.WriteLine($"Erro ao processar a requisição: {ex.Message}");
}
}
}
}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class XmailerDomainList {
public static void main(String[] args) {
// Definindo a URL do endpoint da API
String url = "https://api.xmailer.com.br/domain/list/";
// Dados de autenticação (substitua pelo seu token real)
String tokenAuth = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // Substitua pelo seu token de autenticação
// Montando o JSON com os dados para enviar
String jsonInputString = "{"
+ "\"token_auth\": \"" + tokenAuth + "\""
+ "}";
try {
// Criando um objeto URL a partir da URL do endpoint
URL urlObj = new URL(url);
// Abrindo uma conexão HTTP com o método POST
HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
connection.setRequestMethod("POST");
// Definindo os cabeçalhos da requisição
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true); // Permitindo que dados sejam enviados no corpo da requisição
// Enviando os dados JSON para o corpo da requisição
try (OutputStream os = connection.getOutputStream()) {
byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
os.write(input, 0, input.length); // Escreve os dados no corpo da requisição
}
// Obtendo o código de resposta HTTP
int statusCode = connection.getResponseCode();
// Lendo a resposta da API
try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
// Verificando o código de status e exibindo a resposta
if (statusCode >= 200 && statusCode < 300) {
// Se o código de status for entre 200 e 299, a requisição foi bem-sucedida
System.out.println("Resposta da API: ");
System.out.println(response.toString());
} else {
// Se o código de status for maior ou igual a 400, ocorreu um erro
System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
}
}
} catch (IOException e) {
// Caso ocorra algum erro na requisição, exibe a mensagem de erro
System.out.println("Erro na requisição: " + e.getMessage());
}
}
}
// Importa o módulo https nativo do Node.js para realizar requisições HTTPS
const https = require('https');
// Definição do endpoint da API
const url = "https://api.xmailer.com.br/domain/list/";
// Dados de autenticação (substitua pelo seu token real)
const data = JSON.stringify({
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // Token de autenticação obtido no painel do cliente
});
// Configuração da requisição HTTP
const options = {
hostname: 'api.xmailer.com.br', // Nome do servidor (domínio) para onde vamos enviar a requisição
path: '/domain/list/', // Caminho (endpoint) específico da API
method: 'POST', // Método HTTP a ser utilizado (POST)
headers: {
'Content-Type': 'application/json', // Tipo de conteúdo que estamos enviando, que é JSON
'Content-Length': data.length // Comprimento do conteúdo (tamanho dos dados em bytes)
}
};
// Realizando a requisição HTTP
const req = https.request(options, (res) => {
// Variável para armazenar os dados da resposta
let responseData = '';
// A cada pedaço de dados recebido, adicionamos ao responseData
res.on('data', (chunk) => {
responseData += chunk;
});
// Quando a resposta for completamente recebida
res.on('end', () => {
try {
// Tentamos converter a resposta da API para um objeto JSON
const parsedResponse = JSON.parse(responseData);
// Exibe a resposta formatada em JSON (bem indentado)
console.log("Resposta da API:");
console.log(JSON.stringify(parsedResponse, null, 2)); // JSON.stringify com indentação de 2 espaços
} catch (error) {
// Caso haja erro ao processar a resposta (por exemplo, se não for um JSON válido)
console.log("Erro ao processar a resposta JSON:", error.message);
}
});
});
// Em caso de erro na requisição (como problemas de rede ou no servidor)
req.on('error', (error) => {
console.error("Erro na requisição:", error.message);
});
// Envia os dados no corpo da requisição POST
req.write(data);
// Finaliza a requisição
req.end();
require 'net/http'
require 'json'
require 'uri'
# Definição do endpoint da API
url = URI("https://api.xmailer.com.br/domain/list/")
# Dados de autenticação (substitua pelo seu token real)
data = {
"token_auth" => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # Token obtido no painel do cliente
}
# Configuração da requisição HTTP
http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json # Converte os dados para JSON antes de enviar
# Envia a requisição e obtém a resposta
response = http.request(request)
# Verifica o status da resposta
if response.code.to_i >= 400
# Se o status for maior ou igual a 400, houve erro na requisição
puts "Erro na requisição. Código de status HTTP: #{response.code}"
else
# Caso a resposta seja bem-sucedida, decodifica e exibe o JSON
begin
decoded_response = JSON.parse(response.body)
puts "Resposta da API:"
puts JSON.pretty_generate(decoded_response) # Exibe a resposta formatada
rescue JSON::ParserError
# Caso não consiga processar o JSON, exibe um erro
puts "Erro ao processar a resposta JSON."
end
end
const axios = require('axios');
// Definição do endpoint da API para listar domínios
const url = "https://api.xmailer.com.br/domain/list/";
// Dados de autenticação (substitua pelo seu token real)
const data = {
"token_auth": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // Token obtido no painel do cliente
};
// Configuração da requisição
const config = {
headers: {
'Content-Type': 'application/json' // Define o cabeçalho da requisição como JSON
}
};
// Envia a requisição POST
axios.post(url, data, config)
.then((response) => {
// Se a resposta for bem-sucedida, exibe a resposta formatada
console.log("Resposta da API:");
console.log(JSON.stringify(response.data, null, 2)); // Exibe a resposta formatada
})
.catch((error) => {
// Caso ocorra erro na requisição
if (error.response) {
// A requisição foi feita e o servidor respondeu com um status de erro
console.log("Erro na requisição. Código de status HTTP: " + error.response.status);
console.log("Resposta do servidor:", error.response.data);
} else if (error.request) {
// A requisição foi feita, mas não houve resposta
console.log("Erro na requisição. Sem resposta do servidor:", error.request);
} else {
// Erro ao configurar a requisição
console.log("Erro ao configurar a requisição:", error.message);
}
});
GitHub
No repositório github.com/xmailerbr, disponível no GitHub, você encontra exemplos práticos e fáceis de entender para usar a API de envio de e-mails da Xmailer. Esses exemplos foram criados para ajudar você ou sua equipe a integrar nosso serviço de envio de e-mails transacionais e de marketing ao seu sistema de forma rápida e sem complicações.
O Que Você Encontra Aqui?
Temos instruções e códigos simples em várias linguagens populares, como PHP, Python, JavaScript, Ruby, Node.js, C#, Java e até comandos cURL. Cada exemplo mostra passo a passo como enviar e-mails usando nossa API, incluindo mensagens com anexos, como fotos ou documentos, e personalizações como remetente, destinatário, assunto e corpo do e-mail.
Por Que Isso É Útil Para Você?
Fácil de Começar: Os exemplos são projetados para iniciantes e especialistas, com instruções claras que ajudam a configurar tudo rapidamente, mesmo sem muito conhecimento técnico.
Flexibilidade: Você pode escolher a linguagem que melhor se adapta ao seu sistema ou ao que sua equipe já usa, garantindo uma integração suave.
Economia de Tempo: Com esses modelos prontos, você evita começar do zero, acelerando o processo de implementação e testando envios em poucos minutos.
Suporte Completo: Além de enviar e-mails, os exemplos mostram como lidar com relatórios e verificar o status dos envios, ajudando você a acompanhar tudo de perto.
Como Usar?
Basta acessar o repositório, escolher o exemplo na linguagem que você prefere, e seguir as instruções básicas. Os códigos vêm com dicas simples para substituir informações como credenciais (usuário e senha do SMTP) e ajustar os detalhes do e-mail para o seu negócio. Se precisar de ajuda, nossa equipe de suporte está pronta para orientar você!
Esses exemplos são como um guia amigável para aproveitar ao máximo a API da Xmailer, permitindo que você envie e-mails de forma confiável, rápida e personalizada para seus clientes, sem preocupações. Experimente hoje mesmo e veja como é fácil transformar sua comunicação por e-mail!
