DEV Community: Ivan Djuric

Best Email Encryption Software

Ivan Djuric — Mon, 16 Dec 2024 09:49:49 +0000

There’s a lot of talk going on about data encryption. Nearly every day we hear about email leaks and we start to wonder if our data is secure. And rightly so! Those who ignore such vital concerns are often the hacker’s first victims. However, those who do give it some more thought use some of the best email encryption software on the market and keep their data secure. What should you pick? Let’s go through the best available options.

Is there a need for more email encryption?

A huge majority of emails sent over the internet are transferred via the SMTP protocol. Old technology serves the purpose well but offers little to no security. This means that your emails are often transmitted between servers in plain text mode. If there’s a breach at any stage, all the information will be easily accessible to hackers.

Of course, ever since the 80s, efforts have been made to address this problem. New methods, such as SSL and TLS, have been introduced for encrypting your emails. These days, all major clients provide some form of encryption. Things have definitely improved.

But your emails are still far from safe. SSL/TLS only encrypts emails on their way from a client to an outgoing server. At this point, they’re decrypted and processed further in plain text, making them susceptible to attack. SSL/TLS also doesn’t encrypt emails sitting in your inbox or your receiver’s. If security is breached, all sensitive data will easily be exposed.

Another caveat is that the SSL/TLS used by nearly all clients is, by default, opportunistic. This means that when a transmission is launched, an email client uses a command called STARTTLS to try to upgrade the connection to a secured one. However, if it fails due to a timeout, lack of server support for this solution, or just about any error, the transmission will be processed in plain text. It may be fine for casual messaging, but for companies or governments sending heavily classified data over emails, it’s too much.

If you’re interested to read more about this, check out our article on SMTP Security.

What is email encryption software?

To counter the imperfections of existing encryption methods companies have built lots of sophisticated tools for email and data encryption. They incorporate many different techniques for securing emails, which can be split into two main categories.

Enterprise email encryption platforms are typically used for internal communication in large corporations or between governmental facilities. These platforms only work if both a sender and recipient use the same encryption software. If you were to encrypt an email this way and send it to an external receiver, they would have no way of deciphering it.

These solutions typically rely on public and private keys that they distribute in a network. A message is encrypted with a user’s public key and each of the recipients is able to decrypt an email using the corresponding private keys. Of course, the whole operation happens under the hood and is invisible to actual users.

The advantage for companies is that they can manage their own keys without sharing them with 3rd parties (such as encryption platforms themselves). The disadvantage is that if something goes wrong and the keys are no longer able to be retrieved, the messages encrypted with them won’t be either.

Although some of these solutions can be installed, most work as hosted email encryption platforms. Due to their universality and platform-agnosticism, we recommend using them moving forward.

On the other end of the spectrum, there are webmail services for email encryption. While the enterprise solutions are often difficult to set up and maintain, webmails are (generally) as easy to use as regular Gmail or Yahoo! accounts.

Webmail also relies on public and private keys. Some tools store them for you and automatically exchange them with your recipients. This makes for a pretty seamless experience.

Other web-based tools hand you the task of managing keys. This way, no governments are able to decrypt your data but you’re in charge of storing the keys and sharing them with the recipient(s).

Best hosted email encryption services

Let’s now discuss our top picks for email encryption software in 2020. There are plenty to choose from!

ProtonMail

ProtonMail is a popular free email encryption software. It’s actually an email client that works like any other software of this type. There’s just one “tiny” difference: all emails sent from ProtonMail account are end-to-end encrypted. The same goes for emails accepted from other senders. They remain encrypted while in an inbox.

ProtonMail was launched by a group of scientists and developers concerned about user privacy. They aim to provide a platform where users can freely exchange information and are protected by strict Swiss privacy laws. They have managed to attract millions of users craving for a secure way to send emails.

The account is free with 500MB of storage and allows you to send up to 150 emails per day. Paid plans come with a higher capacity and more features (and they’re quite inexpensive too). Web and mobile apps are available.

Tutanota

Right across the northern border from the Proton guys, there’s Tutanota hailing from Germany.

Tutanota is also a web service with end-to-end encryption for all its emails. The platform encrypts all elements of a message, including a subject, body and attachments. It also removes your IP address from sent messages so that they can’t be tracked down to any specific location.

Tutanota is available as a web service and via native iOS and Android apps. The basic plan is absolutely free of charge, while premium and business setups come with a recurring fee.

Proofpoint

Proofpoint is an enterprise-level solution primarily suitable for large companies and organizations. It’s available as a Cloud service but can also be implemented on-site when required.

Proofpoint comes with two-way encryption. All of your outgoing emails are end-to-end encrypted, while the same software protects you from potential attacks with incoming emails. The software offers policy-driven encryption that happens entirely under the hood. On top of that, features like data loss protection or streamlined storage are also available.

The company doesn’t offer fixed pricing, each client can expect to be priced individually according to the features and capacity needed.

Hushmail

Another software that we can definitely recommend for individuals and small/medium enterprises is Hushmail. Depending on what you need, they probably have something in store.

For individuals, Hushmail offers a regular email account with the @hushmail.com domain priced at $49.99/year. The account comes with 10GB of storage and an encryption relying on OpenPGP standard. Web and mobile (iOS only) access is available.

Businesses can take advantage of dedicated plans for multiple users. When communicating with each user directly, end-to-end encryption covers all emails. Hushmail also offers on-demand encryption for messaging external users. Companies can also take advantage of secure web forms to be placed on websites or linked in emails.

Business plans start at $5.99 per month for each user.

Encyro

Encyro is a powerful service for protecting emails along with their attachments. Users don’t need to create separate email accounts – instead they get full encryption with their existing account. It’s quite an encryption with 16 layers of security that makes you compliant with all major privacy laws, such as HIPAA and GDPR (for other tools that can make you HIPAA-compliant, check out our dedicated article).

Encyro is free to use for individual accounts with a basic set of features. The Premium plan is available for $9.99/month and $7.99 for each additional user.

Sendinc

Another option worth considering is Sendinc. It offers a 256-bit SSL encryption for all of your outgoing emails. You can use your existing email account with the service. To add an extra layer of security, Sendinc doesn’t store your keys, which guarantees only you and the recipients of your messages will be able to decrypt them.

A free plan is available with up to 20 recipients per day and messages automatically vanishing after 7 days. To keep your emails and significantly boost the sending capacity, you’ll need to upgrade to a paid plan priced at $48/year for each user.

Enigmail

Enigmail is a different type of service than those we already described. It’s an add-on for Thunderbird and Postbox that encrypts both email content and its attachments. While doing so, it uses the OpenPGP standard for public-key encryption and signing outgoing emails.

It’s a very simple tool but does exactly what you would require from an encryption tool without tons of additional features. Since it’s open-source, it comes free of charge without any limitations (except for those imposed by the respective email clients, of course).

TrendMicro

TrendMicro is an enterprise solution that provides email encryption along with dozens of other features. These are aimed at protecting entire devices and networks from malware and data leaks. TrendMicro relies on cloud-based encryption with keys automatically managed in the Cloud. For additional security, the keys are automatically regenerated every month and distributed in a network.

While TrendMicro offers individual pricing to its enterprise-level customers, it has a fixed price for less demanding clients. Their limited security plans (appropriately named ‘worry-free plans’) start from $37.75 per user and are paid annually.

NeoCertified

NeoCertified is another solution for individuals and small business. It provides encryption for emails and attachments, and does it really well. When you send an email to external users, they’ll need to create a free NeoCertified account to access its contents. Of course, communication within the NC network is frictionless.

The company offers very easy integration with the most popular email clients. The tool is priced at $99 per year for each account. A discount is available for non-profits.

Mailbox

To wrap up the list, there’s Mailbox.org. It’s a simple and yet powerful tool for email encryption. On top of that, it offers a suite of office tools, such as cloud storage, calendar, or a task list. All of the data you input in any of these tools is encrypted.

Personal accounts at Mailbox cost only €1 per month. More advanced plans start from €2.5 per user.

Wrapping up

This wraps up our summary of the encryption tools we recommend in the upcoming year. We hope you enjoyed it and to see you next time. We write a lot about emails and their security, in particular. Follow our blog so you never miss a thing. Take care!

Article by
Piotr Malek
Technical Content Writer @ Mailtrap

We appreciate you chose this article to know what are the best email encryption software. Follow Mailtrap Blog for more articles on the related topics!

8 Best Responsive HTML Email Builders for Your Next Campaign

Ivan Djuric — Thu, 24 Oct 2024 09:29:43 +0000

How do you usually choose a new tool? Intuition? Friend’s recommendation? We prefer to make decisions based on data. That’s why we’ve prepared this research for you.

Email HTML builders can help you create effective emails to increase your return on investment (ROI) — which currently stands at $38 for every $1 spent — and convert your leads to loyal customers.

Whether you’re a developer or a marketer, this guide will help you know how to choose a tool that fits your needs from hundreds of options.

We’ll look at eight of the best responsive HTML email builders and how you can choose the correct tool for your email marketing needs.

How to Choose the Correct HTML Email Builder

When you start building HTML emails, you should first understand what your business and customer needs. And the first goal an HTML email builder should help you achieve is creating responsive emails that give customers great experiences.

So, when choosing an email builder, look for one with a user-friendly interface that offers reasonable pricing and extra features like an illustrations library.

With that in mind, here are some questions to ask yourself before selecting an HTML email builder:

Do you need to edit the email code?
Do you use an email marketing platform? If yes, starting with its built-in email editor can be a good start.
How often do you create new email templates? Daily, weekly, monthly, or a couple of times per year?

When searching for an HTML email builder, you will find four main types of options.

HTML email generators. This type of tool is designed mostly for developers who are building the email functionality and need to create simple solutions without too much effort. They help to convert your input to the correct HTML (or sometimes another) format and compile it for further usage as a template. The result then can be imported to the email sending system or pasted to your app source code. HTML email generators are similar to the template engines.

Responsive email frameworks. Email framework is the best option for developers. Usually, it is a markup-based language where your code is later converted to a responsive HTML. Email frameworks offer pre-built options and various components to streamline email coding.

Built-in email templates. The vast majority of the email sending systems have their built-in email template builders. In most cases, they provide decent functionality for designing tailored templates. Also, they can support the import of custom templates or writing your HTML from scratch. If you need advanced features, you can use a third-party email building tool, and then import the result to your email sending system. However, it would be pretty weird to create a template in one ESP (email sending provider) and send it with another.

Independent HTML email builders. This category of tools offers wide functionality for creating custom and pre-defined templates for both developers and marketers. They provide drag and drop email builders, HTML email editors, image libraries, and usually can be integrated with the most popular ESPs and CRM systems.

Drag and drop editor doesn’t require any additional skills: you work with pre-designed blocks to add images and edit texts like in a usual document. In most cases, you can switch to a source HTML code to edit it if you need to customize the design.

Let’s now look at the eight best responsive HTML email builders you can use for your next email marketing campaign.

Best HTML Email Builders: Price Comparison Table

Here’s a quick price comparison of the best HTML email builders before we dive into the details of each:

8 Best Responsive HTML Email Builders

It can take time to choose an email builder that suits your needs from the hundreds of tools available on the market. That’s why we researched and compared seven responsive email builders to make your work easier.

Here’s what we considered:

Suitability to both developers’ and marketers’ needs;
Friendly user interface;
Availability of free options or trials and pricing/features ratio;
Additional options like photo editor and libraries;
Compatibility and integrations.

Let’s go through the list of tools one by one.

Sender — Best HTML Email Builder

Sender is one of the best responsive HTML email builders to create, send, and automate your marketing emails. The software offers a drag-and-drop editor that helps you build responsive emails, popups, and forms effortlessly.

Image source: Sender

The platform also has a library of premade free templates, such as cart abandonment and welcome email templates, with all the elements you need to create stunning email campaigns that convert.

If you have coding skills, Sender allows you to design responsive HTML email templates to offer unique experiences to your subscribers.

The software also offers automation, reporting & analytics, and smart segmentation to help you target your audience with automated sequences to increase engagement.

Sender Key Features

Here are some of the key features that Sender offers:

Drag-and-drop email editor that helps you build responsive emails to increase engagement and sales;
Popups and signup forms to help you capture hot leads;
Marketing automation to enable you to reach your audience via email and SMS channels automatically;
Reporting & analytics to help you monitor crucial email and SMS marketing metrics.

Sender Pricing

Starts from $8 per month for up to 2500 subscribers and 30,000 emails;
Free Forever plan is also available for up to 2500 subscribers and 15,000 emails per month.

SendX — Online Creation HTML Email Editor

SendX is an email marketing software known for its high email deliverability. It allows you to create beautiful newsletters using your own email HTML code, the drag-and-drop email builder, or pre-made, fully customizable templates.

The best part is that you can use SendX with any industry (gaming, crypto, or casinos) as long as you send HTML emails to an engaged subscriber base. When you sign up, they’ll migrate you from your old platform for free within a few days.

SendX Key Features

Here are some of the key features that SendX offers:

Easy drag-and-drop email builder to create visually appealing emails without knowing how to code;
A/B testing, tagging, segmentation, personalization, and many such features in SendX to help you run email marketing campaigns;
Offers integration with 5000 apps on Zapier, so you can automate your workflow and save time for strategy;
There are 50+ proven-to-convert templates for landing pages and signup forms to grow your audience;
High email deliverability, even for bulk promotional emails, making email marketing profitable for your business.

SendX Pricing

Starts at $9.99 per month for up to 1000 subscribers;
Free trial plan available with limited features.

Stripo — Email Design Platform

Stripo is a drag-and-drop email template builder that offers a wide range of features to help you design your emails and send them through an email service provider (ESP).

Stripo offers the most extensive list of customizable elements compared to other template-building tools — not only templates and blocks but also modules and structures. You can also switch to a CSS/HTML editor and copy and paste your code anytime.

In addition to the cloud version, Stripo offers a JavaScript plugin, which you can embed in your application as a component.

Stripo Key Features

Here are some of the key features that Stripo offers:

Responsive HTML editor with merge tags, emoji, and custom paddings;
Image editor, where you can upload your own images or choose from the built-in stock images library;
Embed video from YouTube or Vimeo;
Options to display or hide elements on a desktop or mobile client and the ability to choose if to include it in both MIMe versions of the email (classic HTML and AMP HTML).

Stripo Pricing

Starts at $15 per month for up to one user and 50 test emails a day;
Free plan available with limited features.

Unlayer — HTML Email Template Builder for Outlook

Unlayer is an email and page designer for creating HTML emails in Outlook. It’s a JavaScript plugin you embed into your web application. So, you won’t need any PHP, CSS, or HTML coding experience to create responsive email templates, as you can use the editor like a typical email designer.

Unlayer doesn’t offer pre-designed email templates, so you should create your own. You can build your template using the standard blocks (like images, dividers, or text) or add a custom one.

Among Unlayer’s exciting features are merge tag support and the ability to save templates as a JSON file.

Unlayer Key Features

Here are some of the key features that Unlayer offers:

WYSIWYG editor that helps you create engaging, professional emails and pages;
Ready-to-go email templates to kickstart your design process;
Manage and share templates with team members to collaborate and craft the perfect message.

Unlayer Pricing

Starts from $20 per month with services such as mobile-ready campaigns, drag & drop builder, and free stock photos;
Free plan with limited features.

Beefree — Free HTML Mailer Template

BEE stands for Best Email Editor. Behind this ambitious name, you’ll find a simple but powerful drag-and-drop editor for creating HTML email newsletter templates on the go. You can also write your own HTML code and download the source code of the template you create with BEE tools.

You can create your emails from scratch or choose from the platform’s massive library of free templates sorted by categories and industries. You’ll have many options for customizing templates, such as:

Experimenting with text and setting custom paddings;
Uploading your own image, editing it in the app, or choosing from the stock library;
Embedding a YouTube or Vimeo video.

Beefree Key Features

Here are some of the key features that Beefree offers:

Free email template builder for creating emails that get high open and click rates;
Insert merge tags or special links for Mailchimp, Sendgrid, MailUp, Autopilot, and Campaign Monitor;
Write your own HTML5 email code and download the source code of the template you create with the BEE tools.

Beefree Pricing

Starts from $30 per month for unlimited emails, pages, folders and reusable blocks;
Free plan is also available with limited features.

Postcards by Desingmodo — Responsive Newsletter HTML Editor

Postcards is an intuitive drag-and-drop newsletter HTML template builder that offers pre-designed blocks you can combine and customize to create your ideal template.

The blocks are designed like mini-templates and categorized by purpose: e-commerce, transactional, call to action, etc. As a result, you can easily:

Format your text and tables;
Upload images from your computer;
Organize your templates into projects.

The platform also has an email tester feature to help you preview emails from the desktop and mobile view to ensure they’re responsive.

Postcard Key Features

Here are some of the key features that Postcard offers:

Drag & drop template builder;
Add images, links, and texts using intuitive Postcards HTML email editor;
One-click export to HubSpot, Mailchimp or as plain HTML;
900+ Google Fonts to complement your email designs perfectly.

Postcard Pricing

Starts from $24 per month for up to 20 exports per month;
Free plan is also available with limited features.

Mailstyler — HTML Mail Designer Tool

Mailstyler is a desktop application for building email marketing templates for Windows. The Mailstyler HTML editor helps you:

Edit and format email, texts and styles;
Experiment with blocks;
Upload your own image, edit, and resize it in the app, or choose from the MailStyler library.

In general, MailStyler offers a comprehensive list of template options to create HTML emails you can export in Outlook or Thunderbird or even convert to PDF.

Mailstyler Key Features

Here are some of the key features that Mailstyler offers:

Email editor that allows for HTML email styling to create stunning emails;
Fully-customizable dynamic blocks with elements such as mail to button, email footer, and email signature to ensure newsletters are branded well;
Export your email templates directly to Outlook, Gmail, and Thunderbird.

Mailstyler Pricing

Starts at $99 per year for one installation;
Free demo with limited features.

Mailmodo – Great HTML Email Builder

Mailmodo is a complete email marketing solution that lets you create and send interactive emails within minutes with its no-code editor.

You can create campaigns, manage email lists, personalize content, explore ready-to-use templates, save and reuse blocks, and track performance with smart reports – all at the same place. Mailmodo can also integrate with multiple CRMs to manage your workflow.

Mailmodo Key Features

Create and send interactive AMP and HTML emails with our no-code email builder.
Offers 20+ interactive AMO widgets such as carousels, polls, quiz, spin the wheel, shopping carts, and so on.
Customize 200+ pre-made email templates.
100+ Pre-made blocks – headers, footers, layouts, and CTA buttons.
A fallback version is automatically added if the email client doesn’t support AMP emails.

Mailmodo Pricing

Plans start at $99 per month for up to 40,000 contacts.
Free 21 days trial available.

Key Takeaways on the Best Responsive HTML Email Builders

There you have it. Eight different email template builders with HTML code and drag-and-drop interface options.

The most common feature the tools have is each one allows you to build stunning email templates you can send to subscribers and boost engagement.

We appreciate you chose this article to know about different drag and drop email builders. To read more articles on the related topics, follow Mailtrap blog!

Gomail Guide: Configuration, SMTP Setup, and Email Sending

Ivan Djuric — Thu, 10 Oct 2024 09:30:28 +0000

In this article, I break down my email-sending flow with Gomail, a super straightforward package for Golang. Of course, I’ve made sure to include code snippets ready for use.

I’ll also cover debugging and testing so you can make sure your code is working perfectly after following this guide.

How to install Gomail

If you haven’t already, make sure to download Go 1.2 or newer from the official website.

Then, proceed to install Gomail by running the following command in your terminal:

go get gopkg.in/mail.v2

Then, you can include it in your project or application with the following code:

import gomail "gopkg.in/mail.v2"

Useful links:

How to send email using Gomail and SMTP

For starters, let’s send a plain text message. Here’s a code snippet you can paste into your main configuration file (e.g., main.go):

