import requests
from requests.structures import CaseInsensitiveDict

# URL do endpoint da API para envio de emails
url = "https://api.mailgrid.net.br/sendmail/"

# 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",
	"usuario_smtp": "USUARIO-SMTP",
	"senha_smtp": "SENHA-SMTP",
	"emailRemetente": "EMAIL-REMETENTE",
	"nomeRemetente": "NOME-REMETENTE",
	"emailDestino": ["dev@mailgrid.net.br", "postmaster@mailgrid.net.br"],
	"assunto": "Teste da API JSON com anexo",
	"mensagemAnexos": [
	{
		"name": "pixel.jpg",
		"type": "image/jpeg",
		"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQY..."
	},
	{
		"name": "pixel2.jpg",
		"type": "image/jpeg",
		"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQY..."
		}
	],
	"mensagem": "Mensagem de teste da API com anexos. Testando anexos de html no envio da api",
	"mensagemTipo": "html",
	"mensagemEncoding": "quoted-printable",
	"mensagemAlt": "mensagem de teste da API JSON com anexos"
}
"""

# 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 mailgrid com cURL

curl --location 'https://api.mailgrid.net.br/sendmail/' \
	--header 'Content-Type: application/json' \
	--data-raw '{
	"host_smtp": "HOST-SMTP",
	"usuario_smtp": "USUARIO-SMTP",
	"senha_smtp": "SENHA-SMTP",
	"emailRemetente": "EMAIL-REMETENTE",
	"nomeRemetente": "NOME-REMETENTE",
	"emailDestino": ["dev@mailgrid.net.br", "postmaster@mailgrid.net.br"],
	"assunto": "Teste da API JSON com anexo",
	"mensagemAnexos": [
		{
			"name": "pixel.jpg",
			"type": "image/jpeg",
			"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDA...."
		},
		{
			"name": "pixel2.jpg",
			"type": "image/jpeg",
			"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDA...."
		}
	],
	"mensagem": "Mensagem de teste da API com anexos. Testando anexos de html no envio da api",
	"mensagemTipo": "html",
	"mensagemEncoding": "quoted-printable",
	"mensagemAlt": "mensagem de teste da API JSON com anexos"
}'

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.mailgrid.net.br/sendmail/";

  // 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@mailgrid.net.br\",\"postmaster@mailgrid.net.br\"],\r\n" +
		"    \"assunto\": \"Teste da API JSON com anexo\",\r\n" +
		"    \"mensagemAnexos\": [\r\n" +
		"       {\r\n" +
		"            \"name\": \"pixel.jpg\",\r\n" +
		"            \"type\": \"image/jpeg\",\r\n" +
		"            \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYIC...\"\r\n" +
		"       },\r\n" +
		"       {\r\n" +
		"            \"name\": \"pixel2.jpg\",\r\n" +
		"            \"type\": \"image/jpeg\",\r\n" +
		"            \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYIC...\"\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)
	{
	 Console.WriteLine($"Erro ao fazer a requisição: {ex.Message}");
	}
	catch (Exception ex)
	{
		Console.WriteLine($"Erro inesperado: {ex.Message}");
	 }
    }
  }
}

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class mailgridSendEmail

  public static void main(String[] args) {
  // Definindo a URL do endpoint da API
	String apiUrl = "https://api.mailgrid.net.br/sendmail/";

	// 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@mailgrid.net.br\", \"postmaster@mailgrid.net.br\"],\n" +
		"    \"assunto\": \"Teste da API JSON com anexo\",\n" +
		"    \"mensagemAnexos\": [\n" +
		"        {\n" +
		"            \"name\": \"pixel.jpg\",\n" +
		"            \"type\": \"image/jpeg\",\n" +
		"            \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/....\"\n" +
		"        },\n" +
		"        {\n" +
		"            \"name\": \"pixel2.jpg\",\n" +
		"            \"type\": \"image/jpeg\",\n" +
		"            \"content\": \"/9j/4AAQSkZJRgABAQEBLAEsAAD/....\"\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 {
	 URL url = new URL(apiUrl);
	 HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();

	 httpConnection.setRequestMethod("POST");
	 httpConnection.setDoOutput(true);
	 httpConnection.setRequestProperty("Content-Type", "application/json");

	 byte[] out = data.getBytes(StandardCharsets.UTF_8);
	try (OutputStream os = httpConnection.getOutputStream()) {
		os.write(out);
	}

	int statusCode = httpConnection.getResponseCode();
	System.out.println("Código de Status: " + statusCode);

	 try (BufferedReader in = new BufferedReader(new InputStreamReader(httpConnection.getInputStream()))) {
		String inputLine;
		StringBuilder response = new StringBuilder();
		while ((inputLine = in.readLine()) != null) {
			response.append(inputLine);
		}
		System.out.println("Resposta da API:\n" + response.toString());
	 } catch (IOException e) {
		System.out.println("Erro ao ler a resposta da API: " + e.getMessage());
	 }

	httpConnection.disconnect();

	  } catch (IOException e) {
		System.out.println("Erro na requisição HTTP: " + e.getMessage());
	  }
	}
}

// URL do endpoint da API para envio de e-mail
const url = 'https://api.mailgrid.net.br/sendmail/';

// Definição dos dados que serão enviados na requisição (e-mail, anexos, etc)
const data = JSON.stringify({
 "host_smtp": "HOST-SMTP",
 "usuario_smtp": "USUARIO-SMTP",
 "senha_smtp": "SENHA-SMTP",
 "emailRemetente": "EMAIL-REMETENTE",
 "nomeRemetente": "NOME-REMETENTE",
 "emailDestino": ["dev@mailgrid.net.br", "postmaster@mailgrid.net.br"],
 "assunto": "Teste da API JSON com anexo",
 "mensagemAnexos": [
	{
		"name": "pixel.jpg",
		"type": "image/jpeg",
		"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD..."
	},
	{
		"name": "pixel2.jpg",
		"type": "image/jpeg",
		"content": "/9j/4AAQSkZJRgABAQEBLAEsAAD..."
	}
  ],
	"mensagem": "Mensagem de teste da API com anexos. Testando anexos de html no envio da api",
	"mensagemTipo": "html",
	"mensagemEncoding": "quoted-printable",
	"mensagemAlt": "mensagem de teste da API JSON com anexos"
});

// Função assíncrona para enviar a requisição POST para a API
async function sendEmail() {
 try {
   const response = await fetch(url, {
	 method: 'POST',
	 headers: {
		'Content-Type': 'application/json',
	 },
	body: data,
	});

	if (!response.ok) {
		throw new Error(`Erro na requisição: ${response.status} - ${response.statusText}`);
	}

	const text = await response.text();
	console.log("Resposta da API:", text);
	} catch (error) {
		console.error("Erro ao enviar o e-mail:", error);
	}
}

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.mailgrid.net.br/sendmail/'

# Define os cabeçalhos da requisição (headers)
headers = {
	'Content-Type' => 'application/json'
}

# Cria o corpo da requisição como um hash Ruby
body = {
	'host_smtp' => 'HOST-SMTP',
	'usuario_smtp' => 'USUARIO-SMTP',
	'senha_smtp' => 'SENHA-SMTP',
	'emailRemetente' => 'EMAIL-REMETENTE',
	'nomeRemetente' => 'NOME-REMETENTE',
	'emailDestino' => [
	'destinatario1@dominio.com.br',
	'destinatario2@dominio.com.br'
	],
	'assunto' => 'Teste de envio com anexo via API JSON',
	'mensagemAnexos' => [
	{
		'name' =>'anexoexemplo.pdf',
		'type' =>'application/pdf',
		'content' =>'UEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/...//Z'
	}
	],
	'mensagem' = 'Mensagem de teste da API com anexo. O arquivo codificado acima não funciona, é um exemplo.',
	'mensagemTipo' => 'html',
	'mensagemEncoding' => 'base64',
	'mensagemAlt' = 'Mensagem de teste da API com anexo. O arquivo codificado acima não funciona, é um exemplo.'
}

# Faz a requisição POST para a API
response = HTTParty.post(
	API_URL,
	headers: headers,
	body: body.to_json,
	timeout: 0,
	follow_redirects: true
)

# 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.mailgrid.net.br/sendmail/';

// 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 = {
  host_smtp: 'HOST-SMTP',
  usuario_smtp: 'USUARIO-SMTP',
  senha_smtp: 'SENHA-SMTP',
  emailRemetente: 'EMAIL-REMETENTE',
  nomeRemetente: 'NOME-REMETENTE',
  emailDestino: [
    'destinatario1@dominio.com.br',
    'destinatario2@dominio.com.br'
  ],
  assunto: 'Teste de envio com anexo via API JSON',
  mensagemAnexos: [
    {
      name: 'anexoexemplo.pdf',
      type: 'application/pdf',
      content: 'UEAEAAAAAAAAAAAAAAAAAAAAA/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAYH/...//Z'
    }
  ],
  mensagem: 'Mensagem de teste da API com anexo. O arquivo codificado acima não funciona, é apenas um exemplo.',
  mensagemTipo: 'html',
  mensagemEncoding: 'base64',
  mensagemAlt: 'Mensagem de teste da API com anexo. O arquivo codificado acima não funciona, é apenas um exemplo.'
};

// Faz a requisição POST usando axios
axios.post(apiUrl, data, {
  headers: headers,
  maxRedirects: 10,
  timeout: 0,
  httpAgent: new (require('http').Agent)({ keepAlive: true }),
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error =>  {
    console.error('Erro na requisição:', error.message);
});

import requests
from requests.structures import CaseInsensitiveDict

# URL do endpoint da API mailgrid para consultar relatórios
url = "https://api.mailgrid.net.br/report/"

headers = CaseInsensitiveDict()
headers["Content-Type"] = "application/json"

data = '{"token_auth": "INFORME-O-TOKEN-AQUI, "dataini": "2022-09-27", "horaini": "00:01", "datafim": "2022-09-27",
"horafim": "23:59"}'

resp = requests.post(url, headers=headers, data=data)

print(resp.status_code)

if resp.status_code == 200:
	print("Requisição bem-sucedida!")
	print(resp.json())
else:
	print(f"Erro na requisição: {resp.text}")

#!/bin/bash

API_URL="https://api.mailgrid.net.br/report/"

TOKEN_AUTH="INFORME-O-TOKEN-AQUI"
DATA_INICIO="2022-09-27"
HORA_INICIO="00:01"
DATA_FIM="2022-09-27"
HORA_FIM="23:59"

JSON_DATA=$(cat <<DADOS
{
	"token_auth": "$TOKEN_AUTH,
	"dataini": "$DATA_INICIO",
	"horaini": "$HORA_INICIO",
	"datafim": "$DATA_FIM",
	"horafim": "$HORA_FIM"
}
DADOS
)

curl -X POST "$API_URL" \
	-H "Authorization: Content-Type: application/json" \
	-H "Content-Type: application/json" \
	-d "$JSON_DATA"

using System;
using System.IO;
using System.Net;
using System.Text;

class Program
{
    static void Main()
    {
        var url = "https://api.mailgrid.net.br/report/";

        try
        {
            var httpRequest = (HttpWebRequest)WebRequest.Create(url);
            httpRequest.Method = "POST";

            httpRequest.ContentType = "application/json";

            var data = "{\"token_auth\": \"INFORME-O-TOKEN-AQUI\", " +
                       "\"dataini\": \"2022-09-27\", \"horaini\": \"00:01\", \"datafim\": \"2022-09-27\",
					   \"horafim\": \"23:59\"}";

            using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream(), Encoding.UTF8))
            {
                streamWriter.Write(data);
            }

            using (var httpResponse = (HttpWebResponse)httpRequest.GetResponse())
            {
                if (httpResponse.StatusCode == HttpStatusCode.OK)
                {
                    using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
                    {
                        var result = streamReader.ReadToEnd();
                        Console.WriteLine("Resposta da API:\n" + result);
                    }
                }
                else
                {
                    Console.WriteLine($"Erro na requisição. Código de status HTTP: {httpResponse.StatusCode}");
                }
            }
        }
        catch (WebException webEx)
        {
            using (var streamReader = new StreamReader(webEx.Response.GetResponseStream()))
            {
                var errorResponse = streamReader.ReadToEnd();
                Console.WriteLine($"Erro na requisição: {errorResponse}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Erro inesperado: {ex.Message}");
        }
    }
}

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class mailgrid Report {

	public static void main(String[] args) {
		String apiUrl = "https://api.mailgrid.net.br/report/";

		String data = "{\n" +
				"    \"token_auth\": \"INFORME-O-TOKEN-AQUI\",\n" +
				"    \"dataini\": \"2022-09-27\",\n" +
				"    \"horaini\": \"00:01\",\n" +
				"    \"datafim\": \"2022-09-27\",\n" +
				"    \"horafim\": \"23:59\"\n" +
				"}";

		try {
			URL url = new URL(apiUrl);
			HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();

			httpConnection.setRequestMethod("POST");
			httpConnection.setDoOutput(true);
			httpConnection.setRequestProperty("Authorization", "Bearer YOUR_AUTH_TOKEN");
			httpConnection.setRequestProperty("Content-Type", "application/json");

			byte[] out = data.getBytes(StandardCharsets.UTF_8);

			try (OutputStream os = httpConnection.getOutputStream()) {
				os.write(out);
			}

			int statusCode = httpConnection.getResponseCode();
			System.out.println("Código de Status: " + statusCode);

			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());
			}

			if (statusCode == HttpURLConnection.HTTP_OK) {
				System.out.println("Resposta da API:\n" + response.toString());
			} else {
				System.out.println("Erro: " + httpConnection.getResponseMessage());
			}

			httpConnection.disconnect();

		} catch (IOException e) {
			System.out.println("Erro na requisição HTTP: " + e.getMessage());
		}
	}
}

// URL do endpoint da API para gerar relatórios
var url = "https://api.mailgrid.net.br/report/";

var xhr = new XMLHttpRequest();
xhr.open("POST", url);
xhr.setRequestHeader("Content-Type", "application/json");

xhr.onreadystatechange = function () {
	if (xhr.readyState === 4) {
		console.log("Código de status:", xhr.status);
		console.log("Resposta:", xhr.responseText);
		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);
		}
	}
};

var data = JSON.stringify({
	"token_auth": "INFORME-O-TOKEN-AQUI,
	"dataini": "2022-09-27",
	"horaini": "00:01",
	"datafim": "2022-09-27",
	"horafim": "23:59"
});

xhr.send(data);

# Importa a biblioteca HTTParty para fazer requisições HTTP
require 'httparty'

API_URL = 'https://api.mailgrid.net.br/report/'

headers = {
	'Content-Type' => 'application/json'
}

body = {
	'token_auth' => 'INFORME-O-TOKEN-AQUI,
	'dataini' => '2022-09-27',
	'horaini' => '00:01',
	'datafim' => '2022-09-27',
	'horafim' => '23:59'
}

response = HTTParty.post(
	API_URL,
	headers: headers,
	body: body.to_json,
	verify: false
)

puts response.body.inspect

// Importa a biblioteca axios para fazer requisições HTTP
const axios = require('axios');

const apiUrl = 'https://api.mailgrid.net.br/report/';

const headers = {
	'Content-Type': 'application/json'
};

const data = {
	token_auth: 'INFORME-O-TOKEN-AQUI',
	dataini: '2022-09-27',
	horaini: '00:01',
	datafim: '2022-09-27',
	horafim: '23:59'
};

axios.post(apiUrl, data, {
	headers: headers,
	httpsAgent: new (require('https').Agent)({
	rejectUnauthorized: false
	})
})
	.then(response => {
	console.log(response.data);
	})
	.catch(error => {
	console.error('Erro na requisição:', error.message);
	});

import requests
import json

url = "https://api.mailgrid.net.br/consolidate/"

data = {
	"token_auth": "INFORME-O-TOKEN-AQUI",
	"dataini": "2023-02-01",
	"horaini": "00:01",
	"datafim": "2023-08-30",
	"horafim": "23:59"
}

headers = {
	"Content-Type": "application/json"
}

try:
	response = requests.post(url, headers=headers, json=data, timeout=30)

	if response.status_code != 200:
		print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
	else:
		print("Resposta da API:")
		decoded_response = response.json()
		print(json.dumps(decoded_response, indent=4, ensure_ascii=False))

except requests.exceptions.RequestException as e:
	print(f"Erro na requisição: {e}")

URL="https://api.mailgrid.net.br/consolidate/"

TOKEN_AUTH="INFORME-O-TOKEN-AQUI"
DATANAI="2023-02-01"
HORANAI="00:01"
DATAFIM="2023-08-30"
HORAFIM="23:59"

DATA_JSON=$(cat <<DADOS
{
	"token_auth": "$TOKEN_AUTH,
	"dataini": "$DATANAI",
	"horaini": "$HORANAI",
	"datafim": "$DATAFIM",
	"horafim": "$HORAFIM"
}
DADOS
)

curl -X POST "$URL" \
	-H "Content-Type: application/json" \
	-d "$DATA_JSON" \
	--timeout 30 \
	--insecure \
	-v

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
	private static string url = "https://api.mailgrid.net.br/consolidate/";

	static async Task Main(string[] args)
	{
		var data = new
		{
			token_auth = "INFORME-O-TOKEN-AQUI",
			dataini = "2023-02-01",
			horaini = "00:01",
			datafim = "2023-08-30",
			horafim = "23:59"
		};

		using (var client = new HttpClient())
		{
			client.DefaultRequestHeaders.Add("Content-Type", "application/json");

			var jsonData = JsonConvert.SerializeObject(data);
			var content = new StringContent(jsonData, Encoding.UTF8, "application/json");

			try
			{
				HttpResponseMessage response = await client.PostAsync(url, content);

				int statusCode = (int)response.StatusCode;
				Console.WriteLine($"Código de status: {statusCode}");

				if (response.IsSuccessStatusCode)
				{
					string responseBody = await response.Content.ReadAsStringAsync();
					var decodedResponse = JsonConvert.DeserializeObject(responseBody);
					Console.WriteLine("Resposta da API:");
					string formattedResponse =
					JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
					Console.WriteLine(formattedResponse);
				}
				else
				{
					Console.WriteLine($"Erro na requisição. Código de status HTTP: {statusCode}");
				}
			}
			catch (Exception ex)
			{
				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 mailgridConsolidate {
	public static void main(String[] args) {
		String url = "https://api.mailgrid.net.br/consolidate/";

		String token_auth = "INFORME-O-TOKEN-AQUI";
		String dataInicio = "2023-02-01";
		String horaInicio = "00:01";
		String dataFim = "2023-08-30";
		String horaFim = "23:59";

		String jsonInputString = "{"
				+ "\"token_auth\": \"" + token_auth + "\","
				+ "\"dataini\": \"" + dataInicio + "\","
				+ "\"horaini\": \"" + horaInicio + "\","
				+ "\"datafim\": \"" + dataFim + "\","
				+ "\"horafim\": \"" + horaFim + "\""
				+ "}";

		try {
			URL urlObj = new URL(url);
			HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
			connection.setRequestMethod("POST");

			connection.setRequestProperty("Content-Type", "application/json");
			connection.setDoOutput(true);

			try (OutputStream os = connection.getOutputStream()) {
				byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
				os.write(input, 0, input.length);
			}

			int statusCode = connection.getResponseCode();

			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);
				}

				if (statusCode == HttpURLConnection.HTTP_OK) {
					System.out.println("Resposta da API: ");
					System.out.println(response.toString());
				} else {
					System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
				}
			}
		} catch (IOException e) {
			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');

const url = "https://api.mailgrid.net.br/consolidate/";

const data = JSON.stringify({
	"token_auth": "INFORME-O-TOKEN-AQUI",
	"dataini": "2023-02-01",
	"horaini": "00:01",
	"datafim": "2023-08-30",
	"horafim": "23:59"
});

const options = {
	hostname: 'api.mailgrid.net.br',
	path: '/consolidate/',
	method: 'POST',
	headers: {
		'Content-Type': 'application/json',
		'Content-Length': data.length
	}
};

const req = https.request(options, (res) => {
	let responseData = '';

	res.on('data', (chunk) => {
		responseData += chunk;
	});

	res.on('end', () => {
		try {
			const parsedResponse = JSON.parse(responseData);
			if (res.statusCode === 200) {
				console.log("Resposta da API:");
				console.log(JSON.stringify(parsedResponse, null, 2));
			} else {
				console.log(`Erro na requisição. Código de status HTTP: ${res.statusCode}`);
			}
		} catch (error) {
			console.log("Erro ao processar a resposta JSON:", error.message);
		}
	});
});

req.on('error', (error) => {
	console.error("Erro na requisição:", error.message);
});

req.write(data);
req.end();

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.mailgrid.net.br/consolidate/")

data = {
	"token_auth" => "INFORME-O-TOKEN-AQUI",
	"dataini" => "2023-02-01",
	"horaini" => "00:01",
	"datafim" => "2023-08-30",
	"horafim" => "23:59"
}

http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json

response = http.request(request)

if response.code.to_i != 200
	puts "Erro na requisição. Código de status HTTP: #{response.code}"
else
	begin
	decoded_response = JSON.parse(response.body)
	puts "Resposta da API:"
	puts JSON.pretty_generate(decoded_response)
	rescue JSON::ParserError
	puts "Erro ao processar a resposta JSON."
	end
end

const axios = require('axios');

const url = "https://api.mailgrid.net.br/consolidate/";

const data = {
	"token_auth": "INFORME-O-TOKEN-AQUI",
	"dataini": "2023-02-01",
	"horaini": "00:01",
	"datafim": "2023-08-30",
	"horafim": "23:59"
};

const config = {
	headers: {
		'Content-Type': 'application/json'
	}
};

axios.post(url, data, config)
	.then((response) => {
		console.log("Resposta da API:");
		console.log(JSON.stringify(response.data, null, 2));
	})
	.catch((error) => {
		if (error.response) {
			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) {
			console.log("Erro na requisição. Sem resposta do servidor:", error.request);
		} else {
			console.log("Erro ao configurar a requisição:", error.message);
		}
	});

import requests
import json

url = "https://api.mailgrid.net.br/domain/add/"

data = {
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaseradicionado.net.br"
}

headers = {
	"Content-Type": "application/json"
}

try:
	response = requests.post(url, headers=headers, json=data, timeout=30)

	if response.status_code >= 400:
		print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
	else:
		try:
			decoded_response = response.json()
			print("Resposta da API:")
			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:
	print(f"Erro na requisição: {e}")

URL="https://api.mailgrid.net.br/domain/add/"

TOKEN_AUTH="SEU_TOKEN_AQUI"
DOMINIO="dominioaseradicionado.net.br"

DATA="{\"token_auth\":\"$TOKEN_AUTH\", \"dominio\":\"$DOMINIO\"}"

curl -X POST "$URL" \
	-H "Content-Type: application/json" \
	-d "$DATA" \
	--timeout 30 \
	--ssl-verify

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
	private static string url = "https://api.mailgrid.net.br/domain/add/";

	static async Task Main(string[] args)
	{
		var data = new
		{
			token_auth = "SEU_TOKEN_AQUI",
			dominio = "dominioaseradicionado.net.br"
		};

		using (var client = new HttpClient())
		{
			client.DefaultRequestHeaders.Add("Content-Type", "application/json");

			var jsonData = JsonConvert.SerializeObject(data);
			var content = new StringContent(jsonData, Encoding.UTF8, "application/json");

			try
			{
				HttpResponseMessage response = await client.PostAsync(url, content);

				int statusCode = (int)response.StatusCode;
				Console.WriteLine($"Código de status: {statusCode}");

				if (response.IsSuccessStatusCode)
				{
					string responseBody = await response.Content.ReadAsStringAsync();
					var decodedResponse = JsonConvert.DeserializeObject(responseBody);
					Console.WriteLine("Resposta da API:");
					string formattedResponse =
					JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
					Console.WriteLine(formattedResponse);
				}
				else
				{
					Console.WriteLine($"Erro na requisição. Código de status: {statusCode}");
				}
			}
			catch (Exception ex)
			{
				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 mailgridApiExample {
	public static void main(String[] args) {
		String url = "https://api.mailgrid.net.br/domain/add/";

		String tokenAuth = "SEU_TOKEN_AQUI";
		String dominio = "dominioaseradicionado.net.br";

		String jsonInputString = "{"
				+ "\"token_auth\": \"" + tokenAuth + "\","
				+ "\"dominio\": \"" + dominio + "\""
				+ "}";

		try {
			URL urlObj = new URL(url);
			HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
			connection.setRequestMethod("POST");

			connection.setRequestProperty("Content-Type", "application/json");
			connection.setDoOutput(true);

			try (OutputStream os = connection.getOutputStream()) {
				byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
				os.write(input, 0, input.length);
			}

			int statusCode = connection.getResponseCode();

			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);
				}

				if (statusCode >= 200 && statusCode < 300) {
					System.out.println("Resposta da API: ");
					System.out.println(response.toString());
				} else {
					System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
				}
			}
		} catch (IOException e) {
			System.out.println("Erro na requisição: " + e.getMessage());
		}
	}
}

const https = require('https');

const url = "https://api.mailgrid.net.br/domain/add/";

const data = JSON.stringify({
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaseradicionado.net.br"
});

const options = {
	hostname: 'api.mailgrid.net.br',
	path: '/domain/add/',
	method: 'POST',
	headers: {
		'Content-Type': 'application/json',
		'Content-Length': data.length
	}
};

const req = https.request(options, (res) => {
	let responseData = '';

	res.on('data', (chunk) => {
		responseData += chunk;
	});

	res.on('end', () => {
		try {
			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);
		}
	});
});

req.on('error', (error) => {
	console.error("Erro na requisição:", error.message);
});

req.write(data);
req.end();

require 'net/http'
require 'json'
require 'uri'

url = URI.parse("https://api.mailgrid.net.br/domain/add/")

data = {
	"token_auth" => "SEU_TOKEN_AQUI",
	"dominio" => "dominioaseradicionado.net.br"
}

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json

http.read_timeout = 30

begin
	response = http.request(request)

	if response.code.to_i >= 400
	puts "Erro na requisição. Código de status HTTP: #{response.code}"
	else
	parsed_response = JSON.parse(response.body)

	if parsed_response.is_a?(Hash)
		puts "Resposta da API:"
		puts JSON.pretty_generate(parsed_response)
	else
		puts "Erro ao processar a resposta JSON."
	end
	end
rescue StandardError => e
	puts "Erro na requisição: #{e.message}"
end

const axios = require('axios');

const url = "https://api.mailgrid.net.br/domain/add/";

const data = {
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaseradicionado.net.br"
};

const config = {
	headers: {
		'Content-Type': 'application/json'
	}
};

axios.post(url, data, config)
	.then((response) => {
		console.log("Resposta da API:");
		console.log(JSON.stringify(response.data, null, 2));
	})
	.catch((error) => {
		if (error.response) {
			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) {
			console.log("Erro na requisição. Sem resposta do servidor:", error.request);
		} else {
			console.log("Erro ao configurar a requisição:", error.message);
		}
	});

import requests
import json

url = "https://api.mailgrid.net.br/domain/remove/"

data = {
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaseremovido.net.br"
}

headers = {
	"Content-Type": "application/json"
}

try:
	response = requests.post(url, headers=headers, json=data, timeout=30)
	if response.status_code >= 400:
		print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
	else:
		try:
			decoded_response = response.json()
			print("Resposta da API:")
			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:
	print(f"Erro na requisição: {e}")

URL="https://api.mailgrid.net.br/domain/remove/"

TOKEN_AUTH="SEU_TOKEN_AQUI"
DOMINIO="dominioaseremovido.net.br"

DATA="{\"token_auth\":\"$TOKEN_AUTH\", \"dominio\":\"$DOMINIO\"}"

curl -X POST "$URL" \
	-H "Content-Type: application/json" \
	-d "$DATA" \
	--timeout 30 \
	--ssl-verify

import requests
import json

url = "https://api.mailgrid.net.br/domain/check/"

data = {
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaserchecado.net.br"
}

headers = {
	"Content-Type": "application/json"
}

try:
	response = requests.post(url, headers=headers, json=data, timeout=30)

	if response.status_code >= 400:
		print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
	else:
		try:
			decoded_response = response.json()
			print("Resposta da API:")
			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:
	print(f"Erro na requisição: {e}")

URL="https://api.mailgrid.net.br/domain/check/"

TOKEN_AUTH="SEU_TOKEN_AQUI"
DOMINIO="dominioaserchecado.net.br"

DATA="{\"token_auth\":\"$TOKEN_AUTH\", \"dominio\":\"$DOMINIO\"}"

curl -X POST "$URL" \
	-H "Content-Type: application/json" \
	-d "$DATA" \
	--timeout 30 \
	--ssl-verify

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
	private static string url = "https://api.mailgrid.net.br/domain/check/";

	static async Task Main(string[] args)
	{
		var data = new
		{
			token_auth = "SEU_TOKEN_AQUI",
			dominio = "dominioaserchecado.net.br"
		};

		using (var client = new HttpClient())
		{
			client.DefaultRequestHeaders.Add("Content-Type", "application/json");

			var jsonData = JsonConvert.SerializeObject(data);
			var content = new StringContent(jsonData, Encoding.UTF8, "application/json");

			try
			{
				HttpResponseMessage response = await client.PostAsync(url, content);

				int statusCode = (int)response.StatusCode;
				Console.WriteLine($"Código de status: {statusCode}");

				if (response.IsSuccessStatusCode)
				{
					string responseBody = await response.Content.ReadAsStringAsync();
					var decodedResponse = JsonConvert.DeserializeObject(responseBody);
					Console.WriteLine("Resposta da API:");
					string formattedResponse =
					JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
					Console.WriteLine(formattedResponse);
				}
				else
				{
					Console.WriteLine($"Erro na requisição. Código de status: {statusCode}");
				}
			}
			catch (Exception ex)
			{
				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 mailgridDomainCheck {
	public static void main(String[] args) {
		String url = "https://api.mailgrid.net.br/domain/check/";

		String tokenAuth = "SEU_TOKEN_AQUI";
		String dominio = "dominioaserchecado.net.br";

		String jsonInputString = "{"
				+ "\"token_auth\": \"" + tokenAuth + "\","
				+ "\"dominio\": \"" + dominio + "\""
				+ "}";

		try {
			URL urlObj = new URL(url);
			HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
			connection.setRequestMethod("POST");

			connection.setRequestProperty("Content-Type", "application/json");
			connection.setDoOutput(true);

			try (OutputStream os = connection.getOutputStream()) {
				byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
				os.write(input, 0, input.length);
			}

			int statusCode = connection.getResponseCode();

			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);
				}

				if (statusCode >= 200 && statusCode < 300) {
					System.out.println("Resposta da API: ");
					System.out.println(response.toString());
				} else {
					System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
				}
			}
		} catch (IOException e) {
			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');

const url = "https://api.mailgrid.net.br/domain/check/";

const data = JSON.stringify({
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaserchecado.net.br"
});

const options = {
	hostname: 'api.mailgrid.net.br',
	path: '/domain/check/',
	method: 'POST',
	headers: {
		'Content-Type': 'application/json',
		'Content-Length': data.length
	}
};

const req = https.request(options, (res) => {
	let responseData = '';

	res.on('data', (chunk) => {
		responseData += chunk;
	});

	res.on('end', () => {
		try {
			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);
		}
	});
});

req.on('error', (error) => {
	console.error("Erro na requisição:", error.message);
});

req.write(data);
req.end();

require 'net/http'
require 'json'
require 'uri'

url = URI.parse("https://api.mailgrid.net.br/domain/check/")

data = {
	"token_auth" => "SEU_TOKEN_AQUI",
	"dominio" => "dominioaserchecado.net.br"
}

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json

http.read_timeout = 30

begin
	response = http.request(request)

	if response.code.to_i >= 400
	puts "Erro na requisição. Código de status HTTP: #{response.code}"
	else
	parsed_response = JSON.parse(response.body)

	if parsed_response.is_a?(Hash)
		puts "Resposta da API:"
		puts JSON.pretty_generate(parsed_response)
	else
		puts "Erro ao processar a resposta JSON."
	end
	end
rescue StandardError => e
	puts "Erro na requisição: #{e.message}"
end

const axios = require('axios');

const url = "https://api.mailgrid.net.br/domain/check/";

const data = {
	"token_auth": "SEU_TOKEN_AQUI",
	"dominio": "dominioaserchecado.net.br"
};

const config = {
	headers: {
		'Content-Type': 'application/json'
	}
};

axios.post(url, data, config)
 .then((response) => {
	console.log("Resposta da API:");
	console.log(JSON.stringify(response.data, null, 2));
 })
 .catch((error) => {
	if (error.response) {
		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) {
		console.log("Erro na requisição. Sem resposta do servidor:", error.request);
	} else {
		console.log("Erro ao configurar a requisição:", error.message);
	}
});

import requests
import json

url = "https://api.mailgrid.net.br/domain/list/"

data = {
	"token_auth": "SEU_TOKEN_AQUI"
}

headers = {
	"Content-Type": "application/json"
}

try:
	response = requests.post(url, headers=headers, json=data, timeout=30)

	if response.status_code >= 400:
		print(f"Erro na requisição. Código de status HTTP: {response.status_code}")
	else:
		try:
			decoded_response = response.json()
			print("Resposta da API:")
			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:
	print(f"Erro na requisição: {e}")

URL="https://api.mailgrid.net.br/domain/list/"

TOKEN_AUTH="SEU_TOKEN_AQUI"

DATA="{\"token_auth\":\"$TOKEN_AUTH\"}"

curl -X POST "$URL" \
	-H "Content-Type: application/json" \
	-d "$DATA" \
	--timeout 30 \
	--ssl-verify

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
	private static string url = "https://api.mailgrid.net.br/domain/list/";

	static async Task Main(string[] args)
	{
		var data = new
		{
			token_auth = "SEU_TOKEN_AQUI"
		};

		using (var client = new HttpClient())
		{
			client.DefaultRequestHeaders.Add("Content-Type", "application/json");

			var jsonData = JsonConvert.SerializeObject(data);
			var content = new StringContent(jsonData, Encoding.UTF8, "application/json");

			try
			{
				HttpResponseMessage response = await client.PostAsync(url, content);

				int statusCode = (int)response.StatusCode;
				Console.WriteLine($"Código de status: {statusCode}");

				if (response.IsSuccessStatusCode)
				{
					string responseBody = await response.Content.ReadAsStringAsync();
					var decodedResponse = JsonConvert.DeserializeObject(responseBody);
					Console.WriteLine("Resposta da API:");
					string formattedResponse =
					JsonConvert.SerializeObject(decodedResponse, Formatting.Indented);
					Console.WriteLine(formattedResponse);
				}
				else
				{
					Console.WriteLine($"Erro na requisição. Código de status HTTP: {statusCode}");
				}
			}
			catch (Exception ex)
			{
				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 mailgridDomainList {
	public static void main(String[] args) {
		String url = "https://api.mailgrid.net.br/domain/list/";

		String tokenAuth = "SEU_TOKEN_AQUI";

		String jsonInputString = "{"
				+ "\"token_auth\": \"" + tokenAuth + "\""
				+ "}";

		try {
			URL urlObj = new URL(url);
			HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
			connection.setRequestMethod("POST");

			connection.setRequestProperty("Content-Type", "application/json");
			connection.setDoOutput(true);

			try (OutputStream os = connection.getOutputStream()) {
				byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
				os.write(input, 0, input.length);
			}

			int statusCode = connection.getResponseCode();

			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);
				}

				if (statusCode >= 200 && statusCode < 300) {
					System.out.println("Resposta da API: ");
					System.out.println(response.toString());
				} else {
					System.out.println("Erro na requisição. Código de status HTTP: " + statusCode);
				}
			}
		} catch (IOException e) {
			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');

const url = "https://api.mailgrid.net.br/domain/list/";

const data = JSON.stringify({
	"token_auth": "SEU_TOKEN_AQUI"
});

const options = {
	hostname: 'api.mailgrid.net.br',
	path: '/domain/list/',
	method: 'POST',
	headers: {
		'Content-Type': 'application/json',
		'Content-Length': data.length
	}
};

const req = https.request(options, (res) => {
	let responseData = '';

	res.on('data', (chunk) => {
		responseData += chunk;
	});

	res.on('end', () => {
		try {
			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);
		}
	});
});

req.on('error', (error) => {
	console.error("Erro na requisição:", error.message);
});

req.write(data);
req.end();

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.mailgrid.net.br/domain/list/")

data = {
	"token_auth" => "SEU_TOKEN_AQUI"
}

http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Post.new(url.path, {'Content-Type' => 'application/json'})
request.body = data.to_json

response = http.request(request)

if response.code.to_i >= 400
	puts "Erro na requisição. Código de status HTTP: #{response.code}"
else
	begin
	decoded_response = JSON.parse(response.body)
	puts "Resposta da API:"
	puts JSON.pretty_generate(decoded_response)
	rescue JSON::ParserError
	puts "Erro ao processar a resposta JSON."
	end
end

const axios = require('axios');

const url = "https://api.mailgrid.net.br/domain/list/";

const data = {
	"token_auth": "SEU_TOKEN_AQUI"
};

const config = {
	headers: {
		'Content-Type': 'application/json'
	}
};

axios.post(url, data, config)
	.then((response) => {
		console.log("Resposta da API:");
		console.log(JSON.stringify(response.data, null, 2));
	})
	.catch((error) => {
		if (error.response) {
			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) {
			console.log("Erro na requisição. Sem resposta do servidor:", error.request);
		} else {
			console.log("Erro ao configurar a requisição:", error.message);
		}
	});