Envía Emails a tus Clientes casi GRATIS con Oracle Cloud

Seguramente te haya pasado alguna vez: compras un dominio por ahí, montas tu sitio web chulo y de repente piensas… “¿Y si pudiera mandar emails a mis clientes?”

Es súper típico cuando creas un Software as a Service. Pones esa cajita de “Únete a la lista de espera” y luego quieres enviar un email a todas las personas que se hayan apuntado. Normal, ¿no?

Para poder hacer envíos masivos de email necesitas un servidor SMTP, y la verdad es que no siempre es fácil conseguirlo. Si te lo montas tú mismo en tu propio servidor, la IP puede no tener buena reputación y tus correos acabar directos en spam. A parte de que es un rollo hacerlo.

Ya existen servicios que nos ayudan con esto (SendGrid, Mailgun, Amazon SES, Resend…), pero créeme si te digo que son caros. Aunque no te lo parezca de primeras, lo son. Al menos en comparación con lo que te voy a enseñar hoy.

En este post te voy a mostrar:

1. Qué narices es un servidor SMTP (por si aún no lo tienes claro)
2. Por qué los servicios populares te sangran el bolsillo
3. Cómo conseguir un SMTP casi gratis con Oracle Cloud
4. Código de ejemplo para que veas lo fácil que es usarlo

¡Vamos al lío!

¿Qué es un servidor SMTP? (Explicado fácil)

SMTP son las siglas de Simple Mail Transfer Protocol, o lo que es lo mismo, el protocolo simple de transferencia de correo.

Piénsalo como un “cartero digital” encargado de que tu email vaya desde tu servidor hasta la bandeja de entrada del destinatario.

¿Cómo funciona? Muy fácil:

1. Conexión: Tu aplicación se conecta al servidor SMTP usando un puerto (normalmente el 25, 465 o 587)
2. Identificación: El servidor te pregunta “¿quién eres?” y comprueba que tengas permiso para enviar
3. Entrega: Tu app le dice al servidor “oye, manda este mensaje a cliente@ejemplo.com” y le pasa el contenido
4. Distribución: El servidor consulta los registros MX del dominio de destino, encuentra el “cartero” correspondiente y le envía el email

Básicamente, SMTP es como la oficina de correos central: tu servidor mete la carta en el buzón, y desde ahí el protocolo SMTP la reparte hasta llegar al destinatario.

Simple, ¿no? Sin esto no puedes enviar correos desde tu aplicación. Así de sencillo.

La realidad de los servicios SMTP populares

Vamos a ver qué nos ofrecen los servicios más conocidos y por qué te van a costar un ojo de la cara.

SendGrid

SendGrid es uno de los más conocidos, pero sus precios escalan rápido:

• Gratis: 100 emails/día
• Essentials ($19.95/mes): 50,000 emails
• Pro ($89.95/mes): 100,000 emails

Mailgun

Similar historia con Mailgun:

• Gratis: 5,000 emails durante 3 meses, luego de pago
• Foundation ($35/mes): 50,000 emails
• Growth ($80/mes): 100,000 emails

Resend (el favorito actual)

Resend se está volviendo muy popular últimamente porque tiene un panel muy accesible donde puedes ver estadísticas de emails enviados, destinatarios, y además tiene un SDK sencillito para aplicarlo en tus proyectos.

Su capa gratuita permite 3,000 emails gratis al mes, que está bastante bien. Pero cuando quieres ir a más:

• Pro ($20/mes): 50,000 emails (limitado a 10 dominios)
• Business ($90/mes): 100,000 emails

Si tu objetivo actual es solo mandar 3,000 emails o menos al mes desde una dirección de correo, con Resend te basta. Puedes parar de leer e ir a resend.com ahora mismo.

Pero si tienes pensado tener mucho más tráfico o gestionar el envío desde diferentes direcciones de correo…

La alternativa que nadie te cuenta: Oracle Cloud SMTP

Aquí es donde entra la joya oculta. Oracle Cloud ofrece un servicio SMTP que es ridículamente barato.

Si ya eres seguidor del blog, sabrás que gracias a Oracle hemos conseguido tener un servidor de 24GB de RAM y 4 núcleos totalmente gratis. Aquí tienes el tutorial completo.

Pues Oracle Cloud ofrece muchas más cosas aparte de VPS, y una de ellas es su servicio SMTP.

Los precios que te van a enamorar

Agárrate fuerte porque el precio está GENIAL:

• 3,000 emails gratis (iguala a Resend)
• Después: $0.085 por cada 1,000 emails (8 centavos, unos 7 céntimos)

Comparativa real de precios

Vamos a hacer los cálculos que nadie hace:

Cálculo para 50,000 emails:

• 50,000 - 3,000 (gratis) = 47,000 emails de pago
• 47 × $0.085 = $3.995 ≈ $4.00

