Sending Emails with Node.js
Tags: javascript, webdev, node, tutorial
Published: 2022-09-12 08:51:42

Sending emails from Node.js is easy. We have gone over it in our previous blog post on [sending emails with Nodemailer](https://mailtrap.io/blog/sending-emails-with-nodemailer/). Last time we reviewed Nodemailer’s capabilities we focused on sending HTML emails via SMTP. In this post, we will examine how to send emails with Node.js using popular email servers like Gmail. Also, we will have a look at other transport options and packages to build and send emails from Node.js.

## Building and sending emails with Node.js without Nodemailer
In some guides and tutorials, you might find a note that there are a variety of Node.js email packages but Nodemailer is the best one. It’s not true. In fact, you can barely find a decent alternative to Nodemailer (and I can hardly imagine why you might need it.)

On Github, you can find several Node.js packages related to emails but they won’t offer you a wide functionality. With Nodemailer, you can create HTML emails with attachments and send them via SMTP, SES (wrapper for sending emails via [AWS SES](https://mailtrap.io/blog/amazon-ses-explained/)), or sendmail. 

1. The most similar package is Emaijs. Its features include: 

- sending emails via SMTP servers (both SSL and TLS) with authentication
- HTML support and MIME attachments (also, attachments can be added as strings, streams, or file paths)
- asynchronous sending of queued emails 
- UTF-8 encoding in headers and body.

So, the main difference is that in [Emailjs](https://github.com/eleith/emailjs) you will use MIME type to work with attachments, while in Nodemailer you use strings.
 

2. Another quite popular package is [email-templates](https://github.com/niftylettuce/email-templates). As you can see from the name, this package is designed for creating various custom templates for Node.js. It features support for automatic inline CSS, stylesheets, embedded images, and fonts. Also, it has an email preview option. The email templates package was made by the creator of the [Lad](https://lad.js.org/) framework. So it’s recommended to use it with Lad. 

3. One more package worth mentioning here is [Mailgen](https://github.com/eladnava/mailgen). It is aimed at creating HTML templates for transactional emails. There is a note on Github, that with Mailgen you can “Programmatically create beautiful emails using plain old JavaScript.” The package includes several open-source themes as well as supports custom elements like tables, action buttons, etc. It is your choice how to send an email created with Mailgen, but they recommend checking out Nodemailer for this purpose. 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0my5uywa7tz9xm86v0pd.png)

Nodemailer is the most popular package, which offers functionality for both email creation and email sending, period. It’s not limited to one sending method. But it won’t be easy to create a special email template. With no real alternative that surpasses Nodemailer in functionality,  the optimal route is using it in combination with another package.

To find all related packages and plugins, [search for nodemailer](https://www.npmjs.com/search?q=nodemailer) in npm.

## Sending emails with Node.js using Mailtrap

Before we dive into reviewing how dynamic content works with HTML emails, it’s worth mentioning a new package that was just released in June 2022. Mailtrap’s very own [sending package](https://github.com/railsware/mailtrap-nodejs)! Mailtrap provides both sending and testing functionality, and we always aim at saving everyone time and simply making life easier. With that in mind, it only made sense for us to make a package that allows developers to add a sending functionality to a Node.js application quickly. Additionally, it offers integration with the [official API](https://api-docs.mailtrap.io/?_ga=2.50881449.1487355700.1662962770-758897001.1661148652#tag--Email-API) for Mailtrap and will be integrated with Nodemailer in the near future.

Install the Mailtrap package: 

[yarn](https://yarnpkg.com/):

```
yarn add mailtrap
```
[npm](https://www.npmjs.com/):

```
npm install mailtrap
```
To further proceed with adding sending functionality to your Node.js application [refer here](https://github.com/railsware/mailtrap-nodejs/tree/main/examples) for the source code.

If you want to find any issues that can lead to bugs or other inconsistencies use `yarn lint` with [ESLint](https://eslint.org/).

## Sending HTML emails with dynamic content

In our previous blog post, we reviewed [several examples of sending HTML emails](https://mailtrap.io/blog/sending-emails-with-nodemailer/) with Nodemailer, embedding images, and attaching files. In most cases, for [transactional emails](https://mailtrap.io/blog/transactional-emails/) like registration confirmation or resetting passwords, you need to use dynamic content. It will be easier and more efficient to do it with one of the template modules. 

Let’s experiment with the [email-templates](https://www.npmjs.com/package/email-templates) package. It has several interesting features:

- Support for different template engines ([Pug](https://pugjs.org/api/getting-started.html) is a default one)
- Email preview (by default) in the development environment
- Direct email sending. So, you don’t need extra packages like Nodemailer for email sending.
 
First of all, let’s create our templates, for a frequently occurring scenario: new user registration. In this example, we are working with the default option (for more details and samples of using Pug, refer to [Github](https://github.com/pugjs/pug).) 

Install the template engine:

[npm](https://www.npmjs.com/):

```
npm install email-templates pug
```
[yarn](https://yarnpkg.com/):

```
yarn add email-templates pug
```
We should create two files: subject and HTML body.

_subject.pug:_

```
= `Hi ${firstName} ${lastName}, happy to see you at My App!`
```
_html.pug:_

  

```
 h1 Hello #{firstName} #{lastName}
    p.
Welcome to My App! Now your test emails will be safe. We just need to make sure your account is real.
Please, click the button below and start using your account.
a(href='https://example.com/confirmation') Confirm!
```
Now make sure that your directory has the following structure:

```

├── app.js
├── emails
│   └── welcome (the template name)
│       ├── html.pug
│       ├── subject.pug
│       └── text.pug
```
Pay attention to the text part of your message: if you don’t include it, it will be generated automatically. But if you add it, it will be rendered automatically. This means that the content of the text and HTML parts may differ. 

Now we can write some code to gather all the elements together and add transport. As usual, we will use [Mailtrap](https://mailtrap.io/), to be able to test and check everything. In the same way, you can use any other SMTP server like Gmail, for example. Just be careful if experimenting with real email addresses!

```
const Email = require('email-templates');
const email = new Email({
 message: {
   from: 'hi@example.com'
 },
 send: true,
 transport: {
   host: 'smtp.mailtrap.io',
   port: 2525,
   ssl: false,
   tls: true,
   auth: {
     user: '1a2b3c4d5e6f7g', // your Mailtrap username
     pass: '1a2b3c4d5e6f7g' //your Mailtrap password
   }
 }
});
const people = [
 {firstName: 'Diana', lastName: 'One'},
 {firstName: 'Alex', lastName: 'Another'}
];
people.forEach((person) => {
 email
   .send({
     template: 'welcome',
     message: {
       to: 'test@example.com'
     },
     locals: person
   })
   .then(console.log)
   .catch(console.error);
}).

```
By default, the preview of your email will be opened in your browser. It might be helpful if you are working on your template and don’t need to actually send the message. If you need to test how the variables work, and you compose a message to dozens or even hundreds of recipients, be careful with this option. To switch it off, specify `options.open` as `false`.

This is why we use Mailtrap: we will see how the message looks for each recipient, explore both HTML and text versions, and will be able to perform additional checks. With Pug and email-templates, you can build a complex template using CSS, inlined images, tables, etc. Here is an example of how it should look in the Mailtrap virtual inbox:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/byj3towsp30qid8nwhbu.png)

## Sending Emails with Nodemailer and SMTP

If configuring a new message in Nodemailer, we always should start with creating a transport method. The most popular one is the SMTP server, which can be easily set up for the majority of email clients or sending providers (like Sendgrid, Outlook, Gmail, etc.) [SMTP configuration](https://mailtrap.io/blog/setup-smtp-server/) will be very simple and similar. For more detailed instructions on how to use Nodemailer, refer to the “[Sending emails with Nodemailer explained](https://mailtrap.io/blog/sending-emails-with-nodemailer/)” blog post.

Here we will demonstrate how to send emails with Gmail as it requires some tricks related to authentication.

## Sending emails with Gmail 

To be able to use Gmail to send messages via your app, you should start with several account configurations.

If you use a **plain password**, then you should allow access for less secure apps. 

1. Go to the **[Less secure app access](https://myaccount.google.com/lesssecureapps)** section of your Google Account. 
2. Turn **Allow less secure apps** on.
3. Additionally, you should enable **[Display Unlock Captcha](https://accounts.google.com/b/0/displayunlockcaptcha)**. 

If you are using **2-Step Verification**, you should sign in with **[App Passwords](https://support.google.com/accounts/answer/185833?hl=en)**. To create your password:

1. Go to the **Security** section of your [Gmail account](https://myaccount.google.com/). 
2. Choose **App Passwords** in the **Signing into Google** block.
3. Select the app and device from the list and press **Generate**. 

Please note that you can use it for your personal account only. It’s not available for accounts that are a part of an organization. 

What else you should remember when setting the Gmail SMTP:

1. Gmail will automatically set the authenticated username as the From email address. To change it, you should “Add another address you own”. You will find it in your Gmail account -> Settings-> Accounts. For more details, refer to this [Google Help Center article](https://support.google.com/mail/answer/22370?hl=en). 
2. Gmail has its own [email limits](https://support.google.com/a/answer/166852?hl=en). For free (trial) accounts, it’s only 500 emails per day. If you reach the limit, your account might be suspended.
 
Now, when you made all necessary configurations, let’s set up the Gmail SMTP as a transport in the Node.js app. 

Gmail SMTP hostname is `smtp.gmail.com`, the port should be 465 for SSL connection or 587 for TLS.

```
var nodemailer = require('nodemailer');
var transporter = nodemailer.createTransport({
    host: 'smtp.gmail.com',
    port: 465,
    secure: true, // use SSL
    auth: {
        user: 'yourusername@gmail.com',
        pass: 'yourpassword'
    }
});
```
To avoid authentication issues, it is recommended to use oAuth2. Nodemailer requires an _Access Token_ to perform authentication. Read the instructions on the N[odemailer documentation](https://nodemailer.com/usage/using-gmail/) to proceed with this method. 

Once you have retrieved client ID and client Secret, refresh token and enable [Gmail API](https://mailtrap.io/blog/send-emails-with-gmail-api/) at API console. It is recommended to use `bunyan` logger:

```
const bunyan = require('bunyan');
const nodemailer = require('../lib/nodemailer');
let logger = bunyan.createLogger({
    name: 'nodemailer'
});
logger.level('trace');
// Create a SMTP transporter object
let transporter = nodemailer.createTransport(
    {
        service: 'Gmail',
        auth: {
            type: 'OAuth2',
            user: 'mail',
            clientId: 'clientid',
            clientSecret: 'clientsecret',
            refreshToken: 'refreshtoken',
            accessToken: 'accesstoken',
            expires: 12345
        },
```
Otherwise, to get an access token, you can use [xoauth2](https://www.npmjs.com/package/xoauth2) package. 

For more detailed instructions on using Gmail, refer to our [Nodemailer Gmail Tutorial](https://mailtrap.io/blog/nodemailer-gmail/).

## Sending emails without SMTP 
If you stick to one of the popular email sending providers like Sendgrid, Mandrill, Mailgun, or Postmark, you can integrate your Node.js app with their API directly.

For AWS SES, there is a wrapper around Nodemailer, [node-ses](https://nodemailer.com/transports/ses/). You can use aws-sdk directly, but node-ses provides a simpler way to send complex email templates with images and attachments. 

## Bottom line
If you are adding the email sending functionality to your Node.js app, most likely you will use Nodemailer. It is the simplest and most popular sending option compatible with other packages. 

Besides, there are still options for how to send emails in Node.js without Nodemailer and without the SMTP server as well. Choose the option which best suits your current environment and needs. Just don’t forget to inspect and debug your test emails before delivering them to your customers.

And, with Mailtrap, you can do both in one swell swoop. Our [Mailtrap Email API](https://mailtrap.io/email-api/) offers quick setup and deliverability monitoring after you inspect and debug your emails using Mailtrap Email Sandbox.

---

Thank you for reading our article which was originally published on Mailtrap Blog in an in-depth guide on how to [send email via Node.js with examples](https://mailtrap.io/blog/send-emails-with-nodejs/).