package main

import (
    "fmt"
    gomail "gopkg.in/mail.v2"
)

func main() {
    // Create a new message
    message := gomail.NewMessage()

    // Set email headers
    message.SetHeader("From", "youremail@email.com")
    message.SetHeader("To", "recipient1@email.com")
    message.SetHeader("Subject", "Hello from the Mailtrap team")

    // Set email body
`    message.SetBody("text/plain", "This is the Test Body")

    // Set up the SMTP dialer
    dialer := gomail.NewDialer("live.smtp.mailtrap.io", 587, "api", "1a2b3c4d5e6f7g")

    // Send the email
    if err := dialer.DialAndSend(message); err != nil {
        fmt.Println("Error:", err)
        panic(err)
    } else {
        fmt.Println("Email sent successfully!")
    }
}

To run the script, simply execute go run.main.go.

Code breakdown:

**NewDialer** – Initiates a new SMTP connection, specifying the mail server address, port number, and credentials (username and password) to authenticate (auth) the sender.
**NewMessage** – Creates a new email message you can customize.
SetHeader – Sets specific headers such as “From”, “To”, and “Subject,” defining the sender, recipient, and subject line.
**SetBody** – Defines the content of the email body, which is plain text in this example.
DialAndSend – Establishes a connection and sends the email.

Also, as you can notice, I’m using Mailtrap SMTP, a reliable SMTP with robust sending capabilities that ensures my emails reach recipients’ inboxes. It has a high sending throughput and comes with in-depth analytics, dedicated IPs, and other features that help me optimize my email infrastructure.

Oh, and yes, there’s a free plan that lets you try all these features out, so be sure to check it out!

Send HTML email

Sending an HTML email with Gomail is super easy as all you have to do is modify the SetBody method by changing the MIME type from “text/plain” to “text/html”:

For example:

package main

import (
    "fmt"
    gomail "gopkg.in/mail.v2"
)

func main() {
    // Create a new message
    message := gomail.NewMessage()

    // Set email headers
    message.SetHeader("From", "youremail@email.com")
    message.SetHeader("To", "recipient1@email.com")
    message.SetHeader("Subject", "Hello from the Mailtrap team")

    // Set email body to HTML format
    message.SetBody("text/html", `
        <html>
            <body>
                <h1>This is a Test Email</h1>
                <p><b>Hello!</b> This is a test email with HTML formatting.</p>
                <p>Thanks,<br>Mailtrap</p>
            </body>
        </html>
    `)

    // Set up the SMTP dialer
    dialer := gomail.NewDialer("live.smtp.mailtrap.io", 587, "api", "1a2b3c4d5e6f7g")

    // Send the email
    if err := dialer.DialAndSend(message); err != nil {
        fmt.Println("Error:", err)
        panic(err)
    } else {
        fmt.Println("HTML Email sent successfully!")
    }
}

Pro tips:

I recommend writing your HTML code within the string passed to SetBody.
To ensure better readability for multiline HTML content, enclose the HTML in backticks (`).
Another common practice is to attach a plain text version of your HTML message, just in case some of your recipients’ clients don’t support HTML.
- For this, you can use the AddAlternative function:

`
m.SetBody( "text/html", "

Hello!

m.AddAlternative("text/plain", "Hello!")
`
Send Emails with Mailtrap for Free

Send email to multiple recipients

If you have multiple recipients, simply add their addresses in the “To” field under the **SetHeader** method. Of course, don’t forget to separate them with commas.

Check it out:

`
package main

import (
"fmt"
gomail "gopkg.in/mail.v2"
)

func main() {
// Create a new message
message := gomail.NewMessage()

// Set email headers with multiple recipients
message.SetHeader("From", "youremail@email.com")
message.SetHeader("To", "abc@gmail.com", "xyz@gmail.com", "123@gmail.com")  // Multiple recipients
message.SetHeader("Subject", "Test Email to Multiple Recipients")

// Set email body
message.SetBody("text/html", `
    <html>
        <body>
            <h1>This is a Test Email</h1>
            <p><b>Hello!</b> This is a test email sent to multiple recipients.</p>
            <p>Thanks,<br>Mailtrap</p>
        </body>
    </html>
`)

// Set up the SMTP dialer
dialer := gomail.NewDialer("live.smtp.mailtrap.io", 587, "api", "1a2b3c4d5e6f7g")

// Send the email
if err := dialer.DialAndSend(message); err != nil {
    fmt.Println("Error:", err)
    panic(err)
} else {
    fmt.Println("Email sent successfully to multiple recipients!")
}

}
`

Additionally, you can use the Cc and Bcc to send carbon copy or blind carbon copy emails, like so:

message.SetHeader("Cc", "ccperson@example.com") message.SetHeader("Bcc", "bccperson@example.com")

Send email with attachments

When it comes to attachments, Gomail is really hard not to appreciate. To add an attachment to your email, just move the image/document to your project folder and specify its name under the **Attach** method.

Let’s say we want to add an invoice to our email. Simply copy the invoice#1.pdf, and specify its filename in the code, like so:

`
package main

import (
"fmt"
gomail "gopkg.in/mail.v2"
)

func main() {
// Create a new message
message := gomail.NewMessage()

// Set email headers
message.SetHeader("From", "youremail@email.com")
message.SetHeader("To", "abc@gmail.com")
message.SetHeader("Subject", "Test Email with Attachment")

// Set email body
message.SetBody("text/html", `
    <html>
        <body>
            <h1>This is a Test Email</h1>
            <p><b>Hello!</b> Please find the attachment below.</p>
            <p>Thanks,<br>Mailtrap</p>
        </body>
    </html>
`)

// Add attachments
message.Attach("/invoice#1.pdf")

// Set up the SMTP dialer
dialer := gomail.NewDialer("live.smtp.mailtrap.io", 587, "api", "1a2b3c4d5e6f7g")

// Send the email
if err := dialer.DialAndSend(message); err != nil {
    fmt.Println("Error:", err)
    panic(err)
} else {
    fmt.Println("Email sent successfully with attachments!")
}

}
`

Send email with embedded image

If you want to display an image inline rather than as an attachment, you can use the Embed() method, which attaches it directly within the email body.

Here’s a code snippet you can use:

`
package main

import (
"fmt"
gomail "gopkg.in/mail.v2"
)

func main() {
// Create a new message
message := gomail.NewMessage()

// Set email headers
message.SetHeader("From", "youremail@email.com")
message.SetHeader("To", "abc@gmail.com")
message.SetHeader("Subject", "Test Email with Embedded Image")

// Embed image and set email body to reference the embedded image
message.Embed("/path/to/image.jpg", "image123")

message.SetBody("text/html", `
    <html>
        <body>
            <h1>Test Email with Embedded Image</h1>
            <p><b>Hello!</b> This email contains an embedded image:</p>
            <img src="cid:image123" alt="Embedded Image">
            <p>Thanks,<br>Mailtrap</p>
        </body>
    </html>
`)

// Set up the SMTP dialer
dialer := gomail.NewDialer("live.smtp.mailtrap.io", 587, "api", "1a2b3c4d5e6f7g")

// Send the email
if err := dialer.DialAndSend(message); err != nil {
    fmt.Println("Error:", err)
    panic(err)
} else {
    fmt.Println("Email sent successfully with an embedded image!")
}

}
`

Asynchronous email sending

As it’s synchronous by nature, Gomail isn’t really the best bet for sending multiple emails concurrently. However, goroutines, a lightweight thread managed by Go, allows us to get past this by calling **go sendAsyncEmail(recipient, dialer)**.

Check out how it works:

`
package main

import (
"fmt"
"gopkg.in/mail.v2"
"time"
)

func sendAsyncEmail(recipient string, dialer *mail.Dialer) {
// Create a new message
message := mail.NewMessage()

// Set email headers
message.SetHeader("From", "your.email@example.com")
message.SetHeader("To", recipient)
message.SetHeader("Subject", "Async Email Example")
message.SetBody("text/plain", "This is an asynchronously sent email!")

// Send email
if err := dialer.DialAndSend(message); err != nil {
    fmt.Println("Error sending email:", err)
} else {
    fmt.Println("Email sent to:", recipient)
}

}

func main() {
// Configure the SMTP dialer
dialer := mail.NewDialer("live.smtp.mailtrap.io", 587, "username", "password")

// List of recipients
recipients := []string{"recipient1@example.com", "recipient2@example.com", "recipient3@example.com"}

// Loop over the recipient list and send emails asynchronously
for _, recipient := range recipients {
    go sendAsyncEmail(recipient, dialer) // Send email in a separate goroutine
}

// Wait for all emails to be sent
time.Sleep(5 * time.Second) // This gives enough time for goroutines to finish before exiting

}
`

Send bulk emails

When it comes to bulk emails, the situation with Gomail is the same as for asynchronous sending and we have to use goroutines.

Here’s a code snippet:

`
package main

import (
"fmt"
"gopkg.in/mail.v2"
"sync"
"time"
)

func sendAsyncEmail(recipient string, dialer *mail.Dialer, wg *sync.WaitGroup, throttle <-chan time.Time) {
defer wg.Done() // Notify that this goroutine is done

// Wait for the throttle to allow sending
<-throttle

// Create a new message
message := mail.NewMessage()

// Set email headers
message.SetHeader("From", "your.email@example.com")
message.SetHeader("To", recipient)
message.SetHeader("Subject", "Async Email Example")
message.SetBody("text/plain", "This is an asynchronously sent email!")

// Send email
if err := dialer.DialAndSend(message); err != nil {
    fmt.Println("Error sending email:", err)
} else {
    fmt.Println("Email sent to:", recipient)
}

}

func main() {
// Configure the SMTP dialer
dialer := mail.NewDialer("bulk.smtp.mailtrap.io", 587, "username", "password")

// List of recipients (e.g., bulk list)
recipients := []string{"recipient1@example.com", "recipient2@example.com", "recipient3@example.com"}

// Create a WaitGroup to wait for all emails to be sent
var wg sync.WaitGroup

// Throttle to control the rate of email sending (1 email per second)
throttle := time.Tick(1 * time.Second)

// Loop over the recipient list and send emails asynchronously
for _, recipient := range recipients {
    wg.Add(1)
    go sendAsyncEmail(recipient, dialer, &wg, throttle) // Send email in a separate goroutine
}

// Wait for all goroutines to finish
wg.Wait()
fmt.Println("All emails have been sent.")

}
`
Notes:

As opposed to the snippet from the previous chapter, we use **sync.WaitGroup** instead of **time.Sleep** so our app can perform under a heavier load.
I’ve also added throttle control **<-throttle** so you can choose how long the intervals between each email are going to be.
Technically, you could also implement a retry logic with the **sendEmailWithRetry** function by wrapping it around **DialAndSend**. However, be careful with it as too many retried attempts might negatively affect your sender reputation and overall deliverability.
Lastly, I’ve used Mailtrap Bulk Stream, which provides me with a dedicated stream for sending large amounts of emails while keeping my deliverability high.

Also, if your focus is on bulk sending, I should probably mention that Mailtrap has a bulk-aware email API. With it, you can send customized HTML emails to 1,000,000 recipients with a single API call. Most importantly, it will compile the information into emails itself!

Gomail debugging

Done coding? Better not pack up, cause now I’ll show you the most common approaches to debugging in Gomail. ⚒️

- Error handling and logging using the fmt.Println() statement

The simplest way to ensure your Gomail code is working correctly is to use the fmt.Println() statement. As you might have noticed, I’ve added it to all of the code blocks throughout this article to make it a bit easier for you.

Nonetheless, here’s a dissected snippet for you to inspect:

// Add error logging here for better debugging if err := dialer.DialAndSend(message); err != nil { fmt.Println("Failed to send email:", err) // You can add more logging or error handling here if needed } else { fmt.Println("Email sent successfully!") }

Setting the Debug mode in dialer There’s also the Debug field provided by Gomail. You can use it to pass io.Writer (e.g., os.Stdout) and print SMTP communications, which makes it easy to see what’s going on under the hood.

For example:

`
import "os"

dialer := gomail.NewDialer("live.smtp.mailtrap.io", 587, "api", "1a2b3c4d5e6f7g")
dialer.Debug = os.Stdout // Prints out the SMTP session communication
`

Checking the SMTP configuration Although it’s not really a debugging method, I have to mention that if you’re facing issues and errors when trying to send emails, you should always check the SMTP configuration.

Personally, not rarely have I failed to enter my credentials correctly and input the correct port number (looking at you, port 597 🫠).

Additionally, you can log the SMTP details to make sure they’re correct:

fmt.Printf("Using SMTP Server: %s, Port: %d, Username: %s\n", smtp_server, port, login)

“X509: certificate signed by unknown authority” If you’re seeing this error, the client running Gomail is likely not considering the SMTP server’s certificate to be valid. A simple fix would be to use SetTLSConfig and bypass the server’s certificate chain:

`
package main

import (
"crypto/tls"

"gopkg.in/gomail.v2"

)

func main() {
d := gomail.NewDialer("smtp.example.com", 587, "user", "123456")
d.TLSConfig = &tls.Config{InsecureSkipVerify: true}

// Send emails using d.

}
`

Test email and email sending on staging

Debugging is only one part of making sure your email-sending functionality works. However, there’s more to it, like ensuring your messages look how you want them to or that they’re reaching your recipient’s primary inboxes instead of spam folders.

Gomail doesn’t offer an in-built solution for this, but fortunately, there’s Mailtrap Email Testing, another inseparable part of Mailtrap Email Delivery platform, which I personally use and recommend.

Mailtrap Email Testing allows me to inspect the HTML/CSS of my emails and easily fix faulty lines of code, preview my messages, and more.

Once I’m certain my HTML is flawless, I typically proceed to check my spam score. If I keep it below 5, I proactively prevent a lot of potential email deliverability issues my project could face once I move it to production.

And I must admit, if you think that sending emails with Gomail is easy, wait till you see how straightforward it is to test emails with Mailtrap.

