Beste Temp-Mail für Entwickler (API)

Wenn Sie Softwareingenieur sind, kennen Sie den Schmerz: Benutzeranmeldeflüsse zu testen bedeutet, jeden Tag Dutzende von Wegwerf-E-Mail-Konten zu erstellen. Sie füllen das Formular aus, warten auf die Bestätigungs-E-Mail, klicken auf den Link und wiederholen das Ganze — 50, 100, manchmal 200 Mal während eines Sprints.

Die Verwendung von test+1[at]gmail.com, test+2[at]gmail.com funktioniert eine Weile, aber was passiert, wenn Sie testen müssen:

• Einzigartige E-Mail-Einschränkungen (lehnt Ihre DB Duplikate ab?)
• Reale E-Mail-Zustellung (ist Ihre SendGrid-Konfiguration korrekt?)
• E-Mail-Inhalts-Parsing (funktioniert die OTP-Extraktion?)
• Ratenbegrenzung (können Benutzer 10 Konten von derselben E-Mail erstellen?)

Der Gmail + Trick scheitert in all diesen Szenarien. Sie brauchen echte Wegwerf-E-Mail-Adressen, die sich wie echte Benutzerpostfächer verhalten.

Das Problem mit manuellen Tests

Seien wir ehrlich: Manuelles E-Mail-Testen ist ein Produktivitätskiller.

Zeitverschwendung

Ein Testkonto manuell zu erstellen dauert 30-60 Sekunden. Wenn Sie 50 Mal am Tag testen, sind das 25-50 Minuten reine Verschwendung — Zeit, die Sie mit dem Schreiben von Code oder dem Beheben von Fehlern verbringen könnten.

Menschlicher Fehler

Bestätigungslinks manuell zu kopieren ist fehleranfällig. Sie könnten den falschen Link kopieren, ein Zeichen übersehen oder versehentlich auf einen Abmeldelink statt auf den Bestätigungsbutton klicken.

Inkonsistente Testdaten

Wenn Sie Testkonten manuell erstellen, führen Sie Variabilität ein. Ein Test verwendet test1[at]gmail.com, ein anderer maxmustermann[at]example.com. Das macht es schwierig, Fehler zu reproduzieren und Testergebnisse zu analysieren.

Randfälle unmöglich zu testen

Wie testen Sie, was passiert, wenn sich ein Benutzer mit einer 64 Zeichen langen E-Mail anmeldet? Oder einer E-Mail mit Sonderzeichen wie user+tag[at]sub.domain.com? Manuelle Tests machen diese Szenarien unpraktisch.

Hier kommt die Temporary Mail API ins Spiel

Temporary Mail Online bietet eine Entwickler-API, die speziell für automatisierte Tests entwickelt wurde.

Hauptmerkmale für QA-Ingenieure

1. Sofortige Posteingangserstellung

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

Antwort:

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

Erstellt einen neuen Posteingang in weniger als 50ms. Keine Ratenbegrenzung für authentifizierte Benutzer.

2. Echtzeit-Nachrichtenabruf

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

Antwort:

{
  "messages": [
    {
      "id": "msg_abc123",
      "from": "noreply[at]ihrapp.com",
      "subject": "Verifizieren Sie Ihre E-Mail",
      "body": {
        "text": "Ihr Bestätigungscode ist: 123456",
        "html": "<p>Ihr Bestätigungscode ist: <strong>123456</strong></p>"
      },
      "receivedAt": "2026-02-09T10:01:23Z"
    }
  ]
}

Erhalten Sie Nachrichten als JSON mit geparstem HTML, Klartext und Anhängen. Keine Notwendigkeit, MIME-Typen selbst zu parsen.

3. Server-Sent Events (SSE) für Echtzeit-Updates

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

Streamt Ereignisse, wenn E-Mails ankommen:

event: message
data: {"id": "msg_abc123", "subject": "Verifizieren Sie Ihre E-Mail", ...}

Perfekt für lang laufende E2E-Tests, bei denen Sie auf eine E-Mail warten müssen, ohne zu pollen.

4. Webhook-Unterstützung (Demnächst)

Registrieren Sie eine Webhook-URL und wir posten dorthin, wenn E-Mails ankommen. Ideal für CI/CD-Pipelines.

Reale Anwendungsfälle

Anwendungsfall 1: E2E-Tests mit Playwright

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

test('benutzer anmelde fluss', async ({ page }) => {
  // 1. Temporären Posteingang erstellen
  const inbox = await fetch('https://temporary-mail.online/api/inbox/create')
    .then(r => r.json());
  
  const email = inbox.email; // z.B. x8k29a[at]temporary-mail.online
  
  // 2. Anmeldeformular ausfüllen
  await page.goto('https://ihrapp.com/signup');
  await page.fill('#email', email);
  await page.fill('#password', 'TestPass123!');
  await page.click('button[type="submit"]');
  
  // 3. Auf Bestätigungs-E-Mail warten
  await expect(page.locator('.success-message')).toBeVisible();
  
  // 4. E-Mail pollen (oder SSE für Echtzeit nutzen)
  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)); // 1s warten
  }
  
  expect(messages.length).toBeGreaterThan(0);
  
  // 5. Bestätigungslink extrahieren
  const emailBody = messages[0].body.html;
  const verifyLinkMatch = emailBody.match(/href="([^"]*verify[^"]*)"/);
  const verifyLink = verifyLinkMatch[1];
  
  // 6. Bestätigungslink klicken
  await page.goto(verifyLink);
  
  // 7. Bestätigen, dass der Benutzer verifiziert ist
  await expect(page.locator('.verified-badge')).toBeVisible();
  });

Anwendungsfall 2: Komponententests mit Cypress

