# Email API

> Invia email, consulta i messaggi e il loro contenuto, e programmali, annullali, ritentali o inoltrali.

URL di base: `https://api.emailit.com/v2`. Autenticati con `Authorization: Bearer <API key>`.

## Invia un’email — POST /emails

> Invia un’email a uno o più destinatari con HTML o testo, un template, allegati, header personalizzati, metadati, programmazione e tracciamento.

# Invia un’email

Invia un’email da un dominio di invio verificato. Ogni destinatario riceve una copia separata con un proprio ID email, e ogni destinatario costa un credito.

`POST /emails`

Funziona con le chiavi API `sending` e `full`. Gli invii rientrano nei [limiti di invio](/it/docs/api-reference/rate-limits/) del workspace, e una risposta riuscita significa che l’email è stata accettata e messa in coda, non che è già stata consegnata. Segui la consegna con i [webhook](/it/docs/webhooks/) o con [Recupera un’email](/it/docs/api-reference/emails/get/). I workspace non verificati possono inviare solo agli indirizzi email degli account dei loro membri.

## Header

- `Idempotency-Key` (string): Una chiave univoca, fino a 256 caratteri tra lettere, cifre, `-` e `_`. Un nuovo tentativo con la stessa chiave entro 24 ore restituisce la prima risposta invece di inviare di nuovo. Vedi [Idempotenza](/it/docs/api-reference/idempotency/).

## Parametri del corpo

