DEV Community: AlexandraMT

How to Send Emails in Flask

AlexandraMT — Mon, 11 Apr 2022 14:09:47 +0000

Flask is a popular Python web framework and the preferred choice for many web developers. It’s often referred to as a microframework because of its limited capabilities and the general minimalist approach to the development in Python. As such, it also doesn’t offer a native solution for sending emails, but more than makes up for it with an excellent Flask-Mail extension.

In this article, we’ll explain how to configure and send emails with Flask-Mail.To get started, we’ll need to take care of a few brief installs, traditionally done with a pip. If you don’t have Flask installed yet - check out the full article How to Send Emails in Flask at Mailtrap blog.

Sending emails in Flask

Email sending in Flask-Mail is handled by an instance of a Mail class.

from flask import Flask from flask_mail import Mail

app = Flask(app_name) # pick the name mail = Mail(app)
We’ll need to set up a Message object, mapped by the URL rule (‘/’), and insert the base details of our message:

@app.route("/")
def index():
  msg = Message('Hello from the other side!', sender =   'alexandra@mailtrap.io', recipients = ['paul@mailtrap.io'])
  msg.body = "Hey Paul, sending you this email from my Flask app, lmk if it works"
  mail.send(msg)
  return "Message sent!"

All in all, the entire code will look like this:

from flask import Flask
from flask_mail import Mail

app = Flask(app_name)

app.config['MAIL_SERVER']='smtp.mailtrap.io'
app.config['MAIL_PORT'] = 2525
app.config['MAIL_USERNAME'] = '97e041d5e367c7'
app.config['MAIL_PASSWORD'] = 'cfaf5b99f8bafb'
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USE_SSL'] = False
mail = Mail(app)

@app.route("/")
def index():
  msg = Message('Hello from the other side!', sender =   'alexandra@mailtrap.io', recipients = ['paul@mailtrap.io'])
  msg.body = "Hey Paul, sending you this email from my Flask app, lmk if it works"
  mail.send(msg)
  return "Message sent!"

if __name__ == '__main__':
   app.run(debug = True)

Run it in Python Shell, open http://localhost:5000/, and check whether the email arrived in your inbox. It certainly arrived in ours!

Customizing

MAIL_DEFAULT_SENDER from the configuration is, by default, set to none and we skipped it in our setup. However, if you want to keep sending from the same address, it makes sense to specify it there.
A good idea is to also specify the display name for a sender:

