Invia Email

Invia una singola email a uno o più destinatari. Supporta template, variabili, allegati, programmazione e tracciamento.

POST /emails

## Header

Authorization string Required

Token Bearer per l’autenticazione.

Idempotency-Key string

Chiave univoca (max 256 caratteri, alfanumerici/trattini/underscore) per prevenire invii duplicati per 24 ore.

## Corpo della Richiesta

from string Required

Email del mittente in formato RFC: email@dominio.com o Nome Visualizzato <email@dominio.com>.

to string | string[] Required

Indirizzo/i email del destinatario. Massimo 50 destinatari.

subject string

Oggetto dell’email. Obbligatorio a meno che non sia fornito dal template.

html string

Contenuto HTML dell’email. Obbligatorio a meno che non sia fornito dal template o sia presente il testo.

text string

Contenuto in testo semplice dell’email.

reply_to string | string[]

Indirizzo/i email per la risposta.

cc string | string[]

Destinatari in copia conoscenza. Massimo 50 destinatari.

bcc string | string[]

Destinatari in copia nascosta. Massimo 50 destinatari.

template string

Alias o ID del template (formato tem_xxx).

variables object

Variabili per la sostituzione nel template usando la sintassi {{variabile}}.

attachments array

Array di oggetti allegato (vedi Oggetto Allegato di seguito).

headers object

Header email personalizzati come coppie chiave-valore.

meta object

Metadati come coppie chiave-valore stringa. Memorizzati e restituiti con l’email.

scheduled_at string

Orario di invio programmato. Accetta ISO 8601, timestamp Unix, o linguaggio naturale come domani alle 9.

tracking boolean | object

Sovrascrive le impostazioni di tracciamento predefinite del dominio. Può essere un booleano o un oggetto con proprietà loads e clicks.

## Oggetto Allegato

filename string Required

Nome del file con estensione.

content string

Contenuto codificato in Base64. Mutuamente esclusivo con url.

url string

URL da cui recuperare l’allegato. Mutuamente esclusivo con content.

content_type string

Tipo MIME. Obbligatorio quando si usa content.

content_id string

Content-ID per immagini inline (cid:).

encoding string

Codifica del contenuto (predefinito: base64).

## Tipi di File Allegato Consentiti

Categoria	Estensioni
Testo	`.txt`, `.csv`, `.log`, `.css`, `.ics`, `.xml`
Immagini	`.jpg`, `.jpe`, `.jpeg`, `.gif`, `.png`, `.bmp`, `.psd`, `.tif`, `.tiff`, `.svg`, `.indd`, `.ai`, `.eps`
Documenti	`.doc`, `.docx`, `.rtf`, `.odt`, `.ott`, `.pdf`, `.pub`, `.pages`, `.mobi`, `.epub`
Audio	`.mp3`, `.m4a`, `.m4v`, `.wma`, `.ogg`, `.flac`, `.wav`, `.aif`, `.aifc`, `.aiff`
Video	`.mp4`, `.mov`, `.avi`, `.mkv`, `.mpeg`, `.mpg`, `.wmv`
Fogli di calcolo	`.xls`, `.xlsx`, `.ods`, `.numbers`
Presentazioni	`.odp`, `.ppt`, `.pptx`, `.pps`, `.key`
Archivi	`.zip`, `.vcf`
Email	`.eml`
Crittografici	`.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig`

Header Limite di Velocità

I seguenti header sono inclusi in ogni risposta:

Header	Descrizione
ratelimit-limit	Richieste massime per secondo
ratelimit-remaining	Richieste rimanenti nel secondo corrente
ratelimit-reset	Secondi fino al reset del limite di velocità
ratelimit-daily-limit	Richieste giornaliere massime
ratelimit-daily-remaining	Richieste giornaliere rimanenti
ratelimit-daily-reset	Secondi fino al reset del limite giornaliero

::code-snippet{title=“Invia email”}

