Meilleur Email Temporaire (API)

Si vous êtes ingénieur logiciel, vous connaissez la douleur : tester les flux d'inscription utilisateur signifie créer des dizaines de comptes email jetables chaque jour. Vous remplissez le formulaire, attendez l'email de vérification, cliquez sur le lien et répétez — 50, 100, parfois 200 fois pendant un sprint.

Utiliser test+1[at]gmail.com, test+2[at]gmail.com fonctionne un moment, mais que se passe-t-il quand vous devez tester :

• Contraintes d'email unique (votre BD rejette-t-elle les doublons ?)
• Livraison réelle d'email (votre config SendGrid est-elle correcte ?)
• Analyse du contenu de l'email (l'extraction OTP fonctionne-t-elle ?)
• Limitation de débit (les utilisateurs peuvent-ils créer 10 comptes depuis le même email ?)

L'astuce Gmail + échoue dans tous ces scénarios. Vous avez besoin de vraies adresses email jetables qui se comportent comme de vraies boîtes de réception utilisateur.

Le Problème avec les Tests Manuels

Soyons honnêtes : le test manuel d'email est un tueur de productivité.

Gaspillage de Temps

Créer un compte de test manuellement prend 30-60 secondes. Si vous testez 50 fois par jour, c'est 25-50 minutes de pur gaspillage — du temps que vous pourriez passer à écrire du code ou à corriger des bugs.

Erreur Humaine

Copier manuellement des liens de vérification est sujet aux erreurs. Vous pourriez copier le mauvais lien, manquer un caractère ou cliquer accidentellement sur un lien de désabonnement au lieu du bouton de vérification.

Données de Test Incohérentes

Lorsque vous créez manuellement des comptes de test, vous introduisez de la variabilité. Un test utilise test1[at]gmail.com, un autre utilise jeandupont[at]example.com. Cela rend difficile la reproduction des bugs et l'analyse des résultats de test.

Impossible de Tester les Cas Limites

Comment testez-vous ce qui se passe lorsqu'un utilisateur s'inscrit avec une adresse email de 64 caractères ? Ou un email avec des caractères spéciaux comme user+tag[at]sub.domain.com ? Les tests manuels rendent ces scénarios impraticables.

Entrez l'API Temporary Mail

Temporary Mail Online offre une API développeur conçue spécifiquement pour les tests automatisés.

Caractéristiques Clés pour les Ingénieurs QA

1. Création Instantanée de Boîte de Réception

POST https://temporary-mail.online/api/inbox/create

Réponse :

{
  "id": "x8k29a",
  "email": "x8k29a[at]temporary-mail.online",
  "expiresAt": "2026-02-10T10:00:00Z"
}

Crée une nouvelle boîte de réception en moins de 50ms. Pas de limite de débit pour les utilisateurs authentifiés.

2. Récupération des Messages en Temps Réel

GET https://temporary-mail.online/api/inbox/messages?id=x8k29a

Réponse :

{
  "messages": [
    {
      "id": "msg_abc123",
      "from": "noreply[at]votreapp.com",
      "subject": "Vérifiez votre email",
      "body": {
        "text": "Votre code de vérification est : 123456",
        "html": "<p>Votre code de vérification est : <strong>123456</strong></p>"
      },
      "receivedAt": "2026-02-09T10:01:23Z"
    }
  ]
}

Obtenez les messages sous forme de JSON avec HTML analysé, texte brut et pièces jointes. Pas besoin d'analyser les types MIME vous-même.

3. Server-Sent Events (SSE) pour Mises à Jour en Temps Réel

GET https://temporary-mail.online/api/inbox/sse?id=x8k29a

Diffuse les événements à mesure que les emails arrivent :

event: message
data: {"id": "msg_abc123", "subject": "Vérifiez votre email", ...}

Parfait pour les tests E2E de longue durée où vous devez attendre un email sans sonder.

4. Support Webhook (À Venir)

Enregistrez une URL de webhook et nous ferons un POST dessus lorsque les emails arriveront. Idéal pour les pipelines CI/CD.

