Crear Dominio

Crea un dominio a través de la API de Emailit.

POST/domains

Cuerpo de la Solicitud

namestringRequired

El nombre del dominio, en el formato mail.tudominio.com.

track_loadsboolean

Si se debe hacer seguimiento de las aperturas de correo para este dominio (por defecto: false).

track_clicksboolean

Si se debe hacer seguimiento de los clics en correos para este dominio (por defecto: false).

const response = await fetch('https://api.emailit.com/v2/domains', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
name: 'mail.tudominio.com',
track_loads: false,
track_clicks: false
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => json_encode([
'name' => 'mail.tudominio.com',
'track_loads' => false,
'track_clicks' => false
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Error cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/domains',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'name': 'mail.tudominio.com',
    'track_loads': False,
    'track_clicks': False
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
name: 'mail.tudominio.com',
track_loads: false,
track_clicks: false
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/domains"

data := map[string]interface{}{
    "name": "mail.tudominio.com",
    "track_loads": false,
    "track_clicks": false,
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/domains")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "name": "mail.tudominio.com",
        "track_loads": false,
        "track_clicks": false
    }))
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class CrearDominio {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"name\":\"mail.tudominio.com\",\"track_loads\":false,\"track_clicks\":false}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(jsonBody))
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

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

public class CrearDominio
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { name = "mail.tudominio.com", track_loads = false, track_clicks = false };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/domains", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/domains \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"name": "mail.tudominio.com",
"track_loads": false,
"track_clicks": false
}'

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.tudominio.com",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": null,
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": null,
"spf_status": null,
"spf_error": null,
"dkim_status": null,
"dkim_error": null,
"mx_status": null,
"mx_error": null,
"return_path_status": null,
"return_path_error": null,
"dmarc_status": null,
"dmarc_error": null,
"tracking_status": null,
"tracking_error": null,
"inbound_status": null,
"inbound_error": null,
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T00:00:00Z"
}

{
"error": {
"code": 400,
"message": "Solicitud Incorrecta"
}
}

{
"error": {
"code": 409,
"message": "El dominio ya existe"
},
"existing": {
"object": "domain",
"id": 1234567890,
"name": "mail.tudominio.com"
}
}

Obtener Dominio

Consulta la información de un dominio específico en tu cuenta de Emailit.

GET/domains/{id}

Parámetros de Ruta

idstringRequired

El ID del dominio que deseas consultar.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains/sd_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Error cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/domains/sd_1234567890',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains/sd_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/domains/sd_1234567890"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/domains/sd_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetDomain {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains/sd_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetDomain
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/domains/sd_1234567890");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET https://api.emailit.com/v2/domains/sd_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.tudominio.com",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": "2021-01-01T12:00:00Z",
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "ok",
"spf_error": null,
"dkim_status": "ok",
"dkim_error": null,
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "ok",
"dmarc_error": null,
"tracking_status": "ok",
"tracking_error": null,
"inbound_status": "ok",
"inbound_error": null,
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T00:00:00Z"
}

{
"error": {
"code": 401,
"message": "No autorizado"
}
}

{
"error": {
"code": 404,
"message": "Dominio no encontrado"
}
}

Verificar Dominio

Verifica que los registros DNS requeridos hayan sido configurados correctamente para un dominio. Este endpoint revisa todos los registros DNS (MX, SPF, DKIM y DMARC) y actualiza el estado de verificación del dominio.

POST/domains/{id}/verify

Parámetros de Ruta

idstringRequired

El ID del dominio a verificar.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890/verify', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains/sd_1234567890/verify',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Error cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/domains/sd_1234567890/verify',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains/sd_1234567890/verify')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