{% embed https://youtu.be/AveaJc6c3fI %}

To start testing, all you have to do is:

Create a free Mailtrap account
Navigate to Email Testing and choose your inbox
Find your credentials from the Integration tab

Once you obtain the credentials, simply copy/paste them into your Gomail configuration file. More specifically, the credentials in your dialer. Here’s what it should look like:

dialer := gomail.NewDialer("sandbox.smtp.mailtrap.io", 587, "your_mailtrap_username", "your_mailtrap_password")
Test Emails with Mailtrap for Free

Additionally, if you want to automate your testing process, you can use our Email Testing API and leverage it in Golang. For more information, check out the official docs or watch our video!

Wrapping up

Sending emails with Gomail really is the definition of short and sweet!

However, if you want to sweeten things up a bit more, make sure to leverage Mailtrap’s email testing and sending capabilities, ensuring your emails land where you want them to: recipients’ primary folders. 📬

We appreciate you chose this article to know how to send email in Gomail. To read more interesting articles on related topics, follow Mailtrap blog!

Email Workflow Automation 101: Templates, Tools, and Best Practices

Ivan Djuric — Tue, 01 Oct 2024 10:57:09 +0000

Email workflow automation takes over administrative tasks such as following up on sales inquiries, sending targeted promotions, and requesting feedback after a purchase. This helps teams save time, enhance productivity, and retain consistency across all communications.

As you can imagine, this type of automation streamlines lead nurturing processes, increases conversion rates, and boosts engagement. Moreover, teams can focus more on crafting persuasive messages and building efficient pipelines.

Let’s dive deeper into email workflow automation, explore popular tools, and discuss best practices that will help you get the most out of your campaigns.

What is email workflow automation

Email workflow automation is the process of leveraging software to send pre-defined emails based on user actions or specific events.

User action is something that your visitors or customers may do while interacting with your brand. This includes downloading content from your platform, subscribing to the newsletter, or requesting a demo.

To that, specific events are holiday seasons or industry breakthroughs that necessitate sending offers or updates to the recipients.

The key components of email workflow automation include:

Triggers: These are the events and user actions that initiate the workflow, like a user signing up.
Actions: The automated task that the trigger executes, like sending a welcome email.
Conditions: Rules that define the criteria that need to be met before a mail is sent, like “if a new user signs up, send them the welcome email.”
Sequences: A series of emails sent over time that nurture emails, like a quick start guide email after the welcome message.

This is great for lead nurturing, post-purchase follow-ups, onboarding sequences, and more. It allows teams to complete a lot of tedious, repetitive tasks in minutes or even seconds.

Additionally, efficient email workflow automation can support revenue recognition by ensuring timely communication and fulfillment updates that meet the conditions required to recognize revenue. For example, automated emails confirming product delivery or service completion help businesses promptly recognize revenue in line with accounting standards.

Email workflow automation templates and examples

Templates, as pre-built frameworks, help set the foundations of email workflow automation while still allowing room for customization.

The four popular email workflow automation templates include:

1. Welcome email series

The welcome email series is triggered when an interested prospect joins a mailing list or a customer makes their first purchase. These messages are crucial for introducing yourself, setting expectations, and engaging the new recipient.

It establishes initial contact with your prospect or customer and provides them with resources they might need to learn about your offerings. This includes a quick thank you for choosing you, an introduction to the offerings and their configurations, and support content.

In some cases, you can also send over a special offer to encourage the first purchase.

Headspace, a mental health company, sends a warm welcome email that sets user expectations from the get-go:

2. Abandoned cart emails

The abandoned cart emails remind your potential customers that they have chosen products or services they want to motivate them to complete the purchase. There can be several messages in such a campaign, such as regular reminders and offer notifications.

This assists businesses in recovering lost sales by encouraging users to finish the checkout process.

These emails contain a clear call-to-action (CTA) — a direct link to the cart, making it easier for the recipient to complete the purchase.

Loftie, a wellness company that creates products to rest and relax, sends a coupon to encourage customers to complete the purchase:

3. Re-engagement campaigns

Re-engagement campaigns are triggered when a subscriber hasn’t interacted with your brand or an existing customer hasn’t purchased in a while. The key objective is to pique the interest of the prospects again and ultimately reduce churn rates.

These email workflow automation campaigns are designed to win back leads or buyers’ attention. And it’s essential for teams to personalize the re-engagement emails if they’re to be impactful.

Additionally, you can include a survey to learn why they have been inactive for a while.

Duolingo, a popular app to help you learn new languages, motivates you to get back to work when you take a few days off:

Notice how they have incorporated various engaging elements such as a direct CTA to get back to your lessons, what other learners have achieved when you were away to create a sense of FOMO, and an encouraging message to push you to act.

4. Post-purchase follow up

As the name suggests, the post-purchase follow-up email automation workflow is initiated when a customer completes a purchase. The messages may include questions that reveal insights about the checkout experience and feedback on the products or services leveraged.

You can also offer product usage tips to enable the buyers to get the most out of their investment.

The given actions bring the customers closer to your brand because they send empathetic signals. Such follow-ups can play a pivotal role in improving retention and boosting customer lifetime value (CLTV).

Coffee Lab, a premium roaster, sends a heartfelt message after a customer makes a purchase and requests their feedback. Plus, there’s an option to get in touch via a chat feature.

How to create an automated email workflow

I won’t dwell too much to lead you in but focus on a stepped approach you can immediately follow to create your workflow. So, here it is.

1. Define your goal

The objectives of your automated email workflow can range from nurturing leads, educating current customers, and re-engaging inactive prospects. This informs the types of triggers you need to set and messages you need to send.

2. Identify triggers

Determine the events that initiate your email sequences on a tangible level. These are usually IF-THEN statements. For instance, “if a visitor downloads a whitepaper, then send them a thank you email and offer a demo.”

3. Segment your audience

The leads in your pipeline might not be ready to buy now. Moreover, each of them may want a different value from your brand. Therefore, it’s vital to group all the contacts in your database based on criteria like pain points, demographics, or purchase history.

Doing that enables you to personalize your automated email workflow which increases its efficiency in making a sale.

4. Create and map out the email sequence

Once the trigger is set, outline the email sequence for a particular audience segment. In the case of a new subscriber, for example, this could include a first welcome email, a follow-up to include additional resources, and a personalized offer.

It’s crucial to be mindful of the timing here. You do not want to overwhelm your recipients with too many promotional messages.

5. Set conditions and actions

The conditions are the email triggers and the actions are what your email automation software is pre-programmed to do. As indicated earlier, these are the “IF” statements that determine the course of action in your email automation workflow when the conditions are met or unmet.

For instance, “if the welcome email isn’t opened within three days, send a gentle reminder and decrease the lead score by 5 units.” Alternatively, “if the welcome email is opened in three days, send a follow-up with more resources and increase the lead score by 3 units.”

6. Test the workflow

As there are a lot of moving parts in a typical email automation workflow, teams should evaluate it in all aspects before setting it live. Testing also help spot areas of improvement, such as message enhancements.

7. Monitor and optimize

Key performance indicators (KPIs) include open rates, click-through rates, and conversions. Keep in mind that the data is tracked with the permission of your prospects and customers to avoid legal fines and reputational damage.

Best practices while setting up email workflow automation

Planning and implementing email workflow automation requires keen attention to detail while making data-backed decisions. Here are some best practices that will help you get started quickly in this journey:

1. Identify tangible metrics from the beginning

Based on your goals for email workflow automation, recognize the measurable parameters that reflect the progress towards them. For instance, if your objective is to improve customer engagement, then you should focus on click-through rates.

2. Segment audience based on value

As we mentioned earlier, each visitor on your website looks for a different value. Grouping them based on the common value makes it easier for you to write personalized messages. This increases the efficacy of your email campaigns and the ROI of the overall automation workflow.

3. Personalize content with AI

Speaking of personalization, artificial intelligence (AI) technologies can assist in summarizing a client’s profile including past interactions to suggest replies. So, you can write messages that resonate better with your audience without sacrificing productivity.

4. Space emails out strategically

Nobody wants to hear from a business every day, even if their products are amazing and services are best in class. A good rule of thumb is to schedule your messages 2-4 days apart in your email workflow automation.

3 best email workflow automation software for businesses

Useful email workflow automation software allows teams to focus on writing and sending messages that deliver value to their recipients and boost sales. Here are three tools that businesses can consider:

1. Klaviyo

Klaviyo is a marketing automation platform primarily designed for eCommerce businesses. It has become a popular choice among online retailers due to features like real-time segmentation, behavior tracking, and pre-built email workflows.

Teams can quickly set up simple email automations such as welcome series, cart abandonment reminders, and post-purchase follow-ups. Of course, its intuitive interface also makes it easy to create custom workflows for specific use cases.

The free tier allows businesses to store up to 250 contacts and send 500 emails per month. Paid plans begin at $20/month where users can access advanced functionalities. The price then changes based on the number of contacts and emails sent.

Its robust features make it a great option for eCommerce businesses and online sellers.

2. ActiveCampaign

ActiveCampaign is a marketing automation platform that offers robust functionalities. Teams can integrate it seamlessly with their CRM solutions to segment their contacts and send personalized messages. The email workflow automation builder is intuitive and easy to use, even for non-technical professionals.

The plans for ActiveCampaign begin from $19/month for 1,000 contacts with limited automation features.

This solution is great for B2B marketing teams with extensive email workflow automation needs.

3. Mailchimp

Mailchimp is a popular email marketing platform that offers features like customizable templates, A/B testing, and audience segmentation. This can preferred by teams looking to automate their email workflows but also want a minimalist tool to streamline their marketing efforts.

The free plan allows up to 500 contacts, with 1,000 sends per month. The premium plans are charged based on the number of contacts. The lowest tier begins at $13/month for 500 contacts with 10x the sending limit.

Mailchimp can be a solid option for small businesses and startups with limited email marketing needs who need an easy-to-use tool.

Wrapping up

Email workflow automation makes it easier for teams to send timely and relevant messages quickly to their customers. It also simplifies the process of personalizing messages to increase the overall effectiveness of email marketing.

But, keep in mind that email workflow automation requires continuous iterations to remain effective over time. Track the relevant metrics such as open rates and conversion rates to discover areas of improvement.

We appreciate you chose this article to know about email automation workflow template. For more interesting articles on related topics, follow Mailtrap blog!

How to Test Your WooCommerce Emails: Insights and Obstacles to Overcome

Ivan Djuric — Tue, 24 Sep 2024 13:13:01 +0000

After weeks of research and some trial and error, I can firmly say – it is impossible to thoroughly test emails and email sending using any WooCommerce built-in features or plugins.

To be clear – both options offer some email testing features, but they’re pretty limited.

Nevertheless, these features can still be helpful for some minimal email testing.

So, in this guide, I’ll still cover them and show you how to use Mailtrap Email Testing to test your emails and email sending correctly.

Defining email testing and email sending testing

Before we go any deeper into the topic, I want to clarify what email testing involves:

Testing of emails is verifying that the content, layout, and functionality of emails render correctly across various email clients and devices. This ensures that messages are received and visually appear as intended.
Testing of email sending focuses on ensuring the reliability and performance of your email delivery. This process checks that emails are not just sent but also reach the recipients’ inboxes and avoid spam filters.
Email testing in the context of WooCommerce is crucial for ensuring that transactional emails, like order confirmations and shipping updates, are delivered and displayed correctly. This helps boost customer trust, delivers key order details, and improves the shopping experience.

To better understand these nuances, check out the video below:

Test emails using WooCommerce Email Preview

The WooCommerce built-in email preview allows you to only inspect how an email appears. You won’t be able to test email deliverability, get a spam analysis, check device compatibility, etc.

This approach is practical when you are confident in your email-sending service, and you only need to check that the email template’s design correctly displays all its elements.

Here is how you can quickly activate the built-in “Email Preview” feature:

Access WooCommerce Settings

Navigate to your WordPress admin dashboard, click ‘WooCommerce’, and select ‘Settings’.

Go to the Emails Tab

Find and click on the ‘Emails’ tab, where all the types of emails WooCommerce sends are listed. Click the ‘Manage’ button for the email you wish to preview.

Preview the Email Template

In the selected WooCommerce email settings, you’ll find an option to preview your email template. This lets you see how the subject line, email body, and the rest of the layout will appear, helping ensure everything is formatted correctly before sending it out to customers.

As mentioned earlier, this is just a simple email preview, and if you are a high-volume sender, it is always best to test email deliverability issues so they don’t impact your business.

Test emails using a mailing plugin and Mailtrap

With over three million downloads, WP Mail SMTP is the most popular email plugin in the WordPress ecosystem. There is a good chance you already have it installed in your store – if not, here’s the installation guide.

This plugin reconfigures WordPress to use a proper SMTP provider with host credentials instead of the default wp_mail() PHP mail function. To test emails, I simply indicate the fake SMTP server credentials of Mailtrap Email Testing in the plugin.

This way, I can trap the email in a sandbox where I can inspect and debug it before it reaches recipients.

SMTP

To install the plugin and start using it with Email Testing, follow these steps:

Create a new account with Mailtrap and navigate to your first inbox by clicking ‘Email Testing’, ‘Inboxes’, then “My Inbox”.

Once inside “My Inbox”, click “Show credentials”

a. Here, you will find your Email Testing SMTP/POP3 credentials that you’ll need to configure later in WP Mail SMTP plugin’s settings.

Next, from your WordPress admin dashboard, navigate to the ‘Plugins’ section and press ‘Add New’.
Search for ‘WP Mail SMTP’, install it, and press ‘Activate’.

When the plugin is activated, navigate to its settings. Find the fields for ‘From Email’ and ‘From Name’ in the ‘General’ settings and fill them out.

After that, scroll to the section labeled ‘Mailer’ and select ‘Other SMTP’.

Scroll down to add credentials for ‘Other SMTP’, and start copy-pasting Mailtrap Email Testing SMTP credentials into the designated fields:

SMTP Host: sandbox.smtp.mailtrap.io
Encryption: SSL or TLS
SMTP Port: 25 or 465 or 587 or 2525 (will be filled out automatically once you choose encryption)
Authentication: toggle On
SMTP Username: your Mailtrap username
SMTP Password: your Mailtrap password

Click the ‘Save Settings’ button; you’ll see the confirmation notifications at the top of the WP Mail SMTP General tab.
Once the SMTP connection is established, navigate to the ‘Email Test’ tab, enter your email address, toggle the HTML switch on or off, and press ‘Send’.

Within minutes, you can find the email in your Mailtrap inbox to analyze HTML errors, check spam scores, review blacklist status, and more.

Test Emails with Mailtrap for Free

API

To integrate Mailtrap Email Testing via API with the WP Mail SMTP plugin, you’ll need to use PHPMailer in your WordPress environment.

WordPress already includes PHPMailer, so you don’t need to install it separately.

In the ‘My Inbox’ page, scroll down to the ‘Integrations’ drop-down menu, select PHPMailer, and copy the code that will appear.

Next, customize how the WP Mail SMTP plugin sends emails by adding the code to your theme’s functions.php file.

add_action( 'phpmailer_init', 'custom_phpmailer_init' );
function custom_phpmailer_init( PHPMailer $phpmailer ) {
    $phpmailer->isSMTP();     // Set mailer to use SMTP
    $phpmailer->Host = 'sandbox.smtp.mailtrap.io';  // Specify Mailtrap server
    $phpmailer->SMTPAuth = true;                    // Enable SMTP authentication
    $phpmailer->Port = 2525;                        // SMTP port
    $phpmailer->Username = 'your Mailtrap username';    // Your Mailtrap username
    $phpmailer->Password = 'your Mailtrap password';    // Your Mailtrap password
    $phpmailer->SMTPSecure = 'tls';                 // Encryption to use - 'ssl' or 'tls'
}

After you’ve made these changes, just like with SMPT, use the ‘Email Test’ tab in the WP Mail SMTP settings to send a test email.

Wrapping Up

Whether previewing basic WooCommerce email templates directly in the eCommerce platform or leveraging add-ons and advanced email testing tools, the goals remain the same: ensuring your emails look great, achieve optimal deliverability, and perform well across all of the different platforms and devices.

Check out the tutorials below for more help and a deeper understanding of email management. They’re designed to boost your knowledge and skills, making them a great starting point for anyone eager to master WooCommerce test email techniques.

We appreciate you chose this article to know how to send WooCommerce emails with Mailtrap. Read more interesting articles on related topics on Mailtrap blog!

Complete Tutorial on Mailto Links: What They Are & How to Use Them

Ivan Djuric — Wed, 11 Sep 2024 10:28:01 +0000

HTML is nearly as old as the internet, and so is one of its most common schemes: mailto. And, even though so many things have changed since then, good ol’ mailto is still widely used and taught in HTML courses all around the world.

The way it works is very simple. When placed behind a text and clicked/tapped afterward, it triggers a default email client to be opened and a new email message creator pops up on a screen. Usually, one or more fields are already pre-populated to make life easier for a sender (and make typos, and subsequent email bounces, impossible).

We’re going to explore different methods of customizing html mailto links. We’ll also talk about whether it’s still a good approach in the 2020s, and whether there are any viable alternatives. Let’s start!

The basics of mailto

Mailto is a link so you need to use the tag with its href attribute. A very basic mailto syntax that sends an email after clicking/tapping on “I want free Bitcoins” looks like this:

<a href=”mailto:piotr@mailtrap.io”>I want free Bitcoins</a>

They say the more people you email, the higher the chance of getting what you want, right? If that’s what you really want, you can let your leads contact a few people at once. Simply insert their addresses separated with commas.

<a href=”mailto:piotr@mailtrap.io, john@mailtrap.io, kate@mailtrap.io”>I want free Bitcoins</a>

Clicking on such a link will open the default email app or load a web client in the same or a new tab. What exactly happens depends on the default settings of the recipient’s device and browser (more on that later).

If the recipient is logged in to their mail client, an empty new message window will pop up with the pre-filled “To:” field. Here’s a Gmail example:

Customizing further

Okay, that was easy to set up. But the email above is still quite empty and it will take some effort from a customer to populate and send it. Chances are, they’ll change their mind in the process and you really want to give away all those bitcoins you were diligently digging. Luckily, pre-filling a “To:’ field is just the start.

Subject line

To automatically add a text in the subject field, insert it after the ‘subject’ parameter, as in the example below.

<a href=”mailto:piotr@mailtrap.io,john@mailtrap.io,kate@mailtrap.io?subject=Give%20me%20all%20your%20bitcoins”>

If this was the first parameter you added to an email address, use “?” to separate them. For any further parameters, you’ll use ampersand “&” instead. To separate words, use the ‘%20’ tag.

Email body

Chances are you want to pre-populate the email body as well. For that, you’ll use the ‘body’ parameter (surprise surprise).

<a href=”mailto:piotr@mailtrap.io,john@mailtrap.io,kate@mailtrap.io?subject=Give%20me%20all%20your%20bitcoins&body=Here%20are%20my%20parents'%20credit%20card%20numbers%3A%0D%0A%0D%0ACheers%2C%0D%0AHappy%20Customer”>I want free Bitcoins</a>

This looks a bit ugly already as, on top of ‘%20’ for separating words, you may also need to separate lines. Use the ‘%0D%0A’ tag for this purpose.

Now this looks a lot better (depending on who you ask, of course).

CC and BCC

If for any noble reason, you just want to keep Kate and John in the loop, you can easily cc and bcc (blind carbon copy) them. For example like this:

<a href=”mailto:piotr@mailtrap.io? cc=john@mailtrap.io& bcc=kate@mailtrap.io& subject=Give%20me%20all%20your%20bitcoins&body=Here%20are%20my%20parents'%20credit%20card%20numbers%3A%0D%0A%0D%0ACheers%2C%0D%0AHappy%20Customer”>I want free Bitcoins</a>

Skip the ‘To’ field

Or maybe you don’t really want anyone to email you but instead, you want the folks to spread the news about the giveaway you’re doing? You can omit the ‘To’ field with the following construction:

<a href=”mailto:?subject=Folks%2C%20check%20this%20out!&body=These%20losers%20are%20giving%20away%20bitcoins!”>Spread the news</a>

Open in a new tab

The last thing that may be useful to know is related to opening a link containing mailto in a new tab.

<a href=”mailto:piotr@mailtrap.io” target=”_blank” rel=noopener noreferrer””>I want free Bitcoins</a>

If you use this construction and your clients have a native app set up as a default email client (for example, Microsoft Outlook or Apple Mail), nothing will change. The app will open with a pre-filled email whether you include a ‘target’ parameter or not.

If, however, they have a web-based client such as Gmail as a default email client, it will make a difference. Using target=”_blank” parameter will cause the email client to open in a new tab, letting a user stay on your website and browse more of your “great” offers. In any other case (also when no target is specified), an email client will load in the same tab.

Add an attachment

And what if you wanted to automatically add an attachment? It’s not that simple and for a reason – automatically fetching files from a user’s hard drive and sending them in an email would lead to some serious abuse. For that reason, there’s no parameter related to attachments in the mailto protocol.

There can be legitimate use cases for attachments, though.

For example, your site is generating a file (say, a simple design) that users may want to send to a friend right away. To enable this, have a server generate a URL to a file and include it in the body of an email for a recipient to download. The same way, if users are to upload a file, generate a link to it when an upload is finished and include it as a hyperlink in email’s body text.

Either way, it’s going to be a download link, not an attachment that’s sent. But it should do the job in nearly any situation.

You don’t have to do all of this manually

And some good news to wrap up this chapter – there are lots of great tools that will craft a mailto link for you so you don’t need to play with the %20 and %0D%0A tags all day long. Some examples include https://mailtolink.me/ and https://htmlstrip.com/mailto-generator

If you need to make sure that all of your mailto links are inserted properly, other links are sent to the right recipients, and that the HTML is not broken in any way, then check out Mailtrap Email Testing.

Email Testing catches your SMTP traffic in a safe environment and let’s you inspect and debug emails in staging, development, and QA stages without spamming recipients. Check the support for a template’s HTML and CSS with the most popular mailbox providers. Analyze emails’ Spam Scores and see if your IP appears in any blacklist reports. Then, automate testing flows with Mailtrap’s Email Testing API.

Try Mailtrap for Free

Why mailto may not work

As you can see, setting up a mailto is one of the easiest things in HTML. But no matter how hard you try, many of your visitors still won’t take advantage of it.

Most commonly, their default email client won’t correspond to the actual client they use to send emails. For example, they send with Gmail and Outlook or Apple Mail is set as a default client. (Or the other way around).

If that’s the case, a client they don’t normally use (and are likely not even logged in to) will load when clicking a mailto link. Needless to say, it’s more likely to annoy them rather than help them reach you.

They could technically right-click on a mailto link text and copy the mail address to a clipboard for later use:

But let’s face it, how many will?

Is mailto the right approach?

Mailto links, and email addresses hidden behind them, are also very easy to harvest. Endless amounts of bots crawl websites day and night and they add to their long lists whatever even resembles an email address. Since a mailto link is directly encoded into a web page, they can collect an email behind it within milliseconds.

This can lead to obvious abuse, usually in the form of an endless wave of unwanted messages in your inbox. You could try to obfuscate the address with JavaScript or other methods to hinder the harvest. But, with already excellent spam filters put in place by reputable email clients, it may not be worth the effort. We discuss it in more detail in our article on email obfuscation.

By putting a mailto link out there, you also share your contact details with any legitimate outreach specialists that wish to reach you. Finding all your company emails hidden in the html code is as easy as a single tap on a hunter.io widget (many similar tools are also available).

Is there an alternative?

A contact form is. It’s easy to reach you this way (as long as you don’t add 38 required fields). Your email address is not revealed and, as such, is impossible to harvest. You can gather more specific data this way, forcing users to choose items from a list, as in the example below.

There are also many free and paid resources online for building beautiful contact forms. And, of course, with a bit of design effort you can build your own forms that perfectly complement your website design.

On the downside, a contact form may not be the preferred contact method for some of your clients, used to sending emails back and forth. While bots won’t be able to harvest any email this way, they could still populate the fields of a form and hit the ‘send’ button. So if a form is your preferred choice, make sure a latest reCaptcha is in place to quickly filter out these awkward guests.

Changing the default mailto behavior

If mailto links don’t open for you the way they should, a quick look at the system or browser settings should do the job.

In Windows, head to Settings -> Apps -> Default apps. Scroll down and pick “Choose default apps by protocol” from the menu. For ‘Mailto’, choose the client of your choice.

On MacOS, open the default Mail app. Log in to your email account (it’s a required step to edit settings). Choose “Mail” from the menu and then “Preferences”. Change the default client in the first dropdown list.

If you want Chrome and Gmail to open mailto links for you by default, make sure Google Chrome is picked as the default client on either OS.

In Firefox, you can also specify which client should handle mailto links.

Click on the menu button -> Preferences. Then in ‘General’ go to the ‘Applications’ section and search for ‘Content Type ‘mailto’’. In the action field, pick the desired client:

If Gmail is your client of choice and setting it as default doesn’t fix the problem, there’s one more thing you can do. Launch Chrome and type in chrome://settings/handlers into the address field. You should make sure that mail.google.com is added as a default handler, like in the picture below:

If it’s not, make sure “Allow sites…” is enabled and open your Gmail account. You’ll see a popup asking whether Gmail can open these html email link. Grant the permission and it should fix the problem.

Wrapping up

By now, you should have a pretty good idea of how to customize and use mailto link, and whether you actually want to use it. Explore our blog, where we cover various topics related to emails – important infrastructure choices, software worth using, email configuration for many different frameworks and libraries. And a lot more!

We appreciate you chose this article to know how to link an email in HTML. To discover more interesting topics, read other articles on Mailtrap blog!

Broadcast Emails Explained: When and How to Send Them Effectively

Ivan Djuric — Fri, 06 Sep 2024 10:25:42 +0000

Sending the same letter to a large group of people is definitely cost-efficient, but is it effective? In this post, I explain what broadcast emails are, why marketers use them, and how you can send such letters to your audience.

What is a broadcast email?

Broadcast email is a single message sent to multiple subscribers. These can be email newsletters, promotions, special deals, etc. Broadcast emails are also referred to as bulk email or mass email.

Unlike spam, broadcast messages are sent on consent and are typically very effective as they are personalized (arrow 1 on the image above) and offer curated content (arrow 2 on the image above).

The use of broadcast emails is also known as broadcast email marketing and means the same as bulk email marketing or mass email marketing.

Difference between broadcast email and autoresponder

While broadcast emails are sent to a broad audience all at once, email autoresponders are personalized responses sent to one person in reply to a specific event or action.

Marketers use bulk or broadcast emails as a tool for mass communication, typically scheduled or sent as needed. A sender manually creates an email message and schedules the email blast, personalizing content to meet the audience’s needs at that moment. Broadcast emails aim to inform subscribers, promote deals, and drive conversions, making them a key part of marketing emails.

In contrast, autoresponders (also known as user-triggered or transactional emails) are automated, triggered emails sent by an app or a website. Users get such emails after a specific action or event, such as signing up for a newsletter, making a purchase, returning a product, or completing a form. Autoresponders are typically based on standard templates. Their main goal is to nurture leads, guide users through a sales funnel, or maintain ongoing engagement with the audience.

Here are the main differences between broadcast emails and autoresponders:

Examples of broadcast emails

Businesses across various industries worldwide use bulk emails to communicate with their audiences. We get dozens of them every day. Here are some broadcast email examples from my Inbox.

Sephora deals

Every other week, Sephora, a famous luxury cosmetics retailer, sends mass emails about current discounts and deals to its subscribers.

Audible 2-for-1 sale

Audible is a popular subscription-based audiobook service owned by Amazon. Users pay a monthly subscription fee that provides them with one credit, typically used to purchase one audiobook. Occasionally, the service offers sales where users can get two books for one credit.

Grammarly policy update

Grammarly is a digital writing assistant that helps users improve their writing. It operates on a subscription basis and requires users to create personal accounts. Grammarly stores users’ data and follows strict privacy policies to keep this information safe. The service informs users of any updates and changes whenever they occur.

Lisa Eldridge – new product release

Lisa Eldridge, a famous makeup artist, launched her own lipstick line in 2018. Since then, she has expanded the range of products, announcing these updates via email to her wide fan base.

7 Types and use cases of broadcast emails

Broadcast emails serve various purposes and come in different forms. There is no strict classification for these emails since each type is designed to meet specific marketing objectives. They can accomplish various tasks, and new use cases are constantly emerging.

In this post, I have categorized broadcast emails into seven types. However, there may see them overlapping or a need to further divide certain types, as they may appear similar but serve different purposes.

Newsletters

Businesses send email newsletters to keep subscribers informed about company updates, industry news, and valuable content. These emails may include blog posts, info on upcoming events, product launches, and exclusive offers.

Businesses send newsletters regularly, every week, month, or quarter, to maintain consistent communication with their audience.

The rule of thumb here is to personalize and tailor the newsletter content to drive traffic to their websites, increase brand loyalty, and encourage repeat deals.

Promotional emails

Companies send promotional email messages to bring attention to their special offers, discounts, and exclusive deals.

These emails are designed to create a sense of urgency (with all these “Only today” and “2 pairs left in stock”), encouraging recipients to act quickly. Promotional emails often include eye-catching visuals, compelling call-to-action buttons, and personalized recommendations to enhance their appeal and effectiveness.

Invitations

Businesses use emails to inform and invite subscribers to webinars, conferences, local gatherings, or other online or offline events.

Such emails often include details about the event, such as the date, time, location, and agenda of the meeting, speakers, or special activities. Also, they highlight the benefits a person can get from participating in an event.

Product announcements

Product announcement emails are used to inform subscribers and customers about new product launches, feature releases, or updates. Businesses send such emails to generate excitement and raise awareness about the latest offerings from a company.

In a product announcement email, companies often highlight the benefits and unique selling points of the new product or feature. They also explain how a new feature or update can solve a problem or offer something new and innovative. This information helps potential customers understand the value of the new/updated product and drives them to take action, such as purchasing something or visiting the company’s website.

Surveys and feedback requests

Companies often gather customer feedback and opinions on their products, services, and overall experiences. This way they can make informed improvements to their offerings.

The most common surveys companies launch include:

Customer satisfaction surveys to measure how satisfied customers are with a product, service, or experience.
Product feedback surveys to gather detailed opinions about a specific product, its functionality, and design.
Service feedback surveys to focus on the quality of customer service interactions.
Market research surveys to understand broader market trends and customer preferences.

Please note that surveys might also be sent as autoresponder emails after a product return or a product delivery, like this email from the FortunateOne brand.

Content distribution

Content distribution emails aim to educate and engage the audience by sharing valuable content such as blog posts, whitepapers, and case studies.

These emails help position companies as industry leaders by providing relevant and high-quality information. For example, a tech company might send an email featuring its latest blog post on AI trends, a whitepaper on cybersecurity best practices, or a case study showcasing a successful client project.

By regularly sharing valuable content, businesses can build trust and non-intrusively remind clients about themselves.

Seasonal greetings and holiday emails

Retailers love these mass emails and never miss a chance to greet their customers and offer a sale (yes, I’m talking about Christmas offers and Black Friday madness).

Such emails help sell more and enhance brand visibility, especially if it’s a personalized greeting rather than just an upsell offer. By acknowledging significant holidays, brands create a sense of connection and goodwill.

What are the benefits and drawbacks of broadcast emails?

Now the juiciest part. Are broadcast/bulk emails so efficient (given their cost effectiveness) as they say, or is it a myth? Let’s take a look at the honest review of bulk email benefits and drawbacks.

Benefits of broadcast emails

Mass emails offer several significant advantages for businesses that can make you want to use the technology for your business:

Cost-effectiveness is one of the biggest advantages, especially when compared to traditional print or TV advertising. The main expenses include email marketing software like email-sending platform subscription and content creation. Many platforms offer email templates to simplify and speed up the content creation process. Also, they may offer list management, marketing automation, testing, and analytics tools, which further reduce the cost.
Wide reach. Mass emails are an excellent tool for announcements, promotions and updates, or any other information that you would like to convey to a large number of your subscribers.
Measurable results. Email Delivery Platforms like Mailtrap provide detailed analytics on open, click rates and conversions. This data can help you understand the effectiveness of your broadcast campaigns and make data-driven decisions on your email marketing strategy.
Immediate impact. Bulk emails can deliver information instantly, making them ideal for time-sensitive announcements, such as flash sales or urgent updates.
Improved customer relationships. Regularly sending informative and valuable content helps maintain consistent communication with customers, creating loyalty and trust.
Customizable content. You can tailor the content of mass emails to suit different segments of your audience. This way, you can ensure the information is relevant and engaging for each group of recipients.
Automation. Many email marketing tools offer automation features to schedule email sending in advance. By sending relevant emails regularly at the most suitable time for recipients, you can create stronger bonds with your audience and build a loyal community for your brand.

Drawbacks of broadcast emails

If you’ve ever clicked on a link in an email offering special deals and ended up making a purchase, you understand the power of mass emails. However, they only work when done correctly. Otherwise, broadcast emails might damage your relationship with subscribers and hurt your business. Here’s how:

Risk of being marked as spam. If you send emails too frequently or without sufficient relevance, subscribers can perceive them as spam. When many recipients unsubscribe it damages your sender’s reputation and reduces email deliverability.
Limited personalization. Mass emails can be personalized to some extent, yet, they often lack the deep personalization that more targeted email campaigns can offer. As a result, you get lower engagement rates compared to emails that are highly tailored to individual recipient preferences and behaviors.
Broad content. Due to their broad audience, mass emails tend to have more general content, which may not be as compelling or relevant to all recipients. This is why emails usually have lower open and click-through rates.
Deliverability issues. Mindless dispatches of broadcasting emails to a large audience simultaneously can trigger spam filters. If this happens, your emails will end up in the Spam folder. In the future, this will reduce your email deliverability, making it harder to reach your audience.
Over-reliance on automation. While automation can streamline the process, it can also lead to a “set and forget” mentality, where emails are sent without strict supervision, continuous optimization, and improvement based on performance data and feedback.
Resource intensive. Yes, broadcast messages cost less than some other marketing approaches yet they are labor and time-consuming at the preparatory stage. Developing a strategy, planning content creation well in advance, and designing compelling messages demand time and effort. Additionally, ongoing tasks such as segmenting the email list, performing A/B testing, and analyzing campaign performance to optimize future emails can further add to the workload. This resource-intensive process is essential for an effective and successful broadcast campaign.

Email broadcasting tools

There are many email-sending platforms out there. To choose the best one for yourself, you need to focus on those providers, who offer email broadcast capabilities. Here’s a comparison of the most popular options:

*The cost per email is calculated based on the most expensive plan indicated on the service provider’s website. Keep in mind that with lower (cheaper) plans, the cost per email tends to be higher.

**I used a 5-star grading system, where 5 represents the most user-friendly experience and 0 represents the least user-friendly.

How to send broadcast emails?

Of course, I’ll show you how to send broadcast emails with Mailtrap. It’s pretty easy, and the marketing suite is simple to use! The only condition is that you should register and verify your sending domain first. But don’t worry—it won’t take long, and I’m here to walk you through this process!

With Mailtrap, you can quickly set everything up, create an email using a template or drag-and-drop editor, and send it to your subscribers within minutes. Trust me, it’s that simple!

Step 1. Set up an account in Mailtrap

Start by signing up for a Mailtrap account via Google, GitHub, Office 365 account, or your email. Create a password and you are ready to go!

Step 2. Add and verify your sending domain

Set up the sending infrastructure by adding and verifying the domain you own.

First, add your domain or subdomain, you want to use.

Next, add the DNS records provided by Mailtrap. Log in to your domain provider account, select the necessary domain and find the DNS record information. If your domain is hosted on GoDaddy, open the chosen domain in your account, go to the “Additional Setting”’ tab, and click the “Manage DNS” button.

Add the DNS records provided by Mailtrap and hit the “Verify all” button.

Step 3. Create a marketing campaign

Open the “Email Marketing” tap and click the “Open new campaign” button.

Fill in all the necessary fields and hit “Continue”

Select an existing template or create one from scratch.

Add the content and press the “Send Test” button. In a few seconds, the email will land in the inbox of the email address you used to log in to Mailtrap. Check the content, formatting, and overall appearance to make sure everything looks perfect.

Like what you see? If so, click the “Continue” button to proceed to importing your subscriber list.

Most email lists are stored in CSV files. Download the CSV template to ensure your file is correctly formatted, or use this template to complete your user database. Once your list is ready, add it and click “Import recipients.”

Review your CSV mapping and select the variables that will appear in each email. Once everything is set, confirm the mapping.

The import is complete. If any errors occur, you’ll see failed imports listed. You can go back to the mapping step to identify and fix the issue.

Hit the “Finish” button. Now you see all the data of your broadcast email campaign. From here, you can choose to send another test email, send an email now, or schedule it for later.

While scheduling, please note that the time zone is set to UTC

Confirm the sending and wait for emails to be dispatched. In the set date and time, your recipients will get your emails.

Send your First Marketing Campaign with Mailtrap

Email broadcasting best practices

Mass emailing can be very effective for your business if you follow industry best practices. Here are the main ones to always keep in mind.

Segment the audience

Unless you run a very specific, niche business in one particular location, it’s better to segment your subscribers. Divide your contact list into groups based on demographics, behavior, or interests to send more relevant content.

Personalize emails

The least that you can do is to refer to a subscriber by name in every email. However, you can go further and pick the content based on their past interactions, preferences, and behavior.

For example, send product recommendations that align with clients’ previous purchases or interests, and use dynamic content to ensure that each recipient sees the most relevant offers.

Keep it short and focused

If your store receives new products, highlight 5-7 in a newsletter rather than overwhelming subscribers with the entire collection. The same goes for news, updates, and events. Show some diversity, but avoid bombarding users with too much information at once.

Be consistent

Bulk emails are the most effective when sent regularly and at the right time. Start with a thorough content plan that includes your goals, frequency of communication, and content types you’ll be using.

Spend some time analyzing when your audience is most likely to open and read your emails. It might take a bit of experimenting, but once you nail it down, you’ll see better engagement and results.

Consistency is also crucial for your sender’s reputation. Internet and email providers monitor your sending habits to detect spam. Irregular or sporadic email activity can raise red flags, potentially harming your deliverability rates.

By consistently sending well-timed, relevant emails, you build trust not only with your audience but also with email providers, increasing the chances that your emails will land in inboxes rather than the spam folder

Add a straightforward call to action

Not every email needs a CTA. But if you want readers to take action, make it sound short, straightforward, and beneficial.

A/B Testing

A/B testing is the holy grail for all sorts of emails you plan to send. By experimenting with subject lines, images, fonts, and even tone of voice, you can identify what resonates best with your audience and significantly improve your email performance.

Schedule regular email marketing audit

By regularly reviewing your email campaigns, you can analyze the number of customers who open your emails, track your expenses, and pinpoint what is not performing as expected. This process also assists in identifying areas where resources may be wasted. With these insights, you can develop more robust and efficient email campaigns in the future.

Conclusion

In this post, I have covered the most common questions marketers have about email broadcasting. If you plan to closely work with emails in your application, then you might also need to check out the following blog posts:

Article by
Daria Roshchyna

We appreciate you chose this article to know how to send a broadcast email. Click here to find more interesting articles!

The Ins and Outs of POP 3 (Post Office Protocol 3)

Ivan Djuric — Wed, 21 Aug 2024 13:33:12 +0000

Navigating emails can be like driving a car – most of us know how to drive one, but not everyone understands what’s under the hood.

If you have ever opened a new email message and wondered what’s behind it, you’ve come to the right place.

In this article, I’m going to pop open the hood on POP3, one of the mail protocols responsible for retrieving the emails we receive every day. I’ll show you how it works and provide you with a step-by-step tutorial on how to test it out yourself by using some simple POP3 commands.

Don’t worry – it’s not rocket science. Let’s get straight into it!

What is POP3?

POP3, or Post Office Protocol version 3, is an Internet standard protocol that retrieves email messages from a server over a TCP/IP connection. It’s the third version of the Post Office Protocol 3, which is defined in RFC 1939.

Unlike Internet Message Access Protocol (IMAP), which stores your emails on the mail server, POP3 downloads them from the server to your device. It’s important to note that both are “email retrieval” or “pull protocols,” meaning they only receive new messages instead of sending them like Simple Mail Transfer Protocol (SMTP).

Read our article on IMAP vs POP3 for more information.

You can also watch our video tutorial to see what makes POP3 different from the IMAP pull protocol.

How does POP3 work?

POP3 connection is a 4-step process:

The email client connects to the mail server
The email client downloads new emails to the local device from the mail server
By default, the mail server deletes the stored messages
- Note: The protocol can be configured to temporarily save your emails on the server
The transmission ends when the client disconnects from the server

One of the easiest ways to understand POP3 is to think of the protocol as the mail clerk. In this analogy, your email would be physical mail, and the email server the post office.

Now, when you (acting as the email client) go to receive mail from the post office, the clerk (POP3) will give you all the new mail and let you collect (download) it, so you can bring it home (your local computer).

As it isn’t a common practice, the post office doesn’t make any copies of your mail, so the clerk will no longer have access to it once you’ve picked it up. However, you can ask the clerk to make a copy of your mail and keep it at the post office.

What POP3 is used for

Besides its basic functionality to download messages from the email server, POP3 can also be integrated with various APIs for advanced use cases, such as:

Custom API integration – If your business needs it, you can develop custom APIs that integrate with POP3 for specialized functions, like triggering actions in internal systems based on email content.
Analytics and data processing – Once you download your emails via POP3, you can integrate natural language processing (NLP) or text analysis APIs like Google Natural Language or IBM Watson Natural Language Understanding to analyze the content of those emails. This can be super useful for sentiment analysis, keyword extraction, etc.
Security and compliance – You can use POP3 to download emails and then work with security APIs such as VirusTotal or Proofpoint for threat detection, checking for spam, and phishing attempts.

Pros and Cons of POP3

I had a discussion on the advantages and disadvantages of POP3 with our deliverability specialist, Yaroslav, and here’s his breakdown of the protocol’s pros and cons.

Pros

Simple-to-use – POP3 is a straightforward protocol that focuses on delivering simplicity to the user. Implementing and using it is super easy, which makes it an ideal protocol for applications that require basic email functionalities.
Reduced server load – As POP3 downloads and deletes emails from the server by default, it keeps the server storage space manageable, which, in turn, reduces load.
Offline access – Because new emails are stored on your device, you will be able to manage them without an internet connection. This can be super useful for software that operates offline.
Bandwidth efficiency – POP3 minimizes the amount of data transferred between the email client and mail server as you don’t have to be connected to the internet all the time to see your emails. This goes a long way for slow internet connections with limited bandwidth.
Legacy system compatibility – If you’re working with legacy systems, POP3 is the perfect option for you as it’s compatible with most older systems and can be easily integrated with them. Besides POP3, you can also use legacy app modernization.
Supported by numerous email clients – As it’s been around for quite a while, many popular mail clients support POP3, such as Gmail, Mozilla Thunderbird, Apple Mail, Microsoft Outlook, and others.

Cons

Limited features – Simplicity, the protocol’s biggest advantage, might as well be its biggest disadvantage as it lacks features such as folder management, server-side searching, etc.
Risk of data loss – If you don’t configure your POP3 client to store messages on the server after downloading them, you’re essentially facing the risk of data loss as the local copies might be compromised due to hardware failure or malware attacks.
No synchronization – POP3 doesn’t synchronize emails across devices in real-time, which can be a major limitation if you access your emails on different devices. If you can’t live with this, then you might want to check out the two-way IMAP protocol.
No backup solution – The protocol doesn’t offer a backup solution, and as it downloads your messages locally, you will have to either configure it to keep your email on the server or back it up another way.
Limited scalability – Because of its limited set of features and server-side capabilities, POP3 isn’t the most optimal protocol for you if you’re building an application that scales with user growth.
Local storage space consumption – Although a benefit of POP3 is that it reduces server load, there’s a downside to it because all of the emails go to your local machine. This can be a huge issue if you’re dealing with large volumes of email or emails with large attachments or if you’re downloading all of your mail on a single device.

POP3 ports

For connecting to remote servers, the POP3 protocol typically uses two port numbers. Namely:

Port 110 – The non-encrypted, default port, typically used by older email clients, internal networks where external access isn’t an issue, or even for troubleshooting purposes.
Port 995 – The encrypted, more secure port which supports SSL/TLS connections. It’s used as standard by most webmail providers and preferred by the majority of users due to the security it provides.

POP3 settings

The most secure way of testing POP3 for yourself is to use OpenSSL, which encrypts your sensitive data. On top of that, I found it easy and efficient.

Just follow these steps:

Download and install the latest version of OpenSSL
Enable POP in your email provider settings, as it might be disabled by default
Open your command line interface
Connect to a POP3 server with openssls_client -connect pop.yourmailserver.com:995 -crlf
Make sure to replace yourmailserver with your provider’s domain name (e.g., gmail.com or mail.outlook)
If you use Windows OS, you should omit -crlf as it can lead to an error due to double conversion
Send the USER and PASS commands with your credentials. For example:
USER yourusername
PASS yourpassword
Note, that if you have two-factor authentication enabled, you should use your App password to log in (if you’re a Gmail user, make sure to remove spaces in the 16-digit password)
List all messages with the LIST command
Use the retr command followed by the message number to see every message header and the text. For instance:
retr 1
If you’re encountering SSL_renegotiate:wrong ssl version error, simply add -ign_eof at the end of the first command: **openssl s_client -connect pop.yourmailserver.com:995 -crlf -ign_eof

Enter QUIT to finish the session**

The process should look something like this:

Learn more about email protocols

See? Didn’t I tell you it’s not rocket science? We hope we’ve cleared some things up and helped you understand how POP3 works.

If you’re up for more reads, we recommend you go over our article comparing POP3, IMAP4, and SMTP and further expand your knowledge about protocols, which are just a part of email infrastructure.

Now, running a local mail server or integrating an email protocol within your app is one thing, but ensuring your emails are delivered is another. That’s why you should check out deliverability services, such as the Mailtrap email delivery platform, which combines API and SMTP service to make sure your emails get delivered where they’re supposed to and when they’re supposed to.

Good luck!

We appreciate you chose this article to discover what POP3 protocol is. To find even more useful information, click here!

Webhooks Explained

Ivan Djuric — Thu, 15 Aug 2024 09:34:24 +0000

So, what’s the catch with webhooks?

Not using them nowadays would be like commuting to work on a horse. Charming? Yes, definitely, but not very efficient I’m afraid.

In this article, I explain webhooks and provide you with all the technical tidbits you need to know in order to be webhook-fluent.

What are webhooks?

Webhooks are user-defined HTTP callback functions that allow two applications to communicate with each other. They operate via the web, and refer to hooks in software that trigger actions based on specific events. Hence, the name webhooks. 🪝

Put simply, webhooks are automated messages sent from apps when something happens.

You can think of them as hotel receptionists who, when a new guest arrives (specific event), update the hotel’s records (your app) and check the guests in. Similarly, if a new user registers on your website, a webhook will tell your app, which processes the registration and updates the database.

While user registrations are a common trigger, webhooks can be triggered for other events and have more complex use cases, which I delve into a bit later in the article.

How do webhooks work?

When a specified event triggers your app (e.g., a user registers), the webhook sends an HTTP request, which consists of:

Webhook URL – Indicates where you want to send the request.
Body (payload) – Contains the information you want to send to another app.
Header – Specifies how the information in the header is formatted (e.g., XML, JSON)
Request method – The request can either be GET, POST, PUT, or DELETE

Once the app receives the HTTP request from a webhook, it sends a response that lets your trigger app know if the request is completed successfully. Once processed and added to the database, every component of the request will be available on all client connections that may need the data it contains.

And don’t worry, I’ll also show you how webhooks work in detail via practical examples in a minute.

Webhooks vs API

Both webhooks and APIs (application programming interface) are equally important for communication between software. However, although they are similar in their essence, they work in vastly different ways.

Consider APIs and webhooks as siblings, and let’s say those siblings are on a road trip, sitting comfortably in the backseat. APIs will constantly ask: “Are we there yet? Are we there yet?.” In tech terms, this is called polling, a process that asks another system, or even another API, for an update to see if something has changed.

A webhook, on the other hand, is the silent type, the kid who tells you: hey, just let me know when we arrive!” and will elegantly leave when the car stops. Again, in tech terms, this is called pushing, a process that sends, or ‘pushes’ data to a client or server when a specific event occurs. Hence why webhooks are also known as ‘push APIs’ or ‘reverse APIs’.

In a nutshell:

APIs are a set of definitions and protocols that request information through polling, are more complex than webhooks, and are used for purposes such as retrieving data on demand.
Webhooks are a type of event-driven APIs that send information or perform specific functions in response to triggers (e.g., button clicks, user registrations, etc.).

If you’re interested in the more technical side of this comparison, check out the table below:

Webhooks vs WebSockets

As a user from a Stack Overflow thread would put it, webhooks and WebSockets solve different aspects of one problem in very different ways.

The main difference between the two is that webhooks are event-driven, acting only after a specific trigger. On the other hand, WebSockets keep the connection between two apps (or APIs) open, waiting for something to happen. This allows for real-time communication, updates, and synchronization between both sides of the ‘conversation.’

For a clearer picture, here’s how WebSockets work:

Initiation – The client starts a WebSocket connection to the server.
Open connection – Once open, the connection stays open.
Two-way communication – Both the client and the server have the ability to continuously send messages to each other.

Okay, now it’s time for, you guessed it, another allegory! If webhooks are hotel receptionists who only wait for someone to arrive, we can think of WebSockets as some kind of special (quite inefficient) receptionists who keep the doors open all the time, scouting for guests in front of the hotel, even if it’s a very, very slow night.

In a nutshell:

WebSockets provide a long-lived connection that allows a client and a server to send each other messages at any time. They are ideal for applications that require continuous data flow, such as financial trading platforms, live chats, etc.
Webhooks don’t keep an open connection and only perform specific functions in response to triggers.

And of course, a tech-table for all you lovers of geeky info out there:

What are webhooks used for?

Okay, now that you’re familiar with webhooks, it’s time to go over what they’re typically used for, which includes:

Real-time notifications – If you’re running an e-commerce platform, you can use webhooks to notify your inventory management system whenever a new order is placed.
Data synchronization – Have two or more systems in place? No problem, because webhooks can push notifications from one system to the other whenever a change happens (e.g., a user updates their profile).
Workflow automation – You can make a webhook trigger to send a notification in Slack whenever a new issue is created in a project management tool (e.g., Jira).
Monitoring and alerts – If you have a monitoring system in place, you can trigger your webhook to send an alert (via email, sms, etc.) to the responsible person/team whenever a server goes down.
API communication – Besides helping apps communicate, webhooks can also be middlemen in API communication. For instance, when a transaction is completed, a payment gateway can use webhooks to notify your application so your system can respond accordingly in time.
Third-party webhook integration – As you’ll shortly see, you can integrate webhooks with various third-party software, such as CRM systems, project management tools, e-commerce platforms, etc.

Examples of webhooks

Now, as promised, let me show you some real-world uses and examples of webhooks.

Slack

Slack allows you to modify the platform to send a notification to a channel whenever a critical error occurs in your web application. For example, when the error occurs, the webhook will send a detailed message to a specific Slack channel, with the payload containing all the details and a link to the logs.

Here’s an example of a JSON payload:

{
  "channel": "#alerts",
  "username": "ErrorBot",
  "text": "A critical error occurred in the web application:\n*Error Message:* Unexpected token in JSON\n*Timestamp:* 2024-07-25T14:30:00Z\n*Logs:* <http://example.com/logs/error-1234>",
  "icon_emoji": ":warning:"
}

And here’s a code breakdown with principles you can apply to other examples as well:

**"channel":** – Specifies the Slack channel where the message should be sent.
**"username":**– Sets the username that appears next to the message in the Slack channel.
**"text":** – The main content of the message that provides the information about the error.
**"icon_emoji":** – Sets the emoji that appears next to the message.

Also, did you know that you can combine Slack, Zapier, and ESPs? My colleague Piotr talks about it in his Slack email integration article.

GitHub

With GitHub webhooks, you can make a webhook send a notification to a CI/CD service to trigger a build when a new push is made to a repository.

Here’s what you’d have to do:

Go to your repository on GitHub
Navigate to Settings → Webhooks → Add webhook
Enter the Payload URL of your CI/CD service (e.g., Jenkins)
Select application/json as the Content type
Choose Just the push event for the event to trigger the webhook
Click Add webhook

Then, you need to set up a new job to handle builds in your CI/CD service and configure it to listen for incoming webhooks from GitHub. And finally, parse the incoming JSON payload to extract relevant information.

JSON example:

{
  "ref": "refs/heads/main",
  "before": "9c54a35c4d76d567bb5e4b2387bd2c5b4bc1c8d2",
  "after": "de8251ff97a4b5b2e8ad488ebcbd4b12c8d8b987",
  "repository": {
    "id": 123456,
    "name": "example-repo",
    "full_name": "user/example-repo"
  },
  "pusher": {
    "name": "user",
    "email": "user@example.com"
  },
  "commits": [
    {
      "id": "de8251ff97a4b5b2e8ad488ebcbd4b12c8d8b987",
      "message": "Fixed bug in API",
      "timestamp": "2024-07-25T14:30:00Z",
      "url": "https://github.com/user/example-repo/commit/de8251ff97a4b5b2e8ad488ebcbd4b12c8d8b987"
    }
  ]
}

Stripe

Now, let’s say you want to update the order status when a payment is successful. Who do you call? Stripe and webhooks, of course!

Here’s how the process would look like:

Log in to Stripe and navigate to Developers → Webhooks
Click Add endpoint
Enter the Endpoint URL of your server
Select the events you want to listen to (e.g., charge.succeeded)
Click Add endpoint

Then, you’d set up a route in your server to listen to incoming HTTP POST requests from Stripe, verify the Stripe signature, and parse the incoming JSON payload to extract new data.

JSON example:

{
  "id": "evt_1HUz9LFbuFVVSY1hKwJMcHmy",
  "object": "event",
  "api_version": "2020-08-27",
  "created": 1599677774,
  "data": {
    "object": {
      "id": "ch_1HUz8zFbuFVVSY1hkWfyJMWP",
      "object": "charge",
      "amount": 2000,
      "currency": "usd",
      "description": "Payment for order #1234",
      "status": "succeeded"
    }
  },
  "livemode": false,
  "type": "charge.succeeded"
}

With this setup, your server would process the payload and event type and elegantly update the order status in your database.

Moreover, you can even send a confirmation message with the payment details to the customer.

Shopify

Okay, so you’ve successfully set up webhooks to update orders, but how do you notify your packaging/delivery service that a new order has been created? It’s simple—set up a webhook in Shopify.

Source: Shopify.dev

And here’s how you can set them up:

Log in to your Shopify admin panel
Navigate to Settings → Notifications
Scroll down to Webhooks and click Create webhook
Select Event as Order creation
Enter the URL where you want to receive data
Choose JSON as the format and click Save webhook

The next few steps will sound familiar: set up a route in your server to handle POST requests from Shopify and (you know it by now) parse the incoming JSON payload to extract data:

{
  "id": 820982911946154508,
  "email": "user@example.com",
  "closed_at": null,
  "created_at": "2024-07-25T14:30:00-04:00",
  "updated_at": "2024-07-25T14:30:00-04:00",
  "number": 234,
  "note": null,
  "token": "1234567890abcdef",
  "gateway": "credit_card",
  "test": false,
  "total_price": "298.50",
  "subtotal_price": "298.50",
  "total_weight": 0,
  "total_tax": "0.00",
  "currency": "USD",
  "financial_status": "paid",
  "confirmed": true,
  "total_discounts": "0.00",
  "total_line_items_price": "298.50",
  "cart_token": null,
  "buyer_accepts_marketing": true,
  "name": "#1001",
  "total_price_usd": "298.50",
  "line_items": [
    {
      "id": 466157049,
      "variant_id": 39072856,
      "title": "Awesome Product",
      "quantity": 1,
      "price": "199.00",
      "sku": "12345",
      "variant_title": null,
      "vendor": "Awesome Vendor",
      "fulfillment_service": "manual",
      "product_id": 12345678,
      "requires_shipping": true,
      "taxable": true,
      "gift_card": false,
      "name": "Awesome Product",
      "variant_inventory_management": null,
      "properties": [],
      "product_exists": true,
      "fulfillable_quantity": 1,
      "grams": 0,
      "total_discount": "0.00",
      "fulfillment_status": null
    }
  ]
}

Mailtrap

I know, I know, this chapter seems like your typical CTA section where I ask you to buy something from us but trust me, I won’t. Providing a Mailtrap webhook example seemed only logical as I’m well acquainted with the platform.

Anyhow, let’s imagine you want to make your Laravel app send emails and keep an eye out on key deliverability metrics. In such a case, you could use Mailtrap webhooks, which will provide you with information on:

Deliveries
Bounces
Unsubscribes
Spam complaints
Rejections
Soft bounces
Suspensions
Opens
Clicks

And here’s a JSON example from our webhook documentation:

{
  "events": [
    {
      "event": "delivery",
      "email": "mike@mailtrap.io",
      "category": "Password reset",
      "message_id": "aaaaaaaa-bbbb-cccc-dddd-0123456789ab",
      "sending_stream": "bulk",
      "event_id": "aaaaaaaa-bbbb-cccc-ddd

To learn how to set them up, you can simply follow our in-depth knowledge base article.

When shouldn’t you use webhooks?

As with everything in life, even webhooks have their downsides. So, here are some cases when you shouldn’t use them:

High-frequency event triggers – Webhooks can become overwhelmed if your app generates a large number of events in a short period, which can lead to performance issues or, even worse, data loss.
Solution: Batch processing, message queues
Unreliable internet connection – Like hotel receptionists needing coffee to stay awake during long night shifts, webhooks need a stable internet connection to be reliable middlemen between the sender and the receiver. Without a stable connection, you risk facing data loss or delayed processing.
Solution: Regular polling, message queueing system
Handling sensitive data – If you’re handling sensitive data, you should be aware that webhooks can pose a security risk without any encryption or authentication system in place.
Solution: HMAC verification, IP whitelisting, SSL/TLS, authentication tokens, etc.

Lastly, I’d also suggest you pass webhooks if you think you don’t need to act on the data immediately. In such a case, you’d be better off using batch processing or simply regular polling.

Moreover, webhooks don’t support bi-directional syncs or HTTP action methods such as PATCH or DELETE. For these purposes, APIs would be your best bet.

Wrapping up

And there you have it; now you know what the catch is with webhooks!

If you want to cement your knowledge, why not try out webhooks yourself and learn in practice by trial and error? For this, I recommend following our step-by-step tutorial on using webhooks.

Bonus tip: you can test webhooks on the conveniently named Webhooks.site.

Up for more reads? I found the original article about webhooks from 2007, written by their creator, John Lindsay, super interesting. Or, even better, visit the Mailtrap blog and read all things email!

We appreciate you chose this article to find the examples of webhooks. If you want to discover more useful information on related topics, follow Mailtrap blog!

How to Send Emails with Email API: Practical Examples in Popular Languages and Frameworks

Ivan Djuric — Tue, 02 Jul 2024 17:27:45 +0000

In this article, I’ll show you how to send emails using an email API in various programming languages and frameworks.

I’ll also break down the differences between SMTP and email APIs, but if you’re already aware of them and your needs, feel free to skip ahead by clicking on some of the following links:

Note that as my API of choice, I’ll be using Email API, a part of the Mailtrap Email Delivery Platform. However, the core principles in this article can be applied to any email API provider.

Setting up Mailtrap Email API

Mailtrap Email API is based on the REST principles, which classifies it as REST, or RESTful API. These types of APIs offer greater flexibility and, as you’ll notice, are super easy to work with as they use standard HTTP methods (e.g., GET, POST, PUT, DELETE), which most developers are familiar with.

Here’s what you need to do to get started with Mailtrap API and integrate it into your project:

Sign up for a free Mailtrap account: You can sign up using your Google, GitHub, or Office 365 accounts, or, if you prefer, simply use your email address.

Verify your domain: Navigate to the “Sending Domains” tab and click “Add Domain.” Enter your domain name and confirm by clicking the “Add” button.

Update DNS records: Mailtrap will provide and automatically authenticate specific DNS records (SPF, DKIM, DMARC) that should be added to your domain provider’s DNS settings.

Tip: here’s a detailed Getting Started Guide to help you out. 👀

Once your domain is verified, you can integrate your application with Mailtrap’s Email API.

Access API credentials: Go to the Sending Domains tab, select your verified domain, and open the “Integration” tab. Here, you’ll find credentials for both Transactional and Bulk streams.

Build your HTTP request: Use the provided API credentials to configure an authenticated HTTP request in your preferred programming language or framework.
- Mailtrap also offers and maintains official SDKs for PHP, Python, Ruby, Node.js, and Elixir. I’ll show you how to use them in a jiffy.
Run your script: Execute your email sending script. If everything is set up correctly, your email will land in the recipient’s inbox, and you will see it in the “Email Logs” section.

Note: Each domain has unique API tokens. To manage these, go to Settings → API Tokens and click “Add Token” if you need additional tokens. Additionally, Mailtrap’s API supports email templates, attachments, custom variables, and email categories. For detailed information, check the API documentation.

Send emails in PHP

For a comprehensive guide on sending emails in PHP, read the full article here

Since we already covered the Mailtrap installation process, let’s start by integrating the Mailtrap PHP SDK.

First, install Mailtrap PHP SDK using one of the following Composer commands:

With Symfony HTTP client: composer require railsware/mailtrap-php symfony/http-client nyholm/psr7
With Guzzle HTTP client: composer require railsware/mailtrap-php guzzlehttp/guzzle php-http/guzzle7-adapter

Note: Mailtrap API Client uses PSR-18 client abstraction and is thus not hard-coupled to any library that sends HTTP messages. It gives you the flexibility to choose which HTTP client you want to use.

However, it’s recommended to use Symfony for its fast performance, ease of use, flexibility, and strong community support.

Next, using the below code, you can send a plain text email using the Mailtrap PHP SDK:

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

require __DIR__ . '/vendor/autoload.php';

// Your API token from here https://mailtrap.io/api-tokens
$apiKey = getenv('MAILTRAP_API_KEY');
$mailtrap = new MailtrapClient(new Config($apiKey));

$email = (new Email())
    ->from(new Address('example@your-domain-here.com', 'Mailtrap Test'))
    ->replyTo(new Address('reply@your-domain-here.com'))
    ->to(new Address('email@example.com', 'Jon')) // Single recipient
    ->priority(Email::PRIORITY_HIGH)
    ->subject('Best practices of building HTML emails')
    ->text('Hey! Learn the best practices of building HTML emails and play with ready-to-go templates. Mailtrap's Guide on How to Build HTML Email is live on our blog');

// Headers
$email->getHeaders()
    ->addTextHeader('X-Message-Source', 'domain.com')
    ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client')); // the same as addTextHeader

// Custom Variables
$email->getHeaders()
    ->add(new CustomVariableHeader('user_id', '45982'))
    ->add(new CustomVariableHeader('batch_id', 'PSJ-12'));

// Category (should be only one)
$email->getHeaders()
    ->add(new CategoryHeader('Integration Test'));

try {
    $response = $mailtrap->sending()->emails()->send($email); // Email sending API (real)

    var_dump(ResponseHelper::toArray($response)); // body (array)
} catch (Exception $e) {
    echo 'Caught exception: ',  $e->getMessage(), "\n";
}

This script initializes the Mailtrap client with your API key, which can be found in the Integration tab under the Sending Domains section.

It then creates a new email message and sets various properties, such as the sender, recipient, subject, and content. Additionally, it adds custom headers and variables.

Finally, the script sends the email using the send() function and outputs the response or an error message if the email fails to send.

HTML email

Sending HTML emails in PHP couldn’t be easier as all you need to do is add the ->html() method.

To save you some time, I’ve prepared a code you can use to send an HTML email to multiple recipients and attach files to it:

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;
use Symfony\Component\Mime\Part\DataPart;

require __DIR__ . '/vendor/autoload.php';

// Your API token from here https://mailtrap.io/api-tokens


$apiKey = “MAILTRAP_API_KEY”;
$mailtrap = new MailtrapClient(new Config($apiKey));

$email = (new Email())
    ->from(new Address('example@your-domain-here.com', 'Mailtrap Test'))
    ->replyTo(new Address('reply@your-domain-here.com'))
    ->to(new Address('email@example.com', 'Jon'))
    ->priority(Email::PRIORITY_HIGH)
    ->cc('mailtrapqa@example.com')
    ->addCc('staging@example.com')
    ->bcc('mailtrapdev@example.com')
    ->subject('Best practices of building HTML emails')
    ->text('Hey! Learn the best practices of building HTML emails and play with ready-to-go templates. Mailtrap's Guide on How to Build HTML Email is live on our blog')
    ->html(
        '<html>
        <body>
        <p><br>Hey</br>
        Learn the best practices of building HTML emails and play with ready-to-go templates.</p>
        <p><a href="https://mailtrap.io/blog/build-html-email/">Mailtrap's Guide on How to Build HTML Email</a> is live on our blog</p>
        <img src="cid:logo">
        </body>
    </html>'
    )
    ->embed(fopen('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg', 'r'), 'logo', 'image/svg+xml');

// Add an attachment
$email->attachFromPath('/path/to/your/file.pdf', 'Filename.pdf', 'application/pdf');

// Headers
$email->getHeaders()
    ->addTextHeader('X-Message-Source', 'domain.com')
    ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client')); // the same as addTextHeader

// Custom Variables
$email->getHeaders()
    ->add(new CustomVariableHeader('user_id', '45982'))
    ->add(new CustomVariableHeader('batch_id', 'PSJ-12'));

// Category (should be only one)
$email->getHeaders()
    ->add(new CategoryHeader('Integration Test'));

try {
    $response = $mailtrap->sending()->emails()->send($email); // Email sending API (real)

    var_dump(ResponseHelper::toArray($response)); // body (array)
} catch (Exception $e) {
    echo 'Caught exception: ',  $e->getMessage(), "\n";
}

Send emails in Laravel

To quickly integrate the Mailtrap email API into your Laravel application, you can use the official PHP SDK and docs for the Laravel framework bridge. The Mailtrap library is also fully compatible with Laravel 9.x and above.

For more information, read our complete guide on sending emails in Laravel which covers different sending methods as well.

Nonetheless, here’s an example of sending plain-text emails in Laravel;

Install the Mailtrap PHP client and dependencies using composer: composer require railsware/mailtrap-php symfony/http-client nyholm/psr7
Next, add Mailtrap transport into your config/mail.php file:

<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Mailer Configurations
    |--------------------------------------------------------------------------
    */
    'mailers' => [

            // start mailtrap transport
            'mailtrap' => [
                'transport' => 'mailtrap'
            ],
            // end mailtrap transport

    ]
];

Now, to the Laravel .env file, add your Mailtrap credentials:

MAIL_MAILER="mailtrap"
MAILTRAP_HOST="send.api.mailtrap.io"
MAILTRAP_API_KEY="YOUR_API_KEY_HERE"
MAIL_FROM_ADDRESS="name@registered_domain.com"

To send the email, create a mailable class: php artisan make:mail WelcomeMail
Open the newly created WelcomeMail.php file in app/Mail directory, and configure it as follows:

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Attachment;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Headers;
use Illuminate\Queue\SerializesModels;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

class WelcomeMail extends Mailable
{
    use Queueable, SerializesModels;

    private string $name;

    /**
     * Create a new message instance.
     */
    public function __construct(string $name)
    {
        $this->name = $name;
    }

    /**
     * Get the message envelope.
     */
    public function envelope(): Envelope
    {
        return new Envelope(
            from: new Address('jeffrey@example.com', 'Jeffrey Way'),
            replyTo: [
                      new Address('taylor@example.com', 'Taylor Otwell'),
                  ],
            subject: 'Welcome Mail',
            using: [
                      function (Email $email) {
                          // Headers
                          $email->getHeaders()
                              ->addTextHeader('X-Message-Source', 'example.com')
                              ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
                          ;

                          // Custom Variables
                          $email->getHeaders()
                              ->add(new CustomVariableHeader('user_id', '45982'))
                              ->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
                          ;

                          // Category (should be only one)
                          $email->getHeaders()
                              ->add(new CategoryHeader('Integration Test'))
                          ;
                      },
                  ]
        );
    }

    /**
     * Get the message content definition.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail.welcome-email',
            with: ['name' => $this->name],
        );
    }

    /**
     * Get the attachments for the message.
     *
     * @return array<int, \Illuminate\Mail\Mailables\Attachment>
     */
    public function attachments(): array
    {
        return [
           Attachment::fromPath('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg')
                ->as('logo.svg')
                ->withMime('image/svg+xml'),
        ];
    }

    /**
     * Get the message headers.
     */
    public function headers(): Headers
    {
        return new Headers(
            'custom-message-id@example.com',
            ['previous-message@example.com'],
            [
                'X-Custom-Header' => 'Custom Value',
            ],
        );
    }
}

Create a Blade view template for your email in resources/views/emails/welcome.blade.php:

<p>Hey {{$name}}!</p>
<br>
<p>Welcome to the party! You've just joined the coolest club in town.</p>

To the app/routes/console.php file, add the CLI router:

<?php

use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Mail;

/*
|--------------------------------------------------------------------------
| Console Routes
|--------------------------------------------------------------------------
|
*/

Artisan::command('send-welcome-mail', function () {
    Mail::to('testreceiver@gmail.com')->send(new WelcomeMail("Jon"));
    // Also, you can use specific mailer if your default mailer is not "mailtrap" but you want to use it for welcome mails
    // Mail::mailer('mailtrap')->to('testreceiver@gmail.com')->send(new WelcomeMail("Jon"));
})->purpose('Send welcome mail');

Lastly, to send your email, call the CLI command: php artisan send-welcome-mail

HTML email

To send an HTML email via Laravel, all you have to do is add HTML code to the Blade file we previously created (e.g., welcome.blade.php).

For a basic HTML message, use the code below:

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">

    <style>
        p {
            font-size: 12px;
        }

        .signature {
            font-style: italic;
        }
    </style>
</head>
<body>
<div>
    <p>Hey {{ $name }},</p>
    <p>Can your Laravel app send emails yet? 😉 </p>
    <p class="signature">Mailtrap</p>
</div>
</body>
</html>

If you want to customize your HTML emails further, be sure to give our Laravel HTML article a read.

Send emails in Python

Below I’ll show a basic example of how to send an email in Python. However, if you’d like to understand how to handle more complex email-sending scenarios in Python, I recommend reading our dedicated article on this topic.

Similarly to other languages and frameworks, once the Mailtrap account is all set, I’ll use Mailtrap’s official Python SDK to streamline the process of sending emails via the API in Python.

Here’s how it works:

Open your terminal and run the following command: pip install mailtrap
Send a plain-text email by running this script:

from mailtrap import Mail, Address, MailtrapClient

# Create a Mail object with basic details for a plain text email
mail = Mail(
    # Specify the sender's email address and optional name
    sender=Address(email="mailtrap@example.com", name="Mailtrap Test"),
    # Specify one or more recipients; here we use a list with a single recipient
    to=[Address(email="your@email.com", name="Your Name")],
    # Subject of the email
    subject="Simple Plain Text Email",
    # The plain text content of the email
    text="This is a plain text email sent using the Mailtrap SDK. Simple and straightforward.",
    # Optional: categorize this email for easier sorting or management in the Mailtrap service
    category="Test",
    # Optional: Additional headers can be specified, but are not required for plain text emails
    headers={"X-Example-Header": "HeaderValue"}
)

# Initialize the MailtrapClient with your API token
client = MailtrapClient(token="your-api-key")

# Send the email using the client's send method
client.send(mail)

print("Plain text email sent successfully.")

Don’t forget to insert your Mailtrap credentials (e.g., verified sending domain and API key).

HTML email

To send an HTML email, simply adjust the script above by specifying the html parameter in the Mail object with the HTML content. Like so:

from mailtrap import Mail, Address, MailtrapClient

# Create a Mail object for sending an HTML email
mail = Mail(
    sender=Address(email="mailtrap@example.com", name="Mailtrap Test"),
    to=[Address(email="recipient@email.com", name="Recipient Name")],
    subject="Your HTML Email Subject Here",
    text="This is a fallback text for email clients that don't render HTML",
    html="""
    <!DOCTYPE html>
    <html>
        <head>
            <title>Email Title</title>
        </head>
        <body>
            <h1>Hello, World!</h1>
            <p>This is an <strong>HTML email</strong> sent from the Mailtrap Python SDK.</p>
            <p>Here's a link: <a href="https://example.com">Visit Example.com</a></p>
        </body>
    </html>
    """,
    # You can categorize this email or add custom headers as needed
    category="HTML Email",
    headers={"X-Custom-Header": "Value"}
)

# Initialize the MailtrapClient with your API token
client = MailtrapClient(token="your-api-key")

# Send the email
client.send(mail)

print("HTML email sent successfully.")

Send emails in Node.js

In this chapter, I’ll show you how to add email-sending functionality to your Node.js application with Mailtrap’s official SDK that allows easy integration.

The examples I’ll show you will be basic, but, if you’re feeling dev-savvy, feel free to check out our detailed article on sending emails in Node.js.

Now, let’s start by installing Mailtrap Node.js package with either npm or yarn:

npm install mailtrap

# or, if you are using yarn:

yarn add mailtrap

Then, send a plain text email by running the following code:

import { MailtrapClient } from "mailtrap"

/**
 * For this example to work, you need to set up a sending domain,
 * and obtain a token that is authorized to send from the domain.
 */

const TOKEN = "<YOUR-TOKEN-HERE>";
const SENDER_EMAIL = "<SENDER ADDRESS@YOURDOMAIN.COM>";
const RECIPIENT_EMAIL = "<RECIPIENT@EMAIL.COM>";

const client = new MailtrapClient({ token: TOKEN });

const sender = { name: "Mailtrap Test", email: SENDER_EMAIL };

client
  .send({
    from: sender,
    to: [{ email: RECIPIENT_EMAIL }],
    subject: "Hello from Mailtrap!",
    text: "Welcome to Mailtrap Sending!",
  })
  .then(console.log)
  .catch(console.error);

As Mailtrap’s Node.js package uses ECMAScript (ES) modules, I suggest adding “type:” “module” in your package.json file.

HTML email

Use the following code snippet to send an HTML email:

import { MailtrapClient } from "mailtrap"

/**
 * For this example to work, you need to set up a sending domain,
 * and obtain a token that is authorized to send from the domain.
 * @see https://help.mailtrap.io/article/69-sending-domain-setup
 */

const TOKEN = "<YOUR-TOKEN-HERE>";
const SENDER_EMAIL = "<SENDER@YOURDOMAIN.COM>";
const RECIPIENT_EMAIL = "<RECIPIENT@EMAIL.COM>";

const client = new MailtrapClient({ token: TOKEN });

client
  .send({
    category: "test",
    custom_variables: {
      hello: "world",
      year: 2022,
      anticipated: true,
    },
    from: { name: "Mailtrap Test", email: SENDER_EMAIL },
    to: [{ email: RECIPIENT_EMAIL }],
    subject: "Hello from Mailtrap!",
    html: `
    <!doctype html>
    <html>
      <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      </head>
      <body style="font-family: sans-serif;">
        <div style="display: block; margin: auto; max-width: 600px;" class="main">
          <h1 style="font-size: 18px; font-weight: bold; margin-top: 20px">Congrats for sending test email with Mailtrap!</h1>
          <p>Inspect it using the tabs you see above and learn how this email can be improved.</p>
          <p>Now send your email using our fake SMTP server and integration of your choice!</p>
          <p>Good luck! Hope it works.</p>
        </div>
        <!-- Example of invalid for email html/css, will be detected by Mailtrap: -->
        <style>
          .main { background-color: white; }
          a:hover { border-left-width: 1em; min-height: 2em; }
        </style>
      </body>
    </html>
  `,
  })
  .then(console.log)
  .catch(console.error);

Test emails and email sending on staging

This article has ~4,000 words and about 50% of that is code only. Considering this, you can easily imagine the not-so-small potential for errors while implementing the code into your app.

Hence, it’s of utmost importance to test your email-sending functionality. This is an industry-standard practice that ensures your code works properly, your emails are going where they’re supposed to while avoiding spam filters, and much more.

Consider it as tasting a dish you’ve just prepared. After putting in all the effort to make it, you wouldn’t want to serve an omelette that’s not salty at all, would you? 🧂

For this purpose, especially if you’ve used our email API for sending, I recommend using Mailtrap Testing API.

Via Mailtrap Testing API, you can run the following commands:

Inbox – Create new inboxes, reset credentials, receive messages, clean one or all messages in the inbox, mark messages as read, and manage users.
Project – Create new projects, update/delete them, and manage their users.

Email content – Inspect the raw HTML (you can also download it), text, and get detailed info about the HTML part, including a list of possible errors, along with message attachments.

Bcc and message headers – Receive and test message headers.

Deliverability – You get a SPAM report, domain blacklisting details, and a spam score, which if you keep under 5, can proactively solve potential problems such as hitting the spam filters and ending up in the junk folder.

With the Email Testing API, you can also test your templates. Simply enable sandbox, specify the inbox ID, receive template test, and then send it through the API in the production environment.

Lastly, Mailtrap Email Testing API is quite easy to integrate for testing, automation, and testing automated sequences.

For example, here’s how you would test emails using Python and Mailtrap Email Testing API:

Establish a connection to the API endpoint using http.client.HTTPSConnection.
Define your email content (e.g., recipients, sender, subject, text content, attachments, etc.)
Make a POST request to the API with your payload and necessary headers, including your API token for authorization. Here’s how it looks in practice:

import http.client
import json

def test_send_email():
    conn = http.client.HTTPSConnection("sandbox.api.mailtrap.io")

    payload = {
        "to": [{"email": "john_doe@example.com", "name": "John Doe"}],
        "cc": [{"email": "jane_doe@example.com", "name": "Jane Doe"}],
        "bcc": [{"email": "james_doe@example.com", "name": "Jim Doe"}],
        "from": {"email": "sales@example.com", "name": "Example Sales Team"},
        "attachments": [
            {
                "content": "base64_encoded_content_here",
                "filename": "index.html",
                "type": "text/html",
                "disposition": "attachment"
            }
        ],
        "custom_variables": {"user_id": "45982", "batch_id": "PSJ-12"},
        "headers": {"X-Message-Source": "dev.mydomain.com"},
        "subject": "Your Example Order Confirmation",
        "text": "Congratulations on your order no. 1234",
        "category": "API Test"
    }

    headers = {
        'Content-Type': "application/json",
        'Accept': "application/json",
        'Api-Token': "your_api_token_here"  # Replace with your real API token
    }

    # Convert the payload to a JSON string
    json_payload = json.dumps(payload)

    # Make the POST request
    conn.request("POST", "/api/send/inbox_id", json_payload, headers)  # Replace 'inbox_id' with your real inbox ID

    # Get the response
    response = conn.getresponse()
    data = response.read()

    print(data.decode("utf-8"))

if __name__ == "__main__":
    test_send_email()

Of course, if you’re interested in more information, be sure to check the API docs for details on API testing.

[Test Emails with Mailtrap for Free](https://mailtrap.io/register/signup)

Wrapping up

Whether you’ve opted for sending emails with API or, perhaps, with SMTP, I hope you now have a better understanding of the intricacies involved in the email backend.

And one more thing: I heartily invite you to further explore our blog, where you can learn how to send emails in various languages and frameworks and read articles such as:

We appreciate you chose this article to know more about methods of sending emails via API and SMTP. To read more articles on related topics, follow Mailrap Blog!

Node.js Contact Form: How to Create One, Validate Data, and Send Emails

Ivan Djuric — Fri, 31 May 2024 13:50:02 +0000

In this step-by-step tutorial, I’ll show you how to create a Node.js contact form, give it a personal touch, retrieve and validate data from it, and then send emails through the form via SMTP or API.

Note: you’ll need Node.js 6+ or any version released since May 2018 installed on your machine for the provided code snippets to work.

How to create a Node.js contact form

As you’re reading this article, I’m assuming you know how to install Node.js and create a new project, so allow me to keep it brief and get straight into setting up the project.

However, to freshen up your knowledge, you can check out this article on installing Node.js.

Setting up the project

First things first, let’s install some dependencies for our backend by opening the terminal and entering the following commands:

**mkdir contact-form-test && cd contact-form-test** – By running this command, we create a folder for our project, ensuring our project file will be within it instead of the current directory.
**npm init -y** – This will create a package.json file that manages project dependencies and configurations.
**npm i express nodemailer** – We need to install Express.js library and Nodemailer module as we will need them for setting up our server and sending emails with SMTP, respectively.
**npm i -D nodemon** – This is a dev dependency that automates the process of restarting our server whenever we change our code, allowing us to see the changes we made without having us manually restart the server.

Once you install all the dependencies, your package.json file should look something like this:

{
  "name": "contact-form-test",          // Project name
  "version": "1.0.0",                   // Project version
  "description": "",                    // Description of the project
  "main": "server.js",                  // Entry point file of the project
  "scripts": {
    "dev": "nodemon --watch public --watch server.js --ext js,html,css", // Script to run the server with nodemon for development
    "start": "node server.js"           // Script to start the server normally
  },
  "keywords": [],                       // Keywords related to the project
  "author": "",                         // Author of the project
  "license": "ISC",                     // License type
  "dependencies": {
    "express": "^4.19.2",               // Express web server framework
    "nodemailer": "^6.9.13"             // Nodemailer for sending emails via SMTP
  },
  "devDependencies": {
    "nodemon": "^3.1.0"                 // Nodemon for automatically restarting the server on code changes
  }
}

Bonus tips:

**npm i dotenv** – Although optional, this command installs the dotenv package, which loads environment variables where you can safely store your authentication credentials such as an API key. All you have to do is run the command, create an .env file in the root of your project directory, and paste your desired creds in there.
Starting from v20.6.0, Node.js has built-in support for .env files for configuring environment variables. So it is not necessary to use the dotenv package, but a lot of projects still depend on dotenv, so it’s still the de facto standard.

Configuring the server

Next, in our project folder, let’s create a new .js file called server.js which we refer to in the production script from the package.json file.

Then, simply paste the following code snippet into the server.js file:

const express = require('express');
const app = express();
const path = require('path');


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


// Middleware
app.use(express.static('public'));
app.use(express.json());


app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'contactform.html'));
});


app.post('/send-email', (req, res) => {
    console.log(req.body);
    res.send('Data received');
});


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

Note: Later in the article, we’ll use the server.js file to add Nodemailer as a transport via SMTP and an API logic to send emails through our contact form.

Creating the contact form

Now, let’s create a new public folder called public for the static files (style.css, contactform.html, and app.js) we’re going to be using for this contact form.

In the contactform.html file, enter the following code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8"> <!-- Specifies the character encoding for the HTML document -->
    <link rel="stylesheet" href="/style.css"> <!-- Link to external CSS file for styling -->
    <link rel="preconnect" href="https://fonts.gstatic.com"> <!-- Preconnect to load fonts faster -->
    <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet"> <!-- Google fonts link for 'Poppins' font -->
    <meta name="viewport" content="width=device-width, initial-scale=1.0"> <!-- Responsive design meta tag -->
    <title>Contact Form</title> <!-- Title of the document shown in the browser tab -->
</head>
<body>
    <div class="form-container"> <!-- Container for the form to style it specifically -->
        <form class="contact-form"> <!-- Form element where user inputs will be submitted -->
            <h2>CONTACT</h2> <!-- Heading of the form -->
            <input type="text" id="name" placeholder="Full name"><br> <!-- Input field for name -->
            <input type="email" id="email" placeholder="Email"><br> <!-- Input field for email, validates email format -->
            <input type="text" id="subject" placeholder="Subject"><br> <!-- Input field for subject -->
            <textarea id="message" placeholder="Message" cols="30" rows="10"></textarea><br> <!-- Textarea for longer message input -->
            <input type="submit" class="submit" value="Send Message"> <!-- Submit button to send the form data -->
        </form>
    </div>
    <script src="/app.js"></script> <!-- Link to external JavaScript file for scripting -->
</body>
</html>

I’ve added annotations in this code snippet as well to help you navigate through it, but feel free to delete them for a cleaner-looking code. 🙂

Styling the contact form

How about we tackle the frontend for a bit and add a personal touch to our contact form?

In the style.css file, enter the following code which will make our contact form prettier:

/* Global styles for all elements to ensure consistency */
* {
    margin: 0;                          /* Remove default margin */
    padding: 0;                         /* Remove default padding */
    box-sizing: border-box;             /* Include padding and border in the element's total width and height */
    font-family: 'Poppins', sans-serif; /* Set a consistent font family throughout the app */
}


/* Styling for the html and body elements */
html, body {
    background: #c0b7b7;                /* Set the background color for the entire page */
}


/* Container for the form providing relative positioning context */
.form-container {
    position: relative;                 /* Positioning context for absolute positioning inside */
    left: 20%;                          /* Position the container 20% from the left side of the viewport */
    width: 60%;                         /* Set the width of the container to 60% of the viewport width */
    height: 100vh;                      /* Set the height to be 100% of the viewport height */
    background-color: white;            /* Set the background color of the form container */
}


/* Styling for the contact form itself */
.contact-form {
    position: absolute;                 /* Position the form absolutely within its parent container */
    top: 10%;                           /* Position the form 10% from the top of its container */
    left: 10%;                          /* Position the form 10% from the left of its container */
    width: 80%;                         /* The form width is 80% of its container */
    min-height: 600px;                  /* Minimum height for the form */
}


/* Styling for input fields and textarea within the form */
input, textarea {
    width: 100%;                        /* Make input and textarea elements take up 100% of their parent's width */
    margin-top: 2rem;                   /* Add top margin to space out the elements */
    border: none;                       /* Remove default borders */
    border-bottom: 1px solid black;     /* Add a bottom border for a minimalistic look */
    padding: 10px; /* Add padding for better readability */
}


/* Styling for the submit button */
.submit {
    border: 1px solid black;            /* Add a solid border around the submit button */
    padding: 1rem;                      /* Add padding inside the button for better clickability */
    text-align: center;                 /* Center the text inside the button */
    background-color: white;            /* Set the background color of the button */
    cursor: pointer;                    /* Change the cursor to a pointer to indicate it's clickable */
}


/* Styling for the submit button on hover */
.submit:hover {
    opacity: 0.6;                       /* Change the opacity when hovered to give a visual feedback */
}

To see how your contact form looks, you can save the file and enter the following command in your terminal:

npm run dev

Then, you should see the message saying that your contact form is being hosted on the custom port you defined in your .env file or the default port 3000, which allows traffic to reach it.

Finally, paste the following link in your browser’s URL bar: http://localhost:3000/ and you should see your contact form in its full glory.

How to collect data from a Node.js contact form

To collect data from our Node.js contact form, we will add functionality for handling form submissions using JavaScript, which will capture form data and send it to the server without reloading the page.

For this, we’ll use an AJAX request, which allows us to avoid a full-page reload.

I’ve made this easy for you, so all you have to do is navigate to your app.js file and enter the following code:

const contactForm = document.querySelector('.contact-form');
const name = document.getElementById('name');
const email = document.getElementById('email');
const subject = document.getElementById('subject');
const message = document.getElementById('message');


contactForm.addEventListener('submit', (e) => {
    e.preventDefault();  // Prevent the default form submission


    const formData = {
        name: name.value,
        email: email.value,
        subject: subject.value,
        message: message.value
    };


    try {
        const response = await fetch('/send-email', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(formData)
        });


        // Wait for JSON response to be parsed
        const result = await response.json();


        if (!response.ok) {
            // If the response is not OK, handle it by showing an alert
            alert(`Failed to send message: ${result.message}`);
            return;  // Exit the function early if there's an error
        }


        // Check application-specific status from JSON when response is OK
        if (result.status === 'success') {
            alert('Email sent');


            // Reset form fields after successful submission
            name.value = '';
            email.value = '';
            subject.value = '';
            message.value = '';
        } else {
            // Handle application-level failure not caught by response.ok
            alert('Operation failed: ' + result.message);
        }


    } catch (error) {
        // Handle any exceptions that occur during fetch
        console.error('Error:', error);
        alert('Network error or cannot connect to server');
    }


});

Note: I used the fetch API here which is a more modern alternative to ‘XMLHttpRequest’ and leverages async/await syntax for better error handling.

How to validate data from a contact form

To validate data from a contact form in Node.js, you can either use:

Deep email validator – A comprehensive, MIT-certified, dependency package that makes sure an email is valid by running it through several different checks. It validates RegEx, common typos, disposable email blacklists, DNS records, and SMTP server responses.
Regex expressions – Patterns used to match character combinations in strings, ensuring that inputs conform to a predefined format. They provide a more basic level of validation compared to dependency packages like Deep email validator.

Deep email validator module

To install the Deep email validator, I typically use the npm command or Yarn:

npm i deep-email-validator

# or

yarn add deep-email-validator

Then after importing const { validate } = require('deep-email-validator'); simply add the following code in your /send-email controller:

// Endpoint to handle form submission and send email
app.post('/send-email', async (req, res) => {
   const { name, email, subject, message } = req.body;


   if (!name || !email || !subject || !message) {
       return res.status(400).json({ status: 'error', message: 'Missing required fields!' })
   }


   // Validate the email
   const validationResult = await validate(email);


   if (!validationResult.valid) {
       return res.status(400).json({
           status: 'error',
           message: 'Email is not valid. Please try again!',
           reason: validationResult.reason
       });
   }


   // Email sending logic


   // Placeholder response for a successful email submission
   res.status(200).json({
       status: 'success',
       message: 'Email successfully sent'
   });
});

For more information on Deep email validator, consult the official GitHub page.

Regular expressions for email validation

If you’d rather run basic ReGex checks against the email IDs instead of using a dependency package, you can paste the following code into your project file (e.g., server.js):

const emailRegex = 

/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/


function isEmailValid(email) {
    // Check if the email is defined and not too long
    if (!email || email.length > 254) return false;

    // Use a single regex check for the standard email parts
    if (!emailRegex.test(email)) return false;

    // Split once and perform length checks on the parts
    const parts = email.split("@");
    if (parts[0].length > 64) return false;

    // Perform length checks on domain parts
    const domainParts = parts[1].split(".");
    if (domainParts.some(part => part.length > 63)) return false;

    // If all checks pass, the email is valid
    return true;
}

Then in your /send-email route add the following code to perform email validation:

// Endpoint to handle form submission and send email
app.post('/send-email', async (req, res) => {
   const { name, email, subject, message } = req.body;


   if (!name || !email || !subject || !message) {
       res.status(400).json({ status: 'error', message: 'Missing required fields!' })
   }


   // Validate the email
   if (!isEmailValid(email)) {
       return res.status(400).json({
           status: 'error',
           message: 'Email is not valid. Please try again!'
       });
   }


   // Email sending logic


   // Placeholder response for a successful email submission
   res.status(200).json({
       status: 'success',
       message: 'Email successfully sent'
   });
});

For more details on validating emails in Node.js, feel free to consult our dedicated article, where you can also learn how to verify emails by sending an activation link/code the end users activate from their inbox.

How to add reCAPTCHA

Now, let’s add a reCAPTCHA to our Node.js contact form to make sure no robots fill it out. 🤖

First, you need to get your ‘SITE KEY’ and ‘SECRET KEY’ from the Google reCAPTCHA admin console.

In this example we will be using Challenge (v2), so be sure to select it during creation and leave the default “I’m not a robot Checkbox”.

Also, since we are testing from a local computer we need to add ‘localhost’ to allowed domains during creation.
Note: if you are in production you would need to use your own domains. And to use this code, simply copy your SITE KEY and SECRET KEY.

Next, in our contactform.html, add the following code snippet just before the closing of the head section:

<script src="https://www.google.com/recaptcha/api.js" async defer></script> <!-- Load google recaptcha API -->

Inside our form, we can add the reCAPTCHA element after the textarea like this:

<div class="g-recaptcha" data-sitekey="YOUR_SITE_KEY"></div><br> <!-- Google recaptcha element -->

Important: don’t forget to replace YOUR_SITE_KEY with your actual SITE KEY.

Then, we need to update our app.js inside the public folder to pass the reCAPTCHA token to our **formData** so the backend can verify it. To do this, after the e.preventDefault(); paste the following code :

// Get the reCAPTCHA token
   const recaptchaToken = grecaptcha.getResponse();


   if (!recaptchaToken) {
       alert('Please complete the reCAPTCHA');
       return;  // Exit the function early if reCAPTCHA is not completed
   }


   const formData = {
       name: name.value,
       email: email.value,
       subject: subject.value,
       message: message.value,
       'g-recaptcha-response': recaptchaToken
   };

To verify the reCAPTCHA on the server side, we need to make a request. For this, we can use the built in Node.js ‘https’, or a package like ‘node-fetch’ or ‘axios’.

And since Node.js ver 18, the fetch method is available on the global scope natively, so let’s use ‘fetch’.

First, in our server.js let’s create a function to verify the reCAPTCHA (make sure to add the SECRET KEY as RECAPTCHA_SECRET_KEY in environment variables else the verification will not succeed):

// Function to verify reCAPTCHA
async function verifyRecaptcha(token) {
   const recaptchaSecret = process.env.RECAPTCHA_SECRET_KEY;
   const recaptchaUrl = `https://www.google.com/recaptcha/api/siteverify?secret=${recaptchaSecret}&response=${token}`;


   const response = await fetch(recaptchaUrl, { method: 'POST' });
   const result = await response.json();


   return result.success;
}

Then in our /send-email endpoint we can update our code to this:

// Endpoint to handle form submission and send email
app.post('/send-email', async (req, res) => {
   const { name, email, subject, message, 'g-recaptcha-response': recaptchaToken } = req.body;


   if (!name || !email || !subject || !message || !recaptchaToken) {
       res.status(400).json({ status: 'error', message: 'Missing required fields!' })
   }


   // Verify the reCAPTCHA token
   const isRecaptchaValid = await verifyRecaptcha(recaptchaToken);
   if (!isRecaptchaValid) {
       return res.status(400).json({
           status: 'error',
           message: 'reCAPTCHA verification failed. Please try again.'
       });
   }


   // Validate the email
   const validationResult = await validate(email);


   if (!validationResult.valid) {
       return res.status(400).json({
           status: 'error',
           message: 'Email is not valid. Please try again!',
           reason: validationResult.reason
       });
   }


   // Email sending logic


   // Placeholder response for a successful email submission
   res.status(200).json({
       status: 'success',
       message: 'Email successfully sent'
   });
});

Send email from Node.js contact form using SMTP

Now that we have our Node.js contact form flow in place, let’s add an email-sending functionality to it.

For this, we’ll need two things:

Nodemailer – If you’re reading this article, I’m guessing you already have Nodemailer installed, but if you don’t, here’s how to install it.
SMTP credentials – With Nodemailer, you can leverage any SMTP server like, for example, Gmail. However, Gmail has some significant limitations, about which you can find out more in our dedicated Nodemailer Gmail tutorial.

So, to overcome Gmail limitations, we’ll set up Mailtrap Email Sending instead, as the SMTP service in our Nodemailer transporter object. It offers an infrastructure with high deliverability rates by default and by design, plus it’s easy to use.

First, create a free Mailtrap account and verify your domain. It only takes a couple of minutes, and you can watch the video we’ve prepared for you as a step-by-step tutorial.

Then, proceed to the Sending Domains section, choose your domain, and under Integration, select your preferred stream (Transactional, in this case). There, you will find your SMTP credentials, which you can easily paste into the Nodemailer config file.

Speaking of Nodemailer configuration, let’s insert it into the server.js file beneath the comment // Create a transporter object, like so:

// Create a transporter object
const transporter = nodemailer.createTransport({
  host: 'live.smtp.mailtrap.io',
  port: 587,
  secure: false, // use false for STARTTLS; true for SSL on port 465
  auth: {
    user: '1a2b3c4d5e6f7g',
    pass: '1a2b3c4d5e6f7g',
  }
});

// Configure the mailoptions object
const mailOptions = {
  from: 'yourusername@email.com',
  to: 'yourfriend@email.com',
  subject: 'Sending Email using Node.js',
  text: 'That was easy!'
};

// Send the email
transporter.sendMail(mailOptions, (error, info) =>{
  if (error) {
    console.log('Error:' error);
    return res.status(500).json({ status: 'error', message: 'Failed to send email due to server error.' });
  } else {
    console.log('Email sent: ' + info.response);
    return res.status(200).json({
               status: 'success',
               message: 'Email successfully sent'
           });
  }
});

Then, just insert your Mailtrap credentials into their respectable fields, including host, port, user, and pass.

In the end, your server.js file should look something like this:

require('dotenv').config();
const express = require('express');
const { validate } = require('deep-email-validator');
const path = require('path');


const app = express();
const PORT = process.env.PORT || 3000;


// Middleware
app.use(express.static('public'));
app.use(express.json());


app.get('/', (req, res) => {
   res.sendFile(path.join(__dirname, 'public', 'contactform.html'));
});


// Function to verify reCAPTCHA
async function verifyRecaptcha(token) {
   const recaptchaSecret = process.env.RECAPTCHA_SECRET_KEY;
   const recaptchaUrl = `https://www.google.com/recaptcha/api/siteverify?secret=${recaptchaSecret}&response=${token}`;


   const response = await fetch(recaptchaUrl, { method: 'POST' });
   const result = await response.json();


   return result.success;
}


// Endpoint to handle form submission and send email
app.post('/send-email', async (req, res) => {
   const { name, email, subject, message, 'g-recaptcha-response': recaptchaToken } = req.body;


   if (!name || !email || !subject || !message || !recaptchaToken) {
       return res.status(400).json({ status: 'error', message: 'Missing required fields!' })
   }


   // Verify the reCAPTCHA token
   const isRecaptchaValid = await verifyRecaptcha(recaptchaToken);
   if (!isRecaptchaValid) {
       return res.status(400).json({
           status: 'error',
           message: 'reCAPTCHA verification failed. Please try again.'
       });
   }


   // Validate the email
   const validationResult = await validate(email);


   if (!validationResult.valid) {
       return res.status(400).json({
           status: 'error',
           message: 'Email is not valid. Please try again!',
           reason: validationResult.reason
       });
   }


   // Email sending logic
   // Create a transporter object
   const transporter = nodemailer.createTransport({
       host: process.env.SMTP_HOST,
       port: process.env.SMTP_PORT,
       secure: false, // use false for STARTTLS; true for SSL on port 465
       auth: {
           user: process.env.SMTP_USER,
           pass: process.env.SMTP_PASS,
       }
   });


   // Configure the mailoptions object
   const mailOptions = {
       from: process.env.EMAIL_FROM,
       to: process.env.EMAIL_TO,
       replyTo: email,
       subject: subject,
       text: `From: ${name}\nEmail:${email}\n\n${message}`
   };


   // Send the email
   transporter.sendMail(mailOptions, (error, info) => {
       if (error) {
           console.log('Error:', error);
           return res.status(500).json({ status: 'error', message: 'Failed to send email due to server error.' });


       } else {
           console.log('Email sent: ' + info.response);
           return res.status(200).json({
               status: 'success',
               message: 'Email successfully sent'
           });
       }
   });
});


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

To safely store your Mailtrap credentials, you can use the environment variable, or the .env file, like so:

PORT=3200
SMTP_HOST='live.smtp.mailtrap.io'
SMTP_PORT=587
SMTP_USER='1a2b3c4d5e6f7g'
SMTP_PASS='1a2b3c4d5e6f7g'
EMAIL_FROM='yourusername@email.com'
EMAIL_TO='contactformrecipient@yourmail.com'
RECAPTCHA_SECRET_KEY='SECRET-KEY'

Send Emails with Mailtrap for Free

Send email from Node.js contact form using API

If you want to automate your contact form’s email-sending functionality, you can again rely on Mailtrap as it has a robust sending package. The package itself is regularly updated by a team of developers, lets you automate your sending process, and it’s super straightforward to use.

First, you’ll need a Mailtrap account, which, if you don’t already have one, you can create by following the instructions provided in the previous chapter.

Then, let’s install the Mailtrap package:

npm install mailtrap

# or, if you are using yarn:

yarn add mailtrap

Once it’s installed, you can use the following code snippet for email sending:

import { MailtrapClient } from "mailtrap"

/**
 * For this example to work, you need to set up a sending domain,
 * and obtain a token that is authorized to send from the domain.
 */

const TOKEN = "<YOUR-TOKEN-HERE>";
const SENDER_EMAIL = "<SENDER ADDRESS@YOURDOMAIN.COM>";
const RECIPIENT_EMAIL = "<RECIPIENT@EMAIL.COM>";

const client = new MailtrapClient({ token: TOKEN });

const sender = { name: "Mailtrap Test", email: SENDER_EMAIL };

client
  .send({
    from: sender,
    to: [{ email: RECIPIENT_EMAIL }],
    subject: "Hello from Mailtrap!",
    text: "Welcome to Mailtrap Sending!",
  })
 .then(response => {
    console.log("Email sent successfully:", response);
  })
  .catch(error => {
    console.error("Error sending email:", error);
  });

And for your convenience’s sake, here’s what your server.js file should look like:

require('dotenv').config();
const express = require('express');
const { MailtrapClient } = require('mailtrap');
const { validate } = require('deep-email-validator');
const path = require('path');


const app = express();
const PORT = process.env.PORT || 3000;


// Middleware
app.use(express.static('public'));
app.use(express.json());


app.get('/', (req, res) => {
   res.sendFile(path.join(__dirname, 'public', 'contactform.html'));
});


// Function to verify reCAPTCHA
async function verifyRecaptcha(token) {
   const recaptchaSecret = process.env.RECAPTCHA_SECRET_KEY;
   const recaptchaUrl = `https://www.google.com/recaptcha/api/siteverify?secret=${recaptchaSecret}&response=${token}`;


   const response = await fetch(recaptchaUrl, { method: 'POST' });
   const result = await response.json();


   return result.success;
}


// Endpoint to handle form submission and send email
app.post('/send-email', async (req, res) => {
   const { name, email, subject, message, 'g-recaptcha-response': recaptchaToken } = req.body;


   if (!name || !email || !subject || !message || !recaptchaToken) {
       return res.status(400).json({ status: 'error', message: 'Missing required fields!' })
   }


   // Verify the reCAPTCHA token
   const isRecaptchaValid = await verifyRecaptcha(recaptchaToken);
   if (!isRecaptchaValid) {
       return res.status(400).json({
           status: 'error',
           message: 'reCAPTCHA verification failed. Please try again.'
       });
   }


   // Validate the email
   const validationResult = await validate(email);


   if (!validationResult.valid) {
       return res.status(400).json({
           status: 'error',
           message: 'Email is not valid. Please try again!',
           reason: validationResult.reason
       });
   }


   // Configure mailtrap client and define sender
   console.log(process.env.MAILTRAP_TOKEN);
   const client = new MailtrapClient({ token: process.env.MAILTRAP_TOKEN });
   const sender = { name: "NodeJS App", email: process.env.EMAIL_FROM };


   // Send email
   try {
       const response = await client.send({
           from: sender,
           to: [{ email: process.env.EMAIL_TO }],
           subject: subject,
           text: `From: ${name}\nEmail: ${email}\n\n${message}`,
       });


       console.log('Email sent: ', response.message_ids);
       res.status(200).json({
           status: 'success',
           message: 'Email successfully sent'
       });
   } catch (error) {
       console.log('Error:', error);
       res.status(500).json({ status: 'error', message: 'Failed to send email due to server error.' });
   }


});


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

If you want to safely store your credentials in an environment variable, here’s what your .env should look like:

PORT=3200
MAILTRAP_TOKEN='7ff93fc2453461800734fb5c8bbe735d'
EMAIL_FROM='yourusername@email.com'
EMAIL_TO='contactformrecipient@yourmail.com'
RECAPTCHA_SECRET_KEY='SECRET-KEY'

And voila! Your Node.js contact form can now send emails via API.

Keep in mind that the code snippet I’ve shown you here is only for plain-text messages. If you wish to send HTML emails or add embedded images or attachments, please refer to the examples folder in the GitHub repository.

Test email and email sending on staging

If you’re making a contact form, the chances are that you’ll use it for collecting critical user information like email addresses, names, and other sensitive data.

Hence, you need to make sure that your contact form’s functionality is spot on and that your submitted forms are reaching the desired addresses as they’re supposed to.

And that’s exactly where email testing comes in—an industry-standard practice that makes sure your submission system is working as intended, that your emails are looking flawless, and more importantly, that your emails are not being marked as spam.

Personally, I use Mailtrap Email Testing, another integral part of Mailtrap Email Delivery Platform that offers a sandbox for you to inspect and debug emails in staging, dev, and QA environments.

With Mailtrap Email Testing, you can preview how your emails look in different devices/clients, inspect their source HTML/CSS and easily fix any faulty lines of code.

Additionally, thanks to the Spam Report feature, you will be aware of your spam score, which, if you keep under 5, prevents a considerable amount of potential email deliverability issues.

Besides these, you also get access to other features for improving your email deliverability, including:

Email preview in HTML form and raw text
Email Testing API for QA automation
Multiple inboxes for different projects and stages
User management, SSO
Email templates testing

Now, let me show you how it works!

SMTP

To start testing your emails with Nodemailer and SMTP, follow these steps:

Create a free Mailtrap account
Go to Email Testing and select your inbox
Copy your credentials from the Integration tab
Insert the credentials into your server.js file

You can also use Mailtrap’s ready-to-use integration, like so:

Select Nodemailer from the list of integrations

Copy and paste the code snippet into your server.js file Here’s what the snippet should look like:

const transport = nodemailer.createTransport({
  host: "sandbox.smtp.mailtrap.io",
  port: 2525,
  auth: {
    user: "1a2b3c4d5e6f7g",
    pass: "1a2b3c4d5e6f7g"
  }
});

Test Emails with Mailtrap for Free

API

Integrating Mailtrap Email Testing API for testing, automation, and testing automated sequences is as simple as using the following code snippet:

require('dotenv').config();
const { MailtrapClient } = require('mailtrap');
const nodemailer = require('nodemailer');


/* The official mailtrap package doesn't support sending test emails, so we send a mail first with nodemailer */


/* Initialize nodemailer with SMTP configuration from environment variables. */
const transport = nodemailer.createTransport({
   host: process.env.SMTP_HOST,
   port: process.env.SMTP_PORT,
   auth: {
       user: process.env.SMTP_USER,
       pass: process.env.SMTP_PASS
   }
});


/* Asynchronously send a test email using nodemailer. */
async function sendTestEmail() {
   const info = await transport.sendMail({
       from: process.env.EMAIL_FROM,
       to: "user@domain.com",
       subject: "Mailtrap Email Testing",
       html: '<h1>Mailtrap Email Testing</h1>',
       text: 'Mailtrap Email Testing'
   });


   console.log("Message sent: %s", info.messageId);
   return info;
}


/* Configure the Mailtrap client and fetch email information for testing and automation. */
const client = new MailtrapClient({
   token: process.env.MAILTRAP_TOKEN,
   testInboxId: process.env.TEST_INBOX_ID,
   accountId: process.env.ACCOUNT_ID
});


const inboxesClient = client.testing.inboxes;
const messagesClient = client.testing.messages;


/* Send the test email and then retrieve it from Mailtrap for analysis. */
sendTestEmail().then(() => {
   inboxesClient.getList()
       .then(async (inboxes) => {
           if (inboxes && inboxes.length > 0) {
               const firstInboxId = inboxes[0].id;
               console.log(`First inbox ID: ${firstInboxId}`);


               const messages = await messagesClient.get(firstInboxId);
               if (messages && messages.length > 0) {
                   const firstMessageId = messages[0].id;
                   console.log(`First message ID: ${firstMessageId}`);


                   const analysis = await messagesClient.getHtmlAnalysis(firstInboxId, firstMessageId);
                   console.log('HTML Analysis:', analysis);


                   const htmlMessage = await messagesClient.getHtmlMessage(firstInboxId, firstMessageId);
                   console.log('HTML Message:', htmlMessage);


                   const textMessage = await messagesClient.getTextMessage(firstInboxId, firstMessageId);
                   console.log('Text Message:', textMessage);


                   const headers = await messagesClient.getMailHeaders(firstInboxId, firstMessageId);
                   console.log('Mail Headers:', headers);


                   const eml = await messagesClient.getMessageAsEml(firstInboxId, firstMessageId);
                   console.log('Message as EML:', eml);


                   const htmlSource = await messagesClient.getMessageHtmlSource(firstInboxId, firstMessageId);
                   console.log('HTML Source:', htmlSource);


                   const rawMessage = await messagesClient.getRawMessage(firstInboxId, firstMessageId);
                   console.log('Raw Message:', rawMessage);


                   const spamScore = await messagesClient.getSpamScore(firstInboxId, firstMessageId);
                   console.log('Spam Score:', spamScore);


                   const emailMessage = await messagesClient.showEmailMessage(firstInboxId, firstMessageId);
                   console.log('Email Message:', emailMessage);


                   const updateStatus = await messagesClient.updateMessage(firstInboxId, firstMessageId, {
                       isRead: false
                   });
                   console.log('Update Status:', updateStatus);


                   // Forward the message (needs to be a confirmed email for forwarding in mailtrap)
                   // await messagesClient.forward(firstInboxId, firstMessageId, 'mock@mail.com');
                   // console.log('Message forwarded.');


                   // Delete the message
                   const response = await messagesClient.deleteMessage(firstInboxId, firstMessageId);
                   console.log('Delete Response:', response);


               } else {
                   console.log('No messages found in the first inbox.');
               }
           } else {
               console.log('No inboxes found.');
           }
       })
       .catch(error => {
           console.error('Error fetching inboxes or messages:', error);
       });
}).catch(console.error);

With this code, we are first sending a test email using Nodemailer and retrieving the information related to the test email programmatically. This can potentially be used to perform automation. This code only logs the information of the test email.

And of course, here’s what your .env file should look like for the Email Testing API:

MAILTRAP_TOKEN=''
SMTP_HOST='sandbox.smtp.mailtrap.io'
SMTP_PORT=2525
SMTP_USER=''
SMTP_PASS=''
EMAIL_FROM=''
TEST_INBOX_ID=
ACCOUNT_ID=

For more information and use cases of Mailtrap Email Testing API, check out the official GitHub page.

Wrapping up

And with that, we’ve come to the end of the line!

Now that you’ve got the ropes, you can style your Node.js contact form according to your artistic eye and make it function according to your application’s specific needs.

So, code away, and be sure to give our blog a read! We have a plethora of helpful JavaScript-related articles, including:

We appreciate you chose this article to know about creating a Node.js contact form. If you want to see more content on related topics, visit Mailtrap blog and explore it!

Office 365 SMTP: Setup and Configuration Explained

Ivan Djuric — Wed, 01 May 2024 17:35:18 +0000

In this guide, I dive deep into the ins and outs of Office 365, showing you what it’s best used for and how to configure it, while also providing you with some actual examples.

What is an Office 365 SMTP server?

SMTP, or Simple Mail Transfer Protocol, is an internet standard protocol responsible for delivering messages to the email server and relaying emails between senders and recipients.

Thus, Office 365 is an SMTP service from Microsoft.

However, in 2020, Office 365 was renamed to Microsoft 365.

Microsoft 365 is a subscription-based service, which includes Office 365 SMTP. So, when you refer to the Office 365 SMTP, you refer to the Microsoft 365 SMTP.

However, we’ll be using Office 365 to keep things simple.

Office 365 SMTP vs. Outlook SMTP

Office 365 SMTP is often confused with Outlook SMTP on the internet, but don’t mix up the two, because Office 365 is subscription-based, whereas Outlook is free.

Here are some differences between the two:

Why should you use Office 365 as a SMTP server?

Some of the most common Office 365 SMTP use cases include:

Sending transactional emails – Password resets and order confirmations are some of the transactional emails you can send through Office 365 SMTP.
Integration with custom applications – You can use Office 365 to add email-sending functionality to custom applications and send your users updates, reminders, or other emails specific to your app.
Scheduling and event reminders – If you’re operating within the Microsoft 365 ecosystem, you can use Office 365 SMTP to send event reminders, schedule appointments, and more.
Automatic notifications from IoT devices – Besides the standard notifications, you can also leverage Office 365 SMTP to send notifications or alerts from Internet of Things (IoT) devices through email. For example, you can set up your monitoring system to use Office 365 SMTP to notify you when there’s an anomaly.
Sending emails from different clients with an Office 365 address – Whether you prefer using Thunderbird or Yahoo Mail clients, you can send emails through Office 365 from them.
Sending emails for small-scale marketing efforts – Although it’s not the most optimal solution for bulk email campaigns as you’ll see later in the article, Office 365 can be used for marketing campaigns with low volume but highly targeted needs.

How to configure Office 365 SMTP server settings?

According to Microsoft’s official documentation, there are three options for configuring Office 365 SMTP server settings. Namely:

SMTP AUTH client submission – Lets you email anyone both inside or outside an organization and it supports OAuth 2.0, offering a more secure authentication method. Most importantly, it’s easy to configure, making it an ideal choice for sending emails from your application or email client.
Direct send – Doesn’t let you send emails to external recipients and your messages will be subject to Microsoft’s spam filters. Moreover, emails you send via this option don’t get saved in the Sent Items folder, which can be a big drawback.
SMTP relay – Setting up an SMTP relay in Office 365 is the most complex of the three options as it requires configuring a connector in Office 365 and managing static IP addresses or certificates. Like Direct send, SMTP relay also doesn’t support modern authentication methods like OAuth.

As you can see, especially if you’re a developer looking to add email-sending functionality to your application, SMTP AUTH client submission more or less takes the cake. 🎂

Now, let me show you how to configure it.

Step 1. Verify and enable SMTP AUTH

First things first, we need to enable SMTP AUTH on your mailbox to send emails through Office 365 SMTP.

To check if SMTP AUTH is enabled, you can use:

Exchange Admin Center (EAC)

Log in to the EAC with your admin account.
Navigate to “Recipients” → “Mailboxes”
Find and select your mailbox.
Check the status of your SMTP AUTH

PowerShell

Connect to Exchange Online PowerShell using your admin credentials.
You can also use ‘Connect-ExchangeOnline’ cmdlet
Run the following command to check the SMTP AUTH of your mailbox:
Get-CASMailbox -Identity "user@domain.com" | Format-List SmtpClientAuthenticationDisabled

If ‘SmtpClientAuthenticationDisabled’ is ‘False’, SMTP AUTH is enabled
If ‘SmtpClientAuthenticationDisabled’ is ‘True’, SMTP AUTH is disabled
Run the following command to enable SMTP AUTH for your mailbox:

Set-CASMailbox -Identity "user@domain.com" -SmtpClientAuthenticationDisabled $false

Notes:

Any changes you make either through EAC or PowerShell probably won’t take effect immediately, so you might need to wait a while.
Verifying and enabling SMTP AUTH requires administrative access to your Office 365 account.

Step 2. Insert the necessary Office 365 SMTP settings

To send emails via Office 365 SMTP, enter the following settings into your app or email client:

SMTP server name: smtp.office365.com
SMTP port: Port 587 (recommended) or port 25
TLS/StartTLS: Enabled
Username/email address: john.doe@yourcompanyname.com
Password: Your Office 365 password
Note: If you have MFA enabled, you’ll need to generate an app password to log in.

Configuration examples

Now that you’re familiar with Office 365 SMTP and know how to configure it, let’s see some actionable examples in WordPress, PHP, and Thunderbird.

WordPress Office 365 SMTP settings

If you’re a WordPress user, you can configure the Office 365 SMTP with plugins like WP Mail SMTP or Post SMTP for instance.

All you have to do is:

Navigate to WP Mail SMTP → Settings
Choose ‘Other SMTP’ as the mailer
Enter the Office 365 settings

PHP

When it comes to PHP, you have several email-sending libraries to choose from. In this example, I’ll use Symfony because of its practicality.

Here’s a code snippet you can modify with your Office 365 credentials to send emails:

<?php

use Symfony\Component\Mailer\Mailer; 
use Symfony\Component\Mailer\Transport\Smtp\SmtpTransport; 
use Symfony\Component\Mime\Email;

require_once './vendor/autoload.php';


$transport = (new Symfony\Component\Mailer\Transport\Smtp\EsmtpTransport
('smtp.server.com', 587))
                ->setUsername('username')
                ->setPassword('password');

$mailer = new Mailer($transport); 

$email = (new Email())
            ->from('hello@registered.com')
            ->to('you@example.com')
            ->subject('Time for Symfony Mailer!')
            ->text('Sending emails is fun again!')
            ->html('<p>See Twig integration for better HTML integration!</p>');

$mailer->send($email);

Thunderbird

As I’ve previously mentioned, besides custom applications, you can also set up email clients like Thunderbird to send emails through Office 365 SMTP.

Here’s how you can do it:

Open the Thunderbird email client
Click on ‘Account Settings’ in the upper-right corner of the window

Select ‘Outgoing Server (SMTP)’ at the bottom of the drop-down menu

Enter your Office 365 settings

Keep in mind that I’ve used Thunderbird version 115.0 in this example, so there might be differences in your access to ‘Account Settings’ if you’re using an older version of the client.

How to configure Office 365 POP3 settings?

Once you’ve configured your Office 365 SMTP, you’ll need an ”email retrieval” or “pull protocol” for fetching messages from the server. One of such protocols is Post Office Protocol 3, or POP3 for friends.

POP3 lets you download messages from your Office 365 account to your local device. It can be useful if you have a limited connection and want to view your messages offline or if you want to create a backup of emails by storing them locally.

Office 365 POP3 settings

To use Office POP3, insert these settings into your app configuration or email client:

Server name: outlook.office365.com
Port: 995
TLS/StartTLS: Enabled
Username/email address: john.doe@yourcompanyname.com
Password: Your Office 365 password

How to configure Office 365 IMAP settings?

Another pull protocol you can use to retrieve your emails is IMAP or Internet Message Access Protocol.

IMAP is considered by many a more convenient protocol than POP3 as it synchronizes your emails across your devices. It stores them on the email server, where you can manage, open, view, and delete your messages. In essence, IMAP works similarly to cloud email.

Office 365 IMAP settings

To use Office 365 IMAP, you’ll need the following settings:

Server name: smtp.office365.com
Port: 993
TLS/StartTLS: Enabled
Username/email address: john.doe@yourcompanyname.com
Password: Your Office 365 password

POP3 vs IMAP – which one is better?

Simply put, POP3 and IMAP serve different purposes and fit different personal needs, so we can’t really say one is better than the other.

However, most users nowadays could benefit more from IMAP as we use different devices to fetch our emails. And as mobile networks have become more affordable and Wi-Fi is everywhere, the synchronization IMAP offers can really go a long way.

Moreover, IMAP is the default protocol for the majority of modern email clients.

But, whether you want to store your emails on your local devices for security reasons or for convenience’s sake, POP3 is the way to go for you.

Troubleshooting Microsoft Office 365 SMTP server configuration

I’ve scoured the community forums for the most common Microsoft Office 365 errors so you don’t have to, and here are some of the most common ones:

System.Net.Sockets.SocketException (0x80004005)
This error message means that you either don’t meet SMTP AUTH requirements or your network firewall or Internet Service Provider (IDP) are blocking ports 587 or 25.

In case you meet the requirements, here’s how you can check if you’re potentially getting blocked:

Open Command Prompt (CMD) as an administrator
Type ‘telnet’ to run telnet
Run the following command:
open smtp.office365.com 587(25)
If you’re able to successfully connect, you will receive a response line similar to:

220 BY1PR10CA0041.outlook.office365.com Microsoft ESMTP MAIL Service ready at Mon, 1 Jun 2024 12:00:00 +0000
In case you can’t connect, try disabling your firewall or contacting your ISP.

SMTP send error. The operation has timed out
Although a common error, this error is likely caused either by your antivirus software or firewall blocking your SMTP connection or a typo in your Office 365 settings. If neither of these solutions works, then the issue is probably on Microsoft’s end, in which case you’ll need to contact their support.

5.7.60 SMTP; Client does not have permissions to send as this sender.
If you’re seeing this error, check whether your application or email client is trying to send emails from a different address than the one you’ve entered in your SMTP configuration. The two need to be the same for the sending to work.

But, you can also give the ‘Send As’ permission to another address if you plan to use two different addresses for email sending.

Transport Layer Security (TLS) encryption related errors
Recently, Microsoft has started rejecting connections to smtp.office365.com that use TLS1.0/1.1 for SMTP AUTH. So, make sure your device supports TLS version 1.2 or above.

But, if you need to use older versions of TLS for legacy clients and devices, you can:

Go to Settings in your Exchange admin center
Navigate to Mail Flow (under Security)
Check “Turn on use of legacy TLS clients)
Click “Save”
For more information on Office 365 and TLS, read the official Microsoft’s article.