msg = Message('Hello from the other side!', sender = ("Alexandra from Mailtrap", 'peter@mailtrap.io')

You can also specify a HTML version of the message. It can be sent along with a body message or without it.

msg.body = "Hey Paul, sending you this email from my Flask app, lmk if it works" msg.html = "<b>Hey Paul</b>, sending you this email from my <a href="https://google.com">Flask app</a>, lmk if it works"

You may also add someone in cc and/or bcc, set a reply-to address, add extra headers, and so on. Here’s the full list of parameters available:

flask-mail.Message(subject, recipients, body, html, sender, cc, bcc, reply-to, date, charset, extra_headers, mail_options, rcpt_options)

Adding an attachment

Flask-Mail also provides an easy way to attach an attachment to our message. We need to load it with open_resource() method and then use a Python “with” statement to add a file to our email.

with app.open_resource("invoice.pdf") as fp: msg.attach("invoice.pdf", "application/pdf", fp.read())

Make sure you pick a proper MIME Type for each file and that each is uploaded to the same directory as your script.

Sending bulk messages

Most often, the Flask-Mail example above will be sufficient, but there are situations when you need to send dozens or even hundreds of emails for each request. Think about various cron jobs, for example.

For that, we can use a Python “with” statement. The connection to our email will be kept alive until all emails have been sent (at which point it will close automatically). If you wish to specify the maximum number of emails to be sent, use MAIL_MAX_EMAILS from the configuration (by default, no limit is set).

with mail.connect() as conn:
    for user in users:
        message = '...'
        subject = "Hello from the other side!"
        msg = Message(recipients=[user.email],
                      body=message,
                      subject=subject)

        conn.send(msg)

Other options

Flask-Mail also provides many more options for you to quickly configure an email, add the headers, body, and a number of other parameters. It’s concise and very easy to grasp.

Check the official documentation here to see them all.

Sending emails asynchronously

An important aspect to consider when setting up emails is the possibility of sending them asynchronously.

Let’s look at a typical situation. A user enters your site with the intention of sending you an email. They fill out a form, hit a ‘send’ button, and wait.

In the background, a template is put together and an attempt to reach an ESP (email sending provider) is initiated. Most of the time, it responds within a few milliseconds and sends an email while the user is redirected to some “thank you” page.

The problems pile up if the server isn’t very responsive at the moment and it takes seconds rather than milliseconds to get a response. At times, the connection may even time out. Add to this the fact that multiple users could be attempting to perform this or another request at the same time, effectively clogging up the server. If your app crashes because of that, no emails will be sent either.

Now, this is often a hypothetical scenario. Reputable ESPs earned their reputations because of their reliability. Ping Postmark or Sendgrid and you’ll probably never have to wait more than 100-200ms for a response. Send them dozens of emails at once and they’ll handle them with ease.

As a matter of fact, most, if not all, of the popular ESPs send emails async anyway. It’s because of the underlying verifications each of them runs in the background, in attempts to protect their sender reputation.

None of these things change the fact that your app still connects to an external service every time an email is sent. That’s why you may want to consider adding an async capability to your app.
Learn how to send an email with Celery and Flask-Mail in the full article on Email Sending with Flask.

Testing emails in Flask

Before deploying any email functionality, you certainly need a way to test whether emails are actually sent without spamming users.

You also may want to see some of those emails because chances are there will be a thing or two to improve.

The first part can be easily handled with simple Flask settings that will block sending. It can be done in two ways, with the identical outcome:

Set MAIL_SUPPRESS_SEND from the earlier configuration to False, or
Add a new setting to the configuration file – TESTING – and set it to True.

Then, you can use the record_messages method to see what’s being sent from your Flask app (make sure you have blinker package installed). You’ll see the list of Message instances under outbox.

with mail.record_messages() as outbox:

    mail.send_message(subject='testing',
                      body='test',
                      recipients=emails)

    assert len(outbox) == 1
    assert outbox[0].subject == "testing"

If, however, you wish to see the emails that your app sends, you’ll need a different solution. Earlier in the text, we showed that Mailtrap can be easily plugged into a Flask app. It works as a fake SMTP, intercepting your outgoing emails and putting them into virtual inboxes.

Each email is visible in your Mailtrap dashboard. You can preview how it will look like on different screens. You may validate the headers and check the support for its HTML/CSS.

Among other features, there’s a spam score, blacklists, bcc tracking, email forwarding, and multiple inboxes. It’s certainly a more comfortable method of testing than the one above, and you get to test a lot more than just sending.

Test it on your own! You can get started for free with Mailtrap.

Sending emails is a vital part of many Flask applications. When users create an account, a confirmation email should hit their inboxes right away. When they forget their password, a handy mechanism for resetting it built into an app will make their life a lot easier.

There are tons of other situations when an auto-generated email is a must. Luckily, it’s really easy to set things up and send the first emails within minutes. Learn more about Flask-Mail and other options in our full article - Sending Emails with Flask - Step-by-Step Flask-Mail Guide.

Sending Emails with Ruby

AlexandraMT — Mon, 11 Apr 2022 13:50:23 +0000

Let’s say you have a working Ruby app and need to add an email delivery functionality to it. This could be related to user authentication, or any other kind of transactional emails, it makes no difference. This tutorial is tailored is aimed at helping you implement sending emails with Ruby.

If you want to read the full article, check it out the on the Mailtrap’s blog: Sending Emails with Ruby

Options for sending an email in Ruby

Mostly, you can pick one of the three options.

The simplest one is using Net::SMTP class. It provides the functionality to send email via SMTP. The drawback of this option is that Net::SMTP lacks functions to compose emails. You can always create them yourself, but this takes time.

The second option is to use a dedicated Ruby gem like Mail, Pony, or others. These solutions let you handle email activities in a simple and effective way. Action Mailer is a perfect email solution through the prism of Rails. And, most likely, this will be your choice.

The third option is class Socket. Mostly, this class allows you to set communication between processes or within a process. So, email sending can be implemented with it as well. However, the truth is that Socket does not provide you with extensive functionalities, and you’re unlikely to want to go with it.

Now, let’s try to send an email using each of the described solutions.

How to send emails in Ruby via Net::SMTP

From our experience, the use of that option in a regular web app is uncommon. However, sending emails via Net::SMTP could be a fit if you use mruby (a lightweight implementation of the Ruby language) on some IoT device. Also, it will do if used in serverless computing, for example, AWS Lambda. Check out this script example first and then we’ll go through it in detail.

require 'net/smtp'

message = <<END_OF_MESSAGE
From: YourRubyApp <info@yourrubyapp.com>
To: BestUserEver <your@bestuserever.com>
Subject: Any email subject you want
Date: Tue, 02 Jul 2019 15:00:34 +0800

Lorem Ipsum
END_OF_MESSAGE
Net::SMTP.start('your.smtp.server', 25) do |smtp|
  smtp.send_message message,
  'info@yourrubyapp.com',
  'your@bestuserever.com'
end

This is a simple example of sending a textual email via SMTP (official documentation can be found here). You can see four headers: From, To, Subject, and Date. Keep in mind that you have to separate them with a blank line from the email body text. Equally important is to connect to the SMTP server.

Net::SMTP.start('your.smtp.server', 25) do |smtp|

Naturally, here will appear your data instead of ‘your.smtp.server‘, and 25 is a default port number. If needed, you can specify other details like username, password, or authentication scheme (:plain, :login, and :cram_md5). It may look as follows:

Net::SMTP.start('your.smtp.server', 25, ‘localhost’, ‘username’, ‘password’ :plain) do |smtp|

Here, you will connect to the SMTP server using a username and password in plain text format, and the client’s hostname will be identified as localhost.

After that, you can use the send_message method and specify the addresses of the sender and the recipient as parameters. The block form of SMTP.start (Net::SMTP.start('your.smtp.server', 25) do |smtp|) closes the SMTP session automatically.

In the Ruby Cookbook, sending emails with the Net::SMTP library is referred to as minimalism since you have to build the email string manually. Nevertheless, it’s not as hopeless as you may think of. Let’s see how you can enhance your email with HTML content and even add an attachment.

Sending an HTML email in Net::SMTP

Check out this script example that refers to the message section.

message = <<END_OF_MESSAGE
From: YourRubyApp <info@yourrubyapp.com>
To: BestUserEver <your@bestuserever.com>
MIME-Version: 1.0
Content-type: text/html
Subject: Any email subject you want
Date: Tue, 02 Jul 2019 15:00:34 +0800

A bit of plain text.

<strong>The beginning of your HTML content.</strong>
<h1>And some headline, as well.</h1>
END_OF_MESSAGE

Apart from HTML tags in the message body, we’ve got two additional headers: MIME-Version and Content-type. MIME refers to Multipurpose Internet Mail Extensions. It is an extension to Internet email protocol that allows you to combine different content types in a single message body. The value of MIME-Version is typically 1.0. It indicates that a message is MIME-formatted.

As for the Content-type header, everything is clear. In our case, we have two types – HTML and plain text. Also, make sure to separate these content types using defining boundaries.

Except for MIME-Version and Content-type, you can use other MIME headers:

Content-Disposition – specifies the presentation style (inline or attachment)
Content-Transfer-Encoding – indicates a binary-to-text encoding scheme (7bit, quoted-printable, base64, 8bit, or binary).

Sending an email with an attachment in Net::SMTP

Let’s add an attachment, such as a PDF file. In this case, we need to update Content-type to multipart/mixed. Also, use the pack("m") function to encode the attached file with base64 encoding.

require 'net/smtp'

filename = "/tmp/Attachment.pdf"
file_content = File.read(filename)
encoded_content = [file_content].pack("m")   # base64

marker = "AUNIQUEMARKER"

After that, you need to define three parts of your email.

Part 1 – Main headers

part1 = <<END_OF_MESSAGE
From: YourRubyApp <info@yourrubyapp.com>
To: BestUserEver <your@bestuserever.com>
Subject: Adding attachment to email
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
END_OF_MESSAGE

Part 2 – Message action

part2 = <<END_OF_MESSAGE
Content-Type: text/html
Content-Transfer-Encoding:8bit

A bit of plain text.

<strong>The beginning of your HTML content.</strong>
<h1>And some headline, as well.</h1>
--#{marker}
END_OF_MESSAGE

Part 3 – Attachment

part3 = <<END_OF_MESSAGE
Content-Type: multipart/mixed; name = "#{filename}"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"

#{encoded_content}
--#{marker}--
END_OF_MESSAGE
Now, we can put all the parts together and finalize the script. That’s how it will look:
require 'net/smtp'

filename = "/tmp/Attachment.pdf"
file_content = File.read(filename)
encoded_content = [file_content].pack("m")   # base64

marker = "AUNIQUEMARKER"

part1 = <<END_OF_MESSAGE
From: YourRubyApp <info@yourrubyapp.com>
To: BestUserEver <your@bestuserever.com>
Subject: Adding attachment to email
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
END_OF_MESSAGE

part2 = <<END_OF_MESSAGE
Content-Type: text/html
Content-Transfer-Encoding:8bit

A bit of plain text.

<strong>The beginning of your HTML content.</strong>
<h1>And some headline, as well.</h1>
--#{marker}
END_OF_MESSAGE

part3 = <<END_OF_MESSAGE
Content-Type: multipart/mixed; name = "#{filename}"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"

#{encoded_content}
--#{marker}--
END_OF_MESSAGE

message = part1 + part2 + part3

begin
  Net::SMTP.start('your.smtp.server', 25) do |smtp|
    smtp.send_message message,
    'info@yourrubyapp.com',
    'your@bestuserever.com'
  end

Can I send an email to multiple recipients in Net::SMTP?

Definitely, you can. send_message expects second and subsequent arguments to contain recipients’ emails. For example, like this:

Net::SMTP.start('your.smtp.server', 25) do |smtp|
  smtp.send_message message,
  'info@yourrubyapp.com',
  'your@bestuserever1.com',
  ‘your@bestuserever2.com’,
  ‘your@bestuserever3.com
end

Best Ruby gems for sending emails

In Ruby ecosystem, you can find specific email gems that can improve your email sending experience.

Ruby Mail

This library is aimed at giving a single point of access to manage all email-related activities including sending and receiving email.

Pony

You might have heard a fairy tale about sending an email in one command. Hold on to your hats, cause it’s real and provided by Pony gem.

ActionMailer

This is the most popular gem for sending emails on Rails. In case your app is written on top of it, ActionMailer will certainly come up. It lets you send emails using mailer classes and views.

Using Mailtrap to test email sending with Net::SMTP

Setup is very simple. Once you’re in your demo inbox, copy the SMTP credentials on the SMTP Settings tab and insert them in your code. Or you can get a ready-to-use template of a simple message in the Integrations section. Just choose a programming language or framework your app is built with.

require 'net/smtp'

message = <<END_OF_MESSAGE
From: YourRubyApp <info@yourrubyapp.com>
To: BestUserEver <your@bestuserever.com>
Subject: Any email subject you want
Date: Tue, 02 Jul 2019 15:00:34 +0800

Lorem Ipsum
END_OF_MESSAGE
Net::SMTP.start('smtp.mailtrap.io', 587, '<username>', '<password>', :cram_md5) do |smtp|
  smtp.send_message message,
  'info@yourrubyapp.com',
  'your@bestuserever.com'
end

If everything is alright, you’ll see your message in the Mailtrap Demo inbox. Also, you can try to check your email with HTML content and an attachment. Mailtrap allows you to see how your email will look and check HTML if necessary.

Create a Mailtrap account and try to test it on your own for free!

You have just read the full tutorial on how to test and send emails in Ruby. There is still a lot to check out when it comes to Ruby Mail, Pony and Action Mailer. Learn more about Ruby Gems & Socket Class in our full Sending Emails with Ruby article at Mailtrap.io.

How to send Emails in PHP?

AlexandraMT — Mon, 11 Apr 2022 13:29:20 +0000

PHP is one of the most popular web-development languages and a popular way to create dynamic web apps. In this article we’re going to help you painlessly configure the mail function in your application.

So let us start! There are two basic ways of sending emails with PHP: a built-in mail function and external mail packages.

To read the full article, check out Mailtrap's blog: How to Send Emails in PHP?

PHP built-in mail function ()

PHP’s built-in mail function () is very simple, and it provides limited functionality for sending emails. You won’t be able to add attachments to your email, and building a beautiful HTML template with embedded images will be a tricky task to accomplish .

The other side of the PHP mail function () coin is that the email is sent from your web server, which may cause issues with deliverability due to security concerns such as suspicion of spam and blacklisting. The best way to overcome this problem is sending messages via an SMTP server, however, this functionality is limited as well. PHP mail() does not usually allow you to use the external SMTP server and it does not support SMTP authentication.

Here’s what you can do with PHP’s built-in mail function():

create simple HTML/text messages without attachments and images
send emails via localhost and Xmapp
include several recipients with “$to” parameter.

It is suitable for simple, mostly text-based notifications in your local environment. If you need to communicate with your app’s users, it is better to install an external mailer package.

If you are still committed to the PHP built-in mail function() and are ready to accept the challenge, let’s take a look at the basic code and its main parameters.

Syntax and parameters

The PHP mail syntax is pretty simple:

<?php mail($to_email_address,$subject,$message,[$headers],[$parameters]); ?>

It uses the following parameters:

“$to” = your message recipient(s). The email address format may be user@example.com or User user@example.com. In general, it needs to comply with RFC 2822.
“$subject” = your message’s subject
“$message” = the body of your message. Lines should be separated with a CRLF (\r\n). Each line should not exceed 70 characters.
“[$headers]” = additional recipients of your message, which can be included in CC or BCC.

Note that headers are optional, except for the “from” header: it must be specified, otherwise, you will receive an error message like Warning: mail(): “sendmail_from” not set in php.ini or custom “From:” header missing.

You can use additional headers to change the mail “From” address and set the “Reply to” address.

For more details and additional parameters, refer to the PHP documentation.

Sending HTML email using PHP mail() function

The body of the message can be written in HTML. However, as we’ve mentioned above, it should be simple. In the PHP mail function(), the HTML part will look like this:

$message = '
<html>
<head>
  <title>Review Request Reminder</title>
</head>
<body>
  <p>Here are the cases requiring your review in December:</p>
  <table>
    <tr>
      <th>Case title</th><th>Category</th><th>Status</th><th>Due date</th>
    </tr>
    <tr>
      <td>Case 1</td><td>Development</td><td>pending</td><td>Dec-20</td>
    </tr>
    <tr>
      <td>Case 1</td><td>DevOps</td><td>pending</td><td>Dec-21</td>
    </tr>
  </table>
</body>
</html>
';

It’s important to remember that to send HTML mail, you need to set the Content-type header:

$headers[] = 'MIME-Version: 1.0'; $headers[] = 'Content-type: text/html; charset=iso-8859-1';

Simple Transmission Protocol (SMTP)

Where do I specify the SMTP settings? This is a fair question. Go to the PHP installation folder and configure them in the “php.ini” file. But this will only work for localhost or Xmapp like solutions because as we have already mentioned, PHP mail function does not support SMTP authentication and doesn’t allow sending messages via external servers.

There are some other, rather haphazard options but we won’t promote them here. Alternatively, we recommend using external PHP mail packages for sending emails via an external SMTP server.

PHP mailing packages

As we have already mentioned, the native PHP mail() function has limited functionality when it comes to mass sending. For example, it is not designed for creating engaging email templates that may boost your next campaign or sending a large volume of emails.

But since PHP is still one of the most popular programming languages, it also doesn’t lack resources for sending mass emails. We can highly recommend several plugins, such as Pear Mail and Swift Mailer

Pear Mail

Pear Mail is a class that provides multiple interfaces for sending emails (which is stated in their documentation).

Here is what you can do with Pear Mail:

create complex HTML/text messages with attachments and inlined images (with Mail_Mime class)
send emails via PHP’s built-in mail() function, a sendmail program, or SMTP server
send multiple emails from a queue (with Mail_Queue class).

Swift Mailer

Swift Mailer is another popular package for sending emails in PHP. It is feature-rich, well covered by documentation, and pretty straightforward in use.

Here is what you can do with Swift Mailer:

create complex HTML/multipart templates
add attachments and embed images
send emails via authenticated SMTP, sendmail, Postfix, or your own transport
use additional plugins.

Besides that, Swift Mailer offers enhanced security and handles large attachments and images with low memory usage.

PHPMailer

And finally, PHPMailer, which is the classic and the most popular email sending library for PHP. It deserves a separate article and a tutorial. You will find it here.

Here is what you can do with PHPMailer:

create complex HTML/multipart templates
add attachments and embedded images
send emails via authenticated SMTP.

PHPMailer is protected against header injection attacks and automatically validates emails.

In this article, we have described the basic PHP email sending principles, syntax, and parameters. Moreover, we have reviewed the main ways of sending emails with PHP: its built-in mail function and the most popular external mail packages. PHPMailer and Swift Mailer are standard libraries for PHP email sending today, and PEAR Mail is still widely used.

Choose your option according to your current needs and preferences and test your emails beforehand. For email experiments - create an account at Mailtrap, a fake SMTP server. It imitates a real SMTP server and traps your test email in the virtual inboxes. Have a try!

Check the full Sending emails with PHP article at Mailtrap.io to get more details on email packages and examples!

How to send Emails with JavaScript

AlexandraMT — Mon, 11 Apr 2022 13:13:34 +0000

JavaScript is a programming language that you can use for both front-end and back-end development. You can’t send emails using JavaScript code alone due to lack of support for server sockets. For this, you need a server-side language that talks to the SMTP server. You can use JS in conjunction with a server script that will send emails from the browser based on your requests. This is the value we’re going to introduce below.

So, let’s figure out how you can use JS to send emails from the app that has no back-end.

If you want to read a full article, check it out on the Mailtrap’s blog: Sending Emails with JavaScript

SmtpJS.com – true email sending from JavaScript

SmtpJS is a free library you can use for sending emails from JavaScript. All you need is an SMTP server and a few manipulations to get things done. We’ll use Mailtrap as the server because it is an actionable solution for email testing. Below is the flow you should follow:

Create an HTML file (for example, test.html) with the following script:

<script src="https://smtpjs.com/v3/smtp.js"> </script>

Create a button that will trigger the JavaScript function

<input type="button" value="Send Email" onclick="sendEmail()">

Write the JS function to send emails via SmtpJS.com.

function sendEmail() { Email.send({ Host : "smtp.mailtrap.io", Username : "<Mailtrap username>", Password : "<Mailtrap password>", To : 'recipient@example.com', From : "sender@example.com", Subject : "Test email", Body : "<html><h2>Header</h2><strong>Bold text</strong><br></br><em>Italic</em></html>" }).then( message => alert(message) ); }

If you have multiple recipients, you can specify an array of email addresses in the To: property.

Run test.html in the browser and send your email

The drawback with the code sample above is that your username and password are visible in the client-side script. This can be fixed if you utilize the encryption option provided by SmtpJS. Click the Encrypt your SMTP credentials button and fill in the required fields.

After that, press Generate security token and use it then in your JS function instead of SMTP server settings like the following:

SecureToken : "<your generated token>"

EmailJS

EmailJS.com allows you to connect your email service, build an email template and send it from JavaScript without any server code. Let’s check out the scope.

Create an account and choose an email service to connect with. There are the popular transactional services options available, such as Amazon SES or Mailgun, as well as personal services like Gmail or Outlook. You can also add a custom SMTP server. That’s what we’re going to do since we use Mailtrap.

Create an email template using the built-in editor. The editor provides plenty of options for content building and other useful features, such as auto-reply, reCAPTCHA verification, and more. It’s also necessary to understand the basics of coding your own HTML email template. For this, read our Guide on How to Build HTML Email. Once this is done, click Save.

One of the major benefits of EmailJS.com is that the typical email attributes are hidden. The template includes the recipient field and it cannot be overridden from JS, so you send the template you have configured previously.

Now you need to install EmailJS SDK. This can be done with npm: npm install emailjs-com --save or bower bower install emailjs-com --save

If you need to use EmailJS on your website, paste the following code before closing tag:

<script type="text/javascript"
   src="https://cdn.jsdelivr.net/npm/emailjs-com@2.4.0/dist/email.min.js">
</script>
<script type="text/javascript">
   (function(){
      emailjs.init("YOUR_USER_ID"); //use your USER ID
   })();
</script>

The actual email sending can be carried out via two methods: emailjs.send or emailjs.sendForm. Here are the code examples for both of them:

emailjs.send

var templateParams = {
    name: 'James',
    notes: 'Check this out!'
};

emailjs.send('YOUR_SERVICE_ID', 'YOUR_TEMPLATE_ID', templateParams) //use your Service ID and Template ID
    .then(function(response) {
       console.log('SUCCESS!', response.status, response.text);
    }, function(error) {
       console.log('FAILED...', error);
    });

emailjs.sendForm

var templateParams = {
    name: 'James',
    notes: 'Check this out!'
};

emailjs.sendForm('YOUR_SERVICE_ID', 'YOUR_TEMPLATE_ID', templateParams) //use your Service ID and Template ID
    .then(function(response) {
       console.log('SUCCESS!', response.status, response.text);
    }, function(error) {
       console.log('FAILED...', error);
    });

Although sending emails is a server-side thing, you can refrain from dealing with server-side coding. SmtpJS and EmailJS are two actionable solutions to streamline your front-end and make it able to send emails. EmailJS is better because it hides typical email attributes and you are able to send whatever templates you have configured before. You can also use the mailto method, which is different but can still be useful in some cases. Try Mailtrap to test what better works for you!

Learn more about mailto and read the full article: Sending Emails with JavaScript

Consider to create an account at Mailtrap.io and try the described flow by your own!

How to Send an Email with Nodemailer

AlexandraMT — Mon, 11 Apr 2022 12:53:28 +0000

Nodemailer creators say that it makes sending an email a piece of cake. Let’s see if they are talking about cooking or eating 🙂 The idea of this article is to explain how to use Nodemailer for email sending. We will focus mainly on SMTP and HTML aspects but will also do an overview of all Nodemailer capabilities. Besides, this tutorial will help you prepare and test email messages to send out with your Node.js application.

If you want to read the full article, check it out on the Mailtrap’s blog - How to Send an Email with Nodemailer

How to use Nodemailer

Installation

The only thing required to start using Nodemailer is Node.js version 6.0 or above. You should also install Nodemailer itself but it’s really easy with the npm or Yarn package manager. Execute the following command in the Node.js command prompt:

npm install nodemailer
or
yarn add nodemailer

Once completed, include it into your application like this:

var nodemailer = require('nodemailer');

or this if you are using ES modules:

import nodemailer from ‘nodemailer’;

Sending messages

To send a message with Nodemailer, there are three main steps.

Step 1. Create Nodemailer transporter

SMTP is the most common transporter, and below we will describe it in more detail, as well as demonstrate some examples. But there is a list of other available options:

Built-in transports
sendmail, a regular sendmail command for simple messages. It’s similar to the mail() function in PHP
SES , to handle large traffic of emails by sending them using Amazon SES
stream, a buffer for testing purposes, to return messages.

-_ External transport. To put it simply, you can create your own transportation method._

For more details, refer to the Nodemailer documentation.

With SMTP, everything is pretty straightforward. Set host, port, authentication details and method, and that’s it. It’s also useful to verify that SMTP connection is correct at this stage: *add verify(callback) * call to test connection and authentication.

transporter.verify(function(error, success) {
   if (error) {
        console.log(error);
   } else {
        console.log('Server is ready to take our messages');
   }
});

How to test emails in Nodemailer?

To test emails sent with Nodemailer, we will use Mailtrap, an online tool for complex email testing in a pre-production environment. It will catch our messages, display how they look in a real email client, and help analyze and debug them. Mailtrap also provides Bcc testing options and allows you to share your email testing results with other team members, as well as forward emails to the real verified addresses.

Even If you don’t have an account yet, the whole set up process takes just a couple of minutes. Mailtrap integrates as a regular SMTP server. Quickly sign up (it’s free), go to the SMTP settings tab in your Inbox, copy the necessary settings, and insert them to your application script.

Mailtrap offers a ready-to-use integration with Nodemailer: select it from the Integrations section and insert it into your application code. It already contains transporter and syntaxis attributes:

var transport = nodemailer.createTransport({
  host: "smtp.mailtrap.io",
  port: 2525,
  auth: {
    user: "1a2b3c4d5e6f7g", //generated by Mailtrap
    pass: "1a2b3c4d5e6f7g" //generated by Mailtrap
  }
});

Otherwise, you can use auto-generated email test accounts on Ethereal, which is also a fake SMTP service, mostly aimed at Nodemailer users.

Recently, Nodemailer has introduced NodemailerApp. It provides Sendmail replacement, but first of all, is designed to debug emails. NodemailerApp has SMTP and POP3 local servers, a catchall email domain service, along with email preview capabilities.

Step 2. Set Nodemailer message options

At this point, we should specify the sender, message recipients, and the content of our message.

Remember, Unicode is supported, so you can include emojis as well!

To send a text formatted as HTML, no extra attributes are required, just put your HTML body into the message with an html attribute. For advanced templates, you can add attachments and embed images. Let’s take a look at this example of simple message options first:

var mailOptions = {
    from: '"Example Team" <from@example.com>',
    to: 'user1@example.com, user2@example.com',
    subject: 'Nice Nodemailer test',
    text: 'Hey there, it’s our first message sent with Nodemailer ;) ',
    html: '<b>Hey there! </b><br> This is our first message sent with Nodemailer'
};

Attachments in Nodemailer

You can add different types of data to your message in Nodemailer using the following main properties:

filename: the name of the attached file. Here you can use Unicode as well.
content: the body of your attachment. It can be a string, a buffer, or a stream.
path: path to the file, to stream it instead of including it in the message. It is a good option for big attachments.
href: attachment URL. Data URIs are also supported.

 list: {
            // List-Help: <mailto:admin@example.com?subject=help>
            help: 'admin@example.com?subject=help',

            // List-Unsubscribe: <http://example.com> (Comment)
            unsubscribe: [
                {
                    url: 'http://example.com/unsubscribe',
                    comment: 'A short note about this url'
                },
                'unsubscribe@example.com'
            ],

            // List-ID: "comment" <example.com>
            id: {
                url: 'mylist.example.com',
                comment: 'my new list'
            }
        }
    };

