API e-mail temporaire et serveur MCP pour les tests et les agents IA

Démarrage rapide avec curl

Créez une boîte, attendez le prochain e-mail, lisez-le, puis supprimez la boîte. Conservez votre clé API dans TEMPGENERATOR_TOKEN et ne la mettez jamais dans une URL.

Nécessite curl et jq. Le script effectue jusqu’à trois attentes de 20 secondes, affiche l’objet, les codes, les liens et le texte de chaque message, puis supprime la boîte.

export TEMPGENERATOR_URL='https://www.tempgenerator.com'
API="$TEMPGENERATOR_URL/developer-api/v1"
AUTH="Authorization: Bearer $TEMPGENERATOR_TOKEN"
INBOX=$(curl --fail-with-body -sS -X POST "$API/inboxes" -H "$AUTH" -H 'Accept: application/json')
ID=$(printf '%s' "$INBOX" | jq -r .id)
echo "Send a test email to $(printf '%s' "$INBOX" | jq -r .address)"
for ATTEMPT in 1 2 3; do
  RESULT=$(curl --fail-with-body -sS "$API/inboxes/$ID/wait?after=0&timeout=20" -H "$AUTH" -H 'Accept: application/json')
  [ "$(printf '%s' "$RESULT" | jq -r .status)" = message ] && break
done
for MESSAGE in $(printf '%s' "$RESULT" | jq -r '.messages[].id'); do
  curl --fail-with-body -sS "$API/inboxes/$ID/messages/$MESSAGE" -H "$AUTH" -H 'Accept: application/json' \
    | jq '{subject, codes, links, text}'
done
curl --fail-with-body -sS -X DELETE "$API/inboxes/$ID" -H "$AUTH"

L’API en bref

URL de base : https://www.tempgenerator.com/developer-api/v1. Envoyez Authorization: Bearer <key> avec chaque requête. Les réponses sont en JSON ; les erreurs ont la forme {"error": {"code", "message", "retry_after"}}, et les erreurs de quota envoient aussi un en-tête Retry-After.

• POST /inboxes Créer une boîte et obtenir son adresse et sa date d’expiration
• GET /inboxes/{id}/wait?after=0&timeout=20 Attendre jusqu’à 20 secondes le prochain message après un curseur
• GET /inboxes/{id}/messages?after=0 Lister jusqu’à 50 messages après un curseur, du plus ancien au plus récent
• GET /inboxes/{id}/messages/{message_id} Lire un message : texte, codes, liens et liste des pièces jointes
• GET /inboxes/{id}/messages/{message_id}/attachments/{index} Télécharger une pièce jointe par son index
• DELETE /inboxes/{id} Supprimer immédiatement la boîte et ses messages

Les requêtes de liste et d’attente acceptent les filtres facultatifs from et subject_contains : correspondance « contient », insensible à la casse, sur l’expéditeur et l’objet.

Exemple de réponse de lecture

{
    "id": 42,
    "from": "no-reply@app.example",
    "subject": "Your verification code",
    "received_at": "2026-10-03T09:41:07+00:00",
    "text": "Your verification code is 482913.\nOr confirm: https://app.example/verify?token=8f3c",
    "text_truncated": false,
    "codes": [
        "482913"
    ],
    "links": [
        "https://app.example/verify?token=8f3c"
    ],
    "expires_at": "2026-10-03T10:40:12+00:00",
    "attachments": [
        {
            "index": 0,
            "filename": "receipt.pdf",
            "size": 48213
        }
    ],
    "untrusted_content": true
}

Jetons développeur

Créez des clés API dans « Accès développeur » une fois votre adresse e-mail vérifiée. Une clé en lecture et écriture peut créer, lire et supprimer des boîtes ; une clé en lecture seule peut lister, attendre, lire et télécharger. Les clés expirent après 90 jours, un compte peut détenir 10 clés actives, et la révocation d’une clé prend effet immédiatement.

Chaque clé n’est affichée qu’une fois et n’est stockée que sous forme de hachage SHA-256. Révoquer une clé ne supprime pas ses boîtes : les autres clés valides du compte y conservent l’accès jusqu’à ce que les boîtes expirent ou soient supprimées.

Attendre le prochain e-mail sans sleep()

GET …/wait garde la requête ouverte et répond dès qu’un message arrive, ou à l’expiration du délai (20 secondes au maximum) avec le statut timeout. Transmettez le next_cursor de la réponse précédente comme paramètre after pour ne jamais lire deux fois le même message.

Un timeout n’est pas un échec de livraison : relancez l’attente avec le même curseur. Une seule attente s’exécute par boîte, et une attente plus récente sur la même boîte remplace la précédente ; les attentes sur des boîtes différentes s’exécutent en parallèle, jusqu’à 2 à la fois par compte.