Cálculo para 100,000 emails:

• 100,000 - 3,000 (gratis) = 97,000 emails de pago
• 97 × $0.085 = $8.245 ≈ $8.25

Es de risa cómo se reducen los precios. Y todo esto sin contar las ventajas adicionales:

Ventajas que Resend no te da

1. Sin límite de dominios: Resend te restringe a 10 dominios en el plan de $20. Oracle no tiene restricciones
2. Pago por uso real: Si un mes solo envías 20,000 correos, solo pagas ~$1.45. En Resend pagas la cuota entera
3. Escalabilidad: Puedes crecer sin saltos de precio brutales

La única “desventaja” es que no tienes ese SDK tan bonito de Resend, pero más adelante te voy a enseñar lo sencillo que es usar un SMTP normal y corriente.

Cómo conseguir tu servidor SMTP en Oracle Cloud

Paso 1: Crear cuenta en Oracle Cloud

Lo primero es crearte una cuenta en Oracle Cloud si aún no la tienes. Consejo importante: pon datos reales, ya que al final del registro te pedirán verificación con tarjeta para confirmar que el nombre coincide con el tuyo.

Paso 2: Activar la capa de pago (opcional pero recomendado)

Una vez creada la cuenta, si solo quieres usar la capa gratuita ya no tendrás que hacer nada más. Ojo: la capa gratuita te permite enviar solo 100 emails al día (igual que Resend).

Si quieres continuar sin restricciones diarias:

1. Pulsa “Upgrade” en el mensaje que aparece arriba
2. Si no aparece, busca “Billing” en el menú
3. Dale a “Upgrade account” en la sección “Pay as you go”
4. En cuestión de minutos u horas recibirás confirmación por email

Paso 3: Configurar el servicio Email Delivery

Mientras esperamos la confirmación, podemos ir configurando:

1. Busca “Email Delivery” en el menú de Oracle Cloud
2. Crea una nueva configuración de email
3. Añade tu dominio y configúralo con Cloudflare o tu proveedor de DNS
4. Verifica el dominio siguiendo las instrucciones (añadir registros DNS/SPF/DKIM)

Paso 4: Obtener las credenciales SMTP

Una vez verificado el dominio, en “Configuration” aparecerá toda la información para conectarte al SMTP. Guárdate esta info:

• Host: smtp.email.region.oci.oraclecloud.com
• Puerto: 587 (TLS) o 25

Paso 5: Generar credenciales de usuario

Importante: Las credenciales SMTP NO coinciden con tu contraseña de acceso al portal. Se generan y muestran una sola vez, así que no las pierdas.

Para obtener tu contraseña SMTP:

1. Ve a Identity → Domains → Default domain → Users
2. Encuentra tu usuario y entra en SMTP credentials
3. Pulsa Generate credentials
4. Guarda el usuario y contraseña que aparecen

El usuario será una cadena de texto larguísima, pero es normal.

¡Ya tienes todo! Host, puerto, usuario, contraseña y email de origen. Cualquier servicio externo que uses y te pida información SMTP ya se la puedes proporcionar.

Código de ejemplo: Cómo usar tu SMTP en una aplicación real

”Oye Edu, yo soy programador y me encantaba Resend porque era tan fácil como llamar a su API, ¿qué hago ahora con tantas cosas?”

Tranquilo, que si eres programador sabrás que no hay nada imposible. Y hacer esto es súper fácil.

He preparado un proyecto de ejemplo en Astro (pero puedes adaptarlo a Next.js, React, Node.js, Java… lo que quieras).

Instalación de dependencias

npm install nodemailer
npm install --save-dev @types/nodemailer

Variables de entorno

Crea tu archivo .env con las credenciales de Oracle:

SMTP_HOST=smtp.email.eu-frankfurt-1.oci.oraclecloud.com
SMTP_PORT=587
SMTP_USER=tu_usuario_larguisimo_de_oracle
SMTP_PASS=tu_contraseña_generada
SMTP_FROM=noreply@tudominio.com

Código del endpoint

// src/pages/api/send-email.ts
import type { APIRoute } from 'astro';
import nodemailer from 'nodemailer';
import fs from 'fs';
import path from 'path';

interface EmailRequest {
  to: string;
  type: 'raw' | 'template';
  message?: string;
  templateData?: {
    name: string;
    [key: string]: any;
  };
}

