Mailtrap Free Plan Details

please what is the free plan that allowing mailtrap ?

Mailtrap offers a free plan called the "Free Plan", which is designed for testing and
development purposes. It includes the following features:

1 inbox (a virtual email inbox for testing)

500 test emails per month (this means you can send up to 500 emails for testing
purposes)

1 team member (you can only have one user in the free plan)

Limited email logs (a limited retention time for email logs, usually for a short period)

This free plan is useful for individual developers or small teams who want to test email
functionality during development. However, if you need more features like more inboxes,
higher email volume, or collaboration with a team, you would need to upgrade to a paid
plan.

You can sign up for the free plan on the Mailtrap website.

so how i can build in node js with express js framework a

system to handle (forgot password , email verification ) ,
without a limited resource like mailtrap ?

To handle forgot password and email verification functionalities in a Node.js application

using the Express.js framework without relying on a service like Mailtrap, you'll need to set
up a system to send real emails using an email provider like SMTP (e.g., Gmail, SendGrid,
Amazon SES) or even set up your own email server. Here's a step-by-step guide on how to do
that:

1. Set Up Node.js and Express

First, make sure you have a Node.js project set up with the necessary dependencies.

1. Initialize your Node.js project if you haven't already:

bash

mkdir my-app
cd my-app
npm init -y

1/11
 2. Install required dependencies:

bash

npm install express nodemailer bcryptjs jsonwebtoken dotenv

express: For the web framework.

nodemailer: To send emails.

bcryptjs: To hash passwords.

jsonwebtoken: For creating and verifying tokens (for password reset and email
verification).

dotenv: To manage environment variables.

2. Create Environment Variables

In your root directory, create a .env file to store sensitive information such as your email
service credentials:

ini

EMAIL_HOST=smtp.your-email-provider.com
EMAIL_PORT=587
[email protected]
EMAIL_PASS=your-email-password
JWT_SECRET=your-jwt-secret-key
FRONTEND_URL=http://localhost:3000 # Update with your actual frontend URL

Note: You can use email services like SendGrid, Mailgun, Amazon SES, or even a personal
SMTP server. These services offer reliable email sending without the limits of Mailtrap.

3. Setting Up Email Sending Logic

Now, you can configure Nodemailer to send emails through an SMTP provider. Here's how
you can do it.

js

// emailService.js
const nodemailer = require('nodemailer');
require('dotenv').config();

2/11
 // Configure the SMTP transporter
const transporter = nodemailer.createTransport({
host: process.env.EMAIL_HOST,
port: process.env.EMAIL_PORT,
secure: false, // Use TLS
auth: {
user: process.env.EMAIL_USER,
pass: process.env.EMAIL_PASS,
},
});

// Send email function

const sendEmail = (to, subject, text, html) => {
const mailOptions = {
from: process.env.EMAIL_USER,
to,
subject,
text,
html,
};

return transporter.sendMail(mailOptions);
};

module.exports = { sendEmail };

4. Forgot Password Flow

For the forgot password functionality, you will:

1. Generate a reset token (JWT).

2. Send an email with the token link.

3. Allow the user to reset their password using that link.

js

// authController.js
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const { sendEmail } = require('./emailService');
const User = require('./models/User'); // Replace with your User model

3/11
// Forgot Password: Generate reset token and send via email
const forgotPassword = async (req, res) => {
const { email } = req.body;
const user = await User.findOne({ email });

if (!user) {
return res.status(400).json({ message: 'User not found' });
}

const token = jwt.sign({ userId: user._id }, process.env.JWT_SECRET, { expiresIn:

'1h' });
const resetUrl = `${process.env.FRONTEND_URL}/reset-password/${token}`;

try {
await sendEmail(
email,
'Password Reset Request',
`Click here to reset your password: ${resetUrl}`,
`<a href="${resetUrl}">Click here to reset your password</a>`
);

res.status(200).json({ message: 'Password reset link sent to your email' });

} catch (error) {
res.status(500).json({ message: 'Error sending email' });
}
};

// Reset Password: Validate token and update password

const resetPassword = async (req, res) => {
const { token, newPassword } = req.body;
try {
const decoded = jwt.verify(token, process.env.JWT_SECRET);
const user = await User.findById(decoded.userId);

if (!user) {
return res.status(400).json({ message: 'Invalid user' });
}

const hashedPassword = await bcrypt.hash(newPassword, 10);

user.password = hashedPassword;
await user.save();

4/11
 res.status(200).json({ message: 'Password updated successfully' });
} catch (error) {
res.status(400).json({ message: 'Invalid or expired token' });
}
};