Optional properties let you add specific content types or inline images.

contentType: if you don’t set it, it will be inferred from the filename property

` // An array of attachments
    attachments: [
        // String attachment
        {
            filename: 'notes.txt',
            content: 'new important notes',
            contentType: 'text/plain' // optional, would be detected from the filename
        },

`
CID: inline images in the HTML message. For more details on attaching images to HTML emails, read this post. Note that the CID value should be unique.

cid: 'note@example.com' // should be as unique as possible
            },

            // File Stream attachment
            {
                filename: 'matrix neo.gif',
                path: __dirname + '/assets/neo.gif',
                cid: 'neo@example.com' // should be as unique as possible
            }
        ],

Encoding: can be added to the string type of content. It will encode the content to a buffer type according to the encoding value you set (base64, binary, etc.)

     `   // Binary Buffer attachment
        {
            filename: 'image.png',
            content: Buffer.from(
                'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAABlBMVEUAAAD/' +
                    '//+l2Z/dAAAAM0lEQVR4nGP4/5/h/1+G/58ZDrAz3D/McH8yw83NDDeNGe4U' +
                    'g9C9zwz3gVLMDA/A6P9/AFGGFyjOXZtQAAAAAElFTkSuQmCC',
                'base64'
            )`

Step 3. Deliver a message with sendMail()

Once we created a transporter and configured a message, we can send it using the sendMail() method:

transport.sendMail(mailOptions, (error, info) => {
        if (error) {
            return console.log(error);
        }
        console.log('Message sent: %s', info.messageId);
});

Nodemailer capabilities

We have covered the info on how to create and send an email in Nodemailer via SMTP, experimenting with different types of content: HTML, tables, lists, attachments, and embedded images.What is good about Nodemailer is that it offers a bunch of various options and settings, so you can customize every piece of your email.

To get Nodemailer examples and learn more about debugging options in Nodemailer - read our full How to Send an Email with Nodemailer article.