How to Build a Email automation with Replit

To build an email automation in Replit, you can use Node.js with a simple scheduler (using node-cron) and an email library like nodemailer. You’ll put the main logic inside an index.js file, store credentials safely in Replit Secrets, and test emails right from your Repl. Replit can stay awake if you upgrade to “Always On,” or you can manually run it when needed. This setup will let you send automated emails at chosen times or in response to an event in your app.

 

Project Setup in Replit

 

Create a new Node.js Repl (when asked “Language,” select Node.js). The main file (created automatically) is index.js. You’ll write your main logic there.

• In the Replit sidebar, you’ll see a “Secrets” tab (key icon). Add environment variables there — they stay hidden and safe. You’ll need these for your email credentials.
• Name your secrets like EMAIL_USER and EMAIL_PASS if using Gmail or similar service.
• Open the Shell tab at the bottom and install two packages by running:

npm install nodemailer node-cron

 

Basic Email Sending Code

 

Below is a working example of how to send an email. This goes inside your existing index.js file in the root directory.

const nodemailer = require("nodemailer");
const cron = require("node-cron");

// Create reusable transporter using SMTP
const transporter = nodemailer.createTransport({
  service: "gmail", // You can also use another SMTP provider
  auth: {
    user: process.env.EMAIL_USER, // Loaded from your Replit Secrets
    pass: process.env.EMAIL_PASS
  }
});

// Function that sends an email
function sendMail() {
  const mailOptions = {
    from: process.env.EMAIL_USER,
    to: "[email protected]", // Replace with a real address
    subject: "Automated Email from Replit",
    text: "This is an automated email sent from your Replit project!"
  };

  transporter.sendMail(mailOptions, (error, info) => {
    if (error) {
      console.log("Error sending mail:", error);
    } else {
      console.log("Email sent successfully:", info.response);
    }
  });
}

// Run immediately to test
sendMail();

Run the Repl by clicking the “Run” button. Check the console for “Email sent successfully.” This proves that your SMTP credentials and Replit network connection work.

 

Add Email Automation (Scheduled Task)

 

If you want to send emails automatically at certain times, add this code at the bottom of the same index.js file:

// Run every day at 9 AM UTC
cron.schedule("0 9 * * *", () => {
  console.log("Running daily email automation...");
  sendMail();
});

The “0 9 _ _ _” pattern is a cron expression — it means “run at 09:00 UTC every day.” You can customize that pattern as needed (for example, “_/5 _ _ _ _” runs every 5 minutes).

Important note: On a free Replit plan, your Repl sleeps after inactivity, so cron won’t run while it’s asleep. If you upgrade to a Hacker plan and turn on “Always On” in your project's settings, the schedule will keep working in the background.

 

Optional: Better Project Structure

 

When your project grows, you might want to clean things up to stay organized:

• Create a utils folder, and inside it add a file called mailer.js. Move the transporter and sendMail function there.
• In index.js, just import and call these functions. This keeps your main file cleaner.

// Inside utils/mailer.js
const nodemailer = require("nodemailer");

let transporter = nodemailer.createTransport({
  service: "gmail",
  auth: {
    user: process.env.EMAIL_USER,
    pass: process.env.EMAIL_PASS
  }
});

function sendMail(to, subject, text) {
  const mailOptions = { from: process.env.EMAIL_USER, to, subject, text };
  return transporter.sendMail(mailOptions);
}

module.exports = sendMail;

// Inside index.js
const cron = require("node-cron");
const sendMail = require("./utils/mailer");

cron.schedule("0 9 * * *", async () => {
  await sendMail("[email protected]", "Daily report", "Your daily report is ready!");
  console.log("Sent daily report email");
});

 

Troubleshooting & Tips

 

• If Gmail blocks your connection, use an App Password (recommended) instead of your main password. You set this up in your Google account’s security settings.
• If you use another email provider, replace service: "gmail" with custom SMTP settings — for example, host, port, and secure.
• Don’t hardcode passwords or keys in your code. Always keep them in Replit Secrets.
• Test manually before adding a schedule to ensure everything sends properly.

 

This setup gives you a functional email automation running completely inside Replit — using real code, handling credentials securely, and adaptable for production use if you connect it to a database or API later.