5. Email Verification Flow

For email verification, you can send a verification token when the user registers, and they
will click a link to verify their email.

js

// authController.js (continued)

// Email Verification: Send a verification token

const sendVerificationEmail = async (user) => {
const token = jwt.sign({ userId: user._id }, process.env.JWT_SECRET, { expiresIn:
'1h' });
const verificationUrl = `${process.env.FRONTEND_URL}/verify-email/${token}`;

try {
await sendEmail(
user.email,
'Email Verification',
`Click here to verify your email: ${verificationUrl}`,
`<a href="${verificationUrl}">Click here to verify your email</a>`
);
} catch (error) {
throw new Error('Error sending email verification link');
}
};

// Verify Email: Validate token and activate account

const verifyEmail = async (req, res) => {
const { token } = req.params;

try {
const decoded = jwt.verify(token, process.env.JWT_SECRET);
const user = await User.findById(decoded.userId);

if (!user) {

5/11
 return res.status(400).json({ message: 'Invalid user' });
}

user.isVerified = true; // Assuming `isVerified` field exists on User model

await user.save();

res.status(200).json({ message: 'Email verified successfully' });

} catch (error) {
res.status(400).json({ message: 'Invalid or expired verification token' });
}
};

6. Set Up Routes
In your routes file, you can set up routes for these functionalities.

js

// authRoutes.js
const express = require('express');
const router = express.Router();
const { forgotPassword, resetPassword, verifyEmail } = require('./authController');

// Forgot Password Route

router.post('/forgot-password', forgotPassword);

// Reset Password Route

router.post('/reset-password', resetPassword);

// Email Verification Route

router.get('/verify-email/:token', verifyEmail);

module.exports = router;

7. Integrate Routes in Express

Now, integrate these routes in your main Express app:

js

// server.js
const express = require('express');
const dotenv = require('dotenv');

6/11
 const cors = require('cors');
const authRoutes = require('./authRoutes');

dotenv.config();

const app = express();

app.use(cors());
app.use(express.json());

app.use('/api/auth', authRoutes);

const PORT = process.env.PORT || 5000;

app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});

8. Testing Your Application

Run your app: node server.js .

Make sure the email provider you're using is configured correctly and can send emails.

Use Postman or any API testing tool to test the forgot password and email verification
routes.

Important Notes:
1. Email Provider: Use a service like SendGrid, Mailgun, or Amazon SES for production, as
free providers like Gmail might have limitations on sending mass emails or using SMTP
for a production app.

2. Security: Ensure you are hashing passwords securely and storing sensitive information
like API keys in environment variables.

Conclusion
With this setup, you can handle forgot password and email verification flows in your
Node.js + Express.js app without relying on limited services like Mailtrap. You'll have full
control over email sending and can scale based on your needs.

so betwenn these options , what is the best for my big goal

? : SendGrid, Mailgun, Amazon SES,

7/11
Choosing between SendGrid, Mailgun, and Amazon SES depends on your specific use case,
volume, and budget. Each of these services offers different strengths, so let's break down the
key factors to help you decide:

1. SendGrid

Best For: Ease of use, scalability, and built-in analytics.

Ease of Integration: SendGrid is very user-friendly and has comprehensive

documentation, making it a great option if you want to set up email quickly without
deep configuration.

Features: It offers features like email tracking, analytics, and templates, which can be
helpful if you need more than just basic email sending.

Scalability: It's great for both small and large-scale applications. You can start with the
free plan (up to 100 emails/day) and scale as your email volume grows.

Support: Excellent support and a user-friendly dashboard.

Pricing: Offers a free tier (up to 100 emails/day), and pricing increases as your sending
volume goes up. Its pricing model is transparent, which makes it easy to understand
costs.

When to Choose SendGrid:

You need an easy-to-use service with a quick setup.

You want advanced features like email analytics, template management, and email
tracking.

You're planning to scale quickly and want a well-documented service that handles this.

2. Mailgun

Best For: Developers and flexibility, especially if you need advanced email features.

Developer-Focused: Mailgun is geared towards developers and offers flexibility in terms

of API usage, SMTP support, and even routing options.

Features: It includes advanced features like email validation, in-depth analytics, and
automated email flows.

Scalability: It handles large-scale email sending very well and offers detailed analytics.

Pricing: Mailgun offers a free tier with 5,000 emails for the first three months, then it
charges on a pay-as-you-go basis. It’s slightly more expensive than SendGrid but offers

8/11
 higher flexibility for larger needs.

When to Choose Mailgun:

You're looking for more flexibility and control over your email flows.

You need powerful email analytics and validation.