- `from` (string, obbligatorio): Il mittente, nella forma `hello@acme.com` o `Acme <hello@acme.com>`. L’indirizzo deve appartenere a un dominio di invio verificato del workspace e, se la chiave è [limitata a un dominio](/it/docs/api-reference/authentication/#restrict-a-key-to-one-domain), al dominio della chiave.

- `to` (string | string[], obbligatorio): I destinatari, come array o come stringa separata da virgole. Ogni voce può essere `ada@example.com` o `Ada Lovelace <ada@example.com>`. Fino a 50.

- `cc` (string | string[]): I destinatari in copia. Fino a 50.

- `bcc` (string | string[]): I destinatari in copia nascosta. Fino a 50. Non compaiono negli header del messaggio.

- `reply_to` (string | string[]): Gli indirizzi per le risposte. Se invii con un template e ometti questo campo, viene usato il reply-to del template.

- `subject` (string): La riga dell’oggetto. Obbligatorio, a meno che non lo fornisca `template`.

- `html` (string): Il corpo HTML. Ti servono `html`, `text` o entrambi, a meno che il contenuto non lo fornisca `template`.

- `text` (string): Il corpo in testo semplice. Quando invii sia `html` sia `text`, i destinatari ricevono un messaggio multipart.

- `template` (string): Un template da inviare. Passa un ID di template (`tem_…`) per usare esattamente quella versione, oppure un alias per usarne la versione pubblicata. `subject`, `html` e `text` nella richiesta sostituiscono quelli del template. Vedi [Template](/it/docs/templates/).

- `variables` (object): I valori per i segnaposto di [Temple](/it/docs/templates/temple/) come `{{first_name}}`, elaborati nell’oggetto, nell’HTML e nel testo. Funziona con i template e con il contenuto inline.

- `attachments` (object[]): I file da allegare. Vedi [Oggetto allegato](#attachment-object) qui sotto.

- `headers` (object): Header MIME aggiuntivi come coppie nome–valore, ad esempio `{"List-Unsubscribe": "<https://acme.com/unsubscribe>"}`. Il `Message-ID` lo imposta Emailit.

- `meta` (object): I tuoi dati chiave–valore, ad esempio `{"order_id": "1042"}`. I valori devono essere stringhe. Vengono salvati con l’email e inclusi nelle letture e nei payload dei webhook.

- `scheduled_at` (string): Quando inviare, come data e ora ISO 8601, ad esempio `2026-10-02T09:00:00Z`, oppure in inglese, ad esempio `tomorrow at 9am`. Nei valori ISO 8601 includi un fuso orario. Un orario nel passato, o un valore che non è interpretabile (compreso un timestamp Unix), invia subito l’email. Le email programmate hanno lo stato `scheduled` finché non vengono inviate.

- `tracking` (boolean | object): Attiva o disattiva il tracciamento delle aperture e dei clic per questa email: `true`, `false` o `{"loads": true, "clicks": false}`. Per impostazione predefinita usa le impostazioni del dominio di invio. Il tracciamento funziona solo quando il [CNAME di tracciamento](/it/docs/tracking/custom-tracking-domain/) del dominio è verificato; altrimenti è disattivato e la risposta mostra `false`.

### Oggetto allegato

- `filename` (string, obbligatorio): Il nome del file, con un’estensione consentita (vedi sotto).

- `content` (string): Il file, codificato in Base64. Invia `content` o `url`, non entrambi.

- `url` (string): Un URL pubblico `http` o `https` da cui scaricare il file. Emailit lo scarica al momento dell’invio: il download deve terminare entro 30 secondi, non deve superare i 25 MB e non deve passare per reindirizzamenti.

- `content_type` (string): Il tipo MIME, ad esempio `application/pdf`. Obbligatorio con `content`. Con `url`, per impostazione predefinita è il tipo restituito dal server.

- `content_id` (string): Rende l’allegato inline. Nell’HTML fai riferimento a esso con `<img src="cid:logo">` quando `content_id` è `logo`.

- `encoding` (string): La codifica di `content`, ad esempio `base64` o `hex`.

L’intero messaggio, allegati compresi, può arrivare a 40 MB. Sono consentiti questi tipi di file:

| 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` |
| Crittografia | `.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig` |

## Restituisce

Restituisce `200` con l’oggetto email del primo destinatario. Quando il messaggio ha più di un destinatario tra `to`, `cc` e `bcc`, `ids` associa ogni destinatario all’ID della sua copia. Ogni copia genera un evento [`email.accepted`](/it/docs/webhooks/events/email/accepted/) o [`email.scheduled`](/it/docs/webhooks/events/email/scheduled/).

- `object` (string): Sempre `email`.

- `id` (string): L’ID dell’email del primo destinatario.

- `ids` (object): L’ID dell’email di ogni destinatario, indicizzato per indirizzo. Presente solo con più di un destinatario.

- `token` (string): Il token interno della prima email.

- `message_id` (string): L’header `Message-ID` della prima email, ad esempio `<token@acme.com>`.

- `from` (string): Il mittente, così come l’hai inviato.

- `to` (string[]): Gli indirizzi `to`, senza nomi visualizzati né duplicati.

- `cc` (string[]): I destinatari `cc`. Presente solo se li hai inviati.

- `bcc` (string[]): I destinatari `bcc`. Presente solo se li hai inviati.

- `subject` (string): L’oggetto, dopo l’elaborazione del template e delle variabili.

- `status` (string): `accepted`, oppure `scheduled` per uno `scheduled_at` futuro.

- `scheduled_at` (string | null): Quando verrà inviata l’email, oppure `null`.

- `created_at` (string): Quando è stata accettata l’email.

- `tracking` (object): Il tracciamento applicato: i booleani `loads` e `clicks`.

**Richiesta** `POST /emails`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: ['ada@example.com', 'grace@example.com'],
  subject: 'Welcome to Acme',
  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  tracking: {
    loads: true,
    clicks: true,
  },
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.send({
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com", "grace@example.com"],
  "subject": "Welcome to Acme",
  "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  "tracking": {
    "loads": True,
    "clicks": True
  }
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->send([
  'from' => 'Acme <hello@acme.com>',
  'to' => ['ada@example.com', 'grace@example.com'],
  'subject' => 'Welcome to Acme',
  'html' => '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  'tracking' => [
    'loads' => true,
    'clicks' => true,
  ],
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: ["ada@example.com", "grace@example.com"],
  subject: "Welcome to Acme",
  html: "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  tracking: { loads: true, clicks: true }
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Send(&emailit.SendEmailRequest{
  From:    "Acme <hello@acme.com>",
  To:      []string{"ada@example.com", "grace@example.com"},
  Subject: "Welcome to Acme",
  Html:    "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  Tracking: &emailit.TrackingOptions{
    Loads:  true,
    Clicks: true,
  },
})
```

**Rust**

```rust
use emailit::Emailit;
use emailit::types::CreateEmailBaseOptions;

let emailit = Emailit::new("your_api_key");

let opts = CreateEmailBaseOptions::new(
    "Acme <hello@acme.com>",
    ["ada@example.com", "grace@example.com"],
    "Welcome to Acme",
)
.with_html("<h1>Welcome!</h1><p>Thanks for signing up.</p>")
.with_tracking(true, true);

let email = emailit.emails.send(opts).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().send(
  EmailSendParams.builder()
    .setFrom("Acme <hello@acme.com>")
    .setTo(Arrays.asList("ada@example.com", "grace@example.com"))
    .setSubject("Welcome to Acme")
    .setHtml("<h1>Welcome!</h1><p>Thanks for signing up.</p>")
    .setTracking(new TrackingOptions(true, true))
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Send(new EmailSendOptions {
  From = "Acme <hello@acme.com>",
  To = new[] { "ada@example.com", "grace@example.com" },
  Subject = "Welcome to Acme",
  Html = "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  Tracking = new TrackingOptions { Loads = true, Clicks = true },
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->send([
  'from' => 'Acme <hello@acme.com>',
  'to' => ['ada@example.com', 'grace@example.com'],
  'subject' => 'Welcome to Acme',
  'html' => '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  'tracking' => [
    'loads' => true,
    'clicks' => true,
  ],
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": ["ada@example.com", "grace@example.com"],
    "subject": "Welcome to Acme",
    "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
    "tracking": {
      "loads": true,
      "clicks": true
    }
  }'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "template": "welcome",
    "variables": {
      "first_name": "Ada",
      "activation_url": "https://acme.com/activate?token=8f2c1e"
    }
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'ada@example.com',
  template: 'welcome',
  variables: {
    first_name: 'Ada',
    activation_url: 'https://acme.com/activate?token=8f2c1e',
  },
});
```

**Python**

```python
email = client.emails.send({
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "template": "welcome",
  "variables": {
    "first_name": "Ada",
    "activation_url": "https://acme.com/activate?token=8f2c1e"
  }
})
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme Billing <billing@acme.com>",
    "to": "ada@example.com",
    "subject": "Your invoice INV-1042",
    "html": "<img src=\"cid:logo\"><p>Your invoice is attached.</p>",
    "attachments": [
      {
        "filename": "INV-1042.pdf",
        "content": "JVBERi0xLjQKJcOkw7zDqc...",
        "content_type": "application/pdf"
      },
      {
        "filename": "logo.png",
        "url": "https://acme.com/assets/logo.png",
        "content_id": "logo"
      }
    ]
  }'
```

**Node.js**

```javascript
import { readFile } from 'node:fs/promises';

const pdf = await readFile('INV-1042.pdf');

const email = await emailit.emails.send({
  from: 'Acme Billing <billing@acme.com>',
  to: 'ada@example.com',
  subject: 'Your invoice INV-1042',
  html: '<img src="cid:logo"><p>Your invoice is attached.</p>',
  attachments: [
    {
      filename: 'INV-1042.pdf',
      content: pdf.toString('base64'),
      content_type: 'application/pdf',
    },
    {
      filename: 'logo.png',
      url: 'https://acme.com/assets/logo.png',
      content_id: 'logo',
    },
  ],
});
```

**Python**

```python
import base64

with open("INV-1042.pdf", "rb") as f:
    pdf = base64.b64encode(f.read()).decode()

email = client.emails.send({
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "html": '<img src="cid:logo"><p>Your invoice is attached.</p>',
  "attachments": [
    {"filename": "INV-1042.pdf", "content": pdf, "content_type": "application/pdf"},
    {"filename": "logo.png", "url": "https://acme.com/assets/logo.png", "content_id": "logo"}
  ]
})
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: reminder-appt-5531" \
  -d '{
    "from": "Acme <reminders@acme.com>",
    "to": "ada@example.com",
    "subject": "Your appointment tomorrow",
    "text": "See you tomorrow at 2 PM.",
    "scheduled_at": "2026-10-02T09:00:00Z",
    "meta": { "appointment_id": "5531" }
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.send({
  from: 'Acme <reminders@acme.com>',
  to: 'ada@example.com',
  subject: 'Your appointment tomorrow',
  text: 'See you tomorrow at 2 PM.',
  scheduled_at: '2026-10-02T09:00:00Z',
  meta: { appointment_id: '5531' },
});
```

**Python**

```python
email = client.emails.send({
  "from": "Acme <reminders@acme.com>",
  "to": "ada@example.com",
  "subject": "Your appointment tomorrow",
  "text": "See you tomorrow at 2 PM.",
  "scheduled_at": "2026-10-02T09:00:00Z",
  "meta": {"appointment_id": "5531"}
})
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "ids": {
    "ada@example.com": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
    "grace@example.com": "em_4KfIXZSV8v8L1k0Mg2YDR3rytvj"
  },
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com", "grace@example.com"],
  "subject": "Welcome to Acme",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "tracking": {
    "loads": true,
    "clicks": true
  }
}
```

**200 Programmata**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "token": "4KWzEED2cnej6UMjF4v508VqQIp",
  "message_id": "<4KWzEED2cnej6UMjF4v508VqQIp@acme.com>",
  "from": "Acme <reminders@acme.com>",
  "to": ["ada@example.com"],
  "subject": "Your appointment tomorrow",
  "status": "scheduled",
  "scheduled_at": "2026-10-02T09:00:00.000Z",
  "created_at": "2026-10-01T09:30:12.482913Z",
  "tracking": {
    "loads": false,
    "clicks": false
  }
}
```

**400**

```json
{
  "error": "Validation failed",
  "validation_errors": [
    "Missing required field: subject",
    "Invalid to email address at index 1: grace@example"
  ]
}
```

**402**

```json
{
  "error": "Insufficient credits",
  "message": "Insufficient credits to send this email. Required: 2, available: 0."
}
```

**403 Non verificato**

```json
{
  "code": "unverified_workspace_recipient",
  "error": "Workspace not verified",
  "message": "Unverified workspaces can only send to workspace members' account emails. Blocked recipient: grace@example.com.",
  "blocked_recipients": ["grace@example.com"]
}
```

**403 Dominio**

```json
{
  "error": "Domain not authorized",
  "message": "API key is not authorized to send from this domain"
}
```

**404**

```json
{
  "error": "Template not found",
  "message": "Template 'welcome' not found or not published"
}
```

**413**

```json
{
  "error": "Message too large",
  "message": "Message size (41.27MB) exceeds maximum allowed size of 40MB"
}
```

**422**

```json
{
  "error": "Domain not verified"
}
```

**429**

```json
{
  "error": "Rate limit exceeded",
  "message": "Too many requests. Maximum 2 messages per second allowed.",
  "limit": 2,
  "current": 2,
  "retry_after": 1
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/send/

## Elenca le email — GET /emails

> Elenca le email in uscita o in entrata di un workspace, a partire dalla più recente, con ricerca, filtri, ordinamento e un intervallo predefinito di 14 giorni.

# Elenca le email

Restituisce una pagina di email, a partire dalla più recente. Per impostazione predefinita l’elenco mostra le email in uscita degli ultimi 14 giorni.

`GET /emails`

Richiede una chiave API `full`. In questo elenco ogni destinatario di un invio è un’email separata.

## Parametri di query

- `page` (integer): La pagina da restituire.

- `limit` (integer): Email per pagina, da 1 a 100.

- `type` (string): `outbound` per le email che hai inviato, oppure `inbound` per le email che hai [ricevuto](/it/docs/inbound/).

- `date_from` (string): Solo le email create in questa data o dopo, ad esempio `2026-08-01` (dalle 00:00 UTC). Senza questo parametro, l’elenco parte da 14 giorni fa. I filtri `created_at` non cambiano questo intervallo.

- `date_to` (string): Solo le email create in questa data o prima, fino alle 23:59:59 UTC.

- `search` (string): Corrispondenza sul destinatario, sul mittente o sull’oggetto, senza distinzione tra maiuscole e minuscole.

- `match` (string): `all` o `or`. Come si combinano i filtri qui sotto.

- `order` (string): Una chiave di ordinamento della tabella qui sotto.

- `direction` (string): `asc` o `desc`.

## Filtri

Aggiungi i filtri nella forma `key.condition=value`, ad esempio `status.exact=bounced` o `created_at.after=2026-09-01`. Per le condizioni di ciascun tipo, vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

| Chiave | Tipo | Valori e note |
| --- | --- | --- |
| `to` | string | Indirizzo del destinatario. |
| `from` | string | Mittente così come è stato inviato, compreso l’eventuale nome visualizzato. |
| `subject` | string | |
| `status` | enum | `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled`, `held` |
| `tag` | string | Il tag dell’email. Al momento l’invio tramite API o SMTP non imposta alcun tag. |
| `spam_score` | number | |
| `created_at` | date | |
| `updated_at` | date | |
| `api_key_id` | string | ID della chiave API che ha inviato l’email (`key_…`). |
| `sending_domain_id` | string | ID del dominio di invio (`dom_…`). |

Ogni chiave di filtro è anche una chiave di ordinamento. I vecchi parametri di query `status`, `rcpt_to`, `mail_from`, `subject`, `api_key_id` e `sending_domain_id` funzionano ancora: `status` cerca una corrispondenza esatta, mentre i parametri dell’indirizzo e dell’oggetto cercano una corrispondenza parziale.

## Restituisce

Restituisce un array `data` di oggetti email con `next_page_url` e `previous_page_url`. Vedi [Paginazione](/it/docs/api-reference/pagination/). Gli URL delle pagine non riportano i tuoi filtri, quindi richiedi la pagina successiva con i tuoi parametri e `page` aumentato di uno.

- `object` (string): Sempre `email`.

- `id` (string): L’ID dell’email.

- `type` (string): `outbound` o `inbound`.

- `from` (string): Il mittente così come è stato inviato.

- `to` (string): Il destinatario di questa copia.

- `subject` (string): L’oggetto.

- `status` (string): Lo [stato](/it/docs/logs/email-statuses/) attuale.

- `size` (integer): La dimensione del messaggio in byte.

- `scheduled_at` (string | null): Quando è previsto l’invio di un’email programmata, oppure `null`.

- `created_at` (string): Quando l’email è stata accettata o ricevuta.

- `updated_at` (string): Quando lo stato è cambiato l’ultima volta.

- `meta` (object | null): Il `meta` che hai inviato.

**Richiesta** `GET /emails`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const emails = await emailit.emails.list({ page: 1, limit: 25 });
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

emails = client.emails.list({ "page": 1, "limit": 25 })
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$emails = $emailit->emails()->list(['page' => 1, 'limit' => 25]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

emails = client.emails.list(page: 1, limit: 25)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

emails, err := client.Emails.List(&emailit.ListEmailsRequest{
  Page:  1,
  Limit: 25,
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let emails = emailit.emails.list(Some(emailit::types::ListEmailsParams {
  page: Some(1),
  limit: Some(25),
})).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject emails = emailit.emails().list(
  EmailListParams.builder()
    .setPage(1)
    .setLimit(25)
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var emails = emailit.Emails.List(new EmailListOptions {
  Page = 1,
  Limit = 25,
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$emails = Emailit::emails()->list(['page' => 1, 'limit' => 25]);
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d page=1 \
  -d limit=25
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d status.exact=bounced \
  -d status.exact=failed \
  -d match=or \
  -d date_from=2026-09-01 \
  -d order=created_at \
  -d direction=desc
```

**200**

```json
{
  "data": [
    {
      "object": "email",
      "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
      "type": "outbound",
      "from": "Acme <hello@acme.com>",
      "to": "ada@example.com",
      "subject": "Welcome to Acme",
      "status": "delivered",
      "size": 4523,
      "scheduled_at": null,
      "created_at": "2026-10-01T09:30:12.482913Z",
      "updated_at": "2026-10-01T09:30:14.118204Z",
      "meta": null
    },
    {
      "object": "email",
      "id": "em_4KfIXZSV8v8L1k0Mg2YDR3rytvj",
      "type": "outbound",
      "from": "Acme <hello@acme.com>",
      "to": "grace@example.com",
      "subject": "Welcome to Acme",
      "status": "loaded",
      "size": 4527,
      "scheduled_at": null,
      "created_at": "2026-10-01T09:30:12.482913Z",
      "updated_at": "2026-10-01T09:41:03.770521Z",
      "meta": null
    }
  ],
  "next_page_url": "/app/v2/emails?page=2&limit=25",
  "previous_page_url": null
}
```

**400**

```json
{
  "statusCode": 400,
  "error": "Bad Request",
  "message": "Validation error",
  "details": [
    {
      "instancePath": "/limit",
      "schemaPath": "#/properties/limit/maximum",
      "keyword": "maximum",
      "params": { "comparison": "<=", "limit": 100 },
      "message": "must be <= 100"
    }
  ]
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/list/

## Recupera un’email — GET /emails/{id}

> Recupera un’email in uscita o in entrata per ID, con stato, header, corpo HTML e di testo già estratti, metadati e allegati.

# Recupera un’email

Recupera un’email con lo stato, gli header già estratti, il corpo HTML e di testo e gli allegati.

`GET /emails/{id}`

Richiede una chiave API `full`. Il contenuto dei messaggi viene conservato per il [periodo di conservazione](/it/docs/data-retention/) del contenuto previsto dal piano. Dopo questo periodo, `headers`, `body` e `attachments` sono vuoti, mentre lo stato e i metadati restano. Per recuperare solo una parte di un’email, usa [Recupera il corpo](/it/docs/api-reference/emails/body/), [Recupera i metadati](/it/docs/api-reference/emails/meta/), [Elenca gli allegati](/it/docs/api-reference/emails/attachments/) o [Recupera il MIME grezzo](/it/docs/api-reference/emails/raw/).

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email, ad esempio `em_4KYof1ZzXndZE2VPi0DgULiekG8`.

## Restituisce

Restituisce l’oggetto email.

- `object` (string): Sempre `email`.

- `id` (string): L’ID dell’email.

- `type` (string): `outbound` per le email che hai inviato, `inbound` per le email che hai ricevuto.

- `token` (string): Il token interno dell’email.

- `message_id` (string): L’header `Message-ID`.

- `from` (string): Il mittente così come è stato inviato, ad esempio `Acme <hello@acme.com>`.

- `to` (string): Il destinatario di questa copia.

- `subject` (string): L’oggetto.

- `status` (string): Lo stato attuale: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` o `held`. Vedi [Stati delle email](/it/docs/logs/email-statuses/).

- `size` (integer): La dimensione del messaggio in byte.

- `scheduled_at` (string | null): Quando è previsto l’invio di un’email programmata, oppure `null`.

- `created_at` (string): Quando l’email è stata accettata o ricevuta.

- `updated_at` (string): Quando l’email è cambiata l’ultima volta.

- `tracking` (object): Solo per le email in uscita. Indica se il tracciamento delle aperture (`loads`) e dei clic (`clicks`) è attivo.

- `meta` (object | null): Il `meta` che hai inviato, oppure `null`.

- `headers` (object | null): Gli header del messaggio come coppie nome–valore, oppure `null` dopo l’eliminazione definitiva del contenuto.

- `body` (object): `text` e `html`, ciascuno una stringa o `null`.

- `attachments` (object[]): Gli allegati, ciascuno con `filename`, `content_type`, `size` in byte, `content_id` (per i file inline), `content_disposition` (`attachment` o `inline`) e `content` (Base64).

**Richiesta** `GET /emails/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().get("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Get("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200 In uscita**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "status": "delivered",
  "size": 48213,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "meta": {
    "invoice_id": "INV-1042"
  },
  "headers": {
    "From": "Acme Billing <billing@acme.com>",
    "To": "ada@example.com",
    "Subject": "Your invoice INV-1042",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "multipart/mixed; boundary=\"--_NmP-4f1c2a9e7b3d0e5f-Part_1\""
  },
  "body": {
    "text": "Your invoice is attached.",
    "html": "<p>Your invoice is attached.</p>"
  },
  "attachments": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment",
      "content": "JVBERi0xLjQKJcOkw7zDqc..."
    }
  ]
}
```

**200 In entrata**

```json
{
  "object": "email",
  "id": "em_4KbeG9poqTmjvQZeN8pMoJkCVNd",
  "type": "inbound",
  "token": "4KTnDU5PzzqDqp8UWb9qVhPVFOT",
  "message_id": "<CAH7x2k9@mail.example.com>",
  "from": "Ada Lovelace <ada@example.com>",
  "to": "support@inbound.acme.com",
  "subject": "Re: Your invoice INV-1042",
  "status": "received",
  "size": 8234,
  "scheduled_at": null,
  "created_at": "2026-10-01T11:02:45.031877Z",
  "updated_at": "2026-10-01T11:02:45.031877Z",
  "meta": null,
  "headers": {
    "From": "Ada Lovelace <ada@example.com>",
    "To": "support@inbound.acme.com",
    "Subject": "Re: Your invoice INV-1042",
    "Content-Type": "text/plain; charset=utf-8"
  },
  "body": {
    "text": "Thanks, received.",
    "html": null
  },
  "attachments": []
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/get/

## Recupera il MIME grezzo — GET /emails/{id}/raw

> Recupera il sorgente MIME grezzo completo di un’email, con i suoi header, insieme allo stato e ai metadati dell’email.

# Recupera il MIME grezzo

Recupera il sorgente MIME completo di un’email così come è salvato da Emailit, insieme ai suoi metadati.

`GET /emails/{id}/raw`

Richiede una chiave API `full`. Usalo per archiviare un messaggio, fare il debug della sua struttura o elaborarlo con la tua libreria MIME. Al termine del [periodo di conservazione](/it/docs/data-retention/) del contenuto, `raw` e `headers` sono `null`.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email.

## Restituisce

Restituisce i metadati dell’email, come in [Recupera i metadati](/it/docs/api-reference/emails/meta/) ma senza `attachments`, più il messaggio grezzo.

- `raw` (string | null): Il messaggio MIME completo: gli header, una riga vuota e il corpo. `null` dopo l’eliminazione definitiva del contenuto.

- `headers` (object | null): Gli header di primo livello come coppie nome–valore.

Gli altri campi (`object`, `id`, `type`, `token`, `message_id`, `from`, `to`, `subject`, `status`, `size`, `scheduled_at`, `created_at`, `updated_at`, `tracking` e `meta`) sono gli stessi di [Recupera un’email](/it/docs/api-reference/emails/get/).

**Richiesta** `GET /emails/{id}/raw`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const raw = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw",
  headers={"Authorization": "Bearer your_api_key"}
)
raw = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$raw = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
raw = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

raw, err := client.Emails.GetRaw("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let raw = emailit.emails.get_raw("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var raw = emailit.Emails.GetRaw("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$raw = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "subject": "Welcome to Acme",
  "status": "delivered",
  "size": 1342,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": false,
    "clicks": false
  },
  "meta": null,
  "headers": {
    "From": "Acme <hello@acme.com>",
    "To": "ada@example.com",
    "Subject": "Welcome to Acme",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "text/html; charset=utf-8"
  },
  "raw": "From: Acme <hello@acme.com>\r\nTo: ada@example.com\r\nSubject: Welcome to Acme\r\nMessage-ID: <4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=utf-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\n<h1>Welcome!</h1><p>Thanks for signing up.</p>"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/raw/

## Elenca gli allegati — GET /emails/{id}/attachments

> Elenca gli allegati di un’email con nomi dei file, tipi MIME, dimensioni, Content-ID delle parti inline e contenuto codificato in Base64.

# Elenca gli allegati

Restituisce gli allegati di un’email, compreso il loro contenuto.

`GET /emails/{id}/attachments`

Richiede una chiave API `full`. Funziona per le email in uscita e in entrata. Le immagini inline (le parti con un `Content-ID`) sono incluse. Per ottenere l’elenco senza il contenuto dei file, usa [Recupera i metadati](/it/docs/api-reference/emails/meta/). Al termine del [periodo di conservazione](/it/docs/data-retention/) del contenuto, l’elenco è vuoto.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email.

## Restituisce

Restituisce un oggetto di tipo `list` con tutti gli allegati. L’elenco non è paginato.

- `object` (string): Sempre `list`.

- `data` (object[]): Gli allegati.

- `data[].filename` (string): Il nome del file.

- `data[].content_type` (string): Il tipo MIME, ad esempio `application/pdf`.

- `data[].size` (integer): La dimensione del file decodificato, in byte.

- `data[].content_id` (string | null): Il `Content-ID` di un allegato inline, oppure `null`.

- `data[].content_disposition` (string | null): `attachment` o `inline`.

- `data[].content` (string): Il file, codificato in Base64.

**Richiesta** `GET /emails/{id}/attachments`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const attachments = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments",
  headers={"Authorization": "Bearer your_api_key"}
)
attachments = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$attachments = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
attachments = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

attachments, err := client.Emails.GetAttachments("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let attachments = emailit.emails.get_attachments("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var attachments = emailit.Emails.GetAttachments("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$attachments = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "list",
  "data": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment",
      "content": "JVBERi0xLjQKJcOkw7zDqc..."
    },
    {
      "filename": "logo.png",
      "content_type": "image/png",
      "size": 5120,
      "content_id": "logo",
      "content_disposition": "inline",
      "content": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  ]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/attachments/

## Recupera il corpo — GET /emails/{id}/body

> Recupera solo il corpo HTML e in testo semplice di un’email, estratto dal messaggio, senza header, metadati o allegati.

# Recupera il corpo

Restituisce il corpo HTML e in testo semplice di un’email, decodificato dalle sue parti MIME.

`GET /emails/{id}/body`

Richiede una chiave API `full`. Funziona per le email in uscita e in entrata. Per le email in uscita, il corpo è quello inviato, dopo l’elaborazione del template e delle variabili. Al termine del [periodo di conservazione](/it/docs/data-retention/) del contenuto, entrambi i campi sono `null`.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email.

## Restituisce

- `text` (string | null): La parte in testo semplice, oppure `null` se l’email non ne ha.

- `html` (string | null): La parte HTML, oppure `null` se l’email non ne ha.

**Richiesta** `GET /emails/{id}/body`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const body = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body",
  headers={"Authorization": "Bearer your_api_key"}
)
body = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$body = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
body = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

body, err := client.Emails.GetBody("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let body = emailit.emails.get_body("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var body = emailit.Emails.GetBody("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$body = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "text": "Welcome!\n\nThanks for signing up.",
  "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/body/

## Recupera i metadati — GET /emails/{id}/meta

> Recupera lo stato, gli header, i metadati e l’elenco degli allegati di un’email senza scaricare il corpo del messaggio o il contenuto degli allegati.

# Recupera i metadati

Recupera un’email senza il corpo: stato, header, i tuoi dati `meta` e l’elenco degli allegati senza il loro contenuto.

`GET /emails/{id}/meta`

Richiede una chiave API `full`. È il modo più leggero per leggere i dettagli di un’email quando non ti serve il contenuto.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email.

## Restituisce

Restituisce gli stessi campi di [Recupera un’email](/it/docs/api-reference/emails/get/), senza `body` e con gli `attachments` descritti ma non inclusi:

- `attachments` (object[]): Per ogni allegato, `filename`, `content_type`, `size`, `content_id` e `content_disposition`. Nessun `content`.

- `headers` (object | null): Gli header del messaggio come coppie nome–valore, oppure `null` dopo l’eliminazione definitiva del contenuto.

- `meta` (object | null): Il `meta` che hai inviato con l’email.

**Richiesta** `GET /emails/{id}/meta`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const meta = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta",
  headers={"Authorization": "Bearer your_api_key"}
)
meta = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$meta = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
meta = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

meta, err := client.Emails.GetMeta("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let meta = emailit.emails.get_meta("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var meta = emailit.Emails.GetMeta("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$meta = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "status": "delivered",
  "size": 48213,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "meta": {
    "invoice_id": "INV-1042"
  },
  "headers": {
    "From": "Acme Billing <billing@acme.com>",
    "To": "ada@example.com",
    "Subject": "Your invoice INV-1042",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "multipart/mixed; boundary=\"--_NmP-4f1c2a9e7b3d0e5f-Part_1\""
  },
  "attachments": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment"
    }
  ]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/meta/

## Aggiorna un’email programmata — POST /emails/{id}

> Cambia l’orario di invio di un’email programmata. Funziona fino a tre minuti prima dell’invio, e il nuovo orario deve essere ad almeno tre minuti nel futuro.

# Aggiorna un’email programmata

Sposta un’email programmata a un nuovo orario di invio.

`POST /emails/{id}`

Funziona con le chiavi API `sending` e `full`. Puoi riprogrammare solo un’email con stato `scheduled` il cui orario di invio attuale è a più di 3 minuti da adesso. Si può cambiare solo l’orario di invio; per cambiare il contenuto, [annulla](/it/docs/api-reference/emails/cancel/) l’email e inviane una nuova.

Un invio programmato a più destinatari crea un’email per ogni destinatario. Riprogramma ciascun ID della mappa `ids` della [risposta dell’invio](/it/docs/api-reference/emails/send/).

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email programmata.

## Parametri del corpo

- `scheduled_at` (string, obbligatorio): Il nuovo orario di invio, come data e ora ISO 8601, ad esempio `2026-10-03T09:00:00Z`, oppure in inglese, ad esempio `tomorrow at 3pm`. Deve essere a più di 3 minuti nel futuro.

## Restituisce

- `object` (string): Sempre `email`.

- `id` (string): L’ID dell’email.

- `status` (string): Sempre `scheduled`.

- `scheduled_at` (string): Il nuovo orario di invio.

- `updated_at` (string): Quando è stata aggiornata l’email.

- `message` (string): Un messaggio di conferma.

Restituisce `422` se l’email non è programmata, se mancano meno di 3 minuti all’invio, oppure se il nuovo orario non è interpretabile o è troppo vicino.

**Richiesta** `POST /emails/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', {
  scheduled_at: '2026-10-03T09:00:00Z',
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", {
  "scheduled_at": "2026-10-03T09:00:00Z"
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', [
  'scheduled_at' => '2026-10-03T09:00:00Z',
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  scheduled_at: "2026-10-03T09:00:00Z"
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", &emailit.UpdateEmailRequest{
  ScheduledAt: "2026-10-03T09:00:00Z",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", emailit::types::UpdateEmailParams {
  scheduled_at: "2026-10-03T09:00:00Z".to_string(),
}).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  EmailUpdateParams.builder()
    .setScheduledAt("2026-10-03T09:00:00Z")
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", new EmailUpdateOptions {
  ScheduledAt = "2026-10-03T09:00:00Z",
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', [
  'scheduled_at' => '2026-10-03T09:00:00Z',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scheduled_at": "2026-10-03T09:00:00Z"}'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scheduled_at": "tomorrow at 3pm"}'
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "scheduled",
  "scheduled_at": "2026-10-03T09:00:00.000Z",
  "updated_at": "2026-10-01T10:15:40.207316Z",
  "message": "Email schedule has been updated successfully"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4K76IA5sFNIsLXW9QC2ro8cDbOj' not found in your workspace"
}
```

**422 Non programmata**

```json
{
  "error": "Cannot update email",
  "message": "Email cannot be updated. Current status: 'delivered'. Only 'scheduled' emails can be updated."
}
```

**422 Troppo tardi**

```json
{
  "error": "Cannot update email",
  "message": "Scheduled emails can only be updated at least 3 minutes before the scheduled time. This email is scheduled to send in 2 minute(s)."
}
```

**422 Orario non valido**

```json
{
  "error": "Invalid scheduled_at",
  "message": "The new scheduled time must be at least 3 minutes in the future."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/update/

## Annulla un’email — POST /emails/{id}/cancel

> Annulla un’email programmata, accettata o con errore temporaneo e rimuovila dalla coda di invio. L’annullamento non è garantito: una consegna già in corso potrebbe comunque completarsi.

# Annulla un’email

Rimuove un’email dalla coda di invio e ne imposta lo stato su `canceled`.

`POST /emails/{id}/cancel`

Funziona con le chiavi API `sending` e `full`. L’annullamento non è garantito: toglie l’email dalla coda, ma se un tentativo di consegna è già iniziato, quel tentativo potrebbe comunque completarsi e vengono fermati solo i nuovi tentativi rimanenti. La risposta indica in `in_flight` quale dei due casi si applica. L’annullamento genera un [evento](/it/docs/webhooks/event-types/) `email.canceled` e il credito non viene rimborsato. L’azione **Cancel delivery** del pannello fa la stessa cosa.

| Stato | Annullabile | Note |
| --- | --- | --- |
| `scheduled` | Sì | Fino a 3 minuti prima dell’orario programmato. |
| `accepted` | Sì | In coda e non ancora consegnata. |
| `attempted` | Sì | Ferma i nuovi tentativi rimanenti dopo un errore temporaneo. |
| Qualsiasi altro | No | L’email è già stata consegnata, non è riuscita o è stata annullata. |

Per annullare un invio con più destinatari, annulla ciascun ID della mappa `ids` della [risposta dell’invio](/it/docs/api-reference/emails/send/).

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email.

## Restituisce

- `object` (string): Sempre `email`.

- `id` (string): L’ID dell’email.

- `status` (string): Sempre `canceled`.

- `in_flight` (boolean): `true` se un tentativo di consegna potrebbe essere già in corso e potrebbe ancora completarsi. `false` se l’email è stata rimossa dalla coda prima di qualsiasi tentativo.

- `message` (string): Una descrizione del risultato.

**Richiesta** `POST /emails/{id}/cancel`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj/cancel \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "canceled",
  "in_flight": false,
  "message": "Email has been canceled and removed from the send queue."
}
```

**200 In corso**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "canceled",
  "in_flight": true,
  "message": "Email was canceled. The current delivery attempt may still complete; remaining retries were stopped."
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4K76IA5sFNIsLXW9QC2ro8cDbOj' not found in your workspace"
}
```

**422 Stato**

```json
{
  "error": "Cannot cancel email",
  "message": "Email cannot be canceled. Current status: 'delivered'. Only 'scheduled', 'accepted', or 'attempted' emails can be canceled."
}
```

**422 Troppo tardi**

```json
{
  "error": "Cannot cancel email",
  "message": "Scheduled emails can only be canceled at least 3 minutes before the scheduled time. This email is scheduled to send in 2 minute(s)."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/cancel/

## Ritenta un’email — POST /emails/{id}/retry

> Invia di nuovo un’email rimbalzata, non riuscita, soppressa o trattenuta come nuova email con un nuovo ID. L’originale resta invariata.

# Ritenta un’email

Mette in coda una copia di un’email che non è arrivata a destinazione. La copia è una nuova email con un proprio ID, e l’originale mantiene il suo stato.

`POST /emails/{id}/retry`

Funziona con le chiavi API `sending` e `full`. La copia ha lo stesso mittente, destinatario, oggetto, contenuto, header, `meta` e impostazioni di tracciamento, con un nuovo `Message-ID`. Costa crediti come un nuovo invio: un credito, o due per un’email di una campagna.

Puoi ritentare un’email quando:

- Il suo stato è `bounced`, `failed`, `suppressed` o `held`.
- È stata creata negli ultimi 30 giorni.
- Il suo contenuto non è stato eliminato definitivamente in base al [periodo di conservazione](/it/docs/data-retention/) e il suo dominio di invio esiste ancora.

Prima elimina la causa. Un indirizzo soppresso che è ancora nella [lista di soppressione](/it/docs/suppressions/) viene soppresso di nuovo, e un’email [trattenuta](/it/docs/logs/email-statuses/) viene trattenuta di nuovo finché il motivo per cui è stata trattenuta non viene risolto.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email da ritentare.

## Restituisce

- `object` (string): Sempre `email`.

- `id` (string): L’ID della nuova email.

- `original_id` (string): L’ID dell’email che hai ritentato.

- `token` (string): Il token interno della nuova email.

- `message_id` (string): Il `Message-ID` della nuova email.

- `from` (string): Il mittente.

- `to` (string): Il destinatario.

- `subject` (string): L’oggetto.

- `status` (string): Sempre `accepted`.

- `created_at` (string): Quando è stata creata la nuova email.

- `message` (string): Un messaggio di conferma.

**Richiesta** `POST /emails/{id}/retry`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KKrQ7TzsVtzsS8zG069B2aMtoK/retry \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KbeG9poqTmjvQZeN8pMoJkCVNd",
  "original_id": "em_4KKrQ7TzsVtzsS8zG069B2aMtoK",
  "token": "4KTnDU5PzzqDqp8UWb9qVhPVFOT",
  "message_id": "<4KTnDU5PzzqDqp8UWb9qVhPVFOT@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "subject": "Welcome to Acme",
  "status": "accepted",
  "created_at": "2026-10-01T12:04:51.330482Z",
  "message": "Email has been queued for retry"
}
```

**402**

```json
{
  "error": "Insufficient credits",
  "message": "Insufficient credits to retry this email. Required: 1, available: 0."
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KKrQ7TzsVtzsS8zG069B2aMtoK' not found in your workspace"
}
```

**422 Stato**

```json
{
  "error": "Cannot retry email",
  "message": "Only bounced, failed, suppressed, or held emails can be retried. Current status: 'delivered'"
}
```

**422 Troppo vecchia**

```json
{
  "error": "Cannot retry email",
  "message": "Emails older than 30 days cannot be retried"
}
```

**422 Eliminata**

```json
{
  "error": "Cannot retry email",
  "message": "Email raw content has been purged and can no longer be retried"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/retry/

## Inoltra un’email — POST /emails/{id}/forward

> Invia di nuovo un’email in uscita a nuovi destinatari, come semplice reinvio o con l’intestazione del messaggio inoltrato e una nota facoltativa. Limite di 3 all’ora.

# Inoltra un’email

Invia il contenuto di un’email in uscita a nuovi destinatari come nuova email. L’email originale non cambia.

`POST /emails/{id}/forward`

Funziona con le chiavi API `sending` e `full`. Per impostazione predefinita l’inoltro è un semplice reinvio dell’HTML, del testo e degli allegati originali. Imposta `include_headers` per aggiungere un blocco «Forwarded message» e una nota facoltativa sopra il contenuto originale.

Un inoltro è un nuovo invio, quindi valgono le regole di [Invia un’email](/it/docs/api-reference/emails/send/): l’indirizzo `from` deve appartenere a un dominio di invio verificato, ogni destinatario costa un credito e rientra nei [limiti di invio](/it/docs/api-reference/rate-limits/), il tracciamento segue le impostazioni del dominio e l’header `Idempotency-Key` è supportato. In più, un workspace può inoltrare al massimo 3 email all’ora.

Si possono inoltrare solo le email in uscita, e solo finché il loro contenuto viene conservato in base al [periodo di conservazione](/it/docs/data-retention/). Per inoltrare la posta ricevuta, usa un’[automazione](/it/docs/inbound/forward-with-automations/).

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email in uscita da inoltrare.

## Header

- `Idempotency-Key` (string): Permette di ritentare l’inoltro in sicurezza. Vedi [Idempotenza](/it/docs/api-reference/idempotency/).

## Parametri del corpo

- `to` (string | string[], obbligatorio): I nuovi destinatari, come array o come stringa separata da virgole. Fino a 50.

- `include_headers` (boolean): Se `true`, aggiunge un blocco «Forwarded message» con mittente, data, oggetto e destinatario originali, e sopra di esso la tua nota. Se `false`, reinvia il contenuto originale senza modifiche.

- `comment` (string): Una nota in testo semplice da inserire sopra il messaggio inoltrato. Usata solo con `include_headers`. `body` è accettato come alias.

- `html` (string): Una nota HTML da usare nella parte HTML al posto di `comment` con escape. Usata solo con `include_headers`.

- `text` (string): Una nota in testo semplice da usare nella parte di testo al posto di `comment`. Usata solo con `include_headers`.

- `from` (string): Il mittente. Per impostazione predefinita è il `from` dell’email originale.

- `subject` (string): L’oggetto. Per impostazione predefinita è l’oggetto originale, oppure, con `include_headers`, `Fwd: ` seguito dall’oggetto originale.

Gli allegati originali sono inclusi quando il loro tipo di file è [consentito](/it/docs/api-reference/emails/send/#attachment-object).

## Restituisce

Restituisce lo stesso oggetto di [Invia un’email](/it/docs/api-reference/emails/send/), con due campi in più:

- `original_id` (string): L’ID dell’email che hai inoltrato.

- `message` (string): Un messaggio di conferma.

Oltre il limite di inoltri, l’API restituisce `429` con un header `retry-after`.

**Richiesta** `POST /emails/{id}/forward`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  to: 'grace@example.com',
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  "to": "grace@example.com",
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', [
  'to' => 'grace@example.com',
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  to: "grace@example.com"
})
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", emailit.ForwardEmailRequest{
  To: "grace@example.com",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", ForwardEmail {
    to: "grace@example.com".into(),
    ..Default::default()
}).await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", Map.of(
  "to", "grace@example.com"
));
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", new ForwardEmailRequest {
  To = "grace@example.com"
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', [
  'to' => 'grace@example.com',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/forward \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "grace@example.com"
  }'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/forward \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: fwd-inv-1042-grace" \
  -d '{
    "to": ["grace@example.com"],
    "include_headers": true,
    "comment": "Grace, here is the invoice Ada asked about."
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  to: ['grace@example.com'],
  include_headers: true,
  comment: 'Grace, here is the invoice Ada asked about.',
});
```

**Python**

```python
email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  "to": ["grace@example.com"],
  "include_headers": True,
  "comment": "Grace, here is the invoice Ada asked about."
})
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "original_id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "token": "4KWzEED2cnej6UMjF4v508VqQIp",
  "message_id": "<4KWzEED2cnej6UMjF4v508VqQIp@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": ["grace@example.com"],
  "subject": "Fwd: Your invoice INV-1042",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T13:20:07.915203Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "message": "Email has been queued for forwarding"
}
```

**400**

```json
{
  "error": "Validation failed",
  "validation_errors": ["Invalid to email address at index 0: grace@example"]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

**422 In entrata**

```json
{
  "error": "Cannot forward email",
  "message": "Only outgoing emails can be forwarded"
}
```

**422 Eliminata**

```json
{
  "error": "Cannot forward email",
  "message": "Email raw content has been purged and can no longer be forwarded"
}
```

**429**

```json
{
  "error": "too_many_requests",
  "message": "Forwarding is limited to 3 emails per hour for this workspace. Try again later.",
  "limit": 3,
  "current": 4,
  "retry_after": 2711
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/forward/

## Recupera solo lo stato — GET /email/{id}

> Recupera solo lo stato di consegna attuale di un’email per ID, senza header, contenuto o metadati, per controlli rapidi dello stato.

# Recupera solo lo stato

Restituisce solo lo stato attuale di un’email.

`GET /email/{id}`

Richiede una chiave API `full`. Nota il singolare `/email` nel percorso. La risposta è piccola, quindi questo endpoint è comodo per controllare rapidamente lo stato. Per ricevere i cambi di stato nel momento in cui avvengono, usa i [webhook](/it/docs/webhooks/) invece del polling.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’email.

## Restituisce

- `status` (string): Lo stato attuale: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` o `held`. Vedi [Stati delle email](/it/docs/logs/email-statuses/).

**Richiesta** `GET /email/{id}`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const { status } = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8",
  headers={"Authorization": "Bearer your_api_key"}
)
status = response.json()["status"]
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$status = json_decode(curl_exec($ch), true)['status'];
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
status = JSON.parse(http.request(req).body)["status"]
```

**Go**

```go
req, _ := http.NewRequest("GET", "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8", nil)
req.Header.Set("Authorization", "Bearer your_api_key")

resp, err := http.DefaultClient.Do(req)
if err != nil {
  return err
}
defer resp.Body.Close()

var result struct {
  Status string `json:"status"`
}
err = json.NewDecoder(resp.Body).Decode(&result)
```

**Rust**

```rust
let response: serde_json::Value = reqwest::Client::new()
    .get("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8")
    .bearer_auth("your_api_key")
    .send()
    .await?
    .json()
    .await?;
let status = response["status"].as_str();
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using System.Net.Http.Headers;
using System.Net.Http.Json;

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "your_api_key");

var result = await http.GetFromJsonAsync<Dictionary<string, string>>(
  "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8");
var status = result["status"];
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$status = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8')
  ->json('status');
```

**cURL**

```bash
curl https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "status": "delivered"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/emails/status/