const response = await fetch('https://api.emailit.com/v2/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    from: 'La Tua Azienda <hello@tuodominio.com>',
    to: ['destinatario1@esempio.com', 'destinatario2@esempio.com'],
    subject: 'Ciao Mondo',
    html: '<h1>Benvenuto!</h1><p>Grazie per esserti registrato.</p>',
    tracking: {
      loads: true,
      clicks: true
    }
  })
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => 'https://api.emailit.com/v2/emails',
  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([
    'from' => 'La Tua Azienda <hello@tuodominio.com>',
    'to' => ['destinatario1@esempio.com', 'destinatario2@esempio.com'],
    'subject' => 'Ciao Mondo',
    'html' => '<h1>Benvenuto!</h1><p>Grazie per esserti registrato.</p>',
    'tracking' => [
      'loads' => true,
      'clicks' => true
    ]
  ]),
  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 "Errore cURL #:" . $err;
} else {
  $result = json_decode($response, true);
  print_r($result);
}

import requests

response = requests.post(
    'https://api.emailit.com/v2/emails',
    headers={
        'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
        'Content-Type': 'application/json'
    },
    json={
        'from': 'La Tua Azienda <hello@tuodominio.com>',
        'to': ['destinatario1@esempio.com', 'destinatario2@esempio.com'],
        'subject': 'Ciao Mondo',
        'html': '<h1>Benvenuto!</h1><p>Grazie per esserti registrato.</p>',
        'tracking': {
            'loads': True,
            'clicks': True
        }
    }
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails')
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 = {
  from: 'La Tua Azienda <hello@tuodominio.com>',
  to: ['destinatario1@esempio.com', 'destinatario2@esempio.com'],
  subject: 'Ciao Mondo',
  html: '<h1>Benvenuto!</h1><p>Grazie per esserti registrato.</p>',
  tracking: {
    loads: true,
    clicks: true
  }
}.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/emails"
    
    data := map[string]interface{}{
        "from": "La Tua Azienda <hello@tuodominio.com>",
        "to": []string{"destinatario1@esempio.com", "destinatario2@esempio.com"},
        "subject": "Ciao Mondo",
        "html": "<h1>Benvenuto!</h1><p>Grazie per esserti registrato.</p>",
        "tracking": map[string]bool{
            "loads": true,
            "clicks": true,
        },
    }
    
    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]

Elenco Email

Visualizza le email nel tuo workspace con paginazione e filtri opzionali per tipologia.

GET/emails

Parametri di Query

pageinteger

Numero di pagina. Minimo: 1. Predefinito: 1.

limitinteger

Numero di risultati per pagina. Intervallo: 1–100. Predefinito: 10.

typestring

Filtra per tipologia di email: inbound o outbound.

const response = await fetch('https://api.emailit.com/v2/emails?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/emails?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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/emails',
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/emails?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"
)