You’re a developer or have a team with technical expertise that requires advanced
configurations.

3. Amazon SES (Simple Email Service)

Best For: Cost-effective, high-volume sending, and AWS ecosystem users.

Pricing: Amazon SES is the most cost-effective option, especially for high-volume email
sending. It charges based on the number of emails sent (roughly $0.10 per 1,000
emails). This makes it ideal if you're sending a large volume of emails and need to keep
costs low.

Integration: It integrates seamlessly with AWS services, making it a natural choice if

you're already using AWS for other infrastructure.

Features: SES offers fewer features compared to SendGrid or Mailgun (e.g., lacks
advanced email templates or in-depth analytics out of the box). However, you can
integrate it with other AWS services for more advanced functionality (e.g., AWS Lambda
for custom workflows).

Scalability: It's highly scalable and supports sending large volumes of email, making it a
solid choice for applications that expect to scale significantly.

When to Choose Amazon SES:

You need the most cost-effective option for high-volume email sending.

You're already within the AWS ecosystem and prefer a solution that integrates with your
existing infrastructure.

You don't need advanced features like email templates or detailed analytics.

You're comfortable setting up custom workflows using AWS tools.

Comparison Summary

9/11
 Feature SendGrid Mailgun Amazon SES

Ease of Use Very user-friendly Developer-focused but More complex, AWS

easy to integrate integration required

Pricing Free tier (100 emails/day), Free tier (5,000 emails for Extremely cost-effective,
pay-as-you-go 3 months), pay-as-you-go pay-as-you-go

Scalability Good, with paid plans for Good, designed for high Excellent for high
high volumes volume volumes

Features Advanced analytics, email Powerful features like Basic email sending,
templates, tracking email validation, routing limited analytics

Support Great support, extensive Developer-friendly, good Limited support unless

documentation support you're using AWS support

Integration Simple integration, third- Good API, developer tools Best if already using AWS
party support services

Best For Quick setup, analytics, Flexibility, control, High-volume, low-cost,

templates advanced features AWS ecosystem

Recommendation Based on Your Goal:

For High-Volume, Cost-Effective Sending: Amazon SES is the best option, especially if
you're sending a large volume of emails. It’s also highly cost-effective, but keep in mind
it lacks advanced features like email templates or detailed analytics.

For Ease of Use with Advanced Features: SendGrid is an excellent option if you want a
user-friendly interface with robust features like email tracking, templates, and analytics.
It's scalable and provides everything you need to grow without significant technical
overhead.

For Developers Needing Advanced Flexibility: Mailgun would be the best choice if you
need advanced features like email validation, routing, or even building custom email
workflows. It’s great for developers and teams that need fine-grained control over email
sending, but it may come at a slightly higher price than SendGrid.

Conclusion:
If you're just getting started and need simplicity, SendGrid is often the easiest option with
good features. If you want to maximize cost-effectiveness and plan on sending a large
volume of emails, Amazon SES will be your best bet. Mailgun fits well if you need advanced
developer features and have the technical expertise to handle more complex setups.

10/11
 so i can use mailtrap free for ever ?

Mailtrap's free plan is available indefinitely, but it does come with some limitations. Here's a
breakdown of what you get with the Mailtrap free plan:

Mailtrap Free Plan Features:

1 inbox: You get access to one inbox for email testing.

500 test emails per month: You can send up to 500 emails per month for testing.

1 team member: The free plan allows only one user to access the inbox.

Limited email logs: The email logs are stored for a limited time (usually up to 7 days).

Basic email preview: You can preview and inspect the contents of the emails sent to the
inbox.

Limitations of the Free Plan:

1. Low monthly email volume: The limit of 500 emails per month might not be sufficient
for larger projects.

2. Limited functionality: Some features, such as email API access, integration with more
inboxes, and advanced reporting, are only available on higher-paid plans.

3. Only one user: You can’t add multiple team members in the free plan.

Can You Use It Forever?

Yes, the Mailtrap free plan is available indefinitely, but it is designed for small-scale testing
and development. If your needs grow beyond the limitations (e.g., more inboxes, higher
volume, team collaboration), you would need to upgrade to one of their paid plans.

Conclusion:
You can use Mailtrap for free indefinitely as long as you stay within the limits of the free
plan (500 emails per month, 1 inbox, etc.). If your email testing needs exceed those limits,
you would need to explore one of Mailtrap’s paid options.

If you're building a system in development and just need to test email functionality,
Mailtrap's free plan is a great option. But once you're ready to go live or need to scale, you’ll
likely need to consider a paid solution for production or higher volume.

11/11