Envoyer un email

Envoyez un email unique à un ou plusieurs destinataires. Prend en charge les modèles, les variables, les pièces jointes, la programmation et le suivi.

POST /emails

## En-têtes

Authorization string Required

Jeton Bearer pour l’authentification.

Idempotency-Key string

Clé unique (max 256 caractères, alphanumérique/tiret/underscore) pour éviter les envois en double pendant 24 heures.

## Corps de la requête

from string Required

Email de l’expéditeur au format RFC : email@domaine.com ou Nom d'affichage <email@domaine.com>.

to string | string[] Required

Adresse(s) email du/des destinataire(s). Maximum 50 destinataires.

subject string

Objet de l’email. Obligatoire sauf si le modèle le fournit.

html string

Contenu HTML de l’email. Obligatoire sauf si le modèle le fournit ou si le texte brut est fourni.

text string

Contenu en texte brut de l’email.

reply_to string | string[]

Adresse(s) email de réponse.

cc string | string[]

Destinataires en copie. Maximum 50 destinataires.

bcc string | string[]

Destinataires en copie cachée. Maximum 50 destinataires.

template string

Alias ou ID du modèle (format tem_xxx).

variables object

Variables pour la substitution dans le modèle utilisant la syntaxe {{variable}}.

attachments array

Tableau d’objets de pièces jointes (voir Objet Pièce jointe ci-dessous).

headers object

En-têtes d’email personnalisés sous forme de paires clé-valeur.

meta object

Métadonnées sous forme de paires clé-valeur de chaînes. Stockées et retournées avec l’email.

scheduled_at string

Heure d’envoi programmée. Accepte ISO 8601, timestamp Unix, ou langage naturel comme demain à 9h.

tracking boolean | object

Remplace les paramètres de suivi par défaut du domaine. Peut être un booléen ou un objet avec les propriétés loads et clicks.

## Objet Pièce jointe

filename string Required

Nom du fichier avec extension.

content string

Contenu encodé en Base64. Mutuellement exclusif avec url.

url string

URL pour récupérer la pièce jointe. Mutuellement exclusif avec content.

content_type string

Type MIME. Obligatoire lors de l’utilisation de content.

content_id string

Content-ID pour les images intégrées (cid:).

encoding string

Encodage du contenu (par défaut : base64).

