# E-mails API

> Envoyez des e-mails, consultez les messages et leur contenu, et programmez, annulez, relancez ou transférez-les.

URL de base : `https://api.emailit.com/v2`. Authentifiez-vous avec `Authorization: Bearer <API key>`.

## Envoyer un e-mail — POST /emails

> Envoyez un e-mail à un ou plusieurs destinataires avec du HTML ou du texte, un modèle, des pièces jointes, des en-têtes personnalisés, des métadonnées, une programmation et un suivi.

# Envoyer un e-mail

Envoie un e-mail depuis un domaine d’envoi vérifié. Chaque destinataire reçoit une copie distincte avec son propre ID d’e-mail, et chaque destinataire coûte un crédit.

`POST /emails`

Fonctionne avec les clés API `sending` et `full`. Les envois sont décomptés des [limites d’envoi](/fr/docs/api-reference/rate-limits/) de l’espace de travail, et une réponse positive signifie que l’e-mail est accepté et mis en file d’attente, pas encore livré. Suivez la livraison avec les [webhooks](/fr/docs/webhooks/) ou [Récupérer un e-mail](/fr/docs/api-reference/emails/get/). Les espaces de travail non vérifiés ne peuvent envoyer qu’aux adresses e-mail de compte de leurs membres.

## En-têtes

- `Idempotency-Key` (string): Une clé unique de 256 caractères au maximum : lettres, chiffres, `-` et `_`. Une relance avec la même clé dans les 24 heures renvoie la première réponse au lieu d’envoyer de nouveau. Consultez [Idempotence](/fr/docs/api-reference/idempotency/).

## Paramètres du corps