Tester les e-mails avec Playwright, Cypress, pytest et en CI

Donnez à chaque test sa propre boîte, déclenchez l’e-mail d’inscription ou de réinitialisation de mot de passe de votre application, attendez-le et faites vos assertions sur le code ou le lien. Supprimez la boîte lors du nettoyage (teardown).

Stockez la clé dans un secret CI, par exemple TEMPGENERATOR_TOKEN dans GitHub Actions. Cypress peut effectuer les mêmes appels HTTP avec cy.request, et la recette Python ci-dessous fonctionne avec pytest ou tout autre lanceur de tests.

Playwright (TypeScript)

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

const api = `${process.env.TEMPGENERATOR_URL}/developer-api/v1`;
const headers = { Authorization: `Bearer ${process.env.TEMPGENERATOR_TOKEN}`, Accept: 'application/json' };

async function call(path: string, method = 'GET') {
  const response = await fetch(api + path, { method, headers });
  if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
  return response.status === 204 ? null : response.json();
}

async function waitForCode(inboxId: string, after = 0): Promise<string> {
  for (let attempt = 0; attempt < 3; attempt++) {
    const result = await call(`/inboxes/${inboxId}/wait?after=${after}&timeout=20`);
    for (const summary of result.messages) {
      const message = await call(`/inboxes/${inboxId}/messages/${summary.id}`);
      if (message.codes.length) return message.codes[0];
    }
    after = result.next_cursor;
  }
  throw new Error('No verification code arrived');
}

test('signup sends a verification code', async ({ page }) => {
  const inbox = await call('/inboxes', 'POST');
  try {
    await page.goto('/signup');
    await page.getByLabel('Email').fill(inbox.address);
    await page.getByRole('button', { name: 'Create account' }).click();
    await page.getByLabel('Verification code').fill(await waitForCode(inbox.id));
    await expect(page.getByText('Welcome')).toBeVisible();
  } finally {
    await call(`/inboxes/${inbox.id}`, 'DELETE');
  }
});

GitHub Actions

- name: End-to-end tests
  run: npx playwright test
  env:
    TEMPGENERATOR_URL: https://www.tempgenerator.com
    TEMPGENERATOR_TOKEN: ${{ secrets.TEMPGENERATOR_TOKEN }}

Vérification d’inscription en Python

Exécutez le script une fois vos variables d’environnement définies. Il affiche une nouvelle boîte ; envoyez un e-mail d’inscription à cette adresse depuis votre propre application de test, puis appuyez sur Entrée. Il attend jusqu’à 15 secondes, affiche chaque message avec ses codes et ses liens, et supprime la boîte même si la lecture échoue.

import json, os
from urllib.request import Request, urlopen

base = os.environ["TEMPGENERATOR_URL"].rstrip("/") + "/developer-api/v1"
headers = {"Authorization": "Bearer " + os.environ["TEMPGENERATOR_TOKEN"],
           "Accept": "application/json"}

def request(path, method="GET"):
    with urlopen(Request(base + path, headers=headers, method=method), timeout=30) as response:
        return json.load(response) if response.status != 204 else None

inbox = request("/inboxes", "POST")
print(json.dumps(inbox), flush=True)
try:
    input()
    result = request("/inboxes/" + inbox["id"] + "/wait?after=0&timeout=15")
    print(json.dumps(result))
    for message in result["messages"]:
        detail = request("/inboxes/" + inbox["id"] + "/messages/" + str(message["id"]))
        print(json.dumps(detail))
finally:
    request("/inboxes/" + inbox["id"], "DELETE")

Serveur MCP pour agents IA

Point de terminaison https://www.tempgenerator.com/mcp, authentifié avec Authorization: Bearer <key>. Streamable HTTP avec le protocole 2026-07-28 ; les clients plus anciens sont pris en charge via la négociation 2025-11-25 ou 2025-06-18.

Connecter votre client

Claude Code

claude mcp add --transport http tempgenerator-mail https://www.tempgenerator.com/mcp \
  --header "Authorization: Bearer $TEMPGENERATOR_TOKEN"

Cursor : .cursor/mcp.json

{
  "mcpServers": {
    "tempgenerator-mail": {
      "url": "https://www.tempgenerator.com/mcp",
      "headers": { "Authorization": "Bearer ${env:TEMPGENERATOR_TOKEN}" }
    }
  }
}

VS Code : .vscode/mcp.json