## Types de fichiers autorisés en pièce jointe

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`
Tableurs	`.xls`, `.xlsx`, `.ods`, `.numbers`
Présentations	`.odp`, `.ppt`, `.pptx`, `.pps`, `.key`
Archives	`.zip`, `.vcf`
Email	`.eml`
Cryptographique	`.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig`

En-têtes de limitation de débit

Les en-têtes suivants sont inclus dans chaque réponse :

En-tête	Description
ratelimit-limit	Nombre maximum de requêtes par seconde
ratelimit-remaining	Requêtes restantes dans la seconde actuelle
ratelimit-reset	Secondes avant la réinitialisation de la limite
ratelimit-daily-limit	Nombre maximum de requêtes quotidiennes
ratelimit-daily-remaining	Requêtes quotidiennes restantes
ratelimit-daily-reset	Secondes avant la réinitialisation de la limite quotidienne

::code-snippet{title=“Envoyer un email”}

const response = await fetch('https://api.emailit.com/v2/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    from: 'Votre Entreprise <hello@votredomaine.com>',
    to: ['destinataire1@exemple.com', 'destinataire2@exemple.com'],
    subject: 'Bonjour le monde',
    html: '<h1>Bienvenue !</h1><p>Merci de vous être inscrit.</p>',
    tracking: {
      loads: true,
      clicks: true
    }
  })
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => 'https://api.emailit.com/v2/emails',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => json_encode([
    'from' => 'Votre Entreprise <hello@votredomaine.com>',
    'to' => ['destinataire1@exemple.com', 'destinataire2@exemple.com'],
    'subject' => 'Bonjour le monde',
    'html' => '<h1>Bienvenue !</h1><p>Merci de vous être inscrit.</p>',
    'tracking' => [
      'loads' => true,
      'clicks' => true
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type: application/json'
  ],
]);

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

curl_close($curl);

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

import requests

response = requests.post(
    'https://api.emailit.com/v2/emails',
    headers={
        'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
        'Content-Type': 'application/json'
    },
    json={
        'from': 'Votre Entreprise <hello@votredomaine.com>',
        'to': ['destinataire1@exemple.com', 'destinataire2@exemple.com'],
        'subject': 'Bonjour le monde',
        'html': '<h1>Bienvenue !</h1><p>Merci de vous être inscrit.</p>',
        'tracking': {
            'loads': True,
            'clicks': True
        }
    }
)

result = response.json()
print(result)

require 'net/http'
require 'json'

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

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
  from: 'Votre Entreprise <hello@votredomaine.com>',
  to: ['destinataire1@exemple.com', 'destinataire2@exemple.com'],
  subject: 'Bonjour le monde',
  html: '<h1>Bienvenue !</h1><p>Merci de vous être inscrit.</p>',
  tracking: {
    loads: true,
    clicks: true
  }
}.to_json

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

package main

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

func main() {
    url := "https://api.emailit.com/v2/emails"
    
    data := map[string]interface{}{
        "from": "Votre Entreprise <hello@votredomaine.com>",
        "to": []string{"destinataire1@exemple.com", "destinataire2@exemple.com"},
        "subject": "Bonjour le monde",
        "html": "<h1>Bienvenue !</h1><p>Merci de vous être inscrit.</p>",
        "tracking": map[string]bool{
            "loads": true,
            "clicks": true,
        },
    }
    
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(

Lister les emails

Récupérez la liste des emails de votre espace de travail avec pagination et filtrage optionnel par type.

GET/emails

Paramètres de requête

pageinteger

Numéro de page. Minimum : 1. Par défaut : 1.

limitinteger

Nombre de résultats par page. Plage : 1–100. Par défaut : 10.

typestring

Filtrer par type d’email : inbound ou outbound.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

{
"data": [
{
  "object": "email",
  "id": "em_abc123xyz789def456ghi012jkl345",
  "type": "outbound",
  "from": "expediteur@votredomaine.com",
  "to": "destinataire@exemple.com",
  "subject": "Bonjour le monde",
  "status": "delivered",
  "size": 4523,
  "scheduled_at": null,
  "created_at": "2026-01-08T12:00:00.123456Z",
  "updated_at": "2026-01-08T12:01:00.123456Z",
  "meta": null
},
{
  "object": "email",
  "id": "em_def456ghi789jkl012mno345pqr678",
  "type": "inbound",
  "from": "externe@autredomaine.com",
  "to": "boite@votredomaine.com",
  "subject": "Re: Votre demande",
  "status": "delivered",
  "size": 2891,
  "scheduled_at": null,
  "created_at": "2026-01-08T11:30:00.123456Z",
  "updated_at": "2026-01-08T11:30:00.123456Z",
  "meta": null
}
],
"next_page_url": "/v2/emails?page=2&limit=10",
"previous_page_url": null
}

Récupérer un e-mail

Récupère un e-mail spécifique par son ID, incluant les en-têtes, le contenu analysé et les pièces jointes.

GET/emails/{id}

Paramètres de chemin

idstringRequired

L’ID de l’e-mail au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

Champs de réponse

Champ	Type	Description
`object`	string	Toujours `"email"`
`id`	string	ID de l’e-mail au format `em_xxx`
`type`	string	`"inbound"` (entrant) ou `"outbound"` (sortant)
`token`	string	Jeton de l’e-mail
`message_id`	string	Message-ID SMTP
`from`	string	Adresse e-mail de l’expéditeur
`to`	string	Adresse e-mail du destinataire
`subject`	string	Objet de l’e-mail
`status`	string	Statut actuel de l’e-mail
`size`	integer	Taille de l’e-mail en octets
`scheduled_at`	string \| null	Heure de livraison programmée (ISO 8601)
`created_at`	string	Horodatage de création (ISO 8601)
`updated_at`	string	Horodatage de dernière mise à jour (ISO 8601)
`tracking`	object \| null	Paramètres de suivi (omis pour les e-mails entrants)
`meta`	object \| null	Métadonnées personnalisées
`headers`	object	En-têtes d’e-mail analysés
`body`	object	Corps analysé avec les champs `text` et `html`
`attachments`	array	Pièces jointes analysées avec contenu encodé en base64

Objet Body

Champ	Type	Description
`text`	string \| null	Contenu en texte brut
`html`	string \| null	Contenu HTML

Objet Attachment

Champ	Type	Description
`filename`	string	Nom du fichier joint
`content_type`	string	Type MIME
`size`	integer	Taille de la pièce jointe en octets
`content_id`	string \| null	Content-ID pour les pièces jointes intégrées
`content_disposition`	string	`"attachment"` ou `"inline"`
`content`	string	Contenu de la pièce jointe encodé en base64

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

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "inbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@domaineexterne.com>",
"from": "externe@domaineexterne.com",
"to": "boite@votredomaine.com",
"subject": "Re: Votre demande",
"status": "delivered",
"size": 8234,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"meta": null,
"headers": {
"From": "externe@domaineexterne.com",
"To": "boite@votredomaine.com",
"Subject": "Re: Votre demande",
"Content-Type": "text/plain; charset=utf-8"
},
"body": {
"text": "Merci de nous avoir contactés...",
"html": null
},
"attachments": []
}

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

{
"error": "E-mail introuvable",
"message": "L'e-mail avec l'ID 'em_abc123' est introuvable dans votre espace de travail"
}

Récupérer l’e-mail brut

Renvoie le message MIME brut complet accompagné des métadonnées de l’e-mail.

GET/emails/{id}/raw

Paramètres de chemin

idstringRequired

L’identifiant de l’e-mail au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

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

{
"error": "E-mail introuvable",
"message": "L'e-mail avec l'ID 'em_abc123' est introuvable dans votre espace de travail"
}

Récupérer les pièces jointes d’un e-mail

Retourne uniquement la liste des pièces jointes d’un e-mail, avec le contenu encodé en base64.

GET/emails/{id}/attachments

Paramètres de chemin

idstringRequired

L’identifiant de l’e-mail au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

Champs de réponse

Champ	Type	Description
`object`	string	Toujours `"list"`
`data`	array	Tableau d’objets pièce jointe

Objet pièce jointe

Champ	Type	Description
`filename`	string	Nom du fichier joint
`content_type`	string	Type MIME
`size`	integer	Taille de la pièce jointe en octets
`content_id`	string \| null	Content-ID pour les pièces jointes intégrées
`content_disposition`	string	`"attachment"` ou `"inline"`
`content`	string	Contenu de la pièce jointe encodé en base64

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

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

{
"error": "E-mail introuvable",
"message": "L'e-mail avec l'ID 'em_abc123' n'a pas été trouvé dans votre espace de travail"
}

Récupérer le contenu d’un e-mail

Renvoie uniquement le contenu analysé (texte et HTML) d’un e-mail.

GET/emails/{id}/body

Paramètres de chemin

idstringRequired

L’identifiant de l’e-mail au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

{
"text": "Contenu en texte brut de l'e-mail",
"html": "<html><body><h1>Bienvenue !</h1><p>Contenu HTML de l'e-mail</p></body></html>"
}

{
"text": "Contenu en texte brut de l'e-mail",
"html": null
}

{
"error": "E-mail introuvable",
"message": "L'e-mail avec l'ID 'em_abc123' est introuvable dans votre espace de travail"
}

Récupérer les métadonnées d’un email

Retourne les métadonnées d’un email avec les informations des pièces jointes, mais sans le contenu des pièces jointes. Utile pour examiner un email sans télécharger des données de pièces jointes potentiellement volumineuses.

GET/emails/{id}/meta

Paramètres de chemin

idstringRequired

L’identifiant de l’email au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

Champs de réponse

La réponse inclut tous les champs de métadonnées de l’email plus un tableau attachments avec les informations des pièces jointes (sans le champ content).

Objet Pièce jointe (Métadonnées)

Champ	Type	Description
`filename`	string	Nom du fichier de la pièce jointe
`content_type`	string	Type MIME
`size`	integer	Taille de la pièce jointe en octets
`content_id`	string \| null	Content-ID pour les pièces jointes intégrées
`content_disposition`	string	`"attachment"` ou `"inline"`

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

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

{
"error": "Email introuvable",
"message": "L'email avec l'ID 'em_abc123' n'a pas été trouvé dans votre espace de travail"
}

Modifier un email programmé

Modifie l’heure d’envoi d’un email programmé. Fonctionne uniquement pour les emails ayant le statut « programmé » et seulement si l’heure programmée actuelle est au moins 3 minutes dans le futur.

POST/emails/{id}

Paramètres de chemin

idstringRequired

L’ID de l’email au format em_xxx.

Corps de la requête

scheduled_atstringRequired

Nouvelle heure programmée. Accepte le format ISO 8601, un timestamp Unix, ou un langage naturel comme demain à 9h. Doit être au moins 3 minutes dans le futur.

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

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => json_encode([
'scheduled_at' => '2026-01-10T15:00:00Z'
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
scheduled_at: '2026-01-10T15:00:00Z'
}.to_json

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

package main

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

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

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

jsonData, _ := json.Marshal(data)

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

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

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

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

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

let response = client
    .post("https://api.emailit.com/v2/emails/em_abc123xyz789def456")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "scheduled_at": "2026-01-10T15:00:00Z"
    }))
    .send()
    .await?;

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

Ok(())
}

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

public class UpdateEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"scheduled_at\":\"2026-01-10T15:00:00Z\"}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(jsonBody))
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

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

public class UpdateEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { scheduled_at = "2026-01-10T15:00:00Z" };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

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

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"status": "scheduled",
"scheduled_at": "2026-01-10T15:00:00.000Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"message": "La programmation de l'email a été mise à jour avec succès"
}

{
"error": "Email introuvable",
"message": "L'email avec l'ID 'em_abc123' n'a pas été trouvé dans votre espace de travail"
}

{
"error": "Impossible de modifier l'email",
"message": "Les emails programmés ne peuvent être modifiés qu'au moins 3 minutes avant l'heure d'envoi prévue. Cet email est programmé pour être envoyé dans 2 minute(s)."
}

{
"error": "scheduled_at invalide",
"message": "La nouvelle heure programmée doit être au moins 3 minutes dans le futur."
}

Annuler un email

Annule un email programmé ou en attente. Pour les emails programmés, l’annulation n’est possible que si l’heure d’envoi prévue est dans au moins 3 minutes.

POST/emails/{id}/cancel

Paramètres de chemin

idstringRequired

L’identifiant de l’email au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"status": "canceled",
"message": "L'email a été annulé avec succès"
}

{
"error": "Email introuvable",
"message": "L'email avec l'ID 'em_abc123' n'a pas été trouvé dans votre espace de travail"
}

{
"error": "Impossible d'annuler l'email",
"message": "L'email ne peut pas être annulé. Statut actuel : 'sent'. Seuls les emails avec le statut 'scheduled' ou 'pending' peuvent être annulés."
}

{
"error": "Impossible d'annuler l'email",
"message": "Les emails programmés ne peuvent être annulés qu'au moins 3 minutes avant l'heure d'envoi prévue. Cet email est programmé pour être envoyé dans 2 minute(s)."
}

Statuts d’emails annulables

Statut	Annulable ?	Remarques
pending	✅ Oui	L’email est en file d’attente mais pas encore traité
scheduled	✅ Oui	Seulement si l’heure programmée est dans 3 minutes ou plus
sent	❌ Non	L’email a déjà été envoyé au serveur de messagerie
delivered	❌ Non	L’email a déjà été livré au destinataire
bounced	❌ Non	L’email a déjà été traité
canceled	❌ Non	L’email a déjà été annulé

Relancer un email

Relance un email qui a échoué définitivement, qui a généré une erreur, ou qui a été mis en attente. Cette action crée un duplicata de l’email original et l’envoie à nouveau. Le nouvel email reçoit son propre identifiant.

POST/emails/{id}/retry

Paramètres de chemin

idstringRequired

L’identifiant de l’email au format em_xxx.

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

const result = await response.json();

<?php

$curl = curl_init();

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

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

curl_close($curl);

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

import requests

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

result = response.json()
print(result)

require 'net/http'
require 'json'

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

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

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

package main

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

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

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

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

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

use reqwest;
use serde_json::Value;

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

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

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

Ok(())
}

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

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

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

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

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

{
"object": "email",
"id": "em_new789xyz456abc123",
"original_id": "em_abc123xyz789def456",
"status": "pending",
"message": "L'email a été mis en file d'attente pour relance"
}

{
"error": "Email introuvable",
"message": "L'email avec l'ID 'em_abc123' n'a pas été trouvé dans votre espace de travail"
}

{
"error": "Impossible de relancer l'email",
"message": "L'email ne peut pas être relancé. Statut actuel : 'delivered'. Seuls les emails avec le statut 'failed', 'errored' ou 'held' peuvent être relancés."
}

Statuts d’emails éligibles à la relance

Statut	Relance possible ?	Notes
failed	✅ Oui	Email rejeté définitivement
errored	✅ Oui	Erreur lors du traitement de l’email
held	✅ Oui	Email mis en attente pour vérification
pending	❌ Non	Email déjà en file d’attente
sent	❌ Non	Email déjà envoyé
delivered	❌ Non	Email déjà livré

Points importants à retenir

Facturation : Les emails relancés sont facturés comme de nouveaux emails selon la tarification standard
Nouvel identifiant : L’email relancé reçoit un nouvel ID, l’email original reste inchangé
Référence originale : La réponse inclut original_id pour faire le lien avec l’email original

Envoyer un email

En-têtes de limitation de débit

Lister les emails

Paramètres de requête

Récupérer un e-mail

Paramètres de chemin

Champs de réponse

Objet Body

Objet Attachment

Récupérer l’e-mail brut

Paramètres de chemin

Récupérer les pièces jointes d’un e-mail

Paramètres de chemin

Champs de réponse

Objet pièce jointe

Récupérer le contenu d’un e-mail

Paramètres de chemin

Récupérer les métadonnées d’un email

Paramètres de chemin

Champs de réponse

Objet Pièce jointe (Métadonnées)

Modifier un email programmé

Paramètres de chemin

Corps de la requête

Annuler un email

Paramètres de chemin

Statuts d’emails annulables

Relancer un email

Paramètres de chemin

Statuts d’emails éligibles à la relance

Points importants à retenir

Localisé par IA