describe('E-Mail-Verifizierungskomponente', () => {
  it('sollte E-Mail erfolgreich verifizieren', () => {
    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('Code senden').click();
        
        // Auf E-Mail warten
        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('Verifizieren').click();
            cy.contains('E-Mail verifiziert!').should('be.visible');
          });
      });
  });
});

Anwendungsfall 3: Unit-Tests mit Jest (E-Mail-Service)

describe('EmailService', () => {
  it('sollte Willkommens-E-Mail senden', async () => {
    // Temp-Inbox erstellen
    const inbox = await createTempInbox();
    
    // E-Mail-Versand auslösen
    await emailService.sendWelcomeEmail(inbox.email);
    
    // Überprüfen, ob E-Mail empfangen wurde
    const messages = await waitForEmail(inbox.id, 10000); // 10s Timeout
    
    expect(messages).toHaveLength(1);
    expect(messages[0].subject).toBe('Willkommen in unserer App!');
    expect(messages[0].body.text).toContain('Vielen Dank für Ihre Anmeldung');
  });
});

Warum nicht Mailtrap oder MailHog?

Sie denken vielleicht: "Ich benutze schon Mailtrap/MailHog für Tests. Warum wechseln?"

Mailtrap

Pro: Großartig, um E-Mails abzufangen, bevor sie in Produktion gehen Contra:

• Simuliert den E-Mail-Versandprozess (testet nicht die tatsächliche Zustellung)
• Erfordert SMTP-Konfigurationsänderungen
• Testet nicht Ihren Transaktions-E-Mail-Anbieter (SendGrid, AWS SES, etc.)

Temporary Mail Online testet den tatsächlichen Zustellungspfad. Sie wissen, dass Ihre E-Mails tatsächlich in einem Posteingang landen, nicht nur von einem Mock-Server abgefangen werden.

MailHog

Pro: Selbstgehostet, kostenlos, Open Source Contra:

• Erfordert Ausführung eines separaten Dienstes (Docker-Container, etc.)
• Keine Cloud-gehostete Option
• Begrenzte API-Funktionen
• Testet keine externe E-Mail-Zustellung

Temporary Mail Online ist Cloud-gehostet, erfordert keine Konfiguration und testet die E-Mail-Zustellung in der realen Welt.

API-Preise & Limits

Kostenloses Level

• 100 Posteingangserstellungen pro Tag
• 1.000 Nachrichtenabrufe pro Tag
• Perfekt für kleine Projekte und persönlichen Gebrauch

Pro Level ($29/Monat)

• Unbegrenzte Posteingangserstellungen
• Unbegrenzte Nachrichtenabrufe
• Prioritäts-Support
• Webhook-Unterstützung
• Unterstützung für benutzerdefinierte Domains

Enterprise

• SLA-Garantien
• Dedizierte Infrastruktur
• On-Premise-Bereitstellungsoptionen
• Benutzerdefinierte Integrationen

Best Practices für automatisierte Tests

1. Verwenden Sie eindeutige Posteingänge pro Test

Verwenden Sie nicht denselben Posteingang für mehrere Tests wieder. Erstellen Sie für jeden Test einen neuen Posteingang, um instabile Tests durch übrig gebliebene E-Mails zu vermeiden.

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

afterEach(async () => {
  // Posteingang läuft automatisch ab, keine Bereinigung erforderlich
});

2. Setzen Sie vernünftige Timeouts

E-Mail-Zustellung ist nicht sofortig. Setzen Sie ein Timeout von 10-30 Sekunden für das Eintreffen der E-Mail.

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('E-Mail nicht innerhalb des Zeitlimits empfangen');
};

3. Extrahieren Sie Daten mit Regex

Verwenden Sie Regex, um Bestätigungscodes, Magic Links oder andere dynamische Inhalte zu extrahieren.

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

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

4. Testen Sie E-Mail-Inhalt

Überprüfen Sie nicht nur, ob eine E-Mail angekommen ist — überprüfen Sie auch ihren Inhalt.

test('willkommens-email hat korrekten inhalt', async () => {
  const messages = await waitForEmail(inbox.id);
  const email = messages[0];
  
  expect(email.subject).toBe('Willkommen in unserer App!');
  expect(email.body.text).toContain('Vielen Dank für Ihre Anmeldung');
  expect(email.body.html).toContain('<img src="https://ihrapp.com/logo.png"');
});

Fazit

Manuelles E-Mail-Testen ist ein Relikt der Vergangenheit. Im Jahr 2026 nutzen moderne Entwicklungsteams APIs, um alles zu automatisieren — einschließlich E-Mail-Verifizierungsflüssen.

Die Temporary Mail Online Entwickler-API bietet Ihnen:

• ✅ Sofortige Posteingangserstellung (< 50ms)
• ✅ Echtzeit-Nachrichtenabruf
• ✅ Geparste JSON-Antworten (kein MIME-Parsing erforderlich)
• ✅ SSE-Unterstützung für lang laufende Tests
• ✅ Testet reale E-Mail-Zustellung (nicht gemockt)

Bereit, Ihren Test-Workflow zu automatisieren?

1. Besuchen Sie temporary-mail.online/developer-api
2. Holen Sie sich Ihren API-Schlüssel
3. Beginnen Sie in Minuten mit dem Testen

Hören Sie auf, Zeit mit manueller E-Mail-Verifizierung zu verschwenden. Lassen Sie die API die Arbeit machen, während Sie sich auf das Erstellen großartiger Software konzentrieren.

API-Referenz

Posteingang erstellen

POST /api/inbox/create

Nachrichten abrufen

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

Posteingang löschen

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

Nachrichten streamen (SSE)

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