Mejor Email Temporal para Desarrolladores (API)

Si eres ingeniero de software, conoces el dolor: probar flujos de registro de usuarios significa crear docenas de cuentas de correo desechables cada día. Llenas el formulario, esperas el correo de verificación, haces clic en el enlace y repites—50, 100, a veces 200 veces durante un sprint.

Usar test+1[at]gmail.com, test+2[at]gmail.com funciona por un tiempo, pero ¿qué sucede cuando necesitas probar:

• Restricciones de correo único (¿tu BD rechaza duplicados?)
• Entrega real de correo (¿es correcta tu configuración de SendGrid?)
• Análisis de contenido de correo (¿funciona la extracción de OTP?)
• Límite de velocidad (¿pueden los usuarios crear 10 cuentas desde el mismo correo?)

El truco de Gmail + falla en todos estos escenarios. Necesitas direcciones de correo reales y desechables que se comporten como bandejas de entrada de usuarios reales.

El Problema con las Pruebas Manuales

Seamos honestos: la prueba manual de correo electrónico es un asesino de la productividad.

Desperdicio de Tiempo

Crear una cuenta de prueba manualmente toma 30-60 segundos. Si estás probando 50 veces al día, eso son 25-50 minutos de puro desperdicio—tiempo que podrías pasar escribiendo código o arreglando errores.

Error Humano

Copiar manualmente enlaces de verificación es propenso a errores. Podrías copiar el enlace incorrecto, omitir un carácter o hacer clic accidentalmente en un enlace de cancelación de suscripción en lugar del botón de verificar.

Datos de Prueba Inconsistentes

Cuando creas cuentas de prueba manualmente, introduces variabilidad. Una prueba usa test1[at]gmail.com, otra usa johndoe[at]example.com. Esto hace difícil reproducir errores y analizar resultados de pruebas.

No Se Pueden Probar Casos Extremos

¿Cómo pruebas qué sucede cuando un usuario se registra con una dirección de correo de 64 caracteres? ¿O un correo con caracteres especiales como user+tag[at]sub.domain.com? Las pruebas manuales hacen que estos escenarios sean poco prácticos.

Entra la API de Temporary Mail

Temporary Mail Online ofrece una API pensada para desarrolladores diseñada específicamente para pruebas automatizadas.

Características Clave para Ingenieros de QA

1. Creación Instantánea de Bandeja de Entrada

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

Respuesta:

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

Crea una bandeja de entrada fresca en menos de 50ms. Sin límites de velocidad para usuarios autenticados.

2. Recuperación de Mensajes en Tiempo Real

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

Respuesta:

{
  "messages": [
    {
      "id": "msg_abc123",
      "from": "noreply[at]tuapp.com",
      "subject": "Verifica tu correo",
      "body": {
        "text": "Tu código de verificación es: 123456",
        "html": "<p>Tu código de verificación es: <strong>123456</strong></p>"
      },
      "receivedAt": "2026-02-09T10:01:23Z"
    }
  ]
}

Obtén mensajes como JSON con HTML analizado, texto plano y archivos adjuntos. No necesitas analizar tipos MIME tú mismo.

3. Eventos Enviados por el Servidor (SSE) para Actualizaciones en Tiempo Real

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

Transmite eventos a medida que llegan los correos:

event: message
data: {"id": "msg_abc123", "subject": "Verifica tu correo", ...}

Perfecto para pruebas E2E de larga duración donde necesitas esperar un correo sin sondeo.

4. Soporte de Webhook (Próximamente)

Registra una URL de webhook y haremos POST a ella cuando lleguen los correos. Ideal para tuberías CI/CD.

Casos de Uso del Mundo Real

Caso de Uso 1: Pruebas E2E con Playwright

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

test('flujo de registro de usuario', async ({ page }) => {
  // 1. Crear bandeja de entrada temporal
  const inbox = await fetch('https://temporary-mail.online/api/inbox/create')
    .then(r => r.json());
  
  const email = inbox.email; // ej., x8k29a[at]temporary-mail.online
  
  // 2. Llenar formulario de registro
  await page.goto('https://tuapp.com/signup');
  await page.fill('#email', email);
  await page.fill('#password', 'TestPass123!');
  await page.click('button[type="submit"]');
  
  // 3. Esperar correo de verificación
  await expect(page.locator('.success-message')).toBeVisible();
  
  // 4. Sondear correo (o usar SSE para tiempo 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. Extraer enlace de verificación
  const emailBody = messages[0].body.html;
  const verifyLinkMatch = emailBody.match(/href="([^"]*verify[^"]*)"/);
  const verifyLink = verifyLinkMatch[1];
  
  // 6. Hacer clic en enlace de verificación
  await page.goto(verifyLink);
  
  // 7. Afirmar que el usuario está verificado
  await expect(page.locator('.verified-badge')).toBeVisible();
  });

Caso de Uso 2: Pruebas de Componentes con Cypress