Office 365 SMTP limitations or when not to use Microsoft

Office as an SMTP server
While Office 365 does offer a reliable SMTP server, it has some considerable limitations that you should go over before deciding on it as your go-to option.

Namely, they include:

Monthly subscription fees – To have access to Office 365 SMTP server, you’ll need to pay a monthly subscription. It has several pricing plans, with the basic one starting at $6.99 per month and allowing you to send emails to up to 10,000 recipients per day.

It’s important to note that 10,000 recipients per day is not the same as sending 10,000 emails per day.

No support for bulk email sending – Office 365 SMTP is not the most ideal option for sending large amounts of emails as the sending limit is the same for all pricing tiers. This means that even if you pay for Enterprise E3/E5 (the most expensive plan), you will still be limited to 10,000 recipients per day and 30 messages per minute, which can be a considerable issue.

If you’re looking for a bulk-sending alternative, here’s an in-depth article on the top 10 mass email service providers.

Lack of monitoring features – Typically, most SMTP service providers offer in-depth analytics and reporting features, which can help you optimize your campaign and improve your email deliverability. Unfortunately, this isn’t the case with Office 365.
Steep learning curve – Getting the hang of Office 365 can be quite a challenge as it’s not the most user-friendly SMTP service out there. Add to this the wide range of features and services offered by the whole suite, and you’ll realize why most new users may even need training to navigate Office 365 complexities.