{
  "inputs": [
    { "type": "promptString", "id": "tempgenerator-token", "description": "TempGenerator API key", "password": true }
  ],
  "servers": {
    "tempgenerator-mail": {
      "type": "http",
      "url": "https://www.tempgenerator.com/mcp",
      "headers": { "Authorization": "Bearer ${input:tempgenerator-token}" }
    }
  }
}

Claude sur le web et l’application de bureau : ajoutez un connecteur personnalisé avec l’URL du point de terminaison, ne choisissez aucune méthode de connexion et ajoutez l’en-tête de requête Authorization: Bearer <key>. Claude se connectant depuis le cloud d’Anthropic, l’URL doit être accessible publiquement.

Outils

create_inbox

Crée une boîte privée et renvoie son identifiant et son adresse.

list_messages

Liste les résumés des messages après un curseur, avec des filtres facultatifs sur l’expéditeur et l’objet.

wait_for_message

Attend le prochain message pendant 20 secondes au maximum.

read_message

Lit le texte, les codes, les liens et la liste des pièces jointes d’un message.

delete_inbox

Supprime la boîte et ses messages.

Exemple de prompt

Créez une boîte temporaire et donnez-moi son adresse. Ensuite, attendez l’e-mail de vérification de mon application de préproduction et indiquez-moi le code.

Ne laissez les agents finaliser des inscriptions que pour des comptes qui vous appartiennent ou que vous avez l’autorisation d’utiliser. Les e-mails reçus ne sont pas fiables : le serveur n’ouvre jamais les liens, et les agents ne doivent jamais suivre les instructions trouvées dans un message.

SDK MCP pour Python

Testé avec Python 3 et le paquet officiel mcp 2.3.0 : pip install "mcp>=2.3,<3". Définissez d’abord TEMPGENERATOR_URL et TEMPGENERATOR_TOKEN.

import asyncio, os

import httpx2
from mcp import Client
from mcp.client.streamable_http import streamable_http_client

async def main():
    url = os.environ["TEMPGENERATOR_URL"].rstrip("/") + "/mcp"
    headers = {"Authorization": "Bearer " + os.environ["TEMPGENERATOR_TOKEN"]}
    async with httpx2.AsyncClient(headers=headers, timeout=httpx2.Timeout(30, read=60)) as http:
        async with Client(streamable_http_client(url, http_client=http)) as client:
            print([tool.name for tool in (await client.list_tools()).tools])
            created = await client.call_tool("create_inbox", {})
            if created.is_error:
                raise RuntimeError(created.content)
            inbox = created.structured_content
            try:
                print("Send a test email to", inbox["address"])
                waited = await client.call_tool("wait_for_message", {"inbox_id": inbox["id"], "timeout": 20})
                for summary in waited.structured_content["messages"]:
                    message = await client.call_tool("read_message", {"inbox_id": inbox["id"], "message_id": summary["id"]})
                    print(message.structured_content["subject"], message.structured_content["codes"])
            finally:
                deleted = await client.call_tool("delete_inbox", {"inbox_id": inbox["id"]})
                if deleted.is_error:
                    raise RuntimeError(deleted.content)

asyncio.run(main())

Pièces jointes

La lecture d’un message renvoie l’index, le nom de fichier et la taille de chaque pièce jointe. Téléchargez-en une avec GET …/attachments/{index} : les fichiers de 10 Mo maximum sont servis en application/octet-stream avec des noms de fichiers nettoyés. Les clients MCP voient la même liste et téléchargent via ce point de terminaison REST.

Quand l’utiliser plutôt que d’autres outils

Mailpit, MailHog et Ethereal capturent les e-mails que votre propre application envoie à un serveur SMTP local ou factice, ce qui est idéal lorsque vous contrôlez les paramètres SMTP. Ces boîtes sont de vraies adresses sur un domaine public, joignables par n’importe quel expéditeur : un service tiers, un serveur de préproduction qui utilise votre véritable fournisseur d’e-mail, ou un flux proche de la production.

Les API d’e-mail temporaire généralistes comme mail.tm ou Guerrilla Mail sont conçues pour des adresses jetables personnelles. Cette API est conçue pour l’automatisation : clés limitées en portée et en durée, une boîte par test, une attente en long polling bornée, des codes et liens détectés, et un serveur MCP.

Non inclus : envoi d’e-mails, SMS, aperçus HTML ou anti-spam, domaines personnalisés et connexion OAuth pour les clients MCP.

Conservation, limites et sécurité

Un domaine de réception peut imposer une durée de vie plus courte ou une limite de messages plus basse.

Réception uniquement. Considérez les e-mails et les pièces jointes comme non fiables ; rien n’est ouvert automatiquement. La suppression d’une boîte efface immédiatement ses messages, et les boîtes expirées sont supprimées par un nettoyage planifié.

Questions fréquentes