Cas d'Utilisation du Monde Réel

Cas d'Utilisation 1 : Tests E2E avec Playwright

import { test, expect } from '@playwright/test';

test('flux inscription utilisateur', async ({ page }) => {
  // 1. Créer boîte temporaire
  const inbox = await fetch('https://temporary-mail.online/api/inbox/create')
    .then(r => r.json());
  
  const email = inbox.email; // ex., x8k29a[at]temporary-mail.online
  
  // 2. Remplir formulaire d'inscription
  await page.goto('https://votreapp.com/signup');
  await page.fill('#email', email);
  await page.fill('#password', 'TestPass123!');
  await page.click('button[type="submit"]');
  
  // 3. Attendre email de vérification
  await expect(page.locator('.success-message')).toBeVisible();
  
  // 4. Sonder email (ou utiliser SSE pour temps réel)
  let messages = [];
  for (let i = 0; i < 30; i++) {
    const res = await fetch(`https://temporary-mail.online/api/inbox/messages?id=${inbox.id}`);
    messages = (await res.json()).messages;
    if (messages.length > 0) break;
    await new Promise(r => setTimeout(r, 1000)); // attendre 1s
  }
  
  expect(messages.length).toBeGreaterThan(0);
  
  // 5. Extraire lien de vérification
  const emailBody = messages[0].body.html;
  const verifyLinkMatch = emailBody.match(/href="([^"]*verify[^"]*)"/);
  const verifyLink = verifyLinkMatch[1];
  
  // 6. Cliquer lien de vérification
  await page.goto(verifyLink);
  
  // 7. Affirmer que l'utilisateur est vérifié
  await expect(page.locator('.verified-badge')).toBeVisible();
  });

Cas d'Utilisation 2 : Tests de Composants avec Cypress

describe('Composant Vérification Email', () => {
  it('devrait vérifier l\'email avec succès', () => {
    cy.request('POST', 'https://temporary-mail.online/api/inbox/create')
      .then((response) => {
        const email = response.body.email;
        
        cy.visit('/verify');
        cy.get('#email').type(email);
        cy.get('button').contains('Envoyer Code').click();
        
        // Attendre email
        cy.wait(2000);
        
        cy.request(`https://temporary-mail.online/api/inbox/messages?id=${response.body.id}`)
          .then((msgResponse) => {
            const code = msgResponse.body.messages[0].body.text.match(/\\d{6}/)[0];
            cy.get('#code').type(code);
            cy.get('button').contains('Vérifier').click();
            cy.contains('Email verified!').should('be.visible');
          });
      });
  });
});

Cas d'Utilisation 3 : Tests Unitaires avec Jest (Service Email)

describe('EmailService', () => {
  it('devrait envoyer email de bienvenue', async () => {
    // Créer inbox temporaire
    const inbox = await createTempInbox();
    
    // Déclencher envoi email
    await emailService.sendWelcomeEmail(inbox.email);
    
    // Vérifier que l'email a été reçu
    const messages = await waitForEmail(inbox.id, 10000); // 10s timeout
    
    expect(messages).toHaveLength(1);
    expect(messages[0].subject).toBe('Bienvenue sur Notre App !');
    expect(messages[0].body.text).toContain('Merci de vous être inscrit');
  });
});

Pourquoi Pas Mailtrap ou MailHog ?

Vous pourriez penser : "J'utilise déjà Mailtrap/MailHog pour les tests. Pourquoi changer ?"

Mailtrap

Pour : Idéal pour piéger les emails avant qu'ils n'aillent en production Contre :

• Simule le processus d'envoi d'email (ne teste pas la livraison réelle)
• Nécessite des changements de configuration SMTP
• Ne teste pas votre fournisseur d'email transactionnel (SendGrid, AWS SES, etc.)

Temporary Mail Online teste le chemin de livraison réel. Vous savez que vos emails atterrissent réellement dans une boîte de réception, pas juste piégés par un serveur fictif.

MailHog

Pour : Auto-hébergé, gratuit, open source Contre :