Consider an alternative — using Mailtrap Email Sending

If you’re like me and Office 365 SMTP limitations are too much for you, don’t worry—I have just the right solution.

I use Mailtrap, an Email Delivery Platform for developer teams to test, send, and control their email infrastructure in one place.

Personally, I needed to send bulk mail, so I used Mailtrap’s Bulk Stream to send large amounts of marketing and promotional emails in my high-volume campaigns to enhance my deliverability even further.

Additionally, I use Mailtrap’s detailed analytics to check my bounce rates, open rates, click-through rates and other useful stats. This allows me to keep track of my email infrastructure and optimize it accordingly.

Mailtrap Email Sending also provides me with deliverability alerts every Monday to let me know how my emails are doing in the form of in-depth stats and I also get hourly alerts when a critical metric goes below a predetermined threshold.

As enhancing my deliverability goes, I make sure to test my emails before sending them out, a part of the email-sending process that goes with it like salt goes with pepper. 🧂

Without testing my emails, I risk having them being marked as spam, or, worst case scenario: their HTML template getting poorly rendered by certain web browsers.

Mailtrap Email Testing, a part of the Mailtrap Email Delivery Platform lets me check my spam score, inspect and verify my HTML/CSS and make sure it’s pitch-perfect before it reaches my recipients’ inboxes.

Lastly, and perhaps most importantly, Mailtrap is super easy to use.

Check it out:

Navigate to the ‘SMTP/API Settings’ tab and choose your preferred SMTP stream.

Use the SMTP settings provided by Mailtrap to integrate the functionality within your custom application or email client.
Make sure everything is configured and works correctly by sending a test email.

We appreciate the you chose this article to find out how to set up Office 365. If you want to find more interesting content on related topics, follow Mailtrap blog!