If you want to build a reliable email automation system on Replit, use a Node.js backend (Express is a good choice), handle your API keys safely using Replit Secrets, use a trusted mail service like Nodemailer (for SMTP) or a transactional email API (like SendGrid), and separate your logic into small clear files: one for server logic (index.js), one for email logic (mailer.js), and a simple HTML form (for testing) in index.html. Keep secrets out of your code — only use Replit Secrets tab. Replit runs 24/7 only if you use Deployments or Always On, so plan accordingly if you need scheduled or automated sending.

 

Step 1: Setup your Replit environment

 

• Create a new Repl using the “Node.js” template.
• In the Replit left panel, open the Secrets (lock icon) and set environment variables:
  • EMAIL\_USER (your email address)
  • EMAIL\_PASS (app password / SMTP token)
• In the Replit Shell, install required packages:

npm install express nodemailer

 

Step 2: Create your server file (index.js)

 

This file runs your Express server and handles requests that trigger emails. Place this file at your Replit project root (Replit does it automatically when created).

// index.js
import express from "express";
import { sendEmail } from "./mailer.js"; // Import the mailer function

const app = express();
app.use(express.json()); // enables reading JSON from requests

// create an endpoint for triggering email automation
app.post("/send", async (req, res) => {
  const { to, subject, body } = req.body;

  try {
    await sendEmail(to, subject, body); // call the mailer
    res.json({ success: true, message: "Email sent successfully!" });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, error: "Failed to send email." });
  }
});

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

 

Step 3: Create the mail sending logic (mailer.js)

 

This file contains the actual sending function, separated so you can reuse or test it independently. Always read credentials from process.env since Replit injects your secrets automatically.

// mailer.js
import nodemailer from "nodemailer";

// create and export reusable function
export async function sendEmail(to, subject, body) {
  // Configure SMTP transport
  const transporter = nodemailer.createTransport({
    service: "gmail", // works for Gmail or you can change to custom SMTP
    auth: {
      user: process.env.EMAIL_USER,
      pass: process.env.EMAIL_PASS,
    },
  });

  const mailOptions = {
    from: process.env.EMAIL_USER,
    to,
    subject,
    html: `<p>${body}</p>`, // HTML content of email
  };

  // send email
  await transporter.sendMail(mailOptions);
}

 

Step 4: (optional) Create a frontend to test it (index.html)

 

To make it easy for non‑developers to trigger emails, you can have a small test form. In Replit, create index.html in the root folder and link it via Express’s static middleware or open it manually.

<!-- index.html -->
<!DOCTYPE html>
<html>
  <body style="font-family:sans-serif;">
    <h3>Send Test Email</h3>
    <form id="emailForm">
      <input type="email" id="to" placeholder="Recipient" required/><br/><br/>
      <input type="text" id="subject" placeholder="Subject" required/><br/><br/>
      <textarea id="body" placeholder="Email body"></textarea><br/><br/>
      <button type="submit">Send Email</button>
    </form>

    <script>
      const form = document.getElementById("emailForm");
      form.addEventListener("submit", async (e) => {
        e.preventDefault();
        const data = {
          to: document.getElementById("to").value,
          subject: document.getElementById("subject").value,
          body: document.getElementById("body").value
        };
        const res = await fetch("/send", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify(data)
        });
        const result = await res.json();
        alert(result.message || result.error);
      });
    </script>
  </body>
</html>

 

Step 5: Replit Deployment and Automation Tips

 

• Don’t store credentials in code. Always use the Secrets tab. Never git-commit your password or app tokens.
• Test using the Replit "Run" button. Your app will expose a public URL (something like https://yourrepl.username.repl.co).
• For automation (scheduled emails): Replit doesn’t allow traditional cron jobs on free containers. Instead, use an external service like cron-job.org to ping your Replit endpoint periodically.
• For reliability: Use the “Deployments” tab ➜ “Always On” or “Autoscale” if you’re sending on schedule or from webhook calls; otherwise the Repl will sleep after inactivity.
• Logging: Check the “Console” tab — Replit shows server logs live. Use console.log() generously when debugging.

 

Advanced Notes

 

• Use rate limiting (like express-rate-limit) if you publicly expose the send endpoint, to prevent abuse.
• For production email sending (>100/day), consider SendGrid or Resend instead of Gmail SMTP; you can still integrate them easily via their npm packages and store tokens in Secrets.
• Use a database (like Replit DB or external DB) if you want to queue or log sent emails.

 

This approach respects Replit’s constraints, keeps your credentials safe, and gives you a working, realistic base for email automation — not just a demo, but something you can extend for real projects.