export const POST: APIRoute = async ({ request }) => {
  try {
    // Leer y validar el body
    const body: EmailRequest = await request.json();
    
    // Validaciones básicas
    if (!body.type || !['raw', 'template'].includes(body.type)) {
      return new Response(
        JSON.stringify({ error: 'Tipo de email inválido' }),
        { status: 400, headers: { 'Content-Type': 'application/json' } }
      );
    }

    if (!body.to || body.to.trim() === '') {
      return new Response(
        JSON.stringify({ error: 'Email de destino requerido' }),
        { status: 400, headers: { 'Content-Type': 'application/json' } }
      );
    }

    // Leer variables de entorno
    const smtpHost = import.meta.env.SMTP_HOST;
    const smtpPort = parseInt(import.meta.env.SMTP_PORT);
    const smtpUser = import.meta.env.SMTP_USER;
    const smtpPass = import.meta.env.SMTP_PASS;
    const smtpFrom = import.meta.env.SMTP_FROM;

    if (!smtpHost || !smtpPort || !smtpUser || !smtpPass || !smtpFrom) {
      return new Response(
        JSON.stringify({ error: 'Configuración SMTP incompleta' }),
        { status: 500, headers: { 'Content-Type': 'application/json' } }
      );
    }

    // Crear transporter de nodemailer
    const transporter = nodemailer.createTransporter({
      host: smtpHost,
      port: smtpPort,
      secure: false, // true para puerto 465, false para otros
      auth: {
        user: smtpUser,
        pass: smtpPass,
      },
    });

    // Preparar el contenido del email
    let subject: string;
    let htmlContent: string;

    if (body.type === 'raw') {
      if (!body.message || body.message.trim() === '') {
        return new Response(
          JSON.stringify({ error: 'Mensaje requerido para email raw' }),
          { status: 400, headers: { 'Content-Type': 'application/json' } }
        );
      }
      
      subject = 'Mensaje desde tu aplicación';
      htmlContent = `<p>${body.message}</p>`;
      
    } else { // template
      subject = 'Bienvenido a nuestra plataforma';
      
      // Leer template HTML
      const templatePath = path.join(process.cwd(), 'src', 'templates', 'welcome.html');
      let template = fs.readFileSync(templatePath, 'utf-8');
      
      // Reemplazar variables del template
      if (body.templateData) {
        Object.keys(body.templateData).forEach(key => {
          template = template.replace(`{{${key}}}`, body.templateData![key]);
        });
      }
      
      htmlContent = template;
    }

    // Enviar el email
    const info = await transporter.sendMail({
      from: smtpFrom,
      to: body.to,
      subject: subject,
      html: htmlContent,
    });

    return new Response(
      JSON.stringify({ 
        success: true, 
        messageId: info.messageId,
        message: 'Email enviado correctamente' 
      }),
      { status: 200, headers: { 'Content-Type': 'application/json' } }
    );

  } catch (error) {
    console.error('Error enviando email:', error);
    return new Response(
      JSON.stringify({ error: 'Error interno del servidor' }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    );
  }
};

Template HTML de ejemplo

Crea src/templates/welcome.html:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Bienvenido</title>
</head>
<body style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
    <div style="background: #f8f9fa; padding: 20px; text-align: center;">
        <h1 style="color: #333;">¡Hola {{name}}!</h1>
        <p style="color: #666; font-size: 16px;">
            Bienvenido a nuestra plataforma. Estamos emocionados de tenerte con nosotros.
        </p>
        <a href="https://tudominio.com" 
           style="background: #007bff; color: white; padding: 12px 24px; 
                  text-decoration: none; border-radius: 5px; display: inline-block;">
            Empezar ahora
        </a>
    </div>
</body>
</html>

Cómo usar el endpoint

// Envío de email simple
const response = await fetch('/api/send-email', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    to: 'cliente@ejemplo.com',
    type: 'raw',
    message: 'Hola, este es un mensaje de prueba'
  })
});

// Envío con template
const response = await fetch('/api/send-email', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    to: 'cliente@ejemplo.com',
    type: 'template',
    templateData: {
      name: 'Juan Pérez'
    }
  })
});

Como ves, hacer envío de correos con SMTP es muy similar a Resend. La sintaxis apenas cambia, y tienes mucho más control sobre el proceso.

Repositorio completo

He subido todo el código de ejemplo a GitHub para que puedas descargarlo y usarlo como referencia: Ver repositorio

¡MUY IMPORTANTE! No olvides configurar tu archivo .env con las propiedades que hemos visto en Oracle, sino no podrá iniciar sesión.

Conclusión: El SMTP que necesitabas

Como ves, montar un servicio de envío de emails barato y escalable no es nada complicado. Oracle Cloud te ofrece:

✅ 3,000 emails gratis para empezar
✅ Precios ridículos después (91% más barato que la competencia)
✅ Sin límites de dominios
✅ Pago por uso real
✅ Escalabilidad sin saltos de precio brutales

La única “pega” es que no tienes un SDK tan visual como Resend, pero con el código que te he enseñado tienes todo lo que necesitas.

Si quieres llevar tus automatizaciones un paso más allá, te recomiendo que eches un vistazo a N8N, una herramienta de automatizaciones que está revolucionando el mercado. Aquí tienes el tutorial completo para instalártela gratis.

¡Nos vemos en el próximo blog! ❤️