func main() {
url := "https://api.emailit.com/v2/emails?page=1&limit=10"

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/emails?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 ListEmails {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails?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 ListEmails
{
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/emails?page=1&limit=10");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

{
"data": [
{
  "object": "email",
  "id": "em_abc123xyz789def456ghi012jkl345",
  "type": "outbound",
  "from": "mittente@tuodominio.com",
  "to": "destinatario@esempio.com",
  "subject": "Ciao Mondo",
  "status": "delivered",
  "size": 4523,
  "scheduled_at": null,
  "created_at": "2026-01-08T12:00:00.123456Z",
  "updated_at": "2026-01-08T12:01:00.123456Z",
  "meta": null
},
{
  "object": "email",
  "id": "em_def456ghi789jkl012mno345pqr678",
  "type": "inbound",
  "from": "esterno@altrodominio.com",
  "to": "casella@tuodominio.com",
  "subject": "Re: La tua richiesta",
  "status": "delivered",
  "size": 2891,
  "scheduled_at": null,
  "created_at": "2026-01-08T11:30:00.123456Z",
  "updated_at": "2026-01-08T11:30:00.123456Z",
  "meta": null
}
],
"next_page_url": "/v2/emails?page=2&limit=10",
"previous_page_url": null
}

Recupera Email

Recupera una singola email tramite il suo ID, inclusi header, contenuto del corpo analizzato e allegati.

GET/emails/{id}

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456', {
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/emails/em_abc123xyz789def456',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
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/emails/em_abc123xyz789def456')
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/emails/em_abc123xyz789def456"

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/emails/em_abc123xyz789def456")
    .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 GetEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456"))
        .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 GetEmail
{
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/emails/em_abc123xyz789def456");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

Campi della Risposta

Campo	Tipo	Descrizione
`object`	string	Sempre `"email"`
`id`	string	ID dell’email nel formato `em_xxx`
`type`	string	`"inbound"` o `"outbound"`
`token`	string	Token dell’email
`message_id`	string	Message-ID SMTP
`from`	string	Indirizzo email del mittente
`to`	string	Indirizzo email del destinatario
`subject`	string	Oggetto dell’email
`status`	string	Stato attuale dell’email
`size`	integer	Dimensione dell’email in byte
`scheduled_at`	string \| null	Orario di consegna programmato (ISO 8601)
`created_at`	string	Timestamp di creazione (ISO 8601)
`updated_at`	string	Timestamp dell’ultimo aggiornamento (ISO 8601)
`tracking`	object \| null	Impostazioni di tracciamento (omesso per email in entrata)
`meta`	object \| null	Metadati personalizzati
`headers`	object	Header dell’email analizzati
`body`	object	Corpo analizzato con campi `text` e `html`
`attachments`	array	Allegati analizzati con contenuto codificato in base64

Oggetto Body

Campo	Tipo	Descrizione
`text`	string \| null	Contenuto in testo semplice
`html`	string \| null	Contenuto HTML

Oggetto Attachment

Campo	Tipo	Descrizione
`filename`	string	Nome del file allegato
`content_type`	string	Tipo MIME
`size`	integer	Dimensione dell’allegato in byte
`content_id`	string \| null	Content-ID per allegati inline
`content_disposition`	string	`"attachment"` o `"inline"`
`content`	string	Contenuto dell’allegato codificato in base64

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@tuodominio.com>",
"from": "mittente@tuodominio.com",
"to": "destinatario@esempio.com",
"subject": "Ciao Mondo",
"status": "delivered",
"size": 12345,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": true
},
"meta": {
"campaign": "estate",
"type": "marketing"
},
"headers": {
"From": "mittente@tuodominio.com",
"To": "destinatario@esempio.com",
"Subject": "Ciao Mondo",
"Content-Type": "multipart/mixed; boundary=----boundary123"
},
"body": {
"text": "Benvenuto!",
"html": "<html><body><h1>Benvenuto!</h1></body></html>"
},
"attachments": [
{
  "filename": "documento.pdf",
  "content_type": "application/pdf",
  "size": 12345,
  "content_id": null,
  "content_disposition": "attachment",
  "content": "JVBERi0xLjQKJcOkw7zDqc..."
}
]
}

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "inbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@dominioesterno.com>",
"from": "esterno@dominioesterno.com",
"to": "casella@tuodominio.com",
"subject": "Re: La tua richiesta",
"status": "delivered",
"size": 8234,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"meta": null,
"headers": {
"From": "esterno@dominioesterno.com",
"To": "casella@tuodominio.com",
"Subject": "Re: La tua richiesta",
"Content-Type": "text/plain; charset=utf-8"
},
"body": {
"text": "Grazie per averci contattato...",
"html": null
},
"attachments": []
}

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@tuodominio.com>",
"from": "mittente@tuodominio.com",
"to": "destinatario@esempio.com",
"subject": "Promemoria Appuntamento",
"status": "scheduled",
"size": 8234,
"scheduled_at": "2026-01-10T15:00:00.000000Z",
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"tracking": {
"loads": true,
"clicks": true
},
"meta": null,
"headers": {
"From": "mittente@tuodominio.com",
"To": "destinatario@esempio.com",
"Subject": "Promemoria Appuntamento",
"Content-Type": "text/html; charset=utf-8"
},
"body": {
"text": "Promemoria Appuntamento...",
"html": "<html>..."
},
"attachments": []
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

Ottieni Email Raw

Restituisce la stringa completa del messaggio MIME raw insieme ai metadati dell’email.

GET/emails/{id}/raw

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw', {
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/emails/em_abc123xyz789def456/raw',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw',
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/emails/em_abc123xyz789def456/raw')
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/emails/em_abc123xyz789def456/raw"

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/emails/em_abc123xyz789def456/raw")
    .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 GetEmailRaw {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw"))
        .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 GetEmailRaw
{
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/emails/em_abc123xyz789def456/raw");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@yourdomain.com>",
"from": "mittente@tuodominio.com",
"to": "destinatario@esempio.com",
"subject": "Ciao Mondo",
"status": "delivered",
"size": 4523,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": false
},
"meta": null,
"headers": {
"From": "mittente@tuodominio.com",
"To": "destinatario@esempio.com",
"Subject": "Ciao Mondo",
"Content-Type": "text/html; charset=utf-8"
},
"raw": "From: mittente@tuodominio.com\r\nTo: destinatario@esempio.com\r\nSubject: Ciao Mondo\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<html><body><h1>Benvenuto!</h1></body></html>"
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

Ottieni Allegati Email

Restituisce solo l’elenco degli allegati per un’email, con contenuto codificato in base64.

GET/emails/{id}/attachments

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments', {
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/emails/em_abc123xyz789def456/attachments',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments',
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/emails/em_abc123xyz789def456/attachments')
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/emails/em_abc123xyz789def456/attachments"

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/emails/em_abc123xyz789def456/attachments")
    .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 GetEmailAttachments {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments"))
        .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 GetEmailAttachments
{
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/emails/em_abc123xyz789def456/attachments");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

Campi della Risposta

Campo	Tipo	Descrizione
`object`	string	Sempre `"list"`
`data`	array	Array di oggetti allegato

Oggetto Allegato

Campo	Tipo	Descrizione
`filename`	string	Nome del file allegato
`content_type`	string	Tipo MIME
`size`	integer	Dimensione dell’allegato in byte
`content_id`	string \| null	Content-ID per allegati inline
`content_disposition`	string	`"attachment"` o `"inline"`
`content`	string	Contenuto dell’allegato codificato in base64

{
"object": "list",
"data": [
{
  "filename": "documento.pdf",
  "content_type": "application/pdf",
  "size": 12345,
  "content_id": null,
  "content_disposition": "attachment",
  "content": "JVBERi0xLjQKJcOkw7zDqc..."
},
{
  "filename": "logo.png",
  "content_type": "image/png",
  "size": 5678,
  "content_id": "logo@tuodominio.com",
  "content_disposition": "inline",
  "content": "iVBORw0KGgoAAAANSUhEUg..."
}
]
}

{
"object": "list",
"data": []
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

Ottieni Corpo Email

Restituisce esclusivamente il contenuto del corpo analizzato (testo e HTML) di un’email.

GET/emails/{id}/body

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/body', {
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/emails/em_abc123xyz789def456/body',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/body',
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/emails/em_abc123xyz789def456/body')
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/emails/em_abc123xyz789def456/body"

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/emails/em_abc123xyz789def456/body")
    .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 GetEmailBody {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/body"))
        .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 GetEmailBody
{
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/emails/em_abc123xyz789def456/body");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

{
"text": "Contenuto in testo semplice dell'email",
"html": "<html><body><h1>Benvenuto!</h1><p>Contenuto HTML dell'email</p></body></html>"
}

{
"text": "Contenuto in testo semplice dell'email",
"html": null
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

Ottieni Metadati Email

Restituisce i metadati dell’email con le informazioni degli allegati, ma senza il contenuto degli allegati. Utile per ispezionare un’email senza scaricare dati di allegati potenzialmente voluminosi.

GET/emails/{id}/meta

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta', {
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/emails/em_abc123xyz789def456/meta',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta',
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/emails/em_abc123xyz789def456/meta')
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/emails/em_abc123xyz789def456/meta"

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/emails/em_abc123xyz789def456/meta")
    .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 GetEmailMeta {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta"))
        .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 GetEmailMeta
{
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/emails/em_abc123xyz789def456/meta");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

Campi della Risposta

La risposta include tutti i campi dei metadati dell’email più un array attachments con le informazioni degli allegati (senza il campo content).

Oggetto Allegato (Meta)

Campo	Tipo	Descrizione
`filename`	string	Nome del file allegato
`content_type`	string	Tipo MIME
`size`	integer	Dimensione dell’allegato in byte
`content_id`	string \| null	Content-ID per allegati inline
`content_disposition`	string	`"attachment"` o `"inline"`

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@yourdomain.com>",
"from": "sender@yourdomain.com",
"to": "recipient@example.com",
"subject": "Ciao Mondo",
"status": "delivered",
"size": 4523,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": false
},
"meta": null,
"headers": {
"From": "sender@yourdomain.com",
"To": "recipient@example.com",
"Subject": "Ciao Mondo",
"Content-Type": "multipart/mixed; boundary=----boundary123"
},
"attachments": [
{
  "filename": "documento.pdf",
  "content_type": "application/pdf",
  "size": 12345,
  "content_id": null,
  "content_disposition": "attachment"
}
]
}

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@yourdomain.com>",
"from": "sender@yourdomain.com",
"to": "recipient@example.com",
"subject": "Ciao Mondo",
"status": "delivered",
"size": 4523,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": false
},
"meta": null,
"headers": {
"From": "sender@yourdomain.com",
"To": "recipient@example.com",
"Subject": "Ciao Mondo",
"Content-Type": "text/html; charset=utf-8"
},
"attachments": []
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

Aggiorna Email Programmata

Modifica l’orario di invio di un’email programmata. Funziona solo per email con stato “scheduled” e solo se l’orario attualmente programmato è almeno 3 minuti nel futuro.

POST/emails/{id}

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

Corpo della Richiesta

scheduled_atstringRequired

Nuovo orario programmato. Accetta formato ISO 8601, timestamp Unix, o linguaggio naturale come domani alle 9. Deve essere almeno 3 minuti nel futuro.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
scheduled_at: '2026-01-10T15:00:00Z'
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
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([
'scheduled_at' => '2026-01-10T15:00:00Z'
]),
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'scheduled_at': '2026-01-10T15:00:00Z'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456')
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 = {
scheduled_at: '2026-01-10T15:00:00Z'
}.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/emails/em_abc123xyz789def456"

data := map[string]interface{}{
    "scheduled_at": "2026-01-10T15:00:00Z",
}

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/emails/em_abc123xyz789def456")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "scheduled_at": "2026-01-10T15:00:00Z"
    }))
    .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 UpdateEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"scheduled_at\":\"2026-01-10T15:00:00Z\"}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456"))
        .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 UpdateEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { scheduled_at = "2026-01-10T15:00:00Z" };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"scheduled_at": "2026-01-10T15:00:00Z"
}'

curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"scheduled_at": "domani alle 15"
}'

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"status": "scheduled",
"scheduled_at": "2026-01-10T15:00:00.000Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"message": "La programmazione dell'email è stata aggiornata con successo"
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