curl -X POST https://api.emailit.com/v2/domains/sd_1234567890/verify \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.tudominio.com",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": "2021-01-01T12:00:00Z",
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "ok",
"spf_error": null,
"dkim_status": "ok",
"dkim_error": null,
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "ok",
"dmarc_error": null,
"tracking_status": "ok",
"tracking_error": null,
"inbound_status": "ok",
"inbound_error": null,
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC+hb3/Ew7dLpCYVAThs29xMy2aWDPhhdMarieUn/N6x8DOaMar3BQV3ilzUb5F+axVxSYisd6mw9FGuZ48uD2KcOXBWjl5E1R5pYuB13KuVwXUwyzsEeYsGE6kYIpu7Rxn3wQvcGhCrx3RK30Hyw0yNpAcpUtmo+wbIYkJutOquwIDAQAB;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.tudominio.com",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": null,
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "failed",
"spf_error": "Registro SPF no encontrado",
"dkim_status": "failed",
"dkim_error": "Registro DKIM no encontrado",
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "pending",
"dmarc_error": null,
"tracking_status": "missing",
"tracking_error": "No hay registros CNAME en tr.tudominio.com",
"inbound_status": "missing",
"inbound_error": "No hay registros MX en inbound.tudominio.com",
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "failed",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": "Registro SPF no encontrado"
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tudominio.com",
  "ttl": "auto",
  "status": "failed",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA....",
  "priority": null,
  "error": "Registro DKIM no encontrado"
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tudominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tudominio.com",
  "ttl": "auto",
  "status": "missing",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": "No hay registros CNAME en tr.tudominio.com"
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tudominio.com",
  "ttl": "auto",
  "status": "missing",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": "No hay registros MX en inbound.tudominio.com"
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 401,
"message": "No autorizado"
}
}

{
"error": {
"code": 404,
"message": "Dominio no encontrado"
}
}

Estado de Registros DNS

El array dns_records contiene información detallada sobre cada registro DNS requerido para el dominio:

Campo	Tipo	Descripción
`required`	boolean	Si este registro DNS es obligatorio para la verificación
`type`	string	Tipo de registro DNS (MX, TXT, CNAME)
`name`	string	El nombre de host para el registro DNS
`ttl`	string	Tiempo de vida del registro DNS
`status`	string	Estado de verificación: `ok`, `pending`, `failed`, `missing`
`value`	string	El valor que debe configurarse para este registro DNS
`priority`	number/null	Prioridad para registros MX, null para otros
`error`	string/null	Mensaje de error si la verificación falló

Proceso de Verificación

El endpoint revisa todos los registros DNS obligatorios (MX, SPF, DKIM)
También se verifica el registro DMARC opcional, pero no es requerido para la verificación
El dominio se considera verificado solo cuando todos los registros obligatorios pasan la validación
La marca de tiempo verified_at se establece cuando todas las verificaciones obligatorias son exitosas
Los estados individuales de cada registro se almacenan en el array dns_records

Actualizar Dominio

Actualiza un dominio existente en tu cuenta de Emailit.

POST/domains/{id}

Parámetros de Ruta

idstringRequired

El ID del dominio a actualizar.

Cuerpo de la Solicitud

track_loadsboolean

Si se debe rastrear la apertura de correos para este dominio (true/false).

track_clicksboolean

Si se debe rastrear los clics en correos para este dominio (true/false).

tracking_keystring

Clave de subdominio personalizada para el registro CNAME de seguimiento (por defecto: null). Cuando se establece, el CNAME de seguimiento utilizará este valor en lugar del predeterminado go.

inbound_keystring