• Nécessite d'exécuter un service séparé (conteneur Docker, etc.)
• Pas d'option hébergée dans le cloud
• Fonctionnalités API limitées
• Ne teste pas la livraison d'email externe

Temporary Mail Online est hébergé dans le cloud, ne nécessite aucune configuration et teste la livraison d'email dans le monde réel.

Tarification API & Limites

Niveau Gratuit

• 100 créations de boîte de réception par jour
• 1 000 récupérations de messages par jour
• Parfait pour les petits projets et l'usage personnel

Niveau Pro (29 $/mois)

• Créations de boîte de réception illimitées
• Récupérations de messages illimitées
• Support prioritaire
• Support webhook
• Support de domaine personnalisé

Entreprise

• Garanties SLA
• Infrastructure dédiée
• Options de déploiement sur site
• Intégrations personnalisées

Meilleures Pratiques pour les Tests Automatisés

1. Utilisez des Boîtes de Réception Uniques Par Test

Ne réutilisez pas la même boîte de réception pour plusieurs tests. Créez une nouvelle boîte pour chaque test afin d'éviter les tests instables causés par des emails restants.

beforeEach(async () => {
  testInbox = await createTempInbox();
});

afterEach(async () => {
  // La boîte expire automatiquement, pas de nettoyage nécessaire
});

2. Définissez des Délais Raisonnables

La livraison d'email n'est pas instantanée. Définissez un délai d'attente de 10-30 secondes pour l'arrivée de l'email.

const waitForEmail = async (inboxId, timeoutMs = 10000) => {
  const startTime = Date.now();
  while (Date.now() - startTime < timeoutMs) {
    const messages = await getMessages(inboxId);
    if (messages.length > 0) return messages;
    await new Promise(r => setTimeout(r, 1000));
  }
  throw new Error('Email non reçu dans le délai imparti');
};

3. Extrayez les Données avec Regex

Utilisez des regex pour extraire des codes de vérification, des liens magiques ou tout autre contenu dynamique.

const extractOTP = (emailBody) => {
  const match = emailBody.match(/\\b\\d{6}\\b/); // code à 6 chiffres
  return match ? match[0] : null;
};

const extractLink = (emailBody) => {
  const match = emailBody.match(/https:\\/\\/votreapp\\.com\\/verify\\?token=[a-zA-Z0-9]+/);
  return match ? match[0] : null;
};

4. Testez le Contenu de l'Email

Ne vérifiez pas seulement qu'un email est arrivé — vérifiez aussi son contenu.

test('email de bienvenue a le bon contenu', async () => {
  const messages = await waitForEmail(inbox.id);
  const email = messages[0];
  
  expect(email.subject).toBe('Bienvenue sur Notre App !');
  expect(email.body.text).toContain('Merci de vous être inscrit');
  expect(email.body.html).toContain('<img src="https://votreapp.com/logo.png"');
});

Conclusion

Le test manuel d'email est une relique du passé. En 2026, les équipes de développement modernes utilisent des API pour tout automatiser — y compris les flux de vérification d'email.

L'API Développeur Temporary Mail Online vous donne :

• ✅ Création instantanée de boîte de réception (< 50ms)
• ✅ Récupération de messages en temps réel
• ✅ Réponses JSON analysées (pas d'analyse MIME nécessaire)
• ✅ Support SSE pour les tests de longue durée
• ✅ Teste la livraison réelle d'email (pas simulée)

Prêt à automatiser votre workflow de test ?

1. Visitez temporary-mail.online/developer-api
2. Obtenez votre clé API
3. Commencez à tester en quelques minutes

Arrêtez de perdre du temps en vérification manuelle d'email. Laissez l'API faire le travail pendant que vous vous concentrez sur la création de super logiciels.

Référence API

Créer Boîte de Réception

POST /api/inbox/create

Obtenir Messages

GET /api/inbox/messages?id={inboxId}

Supprimer Boîte de Réception

DELETE /api/inbox/delete?id={inboxId}

Diffuser Messages (SSE)

GET /api/inbox/sse?id={inboxId}