describe('Componente de Verificación de Correo', () => {
  it('debería verificar el correo exitosamente', () => {
    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 correo
        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 verified!').should('be.visible');
          });
      });
  });
});

Caso de Uso 3: Pruebas Unitarias con Jest (Servicio de Correo)

describe('EmailService', () => {
  it('debería enviar correo de bienvenida', async () => {
    // Crear inbox temporal
    const inbox = await createTempInbox();
    
    // Disparar envío de correo
    await emailService.sendWelcomeEmail(inbox.email);
    
    // Verificar que el correo fue recibido
    const messages = await waitForEmail(inbox.id, 10000); // 10s timeout
    
    expect(messages).toHaveLength(1);
    expect(messages[0].subject).toBe('¡Bienvenido a Nuestra App!');
    expect(messages[0].body.text).toContain('Gracias por registrarte');
  });
});

¿Por Qué No Usar Mailtrap o MailHog?

Podrías estar pensando: "Ya uso Mailtrap/MailHog para pruebas. ¿Por qué cambiar?"

Mailtrap

Pros: Genial para atrapar correos antes de que vayan a producción Contras:

• Simula el proceso de envío de correo (no prueba la entrega real)
• Requiere cambios en la configuración SMTP
• No prueba tu proveedor de correo transaccional (SendGrid, AWS SES, etc.)

Temporary Mail Online prueba la ruta de entrega real. Sabes que tus correos están llegando realmente a una bandeja de entrada, no solo siendo atrapados por un servidor simulado.

MailHog

Pros: Auto-hospedado, gratis, código abierto Contras:

• Requiere ejecutar un servicio separado (contenedor Docker, etc.)
• Sin opción alojada en la nube
• Funciones API limitadas
• No prueba la entrega de correo externa

Temporary Mail Online está alojado en la nube, requiere cero configuración y prueba la entrega de correo en el mundo real.

Precios de API y Límites

Nivel Gratuito

• 100 creaciones de bandeja de entrada por día
• 1,000 recuperaciones de mensajes por día
• Perfecto para pequeños proyectos y uso personal

Nivel Pro ($29/mes)

• Creaciones de bandeja de entrada ilimitadas
• Recuperaciones de mensajes ilimitadas
• Soporte prioritario
• Soporte de webhook
• Soporte de dominio personalizado

Empresarial

• Garantías SLA
• Infraestructura dedicada
• Opciones de implementación local
• Integraciones personalizadas

Mejores Prácticas para Pruebas Automatizadas

1. Usa Bandejas de Entrada Únicas Por Prueba

No reutilices la misma bandeja de entrada en múltiples pruebas. Crea una nueva bandeja de entrada para cada prueba para evitar pruebas inestables causadas por correos sobrantes.

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

afterEach(async () => {
  // La bandeja de entrada expira automáticamente, no se necesita limpieza
});

2. Establece Tiempos de Espera Razonables

La entrega de correo no es instantánea. Establece un tiempo de espera de 10-30 segundos para la llegada del correo.

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('Correo no recibido dentro del tiempo de espera');
};

3. Extrae Datos con Regex

Usa regex para extraer códigos de verificación, enlaces mágicos u otro contenido 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:\\/\\/tuapp\\.com\\/verify\\?token=[a-zA-Z0-9]+/);
  return match ? match[0] : null;
};

4. Prueba el Contenido del Correo

No solo verifiques que llegó un correo—verifica su contenido también.

test('correo de bienvenida tiene contenido correcto', async () => {
  const messages = await waitForEmail(inbox.id);
  const email = messages[0];
  
  expect(email.subject).toBe('¡Bienvenido a Nuestra App!');
  expect(email.body.text).toContain('Gracias por registrarte');
  expect(email.body.html).toContain('<img src="https://tuapp.com/logo.png"');
});

Conclusión

La prueba manual de correo electrónico es una reliquia del pasado. En 2026, los equipos de desarrollo modernos usan APIs para automatizar todo—incluidos los flujos de verificación de correo.

La API para Desarrolladores de Temporary Mail Online te da:

• ✅ Creación instantánea de bandeja de entrada (< 50ms)
• ✅ Recuperación de mensajes en tiempo real
• ✅ Respuestas JSON analizadas (no se necesita análisis MIME)
• ✅ Soporte SSE para pruebas de larga duración
• ✅ Prueba la entrega real de correo (no simulada)

¿Listo para automatizar tu flujo de trabajo de pruebas?

1. Visita temporary-mail.online/developer-api
2. Obtén tu clave API
3. Comienza a probar en minutos

Deja de perder tiempo en la verificación manual de correo. Deja que la API haga el trabajo mientras tú te concentras en construir un gran software.

Referencia de API

Crear Bandeja de Entrada

POST /api/inbox/create

Obtener Mensajes

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

Eliminar Bandeja de Entrada

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

Transmitir Mensajes (SSE)

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