- `from` (string, obligatoire): L’expéditeur, sous la forme `hello@acme.com` ou `Acme <hello@acme.com>`. L’adresse doit appartenir à un domaine d’envoi vérifié de l’espace de travail, et au domaine de la clé si celle-ci est [limitée à un domaine](/fr/docs/api-reference/authentication/#restrict-a-key-to-one-domain).

- `to` (string | string[], obligatoire): Les destinataires, sous forme de tableau ou de chaîne séparée par des virgules. Chaque entrée peut être `ada@example.com` ou `Ada Lovelace <ada@example.com>`. 50 au maximum.

- `cc` (string | string[]): Destinataires en copie. 50 au maximum.

- `bcc` (string | string[]): Destinataires en copie cachée. 50 au maximum. Ils n’apparaissent pas dans les en-têtes du message.

- `reply_to` (string | string[]): Adresses de réponse. Si vous envoyez avec un modèle sans renseigner ce champ, l’adresse de réponse du modèle est utilisée.

- `subject` (string): La ligne d’objet. Obligatoire, sauf si `template` en fournit une.

- `html` (string): Le corps HTML. Vous devez fournir `html`, `text` ou les deux, sauf si `template` fournit le contenu.

- `text` (string): Le corps en texte brut. Si vous envoyez à la fois `html` et `text`, les destinataires reçoivent un message multipart.

- `template` (string): Un modèle à envoyer. Transmettez un ID de modèle (`tem_…`) pour utiliser cette version précise, ou un alias pour utiliser sa version publiée. Les champs `subject`, `html` et `text` de la requête remplacent ceux du modèle. Consultez [Modèles](/fr/docs/templates/).

- `variables` (object): Les valeurs des variables [Temple](/fr/docs/templates/temple/), comme `{{first_name}}`, insérées lors du rendu de l’objet, du HTML et du texte. Fonctionne avec les modèles comme avec un contenu fourni directement dans la requête.

- `attachments` (object[]): Les fichiers à joindre. Consultez [Objet pièce jointe](#attachment-object) ci-dessous.

- `headers` (object): En-têtes MIME supplémentaires sous forme de paires nom-valeur, par exemple `{"List-Unsubscribe": "<https://acme.com/unsubscribe>"}`. Emailit définit lui-même `Message-ID`.

- `meta` (object): Vos propres données clé-valeur, par exemple `{"order_id": "1042"}`. Les valeurs doivent être des chaînes. Stockées avec l’e-mail et incluses dans les lectures et les payloads de webhook.

- `scheduled_at` (string): Date d’envoi, sous forme de date-heure ISO 8601, comme `2026-10-02T09:00:00Z`, ou en anglais, comme `tomorrow at 9am`. Indiquez un fuseau horaire dans les valeurs ISO 8601. Une date passée, ou une valeur impossible à analyser (y compris un horodatage Unix), envoie l’e-mail immédiatement. Les e-mails programmés ont le statut `scheduled` jusqu’à leur envoi.

- `tracking` (boolean | object): Active ou désactive le suivi des ouvertures et des clics pour cet e-mail : `true`, `false` ou `{"loads": true, "clicks": false}`. Par défaut : les paramètres du domaine d’envoi. Le suivi ne fonctionne que lorsque le [CNAME de suivi](/fr/docs/tracking/custom-tracking-domain/) du domaine est vérifié ; sinon, il est désactivé et la réponse indique `false`.

### Objet pièce jointe

- `filename` (string, obligatoire): Le nom du fichier, avec une extension autorisée (voir ci-dessous).

- `content` (string): Le fichier, encodé en Base64. Envoyez `content` ou `url`, pas les deux.

- `url` (string): Une URL publique `http` ou `https` depuis laquelle télécharger le fichier. Emailit le récupère au moment de l’envoi : le téléchargement doit se terminer en 30 secondes, ne pas dépasser 25 Mo et ne comporter aucune redirection.

- `content_type` (string): Le type MIME, comme `application/pdf`. Obligatoire avec `content`. Avec `url`, vaut par défaut le type renvoyé par le serveur.

- `content_id` (string): Rend la pièce jointe intégrée. Faites-y référence dans le HTML avec `<img src="cid:logo">` lorsque `content_id` vaut `logo`.

- `encoding` (string): L’encodage de `content`, comme `base64` ou `hex`.

Le message complet, pièces jointes comprises, peut atteindre 40 Mo. Les types de fichiers suivants sont autorisés :

| Catégorie | Extensions |
| --- | --- |
| Texte | `.txt`, `.csv`, `.log`, `.css`, `.ics`, `.xml` |
| Images | `.jpg`, `.jpe`, `.jpeg`, `.gif`, `.png`, `.bmp`, `.psd`, `.tif`, `.tiff`, `.svg`, `.indd`, `.ai`, `.eps` |
| Documents | `.doc`, `.docx`, `.rtf`, `.odt`, `.ott`, `.pdf`, `.pub`, `.pages`, `.mobi`, `.epub` |
| Audio | `.mp3`, `.m4a`, `.m4v`, `.wma`, `.ogg`, `.flac`, `.wav`, `.aif`, `.aifc`, `.aiff` |
| Vidéo | `.mp4`, `.mov`, `.avi`, `.mkv`, `.mpeg`, `.mpg`, `.wmv` |
| Feuilles de calcul | `.xls`, `.xlsx`, `.ods`, `.numbers` |
| Présentations | `.odp`, `.ppt`, `.pptx`, `.pps`, `.key` |
| Archives | `.zip`, `.vcf` |
| E-mail | `.eml` |
| Cryptographie | `.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig` |

## Réponse

Renvoie `200` avec l’objet e-mail du premier destinataire. Lorsque le message a plusieurs destinataires dans `to`, `cc` et `bcc`, `ids` associe chaque destinataire à l’ID de sa copie. Chaque copie déclenche l’événement [`email.accepted`](/fr/docs/webhooks/events/email/accepted/) ou [`email.scheduled`](/fr/docs/webhooks/events/email/scheduled/).

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

- `id` (string): L’ID de l’e-mail du premier destinataire.

- `ids` (object): Correspondance entre adresse de destinataire et ID d’e-mail, pour chaque destinataire. Présent uniquement s’il y a plusieurs destinataires.

- `token` (string): Le jeton interne du premier e-mail.

- `message_id` (string): L’en-tête `Message-ID` du premier e-mail, comme `<token@acme.com>`.

- `from` (string): L’expéditeur, tel que vous l’avez envoyé.

- `to` (string[]): Les adresses `to`, sans noms d’affichage ni doublons.

- `cc` (string[]): Les destinataires `cc`. Présent uniquement si vous en avez indiqué.

- `bcc` (string[]): Les destinataires `bcc`. Présent uniquement si vous en avez indiqué.

- `subject` (string): L’objet, après le rendu du modèle et des variables.

- `status` (string): `accepted`, ou `scheduled` pour une valeur `scheduled_at` future.

- `scheduled_at` (string | null): Date à laquelle l’e-mail sera envoyé, ou `null`.

- `created_at` (string): Date à laquelle l’e-mail a été accepté.

- `tracking` (object): Le suivi qui s’applique : booléens `loads` et `clicks`.

**Requête** `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 Programmé**

```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 vérifié**

```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 Domaine**

```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
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/send/

## Lister les e-mails — GET /emails

> Listez les e-mails sortants ou entrants d’un espace de travail, du plus récent au plus ancien, avec recherche, filtres, tri et une fenêtre par défaut de 14 jours.

# Lister les e-mails

Renvoie une page d’e-mails, du plus récent au plus ancien. Par défaut, la liste affiche les e-mails sortants des 14 derniers jours.

`GET /emails`

Nécessite une clé API `full`. Chaque destinataire d’un envoi correspond à un e-mail distinct dans cette liste.

## Paramètres de requête

- `page` (integer): La page à renvoyer.

- `limit` (integer): Nombre d’e-mails par page, de 1 à 100.

- `type` (string): `outbound` pour les e-mails que vous avez envoyés, ou `inbound` pour les e-mails que vous avez [reçus](/fr/docs/inbound/).

- `date_from` (string): Uniquement les e-mails créés à cette date ou après, comme `2026-08-01` (à partir de 0 h 00 UTC). Sans ce paramètre, la liste commence il y a 14 jours. Les filtres `created_at` ne modifient pas cette fenêtre.

- `date_to` (string): Uniquement les e-mails créés à cette date ou avant, jusqu’à 23 h 59 min 59 s UTC.

- `search` (string): Recherche insensible à la casse sur le destinataire, l’expéditeur ou l’objet.

- `match` (string): `all` ou `or`. Mode de combinaison des filtres ci-dessous.

- `order` (string): Une clé de tri du tableau ci-dessous.

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

## Filtres

Ajoutez des filtres sous la forme `key.condition=value`, par exemple `status.exact=bounced` ou `created_at.after=2026-09-01`. Pour les conditions de chaque type, consultez [Filtrage et tri](/fr/docs/api-reference/filtering/).

| Clé | Type | Valeurs et remarques |
| --- | --- | --- |
| `to` | string | Adresse du destinataire. |
| `from` | string | Expéditeur tel qu’envoyé, avec son éventuel nom d’affichage. |
| `subject` | string | |
| `status` | enum | `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled`, `held` |
| `tag` | string | Le tag de l’e-mail. Les envois via l’API ou SMTP ne définissent pas de tag pour le moment. |
| `spam_score` | number | |
| `created_at` | date | |
| `updated_at` | date | |
| `api_key_id` | string | ID de la clé API qui a envoyé l’e-mail (`key_…`). |
| `sending_domain_id` | string | ID du domaine d’envoi (`dom_…`). |

Chaque clé est aussi une clé de tri. Les anciens paramètres de requête `status`, `rcpt_to`, `mail_from`, `subject`, `api_key_id` et `sending_domain_id` fonctionnent toujours : `status` recherche une correspondance exacte, et les paramètres d’adresse et d’objet une correspondance partielle.

## Réponse

Renvoie un tableau `data` d’objets e-mail avec `next_page_url` et `previous_page_url`. Consultez [Pagination](/fr/docs/api-reference/pagination/). Les URL de page ne reprennent pas vos filtres : demandez la page suivante avec vos propres paramètres en augmentant `page` de un.

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

- `id` (string): L’ID de l’e-mail.

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

- `from` (string): L’expéditeur tel qu’envoyé.

- `to` (string): Le destinataire de cette copie.

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

- `status` (string): Le [statut](/fr/docs/logs/email-statuses/) actuel.

- `size` (integer): Taille du message, en octets.

- `scheduled_at` (string | null): Date d’envoi prévue d’un e-mail programmé, ou `null`.

- `created_at` (string): Date à laquelle l’e-mail a été accepté ou reçu.

- `updated_at` (string): Date du dernier changement de statut.

- `meta` (object | null): Le `meta` que vous avez envoyé.

**Requête** `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"
    }
  ]
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/list/

## Récupérer un e-mail — GET /emails/{id}

> Récupérez un e-mail sortant ou entrant par son ID, avec son statut, ses en-têtes, son corps HTML et texte analysé, ses métadonnées et ses pièces jointes.

# Récupérer un e-mail

Récupère un e-mail avec son statut, ses en-têtes analysés, son corps HTML et texte, et ses pièces jointes.

`GET /emails/{id}`

Nécessite une clé API `full`. Le contenu des messages est conservé pendant la [durée de conservation](/fr/docs/data-retention/) du contenu prévue par votre forfait. Ensuite, `headers`, `body` et `attachments` sont vides, mais le statut et les métadonnées restent disponibles. Pour ne récupérer qu’une partie d’un e-mail, utilisez [Récupérer le corps](/fr/docs/api-reference/emails/body/), [Récupérer les métadonnées](/fr/docs/api-reference/emails/meta/), [Lister les pièces jointes](/fr/docs/api-reference/emails/attachments/) ou [Récupérer le MIME brut](/fr/docs/api-reference/emails/raw/).

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail, comme `em_4KYof1ZzXndZE2VPi0DgULiekG8`.

## Réponse

Renvoie l’objet e-mail.

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

- `id` (string): L’ID de l’e-mail.

- `type` (string): `outbound` pour les e-mails que vous avez envoyés, `inbound` pour les e-mails que vous avez reçus.

- `token` (string): Le jeton interne de l’e-mail.

- `message_id` (string): L’en-tête `Message-ID`.

- `from` (string): L’expéditeur tel qu’envoyé, comme `Acme <hello@acme.com>`.

- `to` (string): Le destinataire de cette copie.

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

- `status` (string): Le statut actuel : `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` ou `held`. Consultez [Statuts des e-mails](/fr/docs/logs/email-statuses/).

- `size` (integer): Taille du message, en octets.

- `scheduled_at` (string | null): Date d’envoi prévue d’un e-mail programmé, ou `null`.

- `created_at` (string): Date à laquelle l’e-mail a été accepté ou reçu.

- `updated_at` (string): Date de la dernière modification de l’e-mail.

- `tracking` (object): E-mails sortants uniquement. Indique si le suivi des ouvertures (`loads`) et des clics (`clicks`) est activé.

- `meta` (object | null): Le `meta` que vous avez envoyé, ou `null`.

- `headers` (object | null): Les en-têtes du message sous forme de paires nom-valeur, ou `null` une fois le contenu purgé.

- `body` (object): `text` et `html`, chacun étant une chaîne ou `null`.

- `attachments` (object[]): Les pièces jointes, chacune avec `filename`, `content_type`, `size` en octets, `content_id` (pour les fichiers intégrés), `content_disposition` (`attachment` ou `inline`) et `content` (Base64).

**Requête** `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 Sortant**

```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 Entrant**

```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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/get/

## Récupérer le MIME brut — GET /emails/{id}/raw

> Récupérez la source MIME brute et complète d’un e-mail, en-têtes compris, ainsi que le statut et les métadonnées de l’e-mail.

# Récupérer le MIME brut

Récupère la source MIME complète d’un e-mail telle qu’Emailit l’a stockée, ainsi que ses métadonnées.

`GET /emails/{id}/raw`

Nécessite une clé API `full`. Utilisez-le pour archiver un message, déboguer sa structure ou l’analyser avec votre propre bibliothèque MIME. Une fois la [durée de conservation](/fr/docs/data-retention/) du contenu écoulée, `raw` et `headers` valent `null`.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail.

## Réponse

Renvoie les métadonnées de l’e-mail, comme [Récupérer les métadonnées](/fr/docs/api-reference/emails/meta/) mais sans `attachments`, ainsi que le message brut.

- `raw` (string | null): Le message MIME complet : les en-têtes, une ligne vide et le corps. `null` une fois le contenu purgé.

- `headers` (object | null): Les en-têtes de premier niveau sous forme de paires nom-valeur.

Les autres champs (`object`, `id`, `type`, `token`, `message_id`, `from`, `to`, `subject`, `status`, `size`, `scheduled_at`, `created_at`, `updated_at`, `tracking` et `meta`) sont les mêmes que dans [Récupérer un e-mail](/fr/docs/api-reference/emails/get/).

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/raw/

## Lister les pièces jointes — GET /emails/{id}/attachments

> Listez les pièces jointes d’un e-mail avec leur nom de fichier, leur type MIME, leur taille, l’ID de contenu des fichiers intégrés et leur contenu encodé en Base64.

# Lister les pièces jointes

Renvoie les pièces jointes d’un e-mail, contenu compris.

`GET /emails/{id}/attachments`

Nécessite une clé API `full`. Fonctionne pour les e-mails sortants et entrants. Les images intégrées (parties dotées d’un `Content-ID`) sont incluses. Pour obtenir la liste sans le contenu des fichiers, utilisez [Récupérer les métadonnées](/fr/docs/api-reference/emails/meta/). Une fois la [durée de conservation](/fr/docs/data-retention/) du contenu écoulée, la liste est vide.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail.

## Réponse

Renvoie un objet liste avec toutes les pièces jointes. La liste n’est pas paginée.

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

- `data` (object[]): Les pièces jointes.

- `data[].filename` (string): Le nom du fichier.

- `data[].content_type` (string): Le type MIME, comme `application/pdf`.

- `data[].size` (integer): Taille du fichier décodé, en octets.

- `data[].content_id` (string | null): Le `Content-ID` d’une pièce jointe intégrée, ou `null`.

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

- `data[].content` (string): Le fichier, encodé en Base64.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/attachments/

## Récupérer le corps — GET /emails/{id}/body

> Récupérez uniquement le corps HTML et texte brut analysé d’un e-mail, sans en-têtes, métadonnées ni pièces jointes.

# Récupérer le corps

Renvoie le corps HTML et texte brut d’un e-mail, décodé à partir de ses parties MIME.

`GET /emails/{id}/body`

Nécessite une clé API `full`. Fonctionne pour les e-mails sortants et entrants. Pour les e-mails sortants, le corps correspond à ce qui a été envoyé, après le rendu du modèle et des variables. Une fois la [durée de conservation](/fr/docs/data-retention/) du contenu écoulée, les deux champs valent `null`.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail.

## Réponse

- `text` (string | null): La partie texte brut, ou `null` si l’e-mail n’en a pas.

- `html` (string | null): La partie HTML, ou `null` si l’e-mail n’en a pas.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/body/

## Récupérer les métadonnées — GET /emails/{id}/meta

> Récupérez le statut, les en-têtes, les métadonnées et la liste des pièces jointes d’un e-mail sans télécharger le corps du message ni le contenu des pièces jointes.

# Récupérer les métadonnées

Récupère un e-mail sans son corps : statut, en-têtes, vos données `meta` et la liste des pièces jointes sans leur contenu.

`GET /emails/{id}/meta`

Nécessite une clé API `full`. C’est la façon la plus légère de lire les détails d’un e-mail lorsque vous n’avez pas besoin du contenu.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail.

## Réponse

Renvoie les mêmes champs que [Récupérer un e-mail](/fr/docs/api-reference/emails/get/), sans `body`, et avec des `attachments` décrites mais pas incluses :

- `attachments` (object[]): Pour chaque pièce jointe : `filename`, `content_type`, `size`, `content_id` et `content_disposition`. Pas de `content`.

- `headers` (object | null): Les en-têtes du message sous forme de paires nom-valeur, ou `null` une fois le contenu purgé.

- `meta` (object | null): Le `meta` que vous avez envoyé avec l’e-mail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/meta/

## Mettre à jour un e-mail programmé — POST /emails/{id}

> Modifiez l’heure d’envoi d’un e-mail programmé. Possible jusqu’à trois minutes avant l’envoi prévu ; la nouvelle heure doit se situer au moins trois minutes plus tard.

# Mettre à jour un e-mail programmé

Déplace un e-mail programmé vers une nouvelle heure d’envoi.

`POST /emails/{id}`

Fonctionne avec les clés API `sending` et `full`. Vous ne pouvez reprogrammer qu’un e-mail dont le statut est `scheduled` et dont l’heure d’envoi actuelle est dans plus de 3 minutes. Seule l’heure d’envoi peut changer ; pour modifier le contenu, [annulez](/fr/docs/api-reference/emails/cancel/) l’e-mail et envoyez-en un nouveau.

Un envoi programmé à plusieurs destinataires crée un e-mail par destinataire. Reprogrammez chaque ID listé dans l’objet `ids` de la [réponse d’envoi](/fr/docs/api-reference/emails/send/).

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail programmé.

## Paramètres du corps

- `scheduled_at` (string, obligatoire): La nouvelle heure d’envoi, sous forme de date-heure ISO 8601, comme `2026-10-03T09:00:00Z`, ou en anglais, comme `tomorrow at 3pm`. Elle doit se situer dans plus de 3 minutes.

## Réponse

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

- `id` (string): L’ID de l’e-mail.

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

- `scheduled_at` (string): La nouvelle heure d’envoi.

- `updated_at` (string): Date de mise à jour de l’e-mail.

- `message` (string): Un message de confirmation.

Renvoie `422` si l’e-mail n’est pas programmé, s’il doit partir dans moins de 3 minutes, ou si la nouvelle heure est impossible à analyser ou trop proche.

**Requête** `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 programmé**

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

**422 Trop tard**

```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 Heure invalide**

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

---
Source: https://emailit.com/fr/docs/api-reference/emails/update/

## Annuler un e-mail — POST /emails/{id}/cancel

> Annulez un e-mail programmé, accepté ou en échec temporaire et retirez-le de la file d’envoi. Sans garantie : une livraison déjà en cours peut tout de même aboutir.

# Annuler un e-mail

Retire un e-mail de la file d’envoi et fait passer son statut à `canceled`.

`POST /emails/{id}/cancel`

Fonctionne avec les clés API `sending` et `full`. L’annulation se fait dans la mesure du possible : elle retire l’e-mail de la file d’attente, mais si une tentative de livraison a déjà commencé, cette tentative peut tout de même aboutir et seules les nouvelles tentatives restantes sont arrêtées. Le champ `in_flight` de la réponse indique le cas qui s’applique. L’annulation déclenche l’[événement](/fr/docs/webhooks/event-types/) `email.canceled`, et le crédit n’est pas remboursé. L’action **Cancel delivery** du tableau de bord fait la même chose.

| Statut | Annulation possible | Remarques |
| --- | --- | --- |
| `scheduled` | Oui | Jusqu’à 3 minutes avant l’heure programmée. |
| `accepted` | Oui | En file d’attente et pas encore livré. |
| `attempted` | Oui | Arrête les nouvelles tentatives restantes après un échec temporaire. |
| Tout autre statut | Non | L’e-mail a déjà été livré, est en échec ou a déjà été annulé. |

Pour annuler un envoi à plusieurs destinataires, annulez chaque ID listé dans l’objet `ids` de la [réponse d’envoi](/fr/docs/api-reference/emails/send/).

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail.

## Réponse

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

- `id` (string): L’ID de l’e-mail.

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

- `in_flight` (boolean): `true` si une tentative de livraison est peut-être déjà en cours et pourrait encore aboutir. `false` si l’e-mail a été retiré de la file d’attente avant toute tentative.

- `message` (string): Une description du résultat.

**Requête** `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 En cours**

```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 Statut**

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

**422 Trop tard**

```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)."
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/cancel/

## Relancer un e-mail — POST /emails/{id}/retry

> Renvoyez un e-mail rebondi, en échec, bloqué ou retenu sous la forme d’un nouvel e-mail avec un nouvel ID. L’original reste inchangé.

# Relancer un e-mail

Met en file d’attente une copie d’un e-mail qui n’est pas parvenu à destination. La copie est un nouvel e-mail avec son propre ID, et l’original conserve son statut.

`POST /emails/{id}/retry`

Fonctionne avec les clés API `sending` et `full`. La copie a les mêmes expéditeur, destinataire, objet, contenu, en-têtes, `meta` et paramètres de suivi, avec un nouveau `Message-ID`. Elle coûte des crédits comme un nouvel envoi : un crédit, ou deux pour un e-mail de campagne.

Vous pouvez relancer un e-mail lorsque :

- Son statut est `bounced`, `failed`, `suppressed` ou `held`.
- Il a été créé au cours des 30 derniers jours.
- Son contenu n’a pas été purgé selon votre [durée de conservation](/fr/docs/data-retention/), et son domaine d’envoi existe toujours.

Corrigez d’abord la cause. Une adresse bloquée qui figure toujours dans votre [liste d’adresses bloquées](/fr/docs/suppressions/) est de nouveau bloquée, et un e-mail [retenu](/fr/docs/logs/email-statuses/) est de nouveau retenu tant que la raison de sa rétention n’est pas résolue.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail à relancer.

## Réponse

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

- `id` (string): L’ID du nouvel e-mail.

- `original_id` (string): L’ID de l’e-mail relancé.

- `token` (string): Le jeton interne du nouvel e-mail.

- `message_id` (string): Le `Message-ID` du nouvel e-mail.

- `from` (string): L’expéditeur.

- `to` (string): Le destinataire.

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

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

- `created_at` (string): Date de création du nouvel e-mail.

- `message` (string): Un message de confirmation.

**Requête** `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 Statut**

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

**422 Trop ancien**

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

**422 Purgé**

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

---
Source: https://emailit.com/fr/docs/api-reference/emails/retry/

## Transférer un e-mail — POST /emails/{id}/forward

> Renvoyez un e-mail sortant à de nouveaux destinataires, tel quel ou avec un en-tête de message transféré et une note facultative. Limité à 3 par heure.

# Transférer un e-mail

Envoie le contenu d’un e-mail sortant à de nouveaux destinataires, sous la forme d’un nouvel e-mail. L’e-mail d’origine n’est pas modifié.

`POST /emails/{id}/forward`

Fonctionne avec les clés API `sending` et `full`. Par défaut, le transfert renvoie simplement le HTML, le texte et les pièces jointes d’origine. Définissez `include_headers` pour ajouter un bloc « Forwarded message » et une note facultative au-dessus du contenu d’origine.

Un transfert est un nouvel envoi : les règles d’[Envoyer un e-mail](/fr/docs/api-reference/emails/send/) s’appliquent donc. L’adresse `from` doit appartenir à un domaine d’envoi vérifié, chaque destinataire coûte un crédit et est décompté des [limites d’envoi](/fr/docs/api-reference/rate-limits/), le suivi respecte les paramètres du domaine, et l’en-tête `Idempotency-Key` est pris en charge. En outre, un espace de travail peut transférer au maximum 3 e-mails par heure.

Seuls les e-mails sortants peuvent être transférés, et uniquement tant que leur contenu est conservé selon votre [durée de conservation](/fr/docs/data-retention/). Pour transférer des e-mails reçus, utilisez une [automatisation](/fr/docs/inbound/forward-with-automations/).

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail sortant à transférer.

## En-têtes

- `Idempotency-Key` (string): Permet de relancer le transfert sans risque. Consultez [Idempotence](/fr/docs/api-reference/idempotency/).

## Paramètres du corps

- `to` (string | string[], obligatoire): Les nouveaux destinataires, sous forme de tableau ou de chaîne séparée par des virgules. 50 au maximum.

- `include_headers` (boolean): Si `true`, ajoute un bloc « Forwarded message » avec l’expéditeur, la date, l’objet et le destinataire d’origine, surmonté de votre note. Si `false`, renvoie le contenu d’origine sans modification.

- `comment` (string): Une note en texte brut à placer au-dessus du message transféré. Utilisée uniquement avec `include_headers`. `body` est accepté comme alias.

- `html` (string): Une note HTML à utiliser à la place du `comment` échappé dans la partie HTML. Utilisée uniquement avec `include_headers`.

- `text` (string): Une note en texte brut à utiliser à la place de `comment` dans la partie texte. Utilisée uniquement avec `include_headers`.

- `from` (string): L’expéditeur. Par défaut : le `from` de l’e-mail d’origine.

- `subject` (string): L’objet. Par défaut : l’objet d’origine, ou `Fwd: ` suivi de l’objet d’origine avec `include_headers`.

Les pièces jointes d’origine sont incluses lorsque leur type de fichier est [autorisé](/fr/docs/api-reference/emails/send/#attachment-object).

## Réponse

Renvoie le même objet qu’[Envoyer un e-mail](/fr/docs/api-reference/emails/send/), avec deux champs supplémentaires :

- `original_id` (string): L’ID de l’e-mail transféré.

- `message` (string): Un message de confirmation.

Au-delà de la limite de transferts, l’API renvoie `429` avec un en-tête `retry-after`.

**Requête** `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 Entrant**

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

**422 Purgé**

```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
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/forward/

## Récupérer uniquement le statut — GET /email/{id}

> Récupérez seulement le statut de livraison actuel d’un e-mail par son ID, sans en-têtes, contenu ni métadonnées, pour des vérifications de statut légères.

# Récupérer uniquement le statut

Renvoie uniquement le statut actuel d’un e-mail.

`GET /email/{id}`

Nécessite une clé API `full`. Notez le singulier `/email` dans le chemin. La réponse est courte, ce qui rend cet endpoint pratique pour vérifier rapidement un statut. Pour suivre les changements de statut au fil de l’eau, utilisez des [webhooks](/fr/docs/webhooks/) plutôt que d’interroger régulièrement l’API.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de l’e-mail.

## Réponse

- `status` (string): Le statut actuel : `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` ou `held`. Consultez [Statuts des e-mails](/fr/docs/logs/email-statuses/).

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/emails/status/