Les e-mails transactionnels sont une composante essentielle de la plupart des applications. Ils sont déclenchés par des actions utilisateur ou des événements système et doivent être délivrés de manière fiable et quasi immédiate.
Dans ce guide, nous allons voir comment intégrer l’API de Sweego afin d’envoyer des emails transactionnels depuis votre application, à l’aide d’exemples concrets et de cas d’usage courants.
Qu’est-ce qu’un e-mail transactionnel ?
Un email transactionnel est un message automatisé envoyé en réponse à une action précise. Contrairement aux e-mails marketing, il n’a pas de vocation promotionnelle et est généralement attendu par le destinataire.
Parmi les exemples les plus courants :
- Réinitialisation de mot de passe
- Confirmation de compte et vérification d’adresse e-mail
- Confirmation de commande et factures
- Alertes de sécurité et notifications de connexion
Étant donné leur caractère critique et sensible au temps, le choix d’une API d’envoi fiable est primordial.
Pourquoi utiliser une API pour envoyer des e-mails transactionnels ?
Une API d’envoi d’emails permet aux applications d’envoyer des messages de manière programmatique, avec un contrôle total sur le contenu, le moment d’envoi et la gestion des erreurs.
Une approche basée sur une API permet notamment de :
- Déclencher des e-mails directement depuis la logique applicative
- Gérer les erreurs d’envoi de manière automatique
- Suivre les événements de livraison
- Monter en charge sans modifier l’architecture de l’application
Sweego propose à la fois une API HTTP et un relais SMTP, ce qui facilite l’intégration quel que soit votre stack technique.
Prérequis
Avant d’envoyer votre premier e-mail transactionnel avec Sweego, assurez-vous de disposer de :
- Un compte Sweego
- Une clé API valide
- Un domaine d’envoi vérifié
Une fois ces éléments en place, vous pouvez commencer à envoyer des e-mails depuis votre application.
Envoyer un e-mail transactionnel via l’API
L’API de Sweego est indépendante du langage utilisé et peut être intégrée dans n’importe quel backend capable d’effectuer des requêtes HTTP.
Vous trouverez ci-dessous des exemples montrant comment envoyer un e-mail transactionnel à l’aide de curl, Python, Node.js et PHP.êtes HTTP. Voici des exemples dans quelques langages courants.
curl
Python
Node
PHP
curl --location 'https://api.sweego.io/send' \
--header 'Content-Type: application/json' \
--header 'Api-Key: <API_KEY>' \
--data-raw '{
"channel": "email",
"provider": "sweego",
"recipients": [
{ "email": "<EMAIL_TO>" }
],
"from": {
"name": "MY NAME",
"email": "<EMAIL_FROM>"
},
"subject": "Email subject",
"message-txt": "Email body"
}'import requests
api_url = "https://api.sweego.io/send"
api_key = "votre_clé_API"
email_data = {
"channel": "email",
"provider": "sweego",
"recipients": [{"email": "destinataire@example.com"}],
"from": {"name": "MY NAME", "email": "votre_email@example.com"},
"subject": "Email subject",
"message-txt": "Email body"
}
headers = {
"Api-Key": api_key,
"Content-Type": "application/json"
}
response = requests.post(api_url, json=email_data, headers=headers)
if response.status_code == 200:
print("Email envoyé avec succès!")
else:
print(f"Erreur lors de l'envoi de l'email: {response.status_code}")
const fetch = require('node-fetch');
const apiUrl = "https://api.sweego.io/send";
const apiKey = "votre_clé_API";
const emailData = {
channel: "email",
provider: "sweego",
recipients: [{ email: "destinataire@example.com" }],
from: { name: "MY NAME", email: "votre_email@example.com" },
subject: "Email subject",
"message-txt": "Email body"
};
const headers = {
"Api-Key": apiKey,
"Content-Type": "application/json"
};
fetch(apiUrl, {
method: 'POST',
headers: headers,
body: JSON.stringify(emailData)
})
.then(response => {
if (response.ok) {
return response.json();
}
throw new Error(`Erreur lors de l'envoi de l'email: ${response.status}`);
})
.then(data => {
console.log("Email envoyé avec succès!");
})
.catch(error => {
console.error(error);
});
<?php
$api_url = "https://api.sweego.io/send";
$api_key = "votre_clé_API";
$email_data = [
"channel" => "email",
"provider" => "sweego",
"recipients" => [
["email" => "destinataire@example.com"]
],
"from" => [
"name" => "MY NAME",
"email" => "votre_email@example.com"
],
"subject" => "Email subject",
"message-txt" => "Email body"
];
$headers = [
"Api-Key: $api_key",
"Content-Type: application/json"
];
$ch = curl_init($api_url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($email_data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($http_code == 200) {
echo "Email envoyé avec succès!";
} else {
echo "Erreur lors de l'envoi de l'email: $http_code";
}
?>
L’API retourne une réponse structurée indiquant si le message a bien été accepté pour l’envoi.
Utiliser des données dynamiques dans les e-mails transactionnels
Les e-mails transactionnels contiennent très souvent des données dynamiques, comme le nom de l’utilisateur, un lien de réinitialisation ou des informations de commande.
Sweego prend en charge l’utilisation de variables dans les templates, ce qui permet de :
- Réutiliser les mêmes modèles d’e-mails
- Personnaliser le contenu pour chaque destinataire
- Garder une logique applicative plus propre
Cette approche est particulièrement adaptée aux volumes importants d’e-mails transactionnels.
Gérer les événements de livraison et les erreurs
Une fois l’e-mail envoyé, il est important de suivre ce qu’il se passe ensuite.
Sweego met à disposition des webhooks permettant de notifier votre application lors de :
- La livraison réussie du message
- Les retards temporaires (deferrals)
- Les échecs définitifs (bounces)
En exploitant ces événements, vous pouvez mettre à jour l’état de votre application, relancer certains envois si nécessaire ou informer l’utilisateur en cas de problème.
Envoyer des e-mails transactionnels via SMTP
Si votre application repose déjà sur SMTP, Sweego peut également être utilisé comme relais SMTP.
Cette méthode est souvent privilégiée pour :
- Les applications existantes ou legacy
- Les CMS ou frameworks disposant d’un support SMTP natif
- Les migrations rapides depuis un autre fournisseur
Les mêmes mécanismes de délivrabilité et de supervision s’appliquent, quel que soit le mode d’intégration.
Bonnes pratiques pour l’envoi d’e-mails transactionnels
Pour garantir une délivrabilité optimale :
- Utilisez un domaine d’envoi dédié
- Configurez correctement SPF, DKIM et DMARC
- Séparez les flux transactionnels et marketing
- Surveillez régulièrement les taux de bounce et de livraison
Ces bonnes pratiques contribuent à maintenir une réputation d’expéditeur saine dans le temps.
Conclusion
L’envoi d’e-mails transactionnels via une API offre un contrôle total sur la fiabilité, le suivi et la montée en charge.
En intégrant l’API de Sweego, les développeurs peuvent mettre en place un système d’e-mails transactionnels robuste, adapté aussi bien aux applications modernes qu’aux infrastructures existantes.
Pour plus de détails sur les fonctionnalités avancées et les paramètres de l’API, consultez la documentation complète de l’API Sweego.