{
"error": "Impossibile aggiornare l'email",
"message": "Le email programmate possono essere aggiornate solo almeno 3 minuti prima dell'orario programmato. Questa email è programmata per l'invio tra 2 minuto/i."
}

{
"error": "scheduled_at non valido",
"message": "Il nuovo orario programmato deve essere almeno 3 minuti nel futuro."
}

Annulla Email

Annulla un’email programmata o in attesa. Per le email programmate, l’annullamento è consentito solo se l’orario programmato è almeno 3 minuti nel futuro.

POST/emails/{id}/cancel

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel', {
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/emails/em_abc123xyz789def456/cancel',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel',
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/emails/em_abc123xyz789def456/cancel')
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

package main

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

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

req, _ := http.NewRequest("POST", url, strings.NewReader(""))
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
    .post("https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel")
    .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;
import java.net.http.HttpRequest.BodyPublishers;

public class CancelEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.noBody())
        .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 CancelEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel", 
            new StringContent(""));
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"status": "canceled",
"message": "Email annullata con successo"
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

{
"error": "Impossibile annullare l'email",
"message": "L'email non può essere annullata. Stato attuale: 'sent'. Solo le email con stato 'scheduled' o 'pending' possono essere annullate."
}

{
"error": "Impossibile annullare l'email",
"message": "Le email programmate possono essere annullate solo almeno 3 minuti prima dell'orario programmato. Questa email è programmata per l'invio tra 2 minuto/i."
}

