Melhor Temp Mail para Devs: Guia API

Se você é um engenheiro de software, conhece a dor: testar fluxos de inscrição de usuário significa criar dezenas de contas de email descartáveis todos os dias. Você preenche o formulário, espera pelo email de confirmação, clica no link e repete — 50, 100, às vezes 200 vezes durante um sprint.

Usar user+1[at]gmail.com, user+2[at]gmail.com funciona por um tempo, mas o que acontece quando você precisa testar:

• Restrições de Email Único (seu BD rejeita duplicatas?)
• Entrega de Email Real (sua configuração do SendGrid está correta?)
• Parsing de Conteúdo de Email (a extração de OTP funciona?)
• Rate Limiting (usuários podem criar 10 contas do mesmo email?)

O truque do Gmail + falha em todos esses cenários. Você precisa de endereços de email descartáveis reais que se comportem como caixas de entrada de usuários reais.

O Problema com Testes Manuais

Vamos ser honestos: Teste de email manual é um assassino de produtividade.

Desperdício de Tempo

Criar uma conta de teste manualmente leva 30-60 segundos. Se você testa 50 vezes por dia, são 25-50 minutos desperdiçados — tempo que você poderia gastar escrevendo código ou corrigindo bugs.

Erro Humano

Copiar links de confirmação manualmente é propenso a erros. Você pode copiar o link errado, perder um caractere ou acidentalmente clicar em um link de cancelamento de inscrição em vez do botão de confirmação.

Dados de Teste Inconsistentes

Quando você cria contas de teste manualmente, você introduz variabilidade. Um teste usa teste1[at]gmail.com, outro joaosilva[at]example.com. Isso torna difícil reproduzir bugs e analisar resultados de testes.

Casos de Borda Impossíveis de Testar

Como você testa o que acontece quando um usuário se inscreve com um email de 64 caracteres? Ou um email com caracteres especiais como user+tag[at]sub.domain.com? Testes manuais tornam esses cenários impraticáveis.

Apresentando a API Temporary Mail

Temporary Mail Online oferece uma API de desenvolvedor projetada especificamente para testes automatizados.

Principais Recursos para Engenheiros de QA

1. Criação Instantânea de Caixa de Entrada

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

Resposta:

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

Cria uma nova caixa de entrada em menos de 50ms. Sem limite de taxa para usuários autenticados.

2. Recuperação de Mensagens em Tempo Real

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

Resposta:

{
  "messages": [
    {
      "id": "msg_abc123",
      "from": "noreply[at]seuapp.com",
      "subject": "Verifique seu email",
      "body": {
        "text": "Seu código de verificação é: 123456",
        "html": "<p>Seu código de verificação é: <strong>123456</strong></p>"
      },
      "receivedAt": "2026-02-09T10:01:23Z"
    }
  ]
}

Obtenha mensagens como JSON com HTML analisado, texto simples e anexos. Sem necessidade de analisar tipos MIME você mesmo.

3. Server-Sent Events (SSE) para Atualizações em Tempo Real

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

Transmite eventos assim que emails chegam:

event: message
data: {"id": "msg_abc123", "subject": "Verifique seu email", ...}

Perfeito para testes E2E de longa duração onde você precisa esperar por um email sem fazer polling.

4. Suporte a Webhook (Em Breve)

Registre uma URL de webhook e postaremos nela quando emails chegarem. Ideal para pipelines CI/CD.

Casos de Uso do Mundo Real

Caso de Uso 1: Teste E2E com Playwright

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

test('fluxo de inscricao de usuario', async ({ page }) => {
  // 1. Criar caixa de entrada temporária
  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. Preencher formulário de inscrição
  await page.goto('https://seuapp.com/signup');
  await page.fill('#email', email);
  await page.fill('#password', 'TestPass123!');
  await page.click('button[type="submit"]');
  
  // 3. Esperar por email de verificação
  await expect(page.locator('.success-message')).toBeVisible();
  
  // 4. Polling por email (ou usar SSE para tempo real)
  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)); // esperar 1s
  }
  
  expect(messages.length).toBeGreaterThan(0);
  
  // 5. Extrair link de verificação
  const emailBody = messages[0].body.html;
  const verifyLinkMatch = emailBody.match(/href="([^"]*verify[^"]*)"/);
  const verifyLink = verifyLinkMatch[1];
  
  // 6. Clicar no link de verificação
  await page.goto(verifyLink);
  
  // 7. Confirmar que o usuário está verificado
  await expect(page.locator('.verified-badge')).toBeVisible();
  });

Caso de Uso 2: Teste de Componente com Cypress