Clave de subdominio personalizada para el registro MX de entrada (por defecto: null). Cuando se establece, el MX de entrada utilizará este valor en lugar del predeterminado inbound.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890', {
method: 'PATCH',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
track_loads: true,
track_clicks: false
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains/sd_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'PATCH',
CURLOPT_POSTFIELDS => json_encode([
'track_loads' => true,
'track_clicks' => false
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Error cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.patch(
'https://api.emailit.com/v2/domains/sd_1234567890',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'track_loads': True,
    'track_clicks': False
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains/sd_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
track_loads: true,
track_clicks: false
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/domains/sd_1234567890"

data := map[string]interface{}{
    "track_loads": true,
    "track_clicks": false,
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("PATCH", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .patch("https://api.emailit.com/v2/domains/sd_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "track_loads": true,
        "track_clicks": false
    }))
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class UpdateDomain {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"track_loads\":true,\"track_clicks\":false}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains/sd_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .method("PATCH", BodyPublishers.ofString(jsonBody))
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

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

public class UpdateDomain
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { track_loads = true, track_clicks = false };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var request = new HttpRequestMessage(new HttpMethod("PATCH"), 
            "https://api.emailit.com/v2/domains/sd_1234567890")
        {
            Content = content
        };
        
        var response = await client.SendAsync(request);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X PATCH https://api.emailit.com/v2/domains/sd_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"track_loads": true,
"track_clicks": false
}'

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.tudominio.com",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": "2021-01-01T12:00:00Z",
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "ok",
"spf_error": null,
"dkim_status": "ok",
"dkim_error": null,
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "ok",
"dmarc_error": null,
"tracking_status": "ok",
"tracking_error": null,
"inbound_status": "ok",
"inbound_error": null,
"track_loads": 1,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "go.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tudominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 400,
"message": "Solicitud Incorrecta"
}
}

{
"error": {
"code": 404,
"message": "Dominio no encontrado"
}
}

{
"error": {
"code": 409,
"message": "Conflicto"
}
}

Listar Dominios

Obtén una lista de todos los dominios en tu cuenta de Emailit.

GET/domains

Parámetros de Consulta

pageinteger

Número de página para la paginación (mínimo: 1).

limitinteger

Cantidad de dominios a devolver (mínimo: 1, máximo: 100).

const response = await fetch('https://api.emailit.com/v2/domains?page=1&limit=10', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains?page=1&limit=10',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Error cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/domains',
params={
    'page': 1,
    'limit': 10
},
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains?page=1&limit=10')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"encoding/json"
"fmt"
"net/http"
"net/url"
)

func main() {
baseURL := "https://api.emailit.com/v2/domains"
params := url.Values{}
params.Add("page", "1")
params.Add("limit", "10")

fullURL := baseURL + "?" + params.Encode()

req, _ := http.NewRequest("GET", fullURL, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/domains")
    .query(&[("page", "1"), ("limit", "10")])
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class ListDomains {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains?page=1&limit=10"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ListDomains
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/domains?page=1&limit=10");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET "https://api.emailit.com/v2/domains?page=1&limit=10" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"data": [
{
  "id": 1234567890,
  "uuid": "sd_1234567890",
  "name": "mail.tudominio.com",
  "track_loads": true,
  "track_clicks": true,
  "created_at": "2021-01-01T00:00:00Z",
  "updated_at": "2021-01-01T00:00:00Z"
},
{
  "id": 987654321,
  "uuid": "sd_0987654321",
  "name": "mail2.tudominio.com",
  "track_loads": true,
  "track_clicks": true,
  "created_at": "2021-01-02T00:00:00Z",
  "updated_at": "2021-01-02T00:00:00Z"
}
],
"next_page_url": "https://api.emailit.com/v2/domains?page=2&limit=10",
"previous_page_url": null
}

{
"error": {
"code": 401,
"message": "No autorizado"
}
}

Eliminar Dominio

Elimina un dominio de tu cuenta de Emailit.

DELETE/domains/{id}

Parámetros de Ruta

idstringRequired

El ID del dominio a eliminar.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890', {
method: 'DELETE',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains/sd_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'DELETE',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Error cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.delete(
'https://api.emailit.com/v2/domains/sd_1234567890',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains/sd_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/domains/sd_1234567890"

req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

fmt.Println("Estado:", resp.Status)
}

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .delete("https://api.emailit.com/v2/domains/sd_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

println!("Estado: {}", response.status());

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class DeleteDomain {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains/sd_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .DELETE()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println("Estado: " + response.statusCode());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class DeleteDomain
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.DeleteAsync(
            "https://api.emailit.com/v2/domains/sd_1234567890");
        
        Console.WriteLine("Estado: " + response.StatusCode);
    }
}
}

curl -X DELETE https://api.emailit.com/v2/domains/sd_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "domain",
"id": 1234567890,
"name": "mail.tudominio.com",
"deleted": true
}

{
"error": {
"code": 404,
"message": "Dominio no encontrado"
}
}

Crear Dominio

Cuerpo de la Solicitud

Obtener Dominio

Parámetros de Ruta

Verificar Dominio

Parámetros de Ruta

Estado de Registros DNS

Proceso de Verificación

Actualizar Dominio

Parámetros de Ruta

Cuerpo de la Solicitud

Listar Dominios

Parámetros de Consulta

Eliminar Dominio

Parámetros de Ruta

Localizado por IA