Stati Email Annullabili

Stato	Annullabile?	Note
pending	✅ Sì	Email in coda ma non ancora elaborata
scheduled	✅ Sì	Solo se l’orario programmato è almeno 3 minuti nel futuro
sent	❌ No	Email già inviata al server di posta
delivered	❌ No	Email già consegnata al destinatario
bounced	❌ No	Email già elaborata
canceled	❌ No	Email già annullata

Riprova Email

Riprova un’email che ha fallito definitivamente, ha generato un errore o è stata trattenuta. Questa operazione crea un duplicato dell’email originale e la invia nuovamente. La nuova email riceve un proprio ID univoco.

POST/emails/{id}/retry

Parametri del Percorso

idstringRequired

L’ID dell’email nel formato em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry', {
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/emails/em_abc123xyz789def456/retry',
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 "Errore cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry',
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/emails/em_abc123xyz789def456/retry')
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

package main

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

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

req, _ := http.NewRequest("POST", url, strings.NewReader(""))
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
    .post("https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry")
    .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;
import java.net.http.HttpRequest.BodyPublishers;

public class RetryEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.noBody())
        .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 RetryEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry", 
            new StringContent(""));
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "email",
"id": "em_new789xyz456abc123",
"original_id": "em_abc123xyz789def456",
"status": "pending",
"message": "L'email è stata messa in coda per il nuovo tentativo"
}