describe('Componente de Verificação de Email', () => {
  it('deve verificar email com sucesso', () => {
    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('Enviar Código').click();
        
        // Esperar por 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('Verificar').click();
            cy.contains('Email verificado!').should('be.visible');
          });
      });
  });
});

Caso de Uso 3: Teste Unitário com Jest (Serviço de Email)

describe('EmailService', () => {
  it('deve enviar email de boas-vindas', async () => {
    // Criar caixa temp
    const inbox = await createTempInbox();
    
    // Acionar envio de email
    await emailService.sendWelcomeEmail(inbox.email);
    
    // Verificar se email foi recebido
    const messages = await waitForEmail(inbox.id, 10000); // timeout 10s
    
    expect(messages).toHaveLength(1);
    expect(messages[0].subject).toBe('Bem-vindo ao nosso App!');
    expect(messages[0].body.text).toContain('Obrigado por se inscrever');
  });
});

Por que não Mailtrap ou MailHog?

Você pode estar pensando: "Eu já uso Mailtrap/MailHog para testes. Por que mudar?"

Mailtrap

Pró: Ótimo para capturar emails antes de irem para produção Contra:

• Simula o processo de envio de email (não testa a entrega real)
• Requer mudanças de configuração SMTP
• Não testa seu provedor de email transacional (SendGrid, AWS SES, etc.)

Temporary Mail Online testa o caminho de entrega real. Você sabe que seus emails estão realmente pousando em uma caixa de entrada, não apenas sendo interceptados por um servidor mock.

MailHog

Pró: Auto-hospedado, gratuito, código aberto Contra:

• Requer execução de um serviço separado (container Docker, etc.)
• Sem opção hospedada na nuvem
• Recursos de API limitados
• Não testa entrega de email externa

Temporary Mail Online é hospedado na nuvem, requer configuração zero e testa a entrega de email no mundo real.

Preços & Limites da API

Nível Gratuito

• 100 criações de caixa de entrada por dia
• 1.000 recuperações de mensagens por dia
• Perfeito para pequenos projetos e uso pessoal

Nível Pro ($29/mês)

• Criações de caixa de entrada ilimitadas
• Recuperações de mensagens ilimitadas
• Suporte prioritário
• Suporte a webhook
• Suporte a domínio personalizado

Enterprise

• Garantias SLA
• Infraestrutura dedicada
• Opções de implantação on-premise
• Integrações personalizadas

Melhores Práticas para Testes Automatizados

1. Use Caixas de Entrada Únicas por Teste

Não reutilize a mesma caixa de entrada para múltiplos testes. Crie uma nova caixa de entrada para cada teste para evitar inconsistências de emails remanescentes.

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

afterEach(async () => {
  // Caixa de entrada expira automaticamente, sem limpeza necessária
});

2. Defina Timeouts Razoáveis

A entrega de email não é instantânea. Defina um timeout de 10-30 segundos para o email chegar.

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 não recebido dentro do timeout');
};

3. Extraia Dados com Regex

Use Regex para extrair códigos de verificação, links mágicos ou outro conteúdo dinâmico.

const extractOTP = (emailBody) => {
  const match = emailBody.match(/\\b\\d{6}\\b/); // código de 6 dígitos
  return match ? match[0] : null;
};

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

4. Teste o Conteúdo do Email

Não verifique apenas se um email chegou — verifique seu conteúdo também.

test('email de boas-vindas tem conteudo correto', async () => {
  const messages = await waitForEmail(inbox.id);
  const email = messages[0];
  
  expect(email.subject).toBe('Bem-vindo ao nosso App!');
  expect(email.body.text).toContain('Obrigado por se inscrever');
  expect(email.body.html).toContain('<img src="https://seuapp.com/logo.png"');
});

Conclusão

Teste de email manual é uma relíquia do passado. Em 2026, equipes de desenvolvimento modernas usam APIs para automatizar tudo — incluindo fluxos de verificação de email.

A API de Desenvolvedor do Temporary Mail Online oferece a você:

• ✅ Criação instantânea de caixa de entrada (< 50ms)
• ✅ Recuperação de mensagens em tempo real
• ✅ Respostas JSON analisadas (sem parsing MIME necessário)
• ✅ Suporte SSE para testes de longa duração
• ✅ Testa entrega de email real (não mockado)

Pronto para automatizar seu fluxo de teste?

1. Visite temporary-mail.online/developer-api
2. Obtenha sua chave de API
3. Comece a testar em minutos

Pare de perder tempo com verificação manual de email. Deixe a API fazer o trabalho enquanto você foca em construir um software incrível.

Referência da API

Criar Caixa de Entrada

POST /api/inbox/create

Obter Mensagens

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

Deletar Caixa de Entrada

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

Stream de Mensagens (SSE)

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