{
"error": "Email non trovata",
"message": "Email con ID 'em_abc123' non trovata nel tuo workspace"
}

{
"error": "Impossibile riprovare l'email",
"message": "L'email non può essere riprovata. Stato attuale: 'delivered'. Solo le email con stato 'failed', 'errored' o 'held' possono essere riprovate."
}

Stati Email Riprovabili

Stato	Riprovabile?	Note
failed	✅ Sì	Email respinta definitivamente
errored	✅ Sì	Email in errore durante l’elaborazione
held	✅ Sì	Email trattenuta per revisione
pending	❌ No	Email già in coda
sent	❌ No	Email già inviata
delivered	❌ No	Email già consegnata

Note Importanti

Fatturazione: Le email riprovate vengono fatturate come nuove email secondo i prezzi standard
Nuovo ID: L’email riprovata riceve un nuovo ID, l’email originale rimane invariata
Riferimento originale: La risposta include original_id per collegare l’email all’originale

Invia Email

Header Limite di Velocità

Elenco Email

Parametri di Query

Recupera Email

Parametri del Percorso

Campi della Risposta

Oggetto Body

Oggetto Attachment

Ottieni Email Raw

Parametri del Percorso

Ottieni Allegati Email

Parametri del Percorso

Campi della Risposta

Oggetto Allegato

Ottieni Corpo Email

Parametri del Percorso

Ottieni Metadati Email

Parametri del Percorso

Campi della Risposta

Oggetto Allegato (Meta)

Aggiorna Email Programmata

Parametri del Percorso

Corpo della Richiesta

Annulla Email

Parametri del Percorso

Stati Email Annullabili

Riprova Email

Parametri del Percorso

Stati Email Riprovabili

Note Importanti

Localizzato tramite IA