Forem: Veljko Ristic

How to Set Up, Configure, and Send Emails using Yahoo SMTP Server

Veljko Ristic — Wed, 23 Oct 2024 12:08:05 +0000

No reason to beat around the bush. As the title suggests, I guide you through everything you need to know about Yahoo SMTP.

Let’s get straight to it.

What is Yahoo SMTP?

SMTP, or Simple Mail Transfer Protocol, is a mail server protocol for sending emails over the Internet. Yahoo SMTP allows users to send emails from their Yahoo Mail account through other email clients like Microsoft Outlook, Mozilla Thunderbird, or any other standard email application that supports SMTP.

From the technical side, here are the Yahoo SMTP settings to keep at hand:

SMTP server address: smtp.mail.yahoo.com
Ports: Either 465 (with SSL) or 587 (with TLS), depending on your email client’s capabilities and security preferences.
Encryption: SSL or TLS based on the port you choose.
Authentication: Necessary. Use your full email address and an app-generated password. This goes double if you have 2FA enabled.

Note: I’ll explain the app-generated password and all the setup flows in a later section. If you want to jump to it, click here.

Why should you use Yahoo as an SMTP server?

Assuming you’ll use this email server for a pet project, personal use, or just to see how Yahoo Mail SMTP works, there are a few reasons to do it.

Wide compatibility: Yahoo SMTP is compatible with a broad range of email clients, making it easy to integrate into almost any system without special configuration. (You’ll see it soon, it’s often just a few clicks to have the outgoing mail and incoming mail up and running.)
High deliverability: Yahoo has robust systems in place to ensure high deliverability rates for your emails, minimizing the risk of them being marked as spam. (Keep in mind that deliverability isn’t only on the email service side, it has a lot to do with the type of outgoing emails you send.)
Account security: Yahoo supports secure connections via SSL/TLS, helping protect your data from interception during transmission.
No cost for personal use: Yahoo provides SMTP services at no additional cost, which is beneficial for individuals or small businesses looking to minimize expenses. But the email provider does impose certain (I’d say stringent) limitations.
Reliability: Yahoo is a long-established company with a reputation for reliable service. Using their SMTP server can lend credibility and stability to your email communications. Still, you shouldn’t be surprised if an occasional email lands in tabs or the spam folder with Outlook or Gmail.
Simple setup: This is probably the biggest plus for me. Setting up Yahoo SMTP is straightforward, with clear documentation and support available, making it accessible even for those with minimal technical expertise.

How to configure Yahoo SMTP server settings?

I’ll start with creating the in-app password, then move to show you the email settings with Thunderbird.

Step #1

Create a dedicated app password, you can’t use the password you have for the Yahoo account. Do the following:

Go to your Yahoo account (Note: Not the mail account but your general account info on Yahoo)

Select the Security tab, scroll down, and choose “Generate app password” under ‘App Password’ section. This generates a special SMTP password you can use for third-party integrations.

Follow the wizard, enter the app name, and confirm with the “Generate password” button.

The system will show you the password; copy-paste it somewhere safe for future reference.

Step #2

Now, access the email client you’d like to use and add the SMTP settings. For the purposes of this tutorial, I’ll use Thunderbird.

In Thunderbird, click the Gear icon at the lower left corner, then choose Account Settings.

Click the “Account Actions” menu at the bottom left, then select “Add Mail Account” to add Yahoo SMTP.

Type your Yahoo SMTP credentials into the designated fields. Make sure to use the app password you previously created, and hit Continue.

The wizard takes you to the Yahoo popup where you need to complete the authentication via login and 2FA. Proceed with it; once done, your account will immediately pop up in Thunderbird.

Important Notes:

Thunderbird allows you to automatically set up POP (Post Office Protocol) and IMAP (Internet Message Access Protocol), the later being selected by default. Feel free to proceed with that configuration, there’s no reason to do it manually with this client. But for the sake of this tutorial, I’ll show you the manual setup in the coming sections.
Thunderbird bakes in the POP3 or IMAP settings (‘ON’ by default). You can update some of the credentials, however, there’s no option for manual setup after you add the SMTP. You’d need to re-add the SMTP and then choose “Manual setup”.

How to configure Yahoo POP3 settings?

Here I’ll show you the manual setup that may generally apply to other clients.

Navigate to the account settings or preferences within your email client. This is typically found in the ‘Accounts’ or ‘Email’ settings section.
Choose the option to add a new email account, and select ‘Manual setup’ or ‘Additional server types’ when prompted.
When asked for the account type, select POP settings or POP3.
Enter POP3 server details and your credentials:

POP3 server (Host): pop.mail.yahoo.com
Port: 995.
Encryption: Ensure SSL/TLS encryption is enabled for securing your email data.
Authentication: Required. Enter your full Yahoo email address and the app password. (Reminder: this is the Yahoo mail password you generated, not the Yahoo account password)

[Optional] – Some clients may have the “Leave a copy of messages on the server” option. You can check it if you want the email backup.
Save the settings. Depending on the client, the ‘Test Account Settings’ button could be available. This will send a test message to verify the setup. But with more recent client updates, there’s just a confirmation notification.

How to configure Yahoo IMAP settings?

The manual configuration for IMAP is almost the same as for POP3, so I won’t be repeating all the steps. Basically, you add a new account, select ‘Manual setup’ or ‘Additional server types’, and move on to add the following credentials.

IMAP server (Host): imap.mail.yahoo.com

Port: 993

Encryption: SSL/TLS enabled. This setting secures the data transmission between your email client and Yahoo’s servers.

Authentication: Required. Use your full Yahoo email address and the in-app password you created.

Troubleshooting Yahoo SMTP server configuration

I collected a list of frustrating little errors that may block the server and tips on how to fix them.

Authentication errors – typically occur because of the wrong settings or login credentials. To avoid them, double-check your username and password. Also, as a reminder, you need to use the app password you create, particularly if you have the 2FA ON.
“Server not responding” or the “Connection timed out” – the errors could appear due to network/internet connection issues, incorrect SMTP settings, or server downtime. The only thing you can do is check that the SMTP server address (smtp.mail.yahoo.com) and port numbers (465 with SSL or 587 with TLS) are correct. If it’s server-side, you can only wait and try again later.
SSL/TLS errors – these are rare but may occur if the email client doesn’t support the encryption method you chose. You can check if the SSL/TLS is enabled and if you’re on the correct ports – 465 for SSL and 587 for TLS.
“Email sending limit exceeded” – this happens when you send more emails than you’re allowed to. To offset the limitation, try to reduce the sending frequency. That may help since Yahoo times you out of the service whenever you hit the threshold. But it’s also a signal you should be looking for a different service.
Firewall or ISP blocks – Sometimes certain network configurations or ISPs block SMTP ports used by Yahoo (again, this isn’t common for most IPSs). If it happens, reach out to the ISP to see if they block SMTP ports 465 or 587 (the former is more likely to be blocked). In this case, you may need to use a different port. And if it’s your firewall, you’ll need to reconfigure it to allow Yahoo SMTP.

Yahoo SMTP limitations: when not to use Yahoo as a SMTP server

Interestingly, in an attempt to discourage spammers, Yahoo chooses not to disclose its limitations publicly. But I did some digging, since I didn’t run the testing myself, and came up with a few consistent numbers that make sense.

Based on the Woodpecker blog and a few other resources, you can send up to 500 emails per day, and a single email can be sent to 100 recipients max. Also, it’s speculated that the hourly throughput caps at 100 emails.

More importantly, Yahoo updated its sender requirements not that long ago, making domain authentication via DNS records one of the main requirements for bulk senders. Check the video below where we discuss the update in detail.

Now, I’d always say you need to authenticate your domain via DNS, regardless of the SMTP provider. However, the limitation of 500 emails a day may only be suitable for solopreneur startups and tiny businesses.

But even if you choose to go the Yahoo route, imagine what happens if you get a surge of customers or queries and you need to scale fast. Simply, you’ll be blocked for a while, potentially losing customers.

Finally, Yahoo doesn’t offer advanced analytics and segmentation, A/B testing, and a bunch of other features that are likely to make your campaigns more efficient. So it pays to explore alternatives.

What is a reliable alternative to Yahoo SMTP?

Mailtrap Email API/SMTP is a reliable alternative to Yahoo SMTP. It’s part of the Mailtrap Email Delivery Platform that allows you to test, send, and control your email infrastructure in one place.

Hit play to see it in action.

More importantly, Mailtrap allows you to scale with ease and have access to all the advanced tools that help make your campaigns and email sending more effective.

Okay, I’ve been there to see Mailtrap grow to the platform that it is today, so I could be subjective. But let me break down the features for you to help you make an informed decision.

In-depth analytics: You get a helicopter-view dashboard to assess the email performance at a glance. And there are drill-down reports where you can check the deliverability for different mailbox providers, email categories, and more.

24/7 human support: Yes, there are real people to address your support tickets quickly. Plus, we have deliverability experts who can assist with any technical challenge you may encounter.
Secure setup: All the DNS records are provided for you, and there’s an option to send setup instructions to a team member. And Mailtrap supports SSL and TLS.

SMTP and API: Even if you’re on a free plan, you get access to RESTful APIs and SDKs in major languages. This may be invaluable if you’re a dev and want to automate email-sending processes within your app or service.
Email templates: There’s a drag-and-drop interface to create visually appealing templates and accessible templates.

Dedicated IPs: If you send more than 100K emails a month, you can get a dedicated IP for greater control over your deliverability and sender reputation.
Email testing: Mailtrap email testing provides a fully-featured sandbox solution to check your emails without spamming real recipients.

Hope this gives you enough of a reason to give Mailtrap a try, so go on and hit the button below.

Try Mailtrap Email API/SMTP Now

Wrapping up

When all is said and done, Yahoo SMTP is an okay solution to get your feet wet with SMTP services. It’s super easy to set up, many of the processes have been automated, and email-sending is straightforward regardless of the client or app you use.

However, if you’re down for business, you’ll need to choose an SMTP provider with more features and much less limitations. Hopefully, it’ll be Mailtrap 😀.

We appreciate you chose this article to know about Yahoo SMTP. To read more articles on the related topics, visit Mailtrap blog!

Setting up GoDaddy SMTP to Send Emails

Veljko Ristic — Mon, 21 Oct 2024 12:56:27 +0000

When you think of an SMTP email server, GoDaddy isn’t the first thing that comes to mind. But the hosting behemoth gives you a few options to set it up, even if you want to use a third-party provider.

Here, I cover everything about GoDaddy SMTP, from options to use cases and detailed integrations.

Hop on to make the emails fly from your website or ecommerce.

What is a GoDaddy SMTP server?

GoDaddy SMTP is an SMTP relay that allows you to set up email sending and custom addresses from your domain. There are also email and calendar sharing options, as well as integrations with third-party email clients.

Note that the outgoing server isn’t enabled by default and it’s a paid feature (the basic email is just like a limited free trial), and the paid options are as follows:

Individual – you get a domain-based email and 10GB of storage.
Team – for team collabs; you get 30GB + sharing options.
Microsoft 365 Email Essentials – Microsoft backend + 10 GB of storage + compatibility with Apple Mail and Microsoft Outlook.
Microsoft 365 Online Business Essentials – 50 GB of storage + Microsoft web apps + collaboration options.

I haven’t covered any pricing since it’s hard to pinpoint the exact number because GoDaddy has rolling discounts and marked differences depending on whether you want to pay monthly or yearly. You can check the pricing here.

As for the actual SMTP server details, here’s what they are:

SMTP server address: smtpout.secureserver.net
Port: 465 (SSL) / 587 (TLS)
Authentication: Required
Username: Your full email address
Password: The account password you use for the email address

Important Note: Users report that GoDaddy blocks direct routing to an external SMTP server on all hosting plans, meaning you can only use their servers or Microsoft. The good news is that this isn’t entirely true and there are two ways around the block.

You can set up an external SMTP email provider and have full control over your email sending on GoDaddy VPS hosting plans. (Suggestion: reach out to GoDaddy support for more info on how to migrate from a different plan)
There’s an option to run the email setup via cPanel, but it’s tricky to validate your domain name and handle spam.

Tips:

Choose port number 587, especially if you’re setting up the SMTP for a WordPress website, the 465 alternative could be blocked.
Don’t just copy-paste the SMTP server details into your email client or site, there are steps before that, check the “How to configure…” section below.

Why should you use GoDaddy SMTP server?

If I were to be laconic, I’d say use GoDaddy because it’s convenient, but let’s break down the reasons in more detail:

You’re hosting with GoDaddy – for existing users, GoDaddy allows for a simple way to send professional emails using your custom domain (e.g. email@yourdomain.com).
Ease of use – Setting up GoDaddy SMTP is a click-and-copy-paste job, making the whole process straightforward even if you’re not tech-savvy.
Reliable delivery – The hosting provider uses authentication protocols to ensure emails are delivered securely and with minimal risk of being flagged as spam. (This goes assuming your domain hasn’t been compromised in any way.)

Note: Keep in mind that there are certain limitations that may make GoDaddy webmail a lesser choice, particularly if you want to send email campaigns. ↖️Click the link to learn more.

How to configure GoDaddy SMTP server settings?

For the configuration steps, I’m assuming you already have a domain set up with GoDaddy but haven’t configured email settings yet. The whole process takes a few steps, and I’ll also show you how to integrate the SMTP server with Thunderbird.

Step 1 – Enable email sending

Log into your GoDaddy account, click the account name, and select “My Products”. GoDaddy account dropdown

Scroll down, then click “Set up an email account” under the domain you want to use.

Quick tips: If the “Set up” button is declicked, click it to reveal the options. There’s also an alternative route: Click “Manage”, and then “Email” at the menu on the left.

Choose the option that best suits your needs (Individual or Team), and follow the GoDaddy wizard to add the service.

Step 2: Set up your email with GoDaddy

With the email feature enabled, go back to “My Products”, scroll down, and open the “Email & Office” menu.

Click the “Set up” button to proceed, and choose the domain you’d like to use (this goes assuming you have multiple domains). Then hit “Continue”.
Fill out the form and make sure to add an alternative email address.

Click the “Create” button, then log into your newly created email account to ensure everything’s working as it should.
Important: You need to turn on Authentication to enable GoDaddy’s SMTP. Under “Email & Office” select “Manage all” and navigate to your email address. Then, click the “Manage” button.
Scroll down to the “Account Information” section and click “Advanced settings”.

The action reveals the corresponding menu, where you need to make sure “SMTP Authentication” is toggled on.

Step 3: Integrate GoDaddy SMTP with your email client

As mentioned, I’ll be Thunderbird, but the setup logic is the same for other clients, though the naming and routes could be different. Anyway, here are the SMTP settings:

Launch Thunderbird, hit the gear icon to access “Settings”, and select “Account Settings”.

In the “Account Settings” menu, click “Account Actions” and choose “Add Mail Account”.

Type your email credentials (the credentials for the custom email you created in the previous steps), then hit Continue.

Note: You should be able to use the account almost immediately, but there could be intermediary authentication steps.

With Thunderbird IMAP is configured automatically based on the credentials you provided. But if you need to change the settings, click “Configure manually” and update them. (In most cases, this is a redundant step).

Bonus Step: Integrate GoDaddy SMTP with WordPress plugin

The case is: you’re hosting with GoDaddy and want to send emails from your website but avoid the notoriously unreliable native ‘wp_mail()’ function. I already blogged extensively on how to do this and you can check the full tutorial here. Now, I just want to give you the digest flow, for more details hit the link ⬆️.

Install the WP Mail SMTP plugin and activate it.
Launch the plugin, navigate to “Settings”, then scroll down to the “Mailer” section.
Choose “Other SMTP” and enter GoDaddy SMTP credentials as listed earlier.
Make sure to enter the proper username and password for your GoDaddy account.
Send a test email to confirm the configuration is working.

Reminder: While this is a convenient way and you don’t need to get a dedicated SMTP service, there are still GoDaddy SMTP limitations. So, if you, for example, want to send full-on email campaigns, it’s actually worth considering an alternative.

How to configure GoDaddy POP3 settings?

Depending on the type of setup you choose, POP3 or IMAP settings may be enabled by default. I’ll cover the technical details and a general setup flow for various clients and/or integrations via a WordPress plugin.

Technical details:

POP server address: pop.secureserver.net
Port: 995 (SSL required)
Username: Your GoDaddy email address
Password: The password for your email account

General setup flow:

Open your email client and head to the “Incoming Mail Server” settings. Depending on the client the naming could be different; e.g. Add Server, Incoming Server Settings, etc.
Choose POP3 as the protocol.
Enter the POP3 details for the server address, port, username, and password.
Save the changes and test the incoming mail functionality.

How to configure Godaddy IMAP settings?

As shown earlier, Thunderbird lets you select and integrate IMAP automatically, and you’ll encounter a similar flow with most contemporary clients. But if you need to do it manually (e.g. with a WordPress plugin), check the technical details below.

Note: I won’t include the general setup flow here since it’s not necessary, it’s exactly the same as for POP3. And the protocols are typically one above the other in email clients and WordPress SMTP plugins menus. Therefore, there’s almost no chance of getting lost.

Technical details:

IMAP server address: imap.secureserver.net
Port: 993 (SSL required)
Username: Your GoDaddy email address
Password: The password for your email account

Troubleshooting GoDaddy SMTP server configuration

Honestly, the issues with GoDaddy SMTP setup are few and far between. But just in case, check some problems that you might encounter.

Incorrect username or password: Double-check that you’re using the correct GoDaddy email credentials. These are the same credentials as for your GoDaddy account.
Port not working: Make sure you’re using the correct port (465 for SSL or 587 for TLS). If one port doesn’t work, try the other. As mentioned earlier, it would be better to try the 587 port first.
Firewall or ISP blocking SMTP: Your internal firewall and some ISPs block certain ports for security reasons. With popular ISPs this shouldn’t be too much of a problem, but the firewall could be the likely culprit. If so, whitelist or allow the SMTP in the firewall settings and restart the service.
SMTP Authentication not enabled: Verify that SMTP Authentication is turned on in your email client settings. To stress, you literally have to toggle on the Authentication as shown in the “How to configure…” section.

GoDaddy SMTP limitations or when not to use GoDaddy as a SMTP server

Here are the limitations to consider when choosing GoDaddy:

Email sending limits: GoDaddy imposes a daily sending limit (often 250 emails per day for standard accounts, and 500 emails via SMTP for Professional Email accounts). As indicated, this can be restrictive if you’re running email campaigns.
External SMTP server routing: As a reminder, you need a GoDaddy VPS hosting plan to set up an external SMTP server smoothly.
No advanced email analytics: GoDaddy’s SMTP server is mainly for basic email sending. If you need detailed email tracking, you might want to explore third-party options
Lack of email template support: GoDaddy does not offer built-in support for advanced email templates, making it less ideal for marketing emails.

Consider an alternative – using Mailtrap SMTP Service

Want to send more emails per day? Need detailed analytics to keep tabs on the performance of your emails? Then, Mailtrap Email API/SMTP is the service that ticks all the right boxes.

Why?

The Email API/SMTP is part of Mailtrap Email Delivery Platform that allow you to test, send, and control your emails. As such it’s a great solution for dev and marketing teams.

You can send as many emails a day as you need with flexible throughput limitations. Of course, this goes assuming your domain is healthy and the templates aren’t spammy. And you get email delivery stats that are hard to rival.

But, I’d like to dive a bit deeper into the features and show you all that’s worth your attention.

Security: You are provided with all the DNS records, you can copy-paste to your GoDaddy domain management. Plus, Mailtrap supports SSL and TLS.
Human support 24/7: We employ a team of experts who can address all your needs in a matter of hours. Also, there’s a dedicated delivery expert to assist you if you migrate to Mailtrap, for example.
In-depth analytics: A quick glance at Mailtrap’s helicopter-view dashboard allows you to check your stats on the fly. But there are quick-access drill-down reports across different verticals like email categories, mailbox providers, opens, clicks, etc.
Email templates: You get a drag-and-drop visual template builder. You can add merge fields using Handlebars, and it’s easy to switch to HTML editing.
SMTP and API: Besides SMTP, you get access to RESTful API and Mailtrap SDKs, even on a free plan. This helps you scale email sending and set up automation as your website, product or service grows.
Email testing: This is a sandbox solution to test your emails without spamming recipients. It helps debug the templates fast before moving them to production.
Dedicated IP: If you need to send more than 100,000 emails per month, you can get a dedicated IP to gain more control over your email infrastructure.

Wrapping up

All in all, GoDaddy SMTP is a good solution if you host your websites with them, but the use cases are limited. If you’re a small business or online service with a handful of customers, it may work well.

However, it’s still a paid feature, so it might be better to opt for a third-party provider that allows you to scale properly and have usable analytics. Guess what provider I’d recommend 😀

We appreciate you chose this article to know hoe to set up GoDaddy SMTP for email sending. To read more interesting articles on related topics, follow Mailtrap Blog!

How to Validate Emails in PHP: regex, filter_var(), and API Explained

Veljko Ristic — Tue, 14 May 2024 11:14:33 +0000

Be it marketing or transactional emails, email address validation is a necessity, or you could risk the reputation of your email domain.

This tutorial covers the ins and outs of PHP email validation and is primarily designed for beginners. However, I assume you already got the basics of PHP programming skills.

Also, I’d like to stress the difference between email validation and verification. Validation is about the correct formatting of an email address, and it’s a part of verification. It can be done on the server and the client side and I’ll focus on the server side here (no JavaScript, HTML, etc).

So, let’s get to coding.

Note: The exemplary scripts are based on PHP 8.3.6, and may not work on PHP 7.x.y versions.

PHP email validation function: filter_var()

The filter_var() function is part of PHP’s filter extension, which provides a convenient way to perform validation and sanitization of various data types using a single function call.

For email validation, filter_var() offers a straightforward, reliable method to quickly assess whether an email address is valid according to PHP standards. For instance, you could integrate it with email form validation on your website.

Here, I won’t cover the frontend stuff, input fields, and all. I already created an extensive PHP form validation guide, so feel free to check it out.

Anyway, the FILTER_SANITIZE_EMAIL (as part of ‘filter_var’ function) is engineered to remove characters not permitted in email addresses. This includes, but is not limited to:

Spaces,
Commas
Certain special characters (/, |, #, etc.)

The primary purpose of sanitizing email inputs is to ensure that the data is clean and safe to be processed or stored. This is important when the data gets displayed on a web page, or is included in database queries. The reason is that it helps prevent XSS (Cross-Site Scripting) and SQL injection attacks.

Here’s a practical example of how to sanitize an email input using filter_var():

<?php
// Example email input
$userInputEmail = "john.doe@example.com<script>alert('XSS');</script>";

// Sanitize the email input
$sanitizedEmail = filter_var($userInputEmail, FILTER_SANITIZE_EMAIL);

echo "Original: " . $userInputEmail . "<br>";
echo "Sanitized: " . $sanitizedEmail;
?>

In this example, the script tag would be removed from the email input, displaying the sanitized version as john.doe@example.com. It shows how FILTER_SANITIZE_EMAIL strips unwanted and potentially harmful characters from email inputs.

Following this, you would typically validate the sanitized email to ensure it meets the format standards for a valid email address, which I’ll discuss next using FILTER_VALIDATE_EMAIL.

Validating emails with `FILTER_VALIDATE_EMAIL`

The FILTER_VALIDATE_EMAIL checks whether the given string conforms to the format of a valid email address. It ensures the email address includes a valid username, an @ symbol, and a valid domain name with a domain extension.

Simply, FILTER_VALIDATE_EMAIL enforces proper email format standards. And here’s what the standards typically include:

A username – can contain letters, numbers, dots, hyphens, and underscores.
An @ symbol as a separator.
A domain name that includes letters and may contain dots or hyphens.
A domain extension, which must be at least two characters long and primarily contain letters.

While very effective for basic validation, the filter has some limitations:

Unicode characters: It does not support email addresses with international characters outside of the basic Latin alphabet.
Advanced formats: Certain valid email formats as per the Internet standards (RFC standards) may not be recognized by this filter, such as emails with quoted strings or certain special characters.

The limitations indicate that FILTER_VALIDATE_EMAIL may not suffice for applications requiring robust internationalization or adherence to the latest email address standards.

But no worries, I’ll tell you how to overcome that under the Email validation in PHP using API section. Here’s a practical example of how to use the filter for basic validation.

<?php
// Example email input
$userInputEmail = "john.doe@example.com";

// Validate the email input
if (filter_var($userInputEmail, FILTER_VALIDATE_EMAIL)) {
    echo "The email address '$userInputEmail' is considered valid.";
} else {
    echo "The email address '$userInputEmail' is considered invalid.";
}
?>

To wrap up, I’d like to give you some tips on how to handle verification failures without annoying your users.

User feedback: Just an “Invalid email address” message won’t suffice. Provide clear and constructive feedback to users, helping them understand why their email was invalid and what they can do to correct it.
Logging: Keep logs of failed validation attempts for debugging purposes or to identify potential misuse of the system.
Alternative validation: Consider alternative methods of validation for special cases, such as allowing list-specific addresses or domain-specific addresses

Regular expression for email validation in PHP

Regular expressions (regex) offer a flexible method for validating email addresses in a PHP function.

For instance, this approach works nicely in scenarios where you might need to validate emails based on specific criteria that are not covered by FILTER_VALIDATE_EMAIL, such as:

Restricting email addresses to certain domains.
Enforcing specific prefixes or suffixes in the email username.
Allowing newer top-level domains (TLDs) or internationalized domain names.

Also, regex can be used to implement complex pattern-matching rules necessary for applications requiring precise control over the user input.

Now, I’ll show you how to create and integrate a regex. But before that, I’d have to touch upon the components of an email address as defined by the RFC 5322 standard. It helps wrap your mind around pattern-matching syntax for email validation use cases.

Local part: The local part of the email (before the @ symbol) may include a variety of characters (a-z, A-Z, 0-9) including special characters such as . (dot), – (hyphen), and _ (underscore). It can also contain quoted strings allowing almost any character within the quotes.
Domain part: The domain part (after the @ symbol) typically includes alphanumeric characters and may include hyphens and dots. The domain must not start or end with a hyphen.

Here’s an example of a pattern that matches the given standards.

<?php
$email = "test@example.com";
$pattern = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';

if (preg_match($pattern, $email)) {
    echo "The email address '$email' is considered valid.";
} else {
    echo "The email address '$email' is considered invalid.";
}
?>

The regex matches the following:

One or more characters in the local part, including alphanumeric characters and special characters (._%+-).
An @ symbol, separating the local and domain parts.
A domain part consisting of one or more alphanumeric characters, potentially including dots and hyphens.
A top-level domain (TLD) that must be at least two characters long.

So far so good, but if you need a more custom thing, here are a couple of suggestions on how to tweak the function filters.

Tighten the criteria: Restrict the email to specific domains or subdomains by replacing the domain part of the pattern with a literal string (e.g., example.com).

// Example for tightened criteria: Only allowing emails from specific domains
$pattern = '/^[a-zA-Z0-9._%+-]+@(example\.com|example\.net)$/';

Relax the criteria: Allow additional characters in the local part or more variations in the TLD.

// Example for a relaxed criteria: Allowing international characters in the local part
$pattern = '/^[a-zA-Z0-9._%+-\p{L}]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/u';

Even though regexes provide significant control over input validation, it’s vital to test thoroughly (I’ll cover that in a second) to ensure that the pattern meets all functional requirements. The goal is to avoid excluding valid emails or including invalid ones inadvertently.

This is how you might approach testing a regex pattern for email validation:

<?php
$emails = [
    "test@example.com", // Valid
    "test.example@com", // Invalid: no top-level domain
    "test_example.com", // Invalid: missing '@'
    "test@example.com.", // Invalid: dot at the end of the domain
    "ñandu@dominio.com" // Valid if Unicode is considered
];

$pattern = '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/';

foreach ($emails as $email) {
    if (preg_match($pattern, $email)) {
        echo "The email address '$email' is valid.\n";
    } else {
        echo "The email address '$email' is invalid.\n";
    }
}
?>

Also, you should consider debugging, check the tips to follow:

Use online regex testers: Tools like Regex101 or RegExr can help visualize how your regex matches against test strings, providing explanations and highlighting potential issues.
Log troublesome inputs: When a user input fails validation, log the input for review. This can help identify what the regex may be failing to catch.
Unit testing: Implement unit tests to automatically check the regex against known valid and invalid emails.

As regexes can be a blessing and a curse, I’ll finish this section with some best practices and common mishaps.

Best Practices:

Keep it readable: While regex can be compact, overly complex patterns can become unreadable and difficult to maintain. Use comments and break complex patterns into smaller parts if necessary.
Use non-capturing groups: Unless you need to capture parts of the email for later use in the code, use non-capturing groups(?: ...) to avoid unnecessary performance overhead.
Specify character ranges explicitly: Avoid using broad classes like ‘.\*’ when validating emails. Instead, encode exactly which characters are allowed in each part of the email.
Use anchors: Always use ^ (start of string) and $ (end of string) anchors to ensure that the entire string matches the pattern, preventing partial matches.

** Common Mishaps:**

Escaping characters: Failing to escape special regex characters like ., ?, and + can lead to unintended matches.
Performance issues: Regex that uses excessive backtracking (e.g., nested quantifiers like (a+)+) can cause performance issues.
Unicode ignorance: If international characters are a requirement, forgetting to handle Unicode properly can exclude valid emails with international characters.

Email validation in PHP using API

APIs offer advanced capabilities beyond what local methods can provide, and here’s what they are.

Enhanced accuracy: APIs often use sophisticated algorithms with a real-time data lookup that goes beyond simple format validation. They can check if an email address is correctly formatted and verify it (confirm the address exists and can receive emails).
Reduce local resource usage: Offloading the validation process to an external service can reduce the load on your local systems, which is beneficial for applications with high volumes of email processing.
Access to additional data: Some APIs also offer information like whether the email is a disposable address, its risk score for being spam, or its general reputation.

For this tutorial, I’ll discuss a generic approach to integrating an email validation API. While specific details can vary between providers, the general principles of making a request and handling a response are similar across most services.

I assume that you already chose an email validation API provider and obtained their API credentials. So, here’s how to implement the request.

<?php
$email = "test@example.com";
$apiKey = "YOUR_API_KEY";
$apiUrl = "https://api.emailvalidator.com/validate?apiKey={$apiKey}&email={$email}";

$response = file_get_contents($apiUrl);
if ($response !== false) {
    $data = json_decode($response, true);
    print_r($data);
} else {
    echo "API request failed.";
}
?>

In this scenario, it’s also important to handle API responses properly and manage errors. The responses usually come in JSON format containing various fields indicating the validation results. You need to parse these responses and react accordingly in your application logic.

As for managing errors, you should cover network issues, invalid API keys, or exceeded rate limits. Use try-catch blocks or check for errors in the response to ensure robustness. Here’s an example.

<?php
try {
    $response = file_get_contents($apiUrl);
    if ($response === false) {
        throw new Exception("API request failed.");
    }
    $data = json_decode($response, true);
    if (isset($data['error'])) {
        throw new Exception("Error from API: " . $data['error']);
    }
    print_r($data);
} catch (Exception $e) {
    echo "An error occurred: " . $e->getMessage();
}
?>

Email validation as part of email testing

I won’t beat around the bush, here are four main reasons to validate addresses when testing emails.

Deliverability, deliverability, and always deliverability

By verifying that an email address is formatted correctly and is valid, you reduce the risk of sending emails to non-existent addresses, which can hurt your sender’s reputation and impact deliverability.

Spam compliance

Sending emails to invalid addresses frequently leads to higher bounce rates, which are monitored by Internet Service Providers (ISPs). Consequently, it can lead to blacklisting of your sending IP address. By ensuring that email addresses are valid, you avoid penalties associated with violating spam laws (CAN-SPAM and GDPR).

Improved quality of user data

Regular email validation as part of email testing helps maintain high-quality user data. Clean, validated email lists improve the effectiveness of email marketing campaigns and reduce the cost associated with managing undeliverable emails.

Automation

Automating email validation processes can significantly enhance the efficiency and reliability of your email testing strategies. Automation ensures that email validation checks are performed consistently, without manual intervention, making the processes scalable and error-resistant.

Of course, there are specific tools and techniques to automate email tests. First, I’ll cover Mailtrap Email Testing, part of Mailtrap Email Delivery Platform. Then, I’ll talk about dedicated validation services, custom scripts, and cron jobs.

Mailtrap Email Testing is an email sandbox to inspect and debug emails in staging, dev, and QA environments before sending them to recipients.

I need to stress that the sandbox doesn’t include email validation. However, you can run a custom validation script and a cron job in parallel with Mailtrap Email Testing. Or you could check the addresses just before sending the emails on production.

This is particularly useful if you use Mailtrap Testing API, which allows you to easily test templates and automate QA processes. Then, you can switch from sandbox to production environment and keep sending to valid addresses.

Aside from a reliable REST API, and a fake SMTP server, you also get the following:

HTML/CSS check
Spam score check
API for QA automation
Ready-to-use integrations in 20+ languages (Ruby, Python, PHP, Node.js, .Net, etc.)
Emails preview
Multiple inboxes for different projects and stages
User management, SSO

Lastly, the whole setup is straightforward, you just need to do the following:

Sign up for Mailtrap
Go to Email Testing > Inboxes > My Inbox
Choose your preferred integration or copy-paste SMTP credentials to your project
Run the code and get the test email in an instant

Now, here’s a custom PHP email validation script that can be run as a cron job to validate email addresses with a third-party API:

<?php
function validateEmail($email) {
    $apiKey = 'YOUR_API_KEY';
    $apiUrl = "https://api.emailvalidator.com/validate?apiKey={$apiKey}&email={$email}";

    $response = file_get_contents($apiUrl);
    if ($response !== false) {
        $data = json_decode($response, true);
        return $data['isValid'];
    }
    return false;
}

// Example email to validate
$email = 'test@example.com';
if (validateEmail($email)) {
    echo "Email is valid.\n";
} else {
    echo "Email is invalid.\n";
}
?>

Also, here’s how to automate the whole thing with a cron job on a Linux server.

0 1 * * * /usr/bin/php /path/to/your/script.php

The job runs the script once a day at 1:00 AM.

Now, your task is to set up all the automation, sit back and relax knowing your domain and IP reputations are safe.

We appreciate the you chose this article to know more about PHP email validation. If you want to find more interesting content on related topics, follow Mailtrap blog!

Creating a WordPress Contact Form – Complete Guide

Veljko Ristic — Wed, 17 Apr 2024 05:17:18 +0000

I’ll make you an offer you can’t refuse. 🐈

I’ll tell you how to create a WordPress contact form, covering every imaginable detail, and making sure you won’t be reading only code and industry jargon.

So, this article is suitable for beginners and those who already have some experience and wish to get the most from a basic contact form in terms of security and user experience.

Now, get your fingers cracking and let’s start.

How to create a contact form in WordPress with a plugin?

The contact form plugin method is the simplest and fastest. Though there are some security limitations and plugins aren’t as flexible as coding stuff yourself.

Here I’ll use WPForms (the WPForms Lite – free version) as it’s most reliable and straightforward. Another honourable option to consider is Ninja Forms.

Whichever plugin you choose, it might be worth considering installing auxiliary add-ons like Jetpack for advanced spam control and security. I won’t be going into details of that here, since I cover security, validation, and sanitization the fun way – I tell you how to code it yourself. 😀

Here goes the step-by-step tut to install and use arguably the best WordPress contact form plugin.

Step 1: Install and Activate the WPForms Plugin
Go to the sidebar WordPress admin panel. Then, navigate to Plugins > Add New, look for “WPForms“.

Now, click on the grey Install Now button next to the plugin called Contact Form by WPForms.

The last thing to do is activate the plugin.

Step 2: Create a New Contact Form
After activating WPForms, navigate to WPForms > All Forms in the WordPress dashboard. Then, click the Add New button to open the WPForms drag-and-drop form builder.

In the form builder plugin, give your contact form a name, then select the contact form template. WPForms Lite comes with a few free form templates.

For simplicity, I selected the Simple Contact Form template; it’ll automatically add the Name, Email, and Message fields. But if you’re a small business or ecommerce, the RFQ, Billing, or newsletter signup forms would also work.

Step 3: Customize your form
Click on a form field to bring up a Field Options panel on the left to make changes to the field label or other form settings. You can also use your mouse to drag and drop the fields to change the order.

Here, I’m doing a user-friendly Contact Us form without fancy fields. You can create any other type of registration form and align it with your WordPress themes if necessary.

Pro Tip: Don’t go overboard with the fields as it’ll affect form submissions. 3 to 5 fields is usually more than enough.

Step 4: Save your form
Once you’re done customizing your form, make sure to click the Save button.

Step 5: How to add a contact form to a Page
You can add it to an existing contact page or create a new page in WordPress. To create a new contact form page, go to Pages > Add New and give your page a name.

Use the WPForms block to add the form to the page.

Click the Plus add block button and search for WPForms. Select the simple form you created earlier from the drop-down menu. WPForms will load the contact form preview inside the editor.

Finally, click Publish or Update to save your form.

Step 6: Using WordPress plugin shortcodes
WPForms comes with a WordPress contact form shortcode. You can use it by visiting WPForms > All Forms and then copying the shortcode next to your form.

Open the page builder where you want to add the shortcode, click the Plus add block button, and search for “Shortcode”.

Paste the shortcode that you copied above into the box, then click Update or Publish.

How to create a simple contact form in WordPress without a plugin?

Here, I’ll tell you how to create more advanced forms without any plugins. With that, you’ll have more control over the email notifications from the form itself.

Note: This is one of WordPress tutorials that assumes you have basic coding skills.

Step 1: Create a new HTML form inside WP Pages
You can add the form to an existing page or create a new one.

To create a new contact form page, go to Pages > Add New and give your page a name. Afterward, click add block “Custom HTML”

Step 2: Create the HTML structure of the contact form
Create the HTML structure of your contact form. Here’s an example:

<form id="contact-form" action="/wp-admin/admin-post.php" method="post">
    <input type="hidden" name="action" value="submit_contact_form">
    <label for="name">Name:</label>
    <input type="text" name="name" id="name" required><br>
    <label for="email">Email:</label>
    <input type="email" name="email" id="email" required><br>
    <label for="message">Message:</label>
    <textarea name="message" id="message" required></textarea><br>
    <input type="submit" value="Submit">
</form>

The form contains, Name, Email, and Message fields, and a form button for submitting the form. But if you want to go super fancy you could also add some conditional logic, pull data from a CRM, add checkbox, etc.

Note: The super fancy stuff would require quite a bit of coding and integration of third-party APIs into the PHP structure of your WordPress site.

Intermediary step: Custom CSS styles
The default HTML style looks a bit bland. Here’s a sample CSS to beautify the form:

<style>
#contact-form {
    width: 100%;
    max-width: 500px;
    margin: 0 auto;
    padding: 20px;
    background-color: #f9f9f9;
    border: 1px solid #ddd;
    border-radius: 5px;
}

#contact-form label {
    display: block;
    margin-bottom: 5px;
    font-weight: bold;
}

#contact-form input[type="text"],
#contact-form input[type="email"],
#contact-form textarea {
    width: 90%;
    padding: 10px;
    margin-bottom: 20px;
    border: 1px solid #ddd;
    border-radius: 5px;
}

#contact-form input[type="submit"] {
    background-color: #007BFF;
    color: white;
    padding: 10px 20px;
    border: none;
    border-radius: 5px;
    cursor: pointer;
}

#contact-form input[type="submit"]:hover {
    background-color: #0056b3;
}
</style>

<form id="contact-form" action="/wp-admin/admin-post.php" method="post">
    <input type="hidden" name="action" value="submit_contact_form">
    <label for="name">Name:</label>
    <input type="text" name="name" id="name" required><br>
    <label for="email">Email:</label>
    <input type="email" name="email" id="email" required><br>
    <label for="message">Message:</label>
    <textarea name="message" id="message" required></textarea><br>
    <input type="submit" value="Submit">
</form>

Note/Advanced Tip:

The basic HTML form I created already accepts the styles. The style tag at the beginning of the HTML contains the CSS rules that style the form. These rules apply to all elements within the #contact-form element because of the way CSS works.

However, if you want to separate the CSS from the HTML, you can move the CSS code to a separate .css file and link it to your HTML file. Here’s how you can do it:

Create a new .css file in your theme directory, let’s call it custom_form.css. Copy the CSS rules from the style tag and paste them into this file.
Link the CSS file in your HTML file. You can do this by adding a link tag in the head section of your HTML file. Here’s an example:

<head>
    <!-- Other head elements -->
    <link rel="stylesheet" href="/path/to/your/theme/directory/custom_form.css">
</head>

Replace /path/to/your/theme/directory/ with the actual path to your theme directory.
Now, the styles defined in contact-form.css will be applied to your form.

Step 3: Create a Function to Handle Form Submission
In your theme’s functions.php file, add the following PHP function to handle form submission:

<?php

/**
 * Some other theme functions
 */


function handle_contact_form_submission() {
    if( isset($_POST['action']) && $_POST['action'] === 'submit_contact_form' ) {
        $name = sanitize_text_field( $_POST['name'] );
        $email = sanitize_email( $_POST['email'] );
        $message = sanitize_textarea_field( $_POST['message'] );
        $adminEmail = get_option( 'admin_email' );

        // Here, you can add your code to process the form data (e.g., send an email).
        wp_mail($adminEmail, sprintf("New message from %s email:%s", $name, $email), $message);

        // Redirect the user back to the main or contact page after form submission.
        wp_redirect( home_url('/') );
    }
}


add_action( 'admin_post_nopriv_submit_contact_form', 'handle_contact_form_submission' );
add_action( 'admin_post_submit_contact_form', 'handle_contact_form_submission' );


?>

Step 4: Don’t forget to sanitize and validate user input
Before processing the form data, you should sanitize and validate it to protect your site from malicious inputs. WordPress provides several functions for this purpose, such as sanitize_text_field(), filter_var(), and validate_email().

Pro Tip: If your form has to handle a file upload on top of other functionalities, you need to sanitize and validate that file as well.

And congrats! You’ve created a contact form in WordPress without plugins and extra files.

Create a callback function with validations and a captcha

Here, I’ll tell you how to create more advanced forms, get better spam protection, and improve user registration on your WordPress website with some JavaScript tricks

This step is more secure and easier to maintain, with just a tiny code snippet.

To make everything neat and speed up the integration process for a custom form, I’ll create a single PHP function from all the code discussed under creating a contact form without a plugin.

Then, you can use the function as the callback function of the shortcode. Here are the steps:

Step 1: Create a shortcode
Create a shortcode that will output your form. This can be done in the functions.php file:

add_shortcode( 'custom_contact_form', 'custom_contact_form_shortcode' );
function custom_contact_form_shortcode() {
    // Code goes here
}

Step 2: Shortcode function
Inside the custom_contact_form_shortcode function, add the HTML structure of your contact form.

function custom_contact_form_shortcode() {
    ob_start(); ?>
    <form id="contact-form" action="<?php echo esc_url( $_SERVER['REQUEST_URI'] ); ?>" method="post">
     <input type="hidden" name="action" value="submit_contact_form">
     <label for="name">Name:</label>
     <input type="text" name="name" id="name" required><br>
     <label for="email">Email:</label>
     <input type="email" name="email" id="email" required><br>
     <label for="message">Message:</label>
     <textarea name="message" id="message" required></textarea><br>
     <input type="submit" value="Submit">
    </form>

    <?php return ob_get_clean();
}

Step 3: Handling form submissions
While still inside the custom_contact_form_shortcode function, add the code to handle form submissions, validate data input and display messages.

function custom_contact_form_shortcode() {
    ob_start();

    if( isset($_POST['action']) && $_POST['action'] === 'submit_contact_form' ) {
        $name = sanitize_text_field( $_POST['name'] );
        $email = sanitize_email( $_POST['email'] );
        $message = sanitize_textarea_field( $_POST['message'] );


        // Initialize an array to hold validation messages
        $validation_messages = [];

        // Validate the data
        if (strlen($name) === 0) {
            $validation_messages[] = 'Please enter a valid name.';
        }

        if (strlen($email) === 0 || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $validation_messages[] = 'Please enter a valid email address.';
        }

        if (strlen($message) === 0) {
            $validation_messages[] = 'Please enter a valid message.';
        }

        // Check if there are any validation messages
        if (!empty($validation_messages)) {
            foreach ($validation_messages as $validation_message) {
                echo '<div class="validation-message">' . esc_html($validation_message) . '</div>';
            }
        } else {
            // If there are no validation messages, send the email
            $adminEmail = get_option( 'admin_email' );
            $headers = array('Content-Type: text/html; charset=UTF-8');
            wp_mail($adminEmail, 'New message from ' . $name, $message, $headers);
            echo '<div class="success-message">Your message has been sent successfully.</div>';
        }
    }

    // Code for the form goes here

    return ob_get_clean();
}

Now, after taking the time to create a callback function, you can just use[custom_contact_form] in your WordPress pages or posts, and the contact form will show up.

Nevertheless, my form isn’t ideal yet. For instance, if a user types invalid info, the system gets executed on a reloaded page, so the data is lost. This is as annoying as a floating popup and will surely make people churn.

But, it can be solved if I replicate the PHP validation with JavaScript. I’ll be covering that in the JavaScript validation section.

Step 4 Add Captcha to contact form
To implement reCaptcha, you’ll need to register your site on the Google reCaptcha website to get a site key and secret key. Then, you can add the reCaptcha widget to your form and verify the user’s response using the secret key.

This may seem as an overkill, but bots are getting smarter, so CAPTCHA gives you the extra edge to ward off malicious submissions.

Step 5: Implement CSRF protection
To protect your form from Cross-Site Request Forgery (CSRF) attacks, you can use WordPress’s built-in CSRF API.

First, you’ll need to generate a nonce (number used once) using the wp_nonce_field() function in your form. Then, you can verify the nonce in process-form.php using the wp_verify_nonce() function.

// In your form
wp_nonce_field( 'submit_contact_form_nonce', 'submit_contact_form_nonce_field' );

// In custom_contact_form_shortcode
if (!isset($_POST[submit_contact_form_nonce_field]) || !wp_verify_nonce($_POST[submit_contact_form_nonce_field], submit_contact_form_nonce)) {
    die('Invalid request');
}

Pro Tip:

Some WordPress hosting providers may offer additional CSRF protection. However, this is typically done at the application level. So, you should better search wordpress.org for add-ons or libraries that fit your use case, or just implement the above.

Step 6: Send Email
Finally, you can send an email using the $wpdb->get_row() function to retrieve the site administrator’s email address from the WordPress database, and the wp_mail() function to send the email.

Note: This isn’t the best solution since the given function is notoriously unreliable. No worries, I’ll tell you how to implement a proper email-sending service and avoid wp_mail() limitations.

$adminEmail = get_option( 'admin_email' );
$headers = ['Content-Type: text/html; charset=UTF-8'];
wp_mail($adminEmail, 'New message from ' . $name, $message, $headers);

Thank you for reading the snippet on Creating a WordPress Contact Form, in order to get more information about JavaScript validation and sending email with WP contact form - read the full article on Mailtrap blog.

How to Set up PHP Form Validation – Detailed Tutorial

Veljko Ristic — Fri, 29 Mar 2024 16:49:47 +0000

PHP form validation helps maintain data integrity and security, preventing SQL injection, XSS, and other malicious attacks.

From the user input perspective, it prevents issues such as storing incorrect or incomplete data in the database. Plus, users can get immediate feedback about the input’s correctness, which improves their experience with your product.

In this article, we’ll cover different types of validation for a simple registration form, starting with a quick overview of the available options.

Choosing a PHP form validation method

There are a few options to validate a PHP form – you can use a PHP script, Ajax, JS, or a database.

I’ll briefly cover the benefits and challenges of each. Then, we’ll move to integration tutorials, including exemplary scripts.

Benefits:

Flexibility and control over the validation process.
Scripts can automate repetitive tasks such as data cleaning or analysis after form submission.
They allow for custom processing and logic that may not be possible with standard form handling.

Challenges:

Custom scripts require maintenance and updates as requirements change or technology evolves.
Potential for security vulnerabilities if not implemented securely.

AJAX validation

Benefits:

AJAX allows asynchronous form submissions without page refreshes, providing a smoother user experience.
It enables real-time validation and feedback, which can improve user engagement and reduce errors.

Challenges:

AJAX can add complexity to the development process due to specific syntax and logic. May be challenging for developers unfamiliar with JavaScript and asynchronous operations.
The functionality depends on JavaScript being enabled in the user’s browser, which may not always be the case.
AJAX requests can be vulnerable to cross-site request forgery (CSRF) attacks unless properly secured.

JavaScript validation

Benefits:

JavaScript provides immediate feedback to users, improving the user experience by catching errors before the form is submitted.
By validating on the client side, you can reduce the load on your server since invalid forms won’t reach the server.

Challenges:

Client-side validation can be easily bypassed by disabling JavaScript or manipulating the DOM, so it should never replace server-side validation.
Not all browsers interpret JavaScript in the same way, which can lead to inconsistent behavior.
May not be accessible to users with disabilities who rely on assistive technologies that might not work well with JavaScript.

Database validation

Benefits:

Storing form data in a database ensures that the data is persistent and can be accessed later for various purposes.
Databases are designed to handle large amounts of data and can scale as needed.

Challenges:

Writing to a database can be slower than other methods and can impact performance, especially if the database is not optimized.
Managing database connections and queries adds complexity to the application.

Note that the choice of method depends on the project’s specific needs, the resources available, and the development team’s expertise.

Also, it’s important to implement multiple validation layers:

Client-side for user experience
Server-side for security
Database interaction for data persistence

By combining these layers and incorporating sanitization practices, you can build robust and secure forms that enhance your application’s functionality and user experience. Additionally, consider exploring server-side validation libraries for streamlined implementation and advanced features.

How to validate a form in PHP using script

I’ll start with a basic PHP validation script as it’s one of the quickest methods to implement.

In this PHP tutorial, I won’t be adding any CSS to the HTML entities as the main focus is on the email form validation.

Step 1 – Create an HTML form

Design your form with the necessary fields and include a submit button.

<form method="post" action="validate.php">
    Name: <input type="text" name="name"><br>
    Email: <input type="text" name="email"><br>
    <input type="submit" name="submit" value="Submit">
</form>

Step 2 – Sanitize and validate Input

At the beginning of your PHP script, sanitize and validate the input. Use the $_POST superglobal array to access the input field form data.

<?php
if ($_SERVER["REQUEST_METHOD"] === "POST") {
    // Sanitize and validate name
    $name = test_input($_POST["name"]);
    $nameErr = "";
    if (!preg_match("/^[a-zA-Z ]*$/",$name)) {
        $nameErr = "Only letters and white space allowed";
    }

    // Sanitize and validate email
    $email = test_input($_POST["email"]);
    $emailErr = "";
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $emailErr = "Invalid email format";
    }

    // ... Additional validation checks ...
}

function test_input($data) {
    $data = trim($data);
    $data = stripslashes($data);
    $data = htmlspecialchars($data);
    return $data;
}
?>

Step 3 – Display Errors

If there are validation errors, display them to the user. Otherwise, proceed with the form processing.

if ($nameErr != "" || $emailErr != "") {
    echo "<b>Error:</b>";
    echo "<br>" . $nameErr;
    echo "<br>" . $emailErr;
} else {
    // Process the form data
    echo "Form submitted successfully";
}

Pro Tips

To prevent XSS attacks and preserve data integrity, you can use the php echo htmlspecialchars function. It also makes the validation compatible with different encodings like UTF-8. Here’s the exemplary snippet:

$userInput = "<script>alert('Hello!');</script>";
echo htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8');

If the form passes validation, you can process the data accordingly, such as inserting it into a database or sending an email. I’ll show you how to send an email later.
To avoid repeating code, encapsulate the validation logic within functions or classes and reuse them across different forms.
As your application and validation needs grow, consider structuring the validation using OOP logic. It makes the code more modular, and easier to maintain, and it improves code organization. Check the example below.

class FormValidator {
    private $data;
    private $requiredFields = [];
    public function __construct($postData) {
        $this->data = $postData;
    }

    public function validate() {
        // Common validation rules
        $this->validateRequiredFields();
        $this->validateEmailFormat();
        // Add more validation methods as needed
    }

    private function validateRequiredFields() {
        // Check if required fields are present
        foreach ($this->requiredFields as $field) {
            if (empty($this->data[$field])) {
                throw new Exception("{$field} is required.");
            }
        }
    }

    private function validateEmailFormat() {
        // Check if email field is in a valid format
        if (!filter_var($this->data['email'], FILTER_VALIDATE_EMAIL)) {
            throw new Exception("Invalid email format.");
        }
    }

    // Define other validation methods...
}

// Usage
if ($_SERVER["REQUEST_METHOD"] === "POST") {
    $validator = new FormValidator($_POST);
    try {
        $validator->validate();
        // If validation passes, process the form
    } catch (Exception $e) {
        echo $e->getMessage();
    }
}

If necessary you can add a checkbox or a radio button to the form, then validate that input. Here’s an example:

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    // Radio button validation
    if (!isset($_POST['gender']) || empty($_POST['gender'])) {
        echo "Gender selection is required.<br>";
    } else {
        $gender = $_POST['gender'];
        // You can add additional validation here if needed
    }

    // Checkbox validation
    if (!isset($_POST['terms']) || $_POST['terms'] !== 'agree') {
        echo "You must agree to the terms and conditions.<br>";
    } else {
        // User agreed to terms and conditions
    }

    // If no errors, process the form
    if (empty($errors)) {
        echo "Form submitted successfully.";
    }
}
?>

How to validate a form in PHP using AJAX

AJAX offers a smooth user experience indeed, but note that you’ll also need to implement server-side CSRF protection. I won’t be covering that in this article.

Step1 – Create an HTML form

Start with a simple form in your HTML file with the action set to a PHP script and the method set to POST.

<form id="contactForm" action="process.php" method="post">
    Name: <input type="text" name="name" required><br>
    Email: <input type="email" name="email" required><br>
    Message: <textarea name="message" required></textarea><br>
    <input type="submit" value="Submit">
</form>
<div id="response"></div>

Step 2 – Use Javascript for AJAX submission

Write a native Javascript function that prevents the default form submission and sends the form data via AJAX to the server.

const form = document.getElementById('contactForm');

form.addEventListener('submit', function(event) {
  event.preventDefault();

  const formData = new FormData(form);

  fetch(form.action, {
    method: 'POST',
    body: formData
  })
  .then(response => response.text())
  .then(data => {
    document.getElementById('response').innerHTML = data;
  })
  .catch(error => {
    console.error('Error:', error);
  });
});

Step 3 – Handle form validation in PHP

Create a process.php file to handle the form submission. Use PHP’s built-in functions like filter_var() to check for valid email address and trim() to remove extra spaces.

<?php
$name = trim(filter_input(INPUT_POST, 'name', FILTER_SANITIZE_STRING));
$email = trim(filter_input(INPUT_POST, 'email', FILTER_SANITIZE_EMAIL));
$message = trim(filter_input(INPUT_POST, 'message', FILTER_SANITIZE_STRING));

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    echo "Invalid email format";
} else {
      // Process the form data (using prepared statements for database interaction)

    echo "Form submitted successfully";
}
?>

How to validate a form in PHP using JavaScript

Similar to AJAX, JS is great for improved user experience, but you’ll still need to make sure the method can’t be manipulated. So it’s wise to implement server-side validation as well.

Step 1 – Create an HTML form

Similar to the AJAX example, create a form in your HTML file.

<form id="contactForm" action="process.php" method="post">
    <!-- form fields -->
    <input type="submit" value="Submit">
</form>
<div id="error"></div>

Step 2 – Implement JavaScript validation

Add a JavaScript function to validate the form fields before submission.

function validateForm() {
    var email = document.forms["contactForm"]["email"].value;
    var errorDiv = document.getElementById("error");

    if (!validateEmail(email)) {
        errorDiv.innerHTML = "Invalid email format";
        return false;
    } else {
        errorDiv.innerHTML = "";
        return true;
    }
}

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

Ensure that you also validate the data on the server side using PHP, as client-side validation can be bypassed. And make sure your PHP file is properly protected.

Important Note:

The validation script contains a mile-long regex. It works, but it’s not exactly an example of best coding practice, and in a real-world scenario, you’d want to use a JS validation library to avoid false positives or negatives. Here’s an example with the email-validator lib:

// Import the email-validator library
var validator = require('email-validator');

function validateForm() {
    var email = document.forms["contactForm"]["email"].value;
    var errorDiv = document.getElementById("error");

    if (!validator.validate(email)) {
        errorDiv.innerHTML = "Invalid email format";
        return false;
    } else {
        errorDiv.innerHTML = "";
        return true;
    }
}

PHP form validation: more use cases

Aside from what’s already covered, which is mostly email and name validation. There are several other form elements you may want to validate. Also, it’s advisable to include CAPTCHA with your forms to ward off bots.

The quick tutorials below include CAPTCHA integration, empty field, phone number, and website validation. Depending on your specific use case, and the form you created, you probably won’t need all.

CAPTCHA

As indicated, CAPTCHAs are used to verify that the user is human and not a bot. They typically involve solving a puzzle or identifying objects in images. Here’s how to integrate it.

Include a CAPTCHA library: Choose a library or service to generate the CAPTCHA image. Google’s reCAPTCHA is a popular choice.
Generate CAPTCHA image: When the form is loaded, call the captcha library’s API to generate a captcha challenge.
Embed CAPTCHA in the form: Display the CAPTCHA image in your form where users can see it.
Validate CAPTCHA response: When the form is submitted, check the user’s response against the CAPTCHA library’s verification API.
Handle verification result: If the captcha was solved correctly, continue processing the form. Otherwise, display an error message.

Want to find more code examples and information on PHP Form Validation? Check out an original post published on Mailtrap blog.

Salesforce Apps to Keep Under Your Radar

Veljko Ristic — Mon, 18 Mar 2024 12:40:16 +0000

Salesforce Apps, available through the Salesforce Appexchange, serve a diverse array of business services to help enhance your admins’ operational efficiency.

Among the multitude of functionalities, the role of email infrastructure stands out as integral. And it touches upon critical aspects of your email flows, including:

Synchronization
Analytics
Templates
Campaigns
Security
Compliance
Document generation and validation

To explain it a bit simpler, Salesforce is about the seamless integration of email communication with customer data. In turn, you get to have personalized interactions with your clients. Also, you get to make informed business decisions based on those interactions.

All things considered, it’s safe to say that the existence and usability of these apps also helped with widespread Salesforce adoption.

Speculations aside, we delve into some of the most effective Salesforce applications for various components of your email infrastructure. So, let’s dive right in.

Best Salesforce Apps: A Quick Overview

When evaluating Salesforce apps related to email infrastructure, it’s essential to keep in mind that the “best” app depends heavily on specific business needs and workflows.

For example, sales cloud users looking for ways to improve their sales process might require different apps than service cloud users. But, to guide this exploration, we’ve considered the universal factors that contribute to an array of business workflows related to email infrastructure.

Firstly, the features offered by the app play a significant role. We looked for apps that provide a robust set of capabilities, giving users the flexibility to manage various aspects of email infrastructure efficiently.

Secondly, we took 15+ years of our experience in building and maintaining email infrastructures and distilled it into editorial chunks to give you a first-hand assessment of the given apps.

We aim to gauge the following:

Real-world applications
Reliability
How the apps match up to their advertised promises.

Also, we’ve checked how these apps have aided businesses in solving their unique challenges.

Finally, compatibility with Salesforce is a non-negotiable criterion.

The chosen apps integrate seamlessly with Salesforce.com, ensuring users can conveniently leverage their capabilities within the CRM environment.

However, some of the listed apps are paid-only and geared more towards advanced Salesforce org users, which with be explicitly stated within the review. Some also offer free options and, as there’s no free Salesforce, it’s a good way to test things out before you commit to a plan.

Having accounted for all of the above, we’ve selected and categorized a range of Salesforce apps that excel in handling specific email infrastructure tasks. Read on for more details.

Salesforce Apps for Email Synchronization

Efficient email synchronization is pivotal in streamlining your Salesforce operations, ensuring all relevant communication is captured and accessible within the platform. With these, you take the functionality of the Lightning app to the next level.

Anyway, here’s one of the top apps in this arena.

Cirrus Insight

Cirrus Insight acts as a bridge between the Salesforce environment and your inbox, reducing the tedious task of constantly flipping between email and Salesforce.

Key features

The automatic sync of emails and attachments from your inbox to Salesforce truly stands out. It enables you to efficiently store and access every relevant piece of communication within Salesforce.

Calendar Sync is another notable feature. It ensures all your meetings, calls, and events (like a webinar, for example) are synced between your email and Salesforce, providing frictionless scheduling and improved time management.

Cirrus Insight also offers contextual Salesforce insights right in the inbox. With this feature, you can view and update Salesforce records without leaving your email, making for a more efficient workflow.

Our two cents

Indeed, the automatic sync feature is a significant productivity booster. We appreciate the ease of accessing Salesforce data right from the inbox. This will consistently shave off minutes from your workflow, leading to improved time efficiency.

Now, we have to stress that there’s a bit of a learning curve, as this app is for intermediate to advanced users of the Marketing Cloud, and other Salesforce editions. The good news is that the app is well-documented, so you shouldn’t struggle to figure out the ropes.

Ebsta

Ebsta is another noteworthy app for email synchronization, designed to empower Salesforce users with greater control over their email management. Its core strength lies in the ability to sync and surface relevant Salesforce data directly in your inbox.

Key features

Comprehensive email synchronization is Ebsta’s strong suit. The app ensures that all your email conversations, events, and contacts are automatically synced with Salesforce. It also features a real-time activity tracking capability, enabling users to see who is engaging with their emails right away.

Another standout feature is Ebsta’s cross-platform compatibility. Whether you’re using Gmail, Outlook, or another email client, Ebsta allows you to access crucial Salesforce data without leaving your inbox.

Finally, Ebsta’s calendar synchronization provides the easy scheduling of meetings and events, which are then automatically updated in Salesforce. So, there’s less chance you’ll miss an important interaction.

Our two cents

Again, we like Ebsta’s robust synchronization features, which can notably improve your workflow. The integration with various email clients is seamless, and real-time activity tracking can be a game-changer, particularly for your sales team.

For instance, let’s imagine the interaction happens at an odd hour and your sales rep is out of the office. The rep could get a real-time notification on Salesforce Mobile, and act on it immediately.

Lastly, we observed less of a learning curve compared to Cirrus Insight. But this is a highly subjective parameter, so take it with a grain of salt.

Salesforce Apps for Email Analytics

When it comes to email infrastructure within Salesforce, having insightful analytics is indispensable. It allows for data-driven decisions, ensuring your communication strategy is aligned with your audience’s needs. Let’s explore one of the leading apps for email analytics.

Full Circle Insights

Full Circle Insights is an app designed to offer robust email analytics within the Salesforce CRM. It aims to bridge the gap between data and insights, making it easier to understand your email engagement.

Key features

Full Circle Insights brings several key features to the table.

Response Management – designed to provide a detailed understanding of your email performance, tracking engagement metrics such as opens, clicks, and conversions directly within Salesforce.
Campaign Influence – lets you see the direct and indirect influence of your emails on sales opportunities, providing insights into the effectiveness of your email strategy.
Funnel Metrics – gives a comprehensive view of your sales funnel, helping you understand how emails contribute at each stage of the customer journey.

Our two cents

Full Circle Insights provides a depth of analytics that could satisfy even the most demanding users. The Response Management feature, in particular, offers great granularity and accuracy. We also appreciate the sales funnel insights, which can be quite a helper in optimizing your email strategy.

So, to no surprise, this Salesforce integration requires a certain level of expertise to fully exploit its capabilities. But once mastered, its potential to transform email strategy and inform business processes is undeniable.

On that note, we should stress that this is an enterprise-level app, which is reflected in its pricing.

Salesforce Apps for Feedback and User Experience Management

In the Salesforce landscape, receiving and managing customer feedback is crucial. It can inform and drive improvements to product features, services, and user experience.

Here are two apps designed to simplify feedback collection and enhance user experience.

Zonka Feedback

Zonka Feedback is a comprehensive tool for capturing and analyzing feedback within Salesforce Lightning. Its primary objective is to help businesses measure customer sentiment and improve their overall experience.

Key features

Zonka offers real-time feedback capture, allowing you to respond quickly to customer needs. It supports various feedback channels, including email, SMS, and on-site feedback, giving your customers the flexibility to interact through their preferred channels.

With its rich analytics, you can easily understand customer sentiment, identify trends, and track improvement over time. The app give you the option to set up instant notifications for specific feedback. In turn, you get to act immediately, when required.

Our two cents

The most useful Zonka features are multi-channel feedback collection and in-depth analytics. Plus, real-time feedback capture can have a significant impact on quick problem resolution, particularly for customer success and customer relationship teams.

If we’re really nitpicky (which we aren’t), Zonka might benefit from more customization options. But overall, it’s among the best feedback apps, suitable for small businesses and enterprises alike.

Survicate

Survicate is a survey tool that allows you to collect continuous customer feedback via email, web, in-product, and mobile apps. It offers over 300 ready-to-use survey templates, including NPS, CSAT, and CES, making survey creation a breeze.

Key features

Integrating Salesforce and Survicate is a one-click, code-free process – there’s no need for complex technical configurations.

With Survicate, you can seamlessly embed surveys directly into Salesforce emails, enhancing your feedback collection process and enriching customer interactions. Users can conveniently share valuable insights without having to visit external platforms.

As data between the two tools is synced in real time, survey responses are immediately accessible in Salesforce, which makes it easy to take prompt actions based on customer feedback.

Our two cents

We like that Survicate captures every response, even if a user didn’t fill in every field, meaning you won’t lose any data.

The transfer of contact attributes between Salesforce and Survicate is very easy indeed, and it helps you quickly filter survey insights and trigger workflows based on responses.

Jotform

Jotform Salesforce Forms is a robust solution for creating and managing forms within the Salesforce ecosystem. It’s designed to streamline the sales process by automating form data synchronization with your Salesforce account.

Key Features

The platform offers an intuitive form builder, enabling the creation of custom forms that seamlessly integrate with Salesforce. It’s great that you can start with ready-made templates and customize them fast. Plus, the forms are optimized for iOS and Android users.

Also, the feature that allows sharing prefilled forms with customers is a standout because it simplifies the form-filling process a lot. And the automatic data sync with Salesforce CRM ensures that the data flow into your database is effortless.

Additionally, Jotform offers an electronic signature collection through Jotform Sign. It can be a godsend for sales teams looking to expedite their deal closures.

Our Two Cents

The ease of form creation and customization is a highlight indeed. And the same goes for automatic sync and prefilled forms. The reporting and analytics are adequate, but there’s room for more advanced analytical tools. Nonetheless, Jotform’s balance of simplicity and functionality makes it a great tool for Salesforce users.

Salesforce Apps for Email Security and Compliance

In the realm of Salesforce and the Appexchange apps, security and compliance are paramount. Keeping sensitive data safe and adhering to industry regulations can make a significant difference to your business’s credibility and trustworthiness. Here are the key apps that excel in these aspects.

OwnBackup

OwnBackup is a comprehensive solution designed to protect your Salesforce data, including emails. It offers a suite of tools to ensure your email data remains secure and compliant with industry standards.

Key features

At the core of OwnBackup is a robust backup and restore functionality. It automatically backs up data from the CRM platform, including emails, attachments, and metadata. In the event of data loss, you can restore custom objects or entire orgs without too much hassle.

The app also offers a comprehensive suite of compliance tools. With features like audit trails and encrypted backups, OwnBackup helps you meet compliance standards such as GDPR and HIPAA.

Finally, its Sandbox Seeding feature is a standout, letting you easily create and manage test data environments without compromising security or compliance. If you’re a SaaS, this feature will allow for more stable workflows, helping you remove preventable errors from production.

Our two cents

OwnBackup has backup-and-restore capabilities that can further streamline project management and completion. Also, its comprehensive compliance features can give you the peace of mind that both your static and in-transit data remain intact.

Admittedly, the user interface could be a bit more intuitive. However, for such a robust security and compliance solution, it’s not a deal breaker by any means.

Cloud Compliance

Cloud Compliance is a purpose-built app for Salesforce that provides an efficient solution for data privacy and compliance management.

Basically, the app makes it simpler for you to meet complex regulatory requirements while ensuring the integrity of your email data.

Key features

There’s a comprehensive suite of tools that help manage personal data in Salesforce. And here’s a quick scoop of what you might find most useful.

Data Discovery and Classification – allows you to locate and categorize personal data, aiding in GDPR and CCPA compliance.
Data Retention and Deletion – enables you to set and automate data retention policies, ensuring unnecessary data doesn’t linger and contribute to compliance risks.
Privacy Portal – allows data subjects to access and manage their data rights requests, further enhancing your compliance stance.

Our two cents

Cloud Compliance is a Salesforce native app, so there’s almost no learning curve, and you get the benefit of native integration. In plain English, if you understand Salesforce, you shouldn’t struggle with Cloud Compliance at all.

To that, the efficiency and completeness of the compliance features are hard to rival.

For instance, Data Discovery and Classification, along with automated Data Retention, are great aids in meeting GDPR and CCPA requirements.

The Role of Mailtrap in the Salesforce Ecosystem

In the Salesforce ecosystem, various apps bolster different aspects of email management.

Mailtrap, however, holds a distinct and multifaceted role in this arena.

It’s an email delivery platform for businesses and individuals that offers robust features to test, send, and control emails in one place.

Overview of Mailtrap

As indicated, Mailtrap’s functionality extends beyond the bounds of testing, but first things first.

Mailtrap Testing adds an email sandbox to your Salesforce toolbox to help developers test and debug emails without the risk of email templates from staging ever reaching your recipients.

How?

It goes like this:

We give you a fake SMTP server.
The server captures outgoing test emails.
We analyze content for spam and validate HTML/CSS.
The developers view errors, debug, then proceed to send highly-deliverable emails

The sending part is, of course, covered by Mailtrap Email Sending functionality via API or SMTP. It’s designed for transactional and bulk emails. Plus, there are five SDKs to integrate Mailtrap with your app quicker.

On top of that, Mailtrap provides color-coded, user-friendly analytics, email templates, and webhooks.

Try Mailtrap Now

How does it differ from the aforementioned apps?

While other Salesforce apps focus on aspects such as synchronization, analytics, feedback, user experience, and security, Mailtrap brings a unique combination of pre-production email testing and robust email sending and analytics capabilities.

Also, there’s a technical difference. Unlike other apps in this article, Mailtrap integrates with Salesforce via Salesforce’s Email Relay feature. If you want to learn more about this, check our “How to Set up Salesforce Email Relay” blog post.

Note: Soon, you’ll be able to integrate Mailtrap Email Testing to Lightning Experience via AppExchange.

What added value does it bring to Salesforce users?

We’re at liberty to stress that Mailtrap carves out a special niche in the Salesforce ecosystem. The key highlight is its ability to catch emails from the staging environment and also manage email production operations with just-in-time delivery.

For Salesforce users, Mailtrap provides a unique blend of utility and control over their emails. As indicated, with Mailtrap email sandbox for testing, you can prevent unintended emails from reaching customers during the development phase.

Then, Mailtrap Email Sending allows you to send emails fast and reliably. It also offers comprehensive analytics, email templates, and webhooks. So you can have almost instant access to deliverability events and email data (assuming you use webhooks). And consequently, gain better control over your email infrastructure.

All this results in more effective communication with existing customers, higher user adoption, and better customer support; leading to improved customer experience.

And lastly, we’d need to point out that Mailtrap integrates with Salesforce using the Email Relays functionality, allowing for a seamless transition of data and operations between the two platforms.

What trends to look for with Salesforce apps?

As the Salesforce ecosystem continues to adapt and expand, there are several trends worth keeping an eye on in relation to email infrastructure.

Data management and security

With the growing emphasis on data privacy and regulations, we can expect to see even more sophisticated features dedicated to email security and compliance. This includes more advanced encryption methodologies, AI-powered anomaly detection, and improved auditing capabilities.

For instance, Mailtrap is already using a state-of-the-art AI model for the following.

Filter and block spammers and protect our IPs
Run domain authentication and trustworthiness

Integrations galore

Integration is the key! Expect to see more Salesforce apps offering seamless integration with other platforms and tools. This trend is driven by the need for interconnected tools that provide users with like an all-in-one, streamlined workflow.

Y*our users/customers are front-center*

Undoubtedly, user experience will remain a primary focus. With an increasing demand for personalized customer experiences, email management tools will likely continue to evolve to allow for more personalized and interactive email templates and designs.

Bonus Tip:

Salesforce Labs, which we haven’t covered in this article, also offers plenty of free apps and integrations, some of which are designed as mobile apps. For example, we like the Trail Tracker by Trailhead a lot, even though it’s not directly related to email infrastructure. But if you have a team that just migrated to Salesforce, it could really flatten the learning curve.

Final Thoughts and Conclusion

When all’s said and done, Salesforce apps related to email infrastructure are integral components of an effective Salesforce strategy.

Whether it’s for email synchronization, analytics, user experience management, security, compliance, or whatever you need; these apps provide a measurable value by enhancing efficiency and ensuring the integrity of your email operations.

In this ever-evolving landscape, Mailtrap stands out with its unique combination of robust email testing and sending functionalities, making it an invaluable tool for any business using Salesforce.

We appreciate the you chose this article to know about the most popular Salesforce apps. If you want to find more interesting content on related topics, click here!

Building an HTML email form – Frontend and Backend

Veljko Ristic — Tue, 05 Mar 2024 15:30:22 +0000

There are two ways to create an HTML email form

Use the mailto: address action element.
Use backend script to handle data and send emails.

The first method is something you shouldn’t try. Sending form data directly to an email from a web form without server-side processing isn’t recommended due to security and privacy risks.

The following tutorial covers methods that include server-side scripting. And I added a special section to ensure that any sensitive information is encrypted and transmitted securely.

First, I cover the front end that sends an HTTP POST request to the backend. Next, I go into the backend to send emails, using Laravel, Java, Node.js, Python, or C#. Then, I’ll give you tips and some examples of security measures.

How to create an HTML contact form – Quick guide

As said, I’ll be covering the backend scripting for a few popular languages and frameworks. So, to make the HTML code easily integrated with the scripts, it’s critical to ensure the HTML form is universally compatible with each language.

Here’s how to create a simple HTML form:

Form structure
Start with a basic HTML form structure. The action attribute should be set to a generic handler, which can be specified in the backend script.

<form action="process-form" method="post" enctype="multipart/form-data">
  <!-- Form elements will go here -->
</form>

Note: The enctype="multipart/form-data" is important if you plan to include file uploads. It’s compatible with all backend technologies. The backend scripts also feature exemplary snippets without the support for file uploads.

*Input elements *
As needed, you can include the following elements.

Text fields

<label for="name">Name:</label>
<input type="text" id="name" name="name">

Message field

<label for="message">Message:</label>
<textarea id="message" name="message" rows="4" cols="50">
</textarea>

Message field notes:

<label for="message">: This label is associated with the textarea. The for attribute should match the idof the textarea, which helps with accessibility.
<textarea>: This is the element used for multi-line text input.
id="message": The ID of the textarea, which is referenced by the label.
name="message": The textarea name attribute is important as it’s the key that will be used to access this piece of data on the server side.
rows="4" and cols="50": These attributes define the size of the textarea. rowsspecifies the number of lines, and cols specifies the width in terms of character columns. You can adjust these numbers based on your layout requirements.

Email field

<label for="email">Email:</label>
<input type="email" id="email" name="email">

Submit button

<input type="submit" value="Submit">

Form action
The action attribute in the form should be a placeholder that will be replaced by the specific endpoint of your backend technology (Laravel, Java, Node.js, Python, or C#).

For instance, in Laravel, you might set it to a route defined in your web routes, while in Node.js, it might point to an Express.js route.

Backend integration (quick notes)

Laravel: Use a route in web.php to handle the form submission.
Java: Set up a servlet or a Spring Controller to process the form.
Node.js: Use an Express.js route to handle the POST request.
Python (Flask/Django): Define a view function or a Django view to process the form.
C# (ASP.NET): Use a controller action in an ASP.NET MVC application.

Processing form data
Each backend technology will have its way of accessing form data (e.g., request.getParameter() in Java, req.body in Node.js, request.form in Flask).

Ensure that the form data is properly validated and sanitized in the backend script to prevent security vulnerabilities.

Sending emails
Each backend will have a different method for sending emails. Use the respective libraries or frameworks available for each technology.

Pro tips:

You can also embed radio buttons or checkboxes in the form. Here I aimed for simplicity, focusing on the email and message, so there aren’t checkboxes and radio buttons.
Consider implementing CAPTCHA to prevent spam submissions and confirm that the form is being filled out by a human. Later, I’ll show you how to integrate Google’s reCAPTCHA.
It’s best to use a proper email-sending service like Mailtrap Email Delivery Platform to ensure your emails securely land at the desired address.

HTML email form with CSS styles

Without CSS, the form looks bland and might actually affect the conversions. So, I’ll make it more elegant, and the exemplary form below contains Name, Email, and Message fields, plus the Submit button.

The HTML form

<!DOCTYPE html>
<html>
<head>
    <title>Contact Form</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div class="container">
        <form id="contact-form" action="process-form.php" method="post">
            <div class="form-group">
                <label for="name">Name:</label>
                <input type="text" id="name" name="name" required>
            </div>

            <div class="form-group">
                <label for="email">Email:</label>
                <input type="email" id="email" name="email" required>
            </div>

            <div class="form-group">
                <label for="message">Message:</label>
                <textarea id="message" name="message" rows="4" required></textarea>
            </div>

            <div class="form-group">
                <input type="submit" value="Submit">
            </div>
        </form>
    </div>
</body>
</html>

Quick Explainer:

HTML Structure: The form is wrapped in a div with a class container for styling purposes. Each input field is enclosed in a div with a class form-group for better control over spacing and layout.
Required Fields: The required attribute in the input fields ensures that the form cannot be submitted without filling these fields. The CSS (style.css)

body {
    font-family: Arial, sans-serif;
    background-color: #f4f4f4;
    margin: 0;
    padding: 0;
}

.container {
    width: 70%;
    margin: 30px auto;
    padding: 20px;
    background: #fff;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}

.form-group {
    margin-bottom: 15px;
}

.form-group label {
    display: block;
    margin-bottom: 5px;
}

.form-group input[type="text"],
.form-group input[type="email"],
.form-group textarea {
    width: 100%;
    padding: 8px;
    border: 1px solid #ddd;
    border-radius: 4px;
    box-sizing: border-box;
}

.form-group input[type="submit"] {
    background-color: #5cb85c;
    color: white;
    padding: 10px 15px;
    border: none;
    border-radius: 4px;
    cursor: pointer;
}

.form-group input[type="submit"]:hover {
    background-color: #4cae4c;
}

Quick Explainer:

The body style sets the font and background color of the page.
The container class styles the form’s container with a white background, centered alignment, and a subtle box shadow for a modern look.
The form-group class provides spacing between each form element.
Input fields (text, email, textarea) are styled to take full width with some padding and border-radius for a pleasant rounded corner look. I changed the submit button type a bit. It’s styled with a green background color, which changes to a slightly darker green on hover for a subtle interactive effect. Reminder: Replace process-form.php (placeholder) in the form’s action attribute with the actual script that will process the form data.

JavaScript to enhance the form behavior

HTML provides only basic validation attributes. Whereas, JavaScript allows for more dynamic and responsive validation that can improve user experience. But note that this isn’t by any means a security measure.

However, it’s a much better approach to handling the form code and it can markedly improve user experience. For example, they won’t need to wait for the web page to refresh to see if the submission was successful.

Now, to create a JavaScript-enhanced HTML email form that works seamlessly with various backend technologies (like Laravel, Java, Node.js, Python, and C#), I’ll focus on two main aspects:

Form validation
AJAX submission Check the following code to see how it’s done.

*Form validation *

document.getElementById('contact-form').addEventListener('submit', function(event) {
    var nameInput = document.getElementById('name').value.trim();
    var emailInput = document.getElementById('email').value.trim();
    var messageInput = document.getElementById('message').value.trim();
    var emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; // Simple email regex pattern

    if (nameInput === '') {
        alert('Please enter your name.');
        event.preventDefault();
    } else if (!emailPattern.test(emailInput)) {
        alert('Please enter a valid email address.');
        event.preventDefault();
    } else if (messageInput === '') {
        alert('Please enter your message.');
        event.preventDefault();
    }
});

Pro Tip:

The script above relies on a simple regex to validate an email, and it works for exemplary purposes. But on production, assuming you’re getting a lot of submissions, it may return false positives or false negatives, unless the regex is a mile long.

To offset that, consider using a proper validation library such as:

AbstractAPI javascript-email-validation
Yup

Submitting form data with AJAX

I made script below universal so that it dynamically adapts to the server-side technologies.

document.getElementById('contact-form').addEventListener('submit', function(event) {
    event.preventDefault();

    var formData = new FormData(this);
    var actionUrl = this.getAttribute('action'); // Dynamically get the action URL

    var xhr = new XMLHttpRequest();
    xhr.open('POST', actionUrl, true);
    xhr.onload = function () {
        if (xhr.status === 200) {
            alert('Email sent successfully!');
        } else {
            alert('An error occurred while sending the email.');
        }
    };
    xhr.send(formData);
});

Quick Notes:

Dynamic Action URL: Instead of hardcoding the action URL (like send-email.php), the script now dynamically retrieves the URL from the form’s action attribute. This means you can set the action URL to any server-side script (PHP, Java, Node.js, etc.), and the JavaScript will adapt accordingly.
Form Data: The FormData object is used to capture and send all the form data, making it easy to handle on the server side, regardless of the technology used.
Ensure that the endpoint (e.g., route in Laravel, or controller in ASP.NET) specified in the form’s action attribute can handle FormData sent via POST request.
Each backend technology will have its way of extracting and processing the data, but the front-end submission process remains consistent and universal.

Backed for HTML5 forms to send emails

I’ll give you backend script examples in five popular scripting languages. Note that the exemplary scripts are geared toward Mailtrap users.

HTML form email in PHP (Laravel)

The framework’s Mail class, combined with its view-based approach to email content, allows for easy and flexible email handling.

Before you proceed with the backend, you need to make some changes to frontend HTML file.
First create a view file, for example/resources/views/welcome.blade.php. Then, ensure the specified route is matching this ‘welcome’ view.

Note: Importing CSS and JS files parts are a little bit different from the original file. By default, these assets should be in the ‘public’ folder of your Laravel project.

<link href="{{ asset('css/app.css') }}" rel="stylesheet" type="text/css" >
<script src="{{ asset('js/app.js') }}" ></script>

Set up Laravel for email sending
Before you can send emails with Laravel, you need to configure the mail settings in your .envfile. Laravel supports various mail drivers and here’s an example of setting up SMTP in the .env file:

MAIL_MAILER=smtp
MAIL_HOST=your_mailtrap_smtp_host.io
MAIL_PORT=2525
MAIL_USERNAME=your_mailtrap_username
MAIL_PASSWORD=your_mailtrap_password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=example@example.com
MAIL_FROM_NAME="${APP_NAME}"

Replace the values with your Mailtrap mail server details. And if port 2525 doesn’t work for you, use 587.

Create a mailable class
Laravel uses “mailable” classes to encapsulate each email’s data and configuration. You can generate a new mailable class using the Artisan command:

php artisan make:mail ContactFormMail

This command creates a new class in the App\Mail namespace. You can define the build method to configure the email’s subject, view, and data:

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Attachment;
use Illuminate\Queue\SerializesModels;


class ContactFormMail extends Mailable
{
    use Queueable, SerializesModels;

    public $formData;

    public function __construct($data)
    {
        $this->formData = $data;
    }

    /**
     * Get the message content definition.
     */
    public function content(): Content
    {
        return new Content(
            view: 'emails.contact',
        );
    }

}

Create the email view
Create a view (e.g., resources/views/emails/contact.blade.php) that Laravel will use for the email content. You can use Blade templating to dynamically populate data from the form:

<!DOCTYPE html>
<html>
<head>
    <title>New Contact Form Submission</title>
</head>
<body>
    <h1>Contact Form Submission</h1>
    <p>Name: {{ $formData['name'] }}</p>
    <p>Email: {{ $formData['email'] }}</p>
    <p>Message: {{ $formData['message'] }}</p>
</body>
</html>

Handle form submission in a controller
Important Note:

The frontend may prevent the default event when submitting the email form and just send an API call to the backend server. In this case, the API URL is /api/email. and the API request is handled in routes/api.php. To fix this, add the following line in the apip.php file. I omitted the ‘/api’ because of the structure of the project.

Route::post('/email', [EmailController::class, 'sendEmail']);

In the controller that handles the form submission, use the Mail facade to send the email:

use Illuminate\Support\Facades\Mail;
use App\Mail\ContactFormMail;

public function sendEmail(Request $request)
{
    $formData = $request->all();

    Mail::to('receiver@example.com')->send(new ContactFormMail($formData));

    // Return response or redirect
}

Security and validation
Ensure to validate and sanitize the form data to prevent security issues like XSS and injection attacks. Laravel provides a robust validation system that you can use in your controller:

$request->validate([
    'name' => 'required',
    'email' => 'required|email',
    'message' => 'required'
]);

For more detailed guid on building HTML email form, please check our blog post in the link.

Android Intent Send Email – Quick Tutorial with Examples

Veljko Ristic — Tue, 27 Feb 2024 16:50:10 +0000

After tackling the Android Intent send email task, I have a newfound respect for this OS and its intricacies. The methodology is pretty straightforward and relatively simple to implement.

I’ll cover the steps I took and show you how to use Intent to send emails from an Android app (code examples included). Plus, I dedicate a special section to error handling and email testing.

Let’s start coding!

Android Intent send email

The Intent method is the native way to send email in Android programmatically.

So first, you need to make sure to have an Android project set up in your development environment. Here’s a quick overview of the steps:

Launch Android Studio and select “Start a new Android Studio project”.
Configure: Project name, Save Location, Language (Java or Kotlin), and Minimum API Level (the minimum Android version supported by your project).
Select a template – you can go with “Empty Activity” to get the basic UI.
Hit “Finish” and wait for the Studio to complete the setup.

Inspect the project structure – with the setup complete, you’ll see a directory like app/src/main, and it includes:
– java/: Your source code.

    – `res/`: Resources like layouts, strings, and images.

    – `AndroidManifest.xml`: Configuration file, where you can set the MainActivity.

To test the configuration, hit the “Run” button (the green triangle). Then, choose a connected device or an emulator.

Pro Tips:

Some emulators work well, but it’s best to have a genuine Android phone with the latest version of the software installed. Otherwise, emulators might throw unexpected errors.
If you’re using an emulator, you’ll need to configure the email client. If the email client is not configured, it won’t respond to the Intent.
To see a ‘chooser’ in action, you’ll need to configure a device using multiple messaging applications, for instance, use Gmail application and the Email application.

Now, I’ll use Intentto invoke an existing email client on the Android device. The Intent has to be set up using the correct action: ACTION_SENDor ACTION_SENDTO. Also, you’ll need the correct data: email address, subject, body, etc.

Note: I’m using Java in the examples below. This tutorial doesn’t cover SMS (optionally or otherwise), only an email message.

HTML email

The Intentsystem allows basic HTML via your Android application. Keep in mind that the final email rendering largely depends on the email client used by the recipient. (e.g. The rendering may look and perform differently on Gmail and Microsoft Outlook)

Pro Tip: You can run your email templates through Mailtrap Email Testing to check for support with the most popular email clients and debug the templates if necessary. I’ll show you how to do it at the end of this article.

Here’s the exemplary snippet for the HTML email:

// Method to send an HTML email to a single recipient without attachment
public void sendEmailSingleRecipient(String recipient, String subject, String htmlBody) {
    Intent emailIntent = new Intent(Intent.ACTION_SEND);
    emailIntent.setData(Uri.parse("mailto:")); // only email apps should handle this
    emailIntent.putExtra(Intent.EXTRA_EMAIL, new String[]{recipient}); // Single recipient
    emailIntent.putExtra(Intent.EXTRA_SUBJECT, subject);

    // Adding HTML body
    emailIntent.putExtra(Intent.EXTRA_TEXT, Html.fromHtml(htmlBody));
    emailIntent.setType("text/html");

           startActivity(emailIntent);
}

The method is tailored to a single email recipient, the recipient’s email address is passed a single-element array to the Intent.EXTRA_EMAIL field. Later, I’ll show how to include BCC for multiple recipients.

And with the startActivity(emailIntent); intent, any applications that support plaintext messaging will be able to handle this request. Once you have set the type data for the Intent, you can call the startActivity() method, passing in your Intent.

Email with attachment

To include attachments you need to fetch the file from storage and add it as an extra stream to the intent. Check the example below.

// Import necessary classes
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.FileProvider;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;

import java.io.File;


public class EmailSender extends AppCompatActivity {

public static final int PICK_TEXT_FILE_REQUEST = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button picker = findViewById(R.id.picker);
        picker.setOnClickListener(view -> {
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
            intent.setType("text/plain");
            startActivityForResult(Intent.createChooser(intent, "Select Text File"), PICK_TEXT_FILE_REQUEST);
        });
    }

    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == PICK_TEXT_FILE_REQUEST && resultCode == Activity.RESULT_OK) {
            if (data != null) {
                Uri uri = data.getData();
                if (uri != null) {
                    // Trigger file picker
                    sendEmailSingleRecipient("ghostdev030823@gmail.com",
                            "This is a test subject",
                            "This is a test email body using Android intent", uri);
                }
            }
        }
    }

    // Method to send an HTML email to a single recipient with an attachment
    public void sendEmailSingleRecipient(String recipient, String subject, String body, Uri filePath) {
        Intent emailIntent = new Intent(Intent.ACTION_SEND);
        emailIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
        emailIntent.putExtra(Intent.EXTRA_EMAIL, new String[]{recipient});
        emailIntent.putExtra(Intent.EXTRA_SUBJECT, subject);
        emailIntent.putExtra(Intent.EXTRA_TEXT, body);
        emailIntent.putExtra(Intent.EXTRA_STREAM, filePath);
        emailIntent.setType("message/rfc822"); // only email apps should handle this

        startActivity(emailIntent);
}

}

Also, remember to configure the FileProviderin your Android manifest and resource files to handle file attachments securely.

The correct configuration for the manifest file, particularly for the newer Android versions, is:

<application>
    …
<uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_INTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="${applicationId}.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/provider_paths"/>
        </provider>
    ...
</application>

And in the res/xml/file_paths.xml, it’s:

<paths>
    <external-path name="external_files" path="."/>
</paths>

Configuration notes:

Replace your.authoritywith your app’s authority, typically your application’s package name.
Ensure the file paths and permissions are correctly set for the FileProvider.
Test the functionality with various email clients to check the HTML rendering and attachment handling (Gmail app, Apple Mail, etc.).

Send to multiple recipients

For the sake of convenience, I’ll tweak the example above to include multiple recipients. Here’s the updated code.

// Import necessary classes
import android.content.Intent;
import android.net.Uri;
import android.support.v4.content.FileProvider;
import java.io.File;

public class EmailSender {

    // Method to send an HTML email to multiple recipients with an attachment
    public void sendEmailWithAttachment(String[] recipients, String subject, String htmlBody, File attachmentFile) {
        Intent emailIntent = new Intent(Intent.ACTION_SENDTO);
        emailIntent.setData(Uri.parse("mailto:")); // only email apps should handle this
        emailIntent.putExtra(Intent.EXTRA_EMAIL, recipients); // Multiple recipients
        emailIntent.putExtra(Intent.EXTRA_SUBJECT, subject);

        // Check if the attachment is not null and exists
        if (attachmentFile != null && attachmentFile.exists()) {
            // Add the attachment using FileProvider
            Uri uri = FileProvider.getUriForFile(context, "your.authority", attachmentFile);
            emailIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            emailIntent.putExtra(Intent.EXTRA_STREAM, uri);
        }

        // Adding HTML body
        emailIntent.putExtra(Intent.EXTRA_TEXT, Html.fromHtml(htmlBody));
        emailIntent.setType("text/html");

        // Verify that the intent will resolve to an activity
        if (emailIntent.resolveActivity(getPackageManager()) != null) {
            startActivity(Intent.createChooser(emailIntent, "Send email..."));
        } else {
            // Handle the situation where no email client is installed
            // Show an error message or a notification
        }
    }
}

The recipients parameter is now an array of strings, allowing you to specify multiple email addresses. The rest of the method remains unchanged, supporting both HTML content and file attachments.

General guidelines on the Android Intent methodology

Import statements:I imported necessary classes like Intent,Uri, File, and others.
sendEmail method: This method accepts the recipients’ email addresses, the email subject, the HTML body, and an optional file attachment.
Creating the Intent: We use Intent.ACTION_SENDTO with mailto: to ensure only email apps handle this intent.
Adding recipients and subject: I used Intent.EXTRA_EMAIL and Intent.EXTRA_SUBJECT.
Handling attachment: If an attachment is provided, I use a FileProvider to get a content URI for the file and add it to the intent. This is a secure way to share files between apps starting from Android 7.0 (API level 24). As mentioned earlier, you’ll need to define a FileProvider in your manifest and create an XML file defining available paths.
HTML body:I used Html.fromHtml(htmlBody) to add the HTML formatted text to the email body. The rendering depends on the email client’s capabilities.
Intent type: I set the type to "text/html", it can also be "text/plain".

Other considerations

Here, I’d like to touch upon some functions, commands, and elements that didn’t make it into this tutorial. But, based on your specific use case, you might find them useful.

EditText: It’s a UI element in Android that allows users to enter text. It’s part of the Android SDK and is typically used within layout XML files to design the UI.
TextView: This is another Android UI element that displays read-only text to the user. Unlike EditText, TextView doesn’t allow user input and is used primarily for displaying static text or text that changes dynamically
OnClickListener: It’s an Android interface that listens for click events on views such as buttons. By implementing the OnClickListener interface and its onClick method, you can define what happens when a user clicks on a particular view.
Public void onClick: It’s the declaration method for the onClick method. When you implement the interface, you have to provide a corresponding implementation. It’s called when a view (with the listener attached) receives a click event.

To continue reading on Android Intent Send Email, check out the full article on Mailtrap blog.

How to Test Email: A Personal Journey

Veljko Ristic — Fri, 29 Dec 2023 18:50:18 +0000

I’ve been with Mailtrap since 2021, and I have tested a gazillion emails (using Mailtrap) and talked to god-knows how many SMEs to wrap my mind around all the intricacies.

This piece is an honest account of my ‘how to test email’ journey. It covers every aspect you can test, their importance, and the examples of best practices.

Sure, I used Mailtrap almost exclusively, so the following sections feature a bunch of references and pointers to our platform. But, you’ll also encounter other tools and tips on how to incorporate them into your workflow.

What aspects of an email can you test?

You can test ALL aspects of your email and here’s a quick list:

Email deliverability
SPAM score
Headers
Technical tests (DNS authentication, inbox placement, etc)
Email components and interaction elements

Also when testing, a structured approach is crucial, or you’ll get lost in all the data. Worse yet, you’ll waste a lot of time testing the wrong things.

Deliverability testing

Deliverability testing is the first thing to do because it’s about making sure your emails hit the inbox, not the spam folder. And my dear colleague Piotr wrote a great guide on “Email deliverability: Everything you need to know”.

We even got an entire cheatsheet playlist about it. Hit ▶️below.

DKIM Explained - How It Works | Mailtrap - YouTube

This video offers a step by step explanation on how DKIM protocol works for email authentication.We answer the major questions concerning DKIM: what is DKIM,...

youtube.com

Anyway, moving onto the nitty gritty of deliverability testing.

HTML check

The HTML check is crucial in email content testing. Since this is not only about different content elements working but also about rendering. If the rendering is bad, the customer will think you are a spammer – spam complaint = sending reputation drop.

Note that I’ll be covering sandbox tests with Mailtrap to check emails before sending them. And that’s without spamming real recipients.

If you want to give Mailtrap Email Testing a try, hit the button above ⬆️to sign up, then follow this setup guide. You be testing your first email in minutes and there’s a free email testing plan.

Later, I’ll talk about production email tests (with Mailtrap and otherwise). You can safely run these with a preselected cohort of your subscribers. For example, production email tests are A/B tests and specific aspects of trigger point tests like email heat maps.

Finally, it’s time to move to WHATS and HOWS.

The HTML check takes a deep dive into various elements (HTML and CSS) of your email template and assesses overall market support across different email clients, and different devices; covering web, mobile, and desktop.

There’s a neat “Only” button, which pops up when you hover left of each provider. Hitting it allows you to see the support for only the client you select. And if you’re dreading deliverability to Apple Mail, for example, it’s a cool trick to see how to fix your template so that Apple loves it.

On that note, I’ll move on to show the other email template elements you can test under HTML Check.

Email body

The <body> element section shows you the support for the body of your email template. Note that this isn’t body copy of an email. It’s the HTML body of your email and how deliverable it is across different clients.

In this example, you can see that there’s partial support for the <body> element and the problematic area is on line 6. When I click 6, next to “Found on lines:”, I’m taken to the HTML Source tab, and I can immediately see the problematic line, so it’s straightforward to fix it.

Yeah, it seems the <style> and the <body> elements are in some conflict. So, I’m moving on to check that.

Styling and fonts

The <style> element section checks the support for template’s styling. I’m still using the same example, and as you can see below, some clients partially support the element, it appears buggy, and it’s not supported across all the email client versions.

Again, clicking on the number next to “Found on lines” takes me to the template and clearly shows what’s wrong. The best thing is that if a line gets declared as “Buggy”, there’s a quick explanation why it’s buggy and how to fix it, which may cut template debugging in half.

As for the fonts, one of the key parameters Mailtrap checks is the font-weight. Of course, this is assuming you’re using a standard font family.

Like before, the notes show you that the font-weight is partially supported, plus there’s a quick explanation of why it’s like that. But the check doesn’t stop there, you can also inspect the class selector, max-width, background-color, width property, max-width, and any other CSS or HTML element that might appear in the email.

I know, it may seem that there’s something seriously wrong with the template in the example, but it’s not. As you can see from the first screenshot, it has 93.8% support across different email clients. So it’s a good template, but there are options to make it even better.

When you’re done checking the template, it’s time to see whether it has a chance to trigger spam bots.

SPAM score

The spam testing results are under the Spam Analysis and they give you the overall score for an email. In the background, we’re running an up-to-date SpamAssassin filter to determine the score. And you can see which elements of your template drive the score up.

At the same time, under Blacklists Report, you’ll see if your domain and IP address appear in any of the most common blacklists.

The template I’m using scored 3.3 which is okay. Generally, the recommendation is to keep the spam score under 5. But if you wanna get the score even higher, feel free to fix the rules as described in the table.

If you need more info on how to steer clear of the spam folder, check our blog post on “How to Avoid Emails Going to Spam?”.

That out of the way, you can proceed to check the headers.

Email headers

The Tech Info tab is the header information checker. You should know that it displays the original header values, which might be altered by an MTA or email service provider when sending the emails. However, the data we display are more than enough for debugging purposes.

Also, pointers to header information or buggy headers may also appear under the HTML Check tab, and the Spam Analysis tabs. For example, the Spam Analysis flags ‘Content-Type’ without the proper MIME header (check the screenshot below).

Automation in Email Testing (via Mailtrap API)

Yes, you can automate email testing and if you’re sending a lot of emails, you should consider doing it. Mailtrap allows you to automate via our RESTful API (available on the free pricing plan).

Sure, it requires some coding but you can let the API run the dull tasks and notify you if there’s a problem.

Since I mentioned Mailtrap HTML Check a few times, here’s an exemplary request script for the HTML analysis using PHP/cURL.

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://mailtrap.io/api/accounts/account_id/inboxes/inbox_id/messages/message_id/analyze",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: application/json",
    "Api-Token: 123"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

And here’s an exemplary response to the request.

{
  "report": {
    "status": "success",
    "errors": [
      {
        "error_line": 15,
        "rule_name": "style",
        "email_clients": {
          "desktop": [
            "Notes 6 / 7"
          ],
          "mobile": [
            "Gmail"
          ]
        }
      },
      {
        "error_line": 7,
        "rule_name": "display",
        "email_clients": {
          "desktop": [
            "AOL Desktop",
            "IBM Notes 9",
            "Outlook 2000-03",
            "Outlook 2007-16",
            "Outlook Express",
            "Postbox",
            "Windows 10 Mail",
            "Windows Live Mail"
          ],
          "mobile": [
            "Android 4.2.2 Mail",
            "Android 4.4.4 Mail",
            "BlackBerry",
            "Gmail Android app IMAP",
            "Google Inbox Android app",
            "Windows Phone 8 Mail",
            "Yahoo! Mail Android app",
            "Yahoo! Mail iOS app"
          ],
          "web": [
            "Yahoo! Mail"
          ]
        }
      }
    ]
  }
}

The response you’re looking for is 200. If there are any issues, the system will return 401, 404, or 404 error messages.

Thank you for delving into this section of Mailtrap's article. For a richer understanding, please visit the full article. We appreciate your engagement!

Salesforce Mass Email – How to Send and Test

Veljko Ristic — Tue, 26 Dec 2023 18:33:48 +0000

Welcome to our comprehensive guide on Salesforce mass email sending. Whether you’re a tech-savvy professional or someone new to the platform, this article has got you covered.

We’ll explore various methods and techniques to send mass emails using Salesforce.

Read on to learn how to send targeted marketing campaigns or important updates to your customers. This article walks you through the process step by step and uncovers various methods and features available to help you reach a large audience effortlessly.

Note: This article is for existing Salesforce users. It assumes that you’ve already set up Salesforce, so those steps won’t be covered.

Salesforce mass email limits

Knowing your Salesforce limits helps secure a smooth and efficient emailing experience. Here are the highlights at the time of this writing.

Daily Mass Email Limit

This limit is there to prevent abuse and maintain high deliverability. And it varies depending on your Salesforce edition and the number of user licenses.

Note that the ‘daily mass email limit’ described here is the total maximal number of emails you can send per day, across all options and Editions.

As per Salesforce Help Center, the limit is 5000 emails. And in Apex and API, the limitation is the same.

Make sure to check your specific edition’s limit to ensure you stay within the allowed quota. Note that the highest mass email limit typically applies to the Enterprise Edition.

Recipient Limit:

The Salesforce recipient limit also depends on your edition and the type of emails. For instance, for the six Editions of Salesforce, the recipient limit ranges from a few dozen to 5,000 recipients per mass email.

To stress, the maximal number is again 5,000 but it pays to touch upon the concept so you can better understand the logic.

For example, you could send one email to 5,000 recipients, thus exhausting your limit on the highest Editions. Or you could send multiple emails to specific recipient cohorts, to the same effect. For instance, 10 different emails to 500 recipients each.

Either way, the cap is 5,000 on the highest plan, and you need to carefully plan your campaigns to avoid exhausting the limit too fast.

Pro Tip: If the same external email address appears under different email marketing lists/campaigns, the address will be counted toward the limitation each time.

Data Size Limit:

Each email you send has a maximum data size limit, which includes the combined size of the email content, attachments, and merged fields. The limit varies based on your Salesforce edition and ranges from a few MBs to 25 MB.

The max limit is the same in Lightning Experience and Salesforce Classic, but there’s a difference in the number of attachments you can include.

Salesforce Classic – 10+ attachments, not exceeding 25MB
Lightning Experience – up to 10 attachments, not exceeding 25MB

Email Template Limitations

Salesforce caps the number of templates at 500 for all organizations under Trial or Free plans. For more information on Salesforce platform limitations with paid editions, you’ll need to reach out to Salesforce support.

Also, note that organizations using Developer Edition under a trial period can only send up to 10 emails to external email addresses.

Bonus Tip: Deliverability Considerations

Even though you can send mass emails with Salesforce integration, it’s crucial to maintain good deliverability and avoid practices that may result in your emails being marked as spam. If you want the details, check our blog post – “Email deliverability: everything you need to know”.

Lastly, the limitations mentioned above could be subject to change, and it’s advisable to refer to the official Salesforce documentation for the most up-to-date information regarding mass email limits.

How to send mass emails in Salesforce?

Here, we’ll talk about sending mass emails in Salesforce Classic, so it’s more geared to legacy users (those who began using Salesforce prior to 2018 but still haven’t switched). However, we also cover Lightning Experience later in the article.

Note: Make sure to enable mass email with your Salesforce implementation. If that’s not done, you’re likely to get a message similar to the one below.

System.EmailException: SendEmail failed. First exception on row 0; first error: NO_MASS_MAIL_PERMISSION, Single email is not enabled for your organization or profile.: []

Create a mass mailing list of Contacts or Leads

Navigate to Contacts or Leads

Click the Contacts or Leads tab, depending on the type of recipients you want to include in your mass email.

Scroll down to the Tools section, and click Mass Email Contacts.

Follow the Mass Email tool wizard

After clicking Mass Email Contacts, you enter a four-step process to set up and customize your mass email campaigns.

First, you need to choose the recipients for the campaign. Then, choose a View from the drop-down menu, or click Create New View. For the purposes of this tutorial, we’ll choose the latter.

Next, add the View name, and use filters, such as specific fields, campaign membership, or custom criteria, to narrow down your target audience.

Make sure to leverage specific Salesforce customization options and select filters and criteria only for the mass email leads you’d like to contact.

Salesforce offers quite a few filtration options and allows you to choose fields to display and filter by specific fields. That allows you to create a mass email list, zeroing in only on the user cohort you wish to contact.

Also, you can change the visibility of your campaign under Step 4.

Save the Mailing List:

Once you have defined your criteria, save the mailing list. Upon clicking the button, you’ll see the filtered list of recipients. You can add or remove recipients by checking or unchecking the box in front of their names.

Reminder: The number of recipients per single email varies based on the Salesforce edition you use.

Choose an email template

After saving the list, you move to Step 2 of Mass Email with Salesforce. Here, you choose the email template. Keep in mind that you can’t create a new template at this step.

Confirm your choice and send

Step 3 gives you the option to BCC an email copy to yourself, you can create a custom Mass Email Name, and send it immediately, or schedule the campaign.

A scheduled email has a “pending” status until sent, and you can cancel it anytime prior to the due date/time.

Should you choose to hit the Send button, your email gets sent immediately, and you’ll get the confirmation window.

Check status and manage

To see the status of your emails and manage campaigns, you need to do the following.

Click your account name in the upper right section and choose My Settings.
Select Email in the side menu, then click Mass Email.

Check the list of all your campaigns per the selected View. This is also where you can cancel pending campaigns.

Sending bulk emails in Lightning Experience

Overall, the processes and functionalities are mostly consistent across Salesforce Classic and its revamped sibling. Though, we should stress that Salesforce Lightning is more feature-rich, particularly in the area of data management, analytics, and marketing automation. And sending bulk emails in Lightning Experience is faster and more user-friendly.

However, we won’t focus on features comparison here. Instead, we’ll show you the most effective way to send mass emails and highlight any significant differences, if necessary.

Create an email template Click the App Launcher (nine colorful dots) in the upper left corner of the screen, type ‘Email Templates’, and hit enter.

Click the New Email Template button, and create your template. Make sure to include the subject, message body, and any merge fields or templates you wish to utilize, then Save it.

Note: You don’t have to start by creating a template, you can do it later, or select one of the existing templates.

Navigate to Send List Email

In Lightning Experience, the feature is actually called Send List Email, instead of Mass Email. And it appears under the Contacts, Leads, or Campaign Member view. And the steps are largely the same regardless of the method you choose.

Click Send List Email and, under New List View, type List Name and List API Name into the designated fields. Then, choose ‘view permissions’ and click Save.

Select the Recipients

Hover over the Filter by Owner box and choose the contacts to send bulk email to.

Proceed to Add Filter and segment your recipients based on the given Field, Operator, and Value criteria.

Depending on your requirements, you can opt to send the email to specific campaign members, contacts, or leads from a report, or custom lists. Plus, you can use the Add Filter Logic option to give your list another dimension.

Review and Send

Before sending the email, take a moment to review the recipient list, email content, and any attached files. Ensure everything is accurate and aligns with your intended communication.

Afterward, click the Send List Email button, then the Insert, create, or update template icon. Insert the template you created in the first step; here you can also add merged fields by clicking on the ‘braces’ icon.

Once you confirm all’s well and you’re sending to the right recipients, hit Send, and your campaign will be deployed.

How to send mass email through Batch Apex in Salesforce

In addition to the built-in Mass Email or Send List Email functionality, Salesforce provides Apex, a versatile object-oriented language, similar to Java.

By leveraging Apex, you can automate the process of sending bulk emails, enabling you to handle larger volumes of email communications.

Let’s explore how you can send mass emails through Apex in Salesforce.

Import statements and create an Apex class:

Begin by importing statements and creating an Apex class that implements the ‘Batchable’ interface. This class will define the logic and behavior for sending the mass email.

Here are the import statements.

import Database;
import Messaging;

Note: Importing Database and Messaging is optional.

And you define the class using the following line.

public class MassEmailBatch implements Database.Batchable<sObject> {

This declares a class named MassEmailBatch that implements the Database.Batchable<sObject> interface. It signifies that this class can be used as a batch job for processing records.

Implement the Start, Execute, and Finish Methods

In the Apex class, implement the Start method, which retrieves the collection of records to process (your recipients, in this particular case). This can be based on criteria or queries.

public Database.QueryLocator start(Database.BatchableContext context) {
    String query = 'SELECT Email, Name FROM Contact WHERE Email IN (\'fd547125b4-5ea78e@inbox.mailtrap.io\')'; //SELECT Id, Email, Name FROM Contact WHERE <your_criteria_here>
    return Database.getQueryLocator(query);
}

To stress, the start method is required for a batch job and specifies the initial step of the batch process. It returns a Database.QueryLocator object that defines the records to be processed.

In this case, the method queries the Contact records based on specific criteria and returns a query locator for those records.

Reminder: Don’t forget to specify the criteria under <your_criteria_here>

That out of the way, you can implement the Execute method, where the script iterates through the collection of records and constructs personalized email messages using Apex Email Messaging classes.

public void execute(Database.BatchableContext context, List<sObject> scope) {
    List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>();

    for (sObject record : scope) {
        Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
        email.setSubject('Your Subject Here');
        email.setPlainTextBody('Hello,\n' + String.valueOf(record.get('Name')));
        email.setToAddresses(new String[] { (String) record.get('Email') });

        emails.add(email);
    }

    Messaging.SendEmailResult[] results = Messaging.sendEmail(emails);

    for (Messaging.SendEmailResult result : results) {
        if (result.isSuccess()) {
            // Email sent successfully
            System.debug('Email sent successfully');
        } else {
            // Handle any errors or exceptions
            System.debug('Error sending email: ' + result.getErrors()[0].getMessage());
        }
    }
}

This is where the actual record processing takes place. The script receives a batch of records (a scope) to process. In our example, it iterates through each record and constructs a personalized email message using the Messaging.SingleEmailMessage class.

The script then sets the email subject, plain text body, and recipient’s email address based on the record’s data.

The constructed email messages are added to the email list. After all the records are processed, the Messaging.sendEmail method is used to send the batch of email messages. The Messaging.SendEmailResult array contains the results of the email-sending operation, which are then processed to check for any errors or exceptions.

Lastly, you’ll need to implement the Finish method, which handles any necessary cleanup tasks or post-processing actions.

public void finish(Database.BatchableContext context) {
    // Perform any necessary cleanup tasks or post-processing actions
}

For your reference, here’s the full script.

import Database;
import Messaging;

public class MassEmailBatch implements Database.Batchable<sObject> {

    public Database.QueryLocator start(Database.BatchableContext context) {
        // Retrieve the collection of records to process based on specific criteria or queries
        String query = 'SELECT Email, Name FROM Contact WHERE Email IN (\'fd547125b4-5ea78e@inbox.mailtrap.io\')'; //SELECT Id, Email, Name FROM Contact WHERE <your_criteria_here>
        return Database.getQueryLocator(query);
    }

    public void execute(Database.BatchableContext context, List<sObject> scope) {
        List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>();

        // Iterate through the collection of records and construct personalized email messages
        for (sObject record : scope) {
            // Construct the email message using Apex Email Messaging classes
            Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
            email.setSubject('Your Subject Here');
            email.setPlainTextBody('Hello, ' + String.valueOf(record.get('Name')));
            email.setToAddresses(new String[] { (String) record.get('Email') });

            emails.add(email);
        }

        // Send the batch of email messages
        Messaging.SendEmailResult[] results = Messaging.sendEmail(emails);

        // Process the results if needed
        for (Messaging.SendEmailResult result : results) {
            if (result.isSuccess()) {
                // Email sent successfully
                System.debug('Email sent successfully');
            } else {
                // Handle any errors or exceptions
                System.debug('Error sending email: ' + result.getErrors()[0].getMessage());
            }
        }
    }

    public void finish(Database.BatchableContext context) {
        // Perform any necessary cleanup tasks or post-processing actions
    }
}

Send with email template

Create and customize the template according to your needs and include any merge fields as required. You can do all that within the Salesforce interface, but make sure to save the template ID to reference it in the code.

Now, we’d need to rework the ‘execute’ method so it references a template, here’s the snippet.

public class MassEmailBatchWithTemplate implements Database.Batchable<sObject> {

    public static final String EMAIL_TEMPLATE_NAME = 'MyTemplate';

    public Database.QueryLocator start(Database.BatchableContext context) {
        // Retrieve the collection of records to process based on specific criteria or queries
        String query = 'SELECT Email, Name FROM Contact WHERE Email IN (\'fd547125b4-5ea78e@inbox.mailtrap.io\')'; //SELECT Id, Email, Name FROM Contact WHERE <your_criteria_here>
        return Database.getQueryLocator(query);
    }

    public void execute(Database.BatchableContext context, List<sObject> scope) {
        List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>();

        // Get the email template
        EmailTemplate emailTemplate = [
            SELECT Id, Subject, Body, HtmlValue
            FROM EmailTemplate
            WHERE Name = :EMAIL_TEMPLATE_NAME
            LIMIT 1
        ];

        // Iterate through the collection of records and construct personalized email messages
        for (sObject record : scope) {
            // Construct the email message using Apex Email Messaging classes
            Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();

            // Set the email template ID
            email.setTemplateId(emailTemplate.Id);
            // Set the email template Subject
            email.setSubject(emailTemplate.Subject);
            // Set the email html Body
            email.setHtmlBody(emailTemplate.HtmlValue);
            email.setToAddresses(new String[] { (String) record.get('Email') });

            // Set the target object ID
            email.setTargetObjectId((Id) record.get('Id'));

            emails.add(email);
        }
    }
}

Here’s what we did:

Added the line email.setTemplateId('<your_template_id_here>'); to set the ID of the email template you want to use. Replace <your_template_id_here> with the actual ID of your email template.
Added the line email.setTargetObjectId((Id) record.get('Id')); to set the ID of the recipient object. This can be the ID of the contact, lead, or user to whom you want to send the email.

Check the full reworked script.

import Database;
import Messaging;

public class MassEmailBatchWithTemplate implements Database.Batchable<sObject> {

    public static final String EMAIL_TEMPLATE_NAME = 'MyTemplate';

    public Database.QueryLocator start(Database.BatchableContext context) {
        // Retrieve the collection of records to process based on specific criteria or queries
        String query = 'SELECT Email, Name FROM Contact WHERE Email IN (\'fd547125b4-5ea78e@inbox.mailtrap.io\')'; //SELECT Id, Email, Name FROM Contact WHERE <your_criteria_here>
        return Database.getQueryLocator(query);
    }

    public void execute(Database.BatchableContext context, List<sObject> scope) {
        List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>();

        // Get the email template
        EmailTemplate emailTemplate = [
            SELECT Id, Subject, Body, HtmlValue
            FROM EmailTemplate
            WHERE Name = :EMAIL_TEMPLATE_NAME
            LIMIT 1
        ];

        // Iterate through the collection of records and construct personalized email messages
        for (sObject record : scope) {
            // Construct the email message using Apex Email Messaging classes
            Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();

            // Set the email template ID
            email.setTemplateId(emailTemplate.Id);
            // Set the email template Subject
            email.setSubject(emailTemplate.Subject);
            // Set the email HTML Body
            email.setHtmlBody(emailTemplate.HtmlValue);
            email.setToAddresses(new String[] { (String) record.get('Email') });

            // Set the target object ID
            email.setTargetObjectId((Id) record.get('Id'));

            emails.add(email);
        }

        // Send the batch of email messages
        Messaging.SendEmailResult[] results = Messaging.sendEmail(emails);

        // Process the results if needed
        for (Messaging.SendEmailResult result : results) {
            if (result.isSuccess()) {
                // Email sent successfully
                System.debug('Email sent successfully');
            } else {
                // Handle any errors or exceptions
                System.debug('Error sending email: ' + result.getErrors()[0].getMessage());
            }
        }
    }

    public void finish(Database.BatchableContext context) {
        // Perform any necessary cleanup tasks or post-processing actions
    }
}

Schedule and execute an Apex batch

To schedule and execute a batch, and then send mass email from custom object, we’ll need to go back to the script above and add yet another layer of functionality.

import Database;
import Messaging;
import System;

public class MassEmailBatch implements Database.Batchable<sObject>, Database.AllowsCallouts, Schedulable {

    public Database.QueryLocator start(Database.BatchableContext context) {
        // Retrieve the collection of records to process based on specific criteria or queries
        String query = 'SELECT Email, Name FROM Contact WHERE Email IN (\'fd547125b4-5ea78e@inbox.mailtrap.io\')'; //SELECT Id, Email, Name FROM Contact WHERE <your_criteria_here>
        return Database.getQueryLocator(query);
    }

    public void execute(Database.BatchableContext context, List<sObject> scope) {
        List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>();

        // Get the email template
        EmailTemplate emailTemplate = [
            SELECT Id, Subject, Body, HtmlValue
            FROM EmailTemplate
            WHERE Name = :EMAIL_TEMPLATE_NAME
            LIMIT 1
        ];

        // Iterate through the collection of records and construct personalized email messages
        for (sObject record : scope) {
            // Construct the email message using Apex Email Messaging classes
            Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();

            // Set the email template ID
            email.setTemplateId(emailTemplate.Id);
            // Set the email template Subject
            email.setSubject(emailTemplate.Subject);
            // Set the email HTML Body
            email.setHtmlBody(emailTemplate.HtmlValue);
            email.setToAddresses(new String[] { (String) record.get('Email') });

            // Set the target object ID
            email.setTargetObjectId((Id) record.get('Id'));

            emails.add(email);
        }

        // Send the batch of email messages
        Messaging.SendEmailResult[] results = Messaging.sendEmail(emails);

        // Process the results if needed
        for (Messaging.SendEmailResult result : results) {
            if (result.isSuccess()) {
                // Email sent successfully
                System.debug('Email sent successfully');
            } else {
                // Handle any errors or exceptions
                System.debug('Error sending email: ' + result.getErrors()[0].getMessage());
            }
        }
    }

    public void execute(SchedulableContext context) {
        // Create an instance of the batch class
        MassEmailBatch batch = new MassEmailBatch();

        // Schedule the batch job
        Database.executeBatch(batch);
    }
}

With these additions, the class now implements the ‘Schedulable’ interface, allowing you to schedule and execute the batch job using the Salesforce scheduler. The execute() method from the ‘Schedulable’ interface is implemented, where you create an instance of the batch class and call Database.executeBatch() to schedule the batch job.

Thereon, you can use the System.schedule() method in Salesforce to schedule the execution of the MassEmailBatch class based on your desired schedule. For example:

String scheduleExpression = '0 0 0 1 1 ? 2024'; // Schedule for January 1, 2024
MassEmailBatch scheduler = new MassEmailBatch();
System.schedule('Mass Email Job', scheduleExpression, scheduler);

In the above example, the MassEmailBatch class is scheduled to run on January 1, 2024. You can modify the scheduleExpression to define your desired schedule.

Make sure to adjust the schedule expression and any other parameters to fit your specific requirements.

Monitor the Progress and Results

Keep an eye on the progress of the Batch Apex job by reviewing the Apex job queue or monitoring logs.

Once the job completes, analyze the results and track any errors or exceptions for troubleshooting purposes.

Remember to ensure that your Apex implementation adheres to Salesforce’s best practices, follows email regulations and permissions, and respects the privacy and preferences of your recipients.

And if you need more information on sending emails using Apex, check our “In-Depth Gide on Sending Emails With Apex”.

How to test emails before sending them?

There are two options to test emails in Salesforce – use Apex test class, which we cover in a separate article. Or you could use a third-party tool such as Mailtrap.

But why third-party tools when there’s an Apex test class?

Well, the Apex class test results are one-dimensional, and only check the code functionality. But besides testing the functionality, you’ll also want to:

Determine how much different mailbox providers support your HTML and CSS templates.
Check the spam score in sandbox.
Debug an email notification in staging without risking your sender’s reputation.
Fully automate test flows and scenarios. Minimize the chance to experience a lot of bounces.
Without much further ado, we’ll jump right into the methods. And note that we assume that you already have a Mailtrap account.

Tip: You don’t have to add and verify a domain to test emails. This doesn’t apply to Mailtrap Email Sending.

SMTP Method

Get your Mailtrap SMTP credentials

Once inside Mailtrap, click Email Testing in the menu on the left, then the inbox you’d like to use under Inboxes.

Under SMTP settings click “Show Credentials” to reveal them.

Configure an email relay

Navigate to the Email Relays menu by typing ‘relays’ into the search box. Generally, the Email Relays menu is under Setup.

Then, click the Create Email Relay button, and copy-paste the credentials provided by Mailtrap.

Make sure to tick the box next to Enable SMTP Auth, and use the credentials provided by Mailtrap. Also, keep the box next to Change Password unchecked.

Save and set up filters

Click the Save button, but note that your relay still isn’t active. Under Email Relays, click the “filters for recipients and sender domains” link. Then, proceed to create a fliter.

Email Domain Filters configuration

Upon creating a filter, the default configuration is to send emails to all user domains from all sender domains. Of course, for testing purposes, you should choose the Mailtrap Testing SMTP relay, you just created from the Email Relay dropdown.

Save the filter, and proceed to use the flowing script to send test emails.

public class ApexEmailSample {
    public static void sendEmail(String useremail){      
    Messaging.reserveSingleEmailCapacity(20);
        Messaging.SingleEmailMessage mymail = new Messaging.SingleEmailMessage();
        String[] toaddresses = new String[] {useremail};
        String[] toccaddresses = new String[] {'som****@gmail.com'};
        String[] tobccaddresses = new String[] {'ez*****@gmail.com'};

        mymail.setToAddresses(toaddresses);
        mymail.setCcAddresses(toccaddresses);
        mymail.setBccAddresses(tobccaddresses);
        mymail.setReplyTo('support@example.com');
        mymail.setSenderDisplayName('Salesforce Support');
        mymail.setSubject('An email from Salesforce');
        mymail.setPlainTextBody('This email has been sent through Apex');
        mymail.setHtmlBody('<p>This email has been sent through Apex.</p>');

        Messaging.sendEmail(new Messaging.SingleEmailMessage[] { mymail });
    system.debug(useremail);
    }
}

Now, this is only one of the ways you can test Salesforce emails with Mailtrap. If you want to dive deeper into all available methods and workflows, check our comprehensive guide on “How to Test Emails in Salesforce with Mailtrap Email Testing”.

Sending with 3rd party email providers: why and how?

As we already covered sending emails natively with Salesforce, this section focuses on third-party email providers. We cover the reasons to use third-party providers, as well as some downsides to keep in mind.

Also, the exemplary integration is geared toward Mailtrap users. For now, you’ll only be able to send transactional emails – our bulk email feature is currently under development.

Be that as it may, Mailtrap and Salesforce make a killer marketing tool. They allow you to seamlessly merge the CRM and email solutions and take the sales in your company to the next level.

The Whys

When it comes to sending emails from Salesforce, you have a couple of options. You can use Salesforce’s built-in email services, or you can use a third-party email service provider.

While Salesforce’s built-in services are convenient, there are several compelling reasons to consider using a third-party service:

Deliverability: Third-party email service providers such as Mailtrap specialize in email deliverability. They have dedicated teams and technologies to ensure your emails reach the recipient’s inbox and not their spam folder.
Scalability: If you’re sending at a volume, third-party services are designed to handle and balance that load. Salesforce has daily limits on the number of emails you can send, which can be a constraint for some businesses.
Features: Third-party services often come with additional features such as email templates, analytics, A/B testing, automation, and more. These can be valuable tools for optimizing your email campaigns.
Cost-effectiveness: Depending on your volume of emails and the specific features you need, third-party services can often be a more cost-effective solution.

However, there are also some potential downsides to consider:

Integration: You’ll need to integrate the third-party service with Salesforce, which can require some technical setup. But at Mailtrap, we ensured the integration process is as smooth as possible.
Dependency: You’re relying on another service, which could potentially have its own downtime or issues.
Cost: While often cost-effective, there is still a cost associated with third-party services. You’ll need to evaluate this against your budget and needs.

The How

As a reminder, the quick tutorial below is geared toward transactional emails that you can send at scale with Mailtrap.

Also, unlike Mailtrap Testing, Mailtrap Sending requires you to add and verify a domain. And, in the sections below, we assume you already did it.

If you need any help adding or verifying your domain, check our Getting Started Guide. Or watch our Domain Setup Video.

Add Email Relay

To start sending transactional emails via Mailtrap Sending, you need to set up another Email Relay. The steps are pretty much the same as previously described under the Testing tutorial. So, we won’t go into details here, only pay attention to the number of relays you can add as per your Salesforce Edition.

Also, keep in mind that, of course, we have somewhat different credentials for Testing and Sending. Take the following path to get to them.

Sending Domains > Choose a domain > SMTP/API Settings

Send test email

To stress, the ‘test email’ you’ll be sending is there to confirm your configuration. By default, the ‘test email’ gets sent to the email address you use to sing into Mailtrap.

Here’s the code snippet to send a test email.

public class MailTrapEmailAPI {
  public static void sendMail(){
      String body = '{"to": [{"email": "john.doe@example.com", "name": "Mailtrap Inbox"}], "from": {"email": "mailtrap@example.com", "name": "Magic Elves"}, "subject": "You are awesome!", "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><img alt=\\"Inspect with Tabs\\" src=\\"https://assets-examples.mailtrap.io/integration-examples/welcome.png\\" style=\\"width: 100%;\\"><p>Now send your email using our fake SMTP server and integration of your choice!</p><p>Good luck! Hope it works.</p></div></body></html>", "text": "Congrats for sending test email with Mailtrap!\\n\\nInspect it using the tabs above and learn how this email can be improved.\\nNow send your email using our fake SMTP server and integration of your choice!\\n\\nGood luck! Hope it works."}';

      Http http = new Http();
      HttpRequest request = new HttpRequest();
      request.setEndpoint('https://send.api.mailtrap.io/api/send');
      request.setMethod('POST');
      request.setHeader('Api-Token', 'YourMailtrapAPIToken');
      request.setHeader('Content-Type', 'application/json;charset=UTF-8');
      request.setBody(body);
      System.debug('1 ' + request);
      HttpResponse response = http.send(request);
      System.debug('2 ' + response);
  }
}

And here’s the addition to include a string from a List.

List<String> emailAddresses = new List<String>();
// Populate the list with email addresses from your data source
// ...
mail.setToAddresses(emailAddresses);

Mass Send to the Rescue

We’ve covered a lot of ground in this article, diving deep into the process of Salesforce mass email sending. From Apex to testing, and the nuances of Salesforce Classic and Lightning Experience, we’ve seen that Salesforce offers a range of powerful tools for mass emailing.

As we wrap up our exploration of sending mass emails in Salesforce, keep in mind that each method has its own strengths and considerations. We hope this guide shed some light on these processes and will serve as a stepping stone for your future endeavors in Salesforce.

Remember, the world of Salesforce is vast and ever-evolving, so keep exploring, keep learning, and most importantly, keep emailing!

Thank you for choosinf this article! Discover more articles about how to send mass email in salesforce in Mailtrap blog!

Send Emails with Rust – SMTP and API Methods with Examples

Veljko Ristic — Mon, 11 Dec 2023 10:15:22 +0000

This article explores the practical steps and considerations for utilizing Rust to manage email sending, from setting up SMTP to leveraging APIs for both sending and testing emails.

How to send emails using Rust and SMTP

The lettre crate is among the most straightforward methods to send emails from Rust via SMTP. The following sections cover different scenarios using lettre crate and they include:

Sending a simple plain.txt email
Sending an HTML email
Sending attachments
Sending to multiple recipients

Feel free to copy-paste the scripts below minding your credentials as well as recipient and sender addresses, and SMTP endpoints. Also, note that these are designed for Mailtrap Email Sending SMTP users.

Later in the article, we cover the API method. And here, we’d like to offer some pointers for Mailtrap users.

Before you start sending your emails, you need to verify your domain with Mailtrap.
Make sure to use the script with TLS handling, since Mailtrap requires STARTTLS.
Use only the domain that you set up and verified with Mailtrap. Or, you’ll get the “Unauthorized 401” error.

Send emails using `lettre` crate

Add ‘lettre’ to the ‘Cargo.toml’ file:

[dependencies]
lettre = "0.10"
lettre_email = "0.9"

Note: the lettre and lettre_emailversions might be updated when you’re reading this article. Click here for the latest versions.

Write the email-sending script:

use lettre::{Message, SmtpTransport, Transport};
use lettre::smtp::authentication::Credentials;

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    // Define the email
    let email = Message::builder()        .from("Your Name <your.email@example.com>".parse().unwrap())        .reply_to("your.email@example.com".parse().unwrap())        .to("Recipient Name <recipient.email@example.com>".parse().unwrap())        .subject("Rust Email")        .body(String::from("Hello, this is a test email from Rust!"))        .unwrap();
    // Set up the SMTP client    let creds = Credentials::new("Mailtrap_smtp_username".to_string(), "Mailtrap_smtp_password".to_string());
    // Open a remote connection to gmail    let mailer = SmtpTransport::relay("your_mailtrap_Host.io")?        .credentials(creds)        .build();
    // Send the email    match mailer.send(&email) {        Ok(_) => println!("Email sent successfully!"),        Err(e) => eprintln!("Could not send email: {:?}", e),    }
    Ok(())
}

Important: Replace all the variables with your actual credentials, relay endpoints, and corresponding email addresses.

*TLS handling *

If you’re a Mailtrap user, TLS handling is required. lettre supports ‘None’, ‘Starttls’ and ‘Required’ TLS settings. The TLS settings are specified in the SmtpTransport block, and here’s what the TLS-enabled script might look like.

use lettre::{Message, SmtpTransport, Transport}; 
use lettre::transport::smtp::{authentication::{Credentials}}; 

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    // Build an email message using the builder pattern
    let email = Message::builder()
        // Set the sender's name and email address
        .from("Your Name <your address@gmail.com>".parse().unwrap()) 
        // Set the recipient's name and email address
        .to("Recipient Name <receiver address@gmail.com>".parse().unwrap()) 
        // Set the subject of the email
        .subject("Rust Email") 
        // Set the body content of the email
        .body(String::from("Hello World, this is a test email from Rust!")) 
        .unwrap();

    // Create SMTP client credentials using username and password
    let creds = Credentials::new("mailtrap_username".to_string(), "mailtrap_password".to_string()); 

    // Open a secure connection to the SMTP server using STARTTLS
    let mailer = SmtpTransport::starttls_relay("your_mailtrap_host.io")
        .unwrap()  // Unwrap the Result, panics in case of error
        .credentials(creds)  // Provide the credentials to the transport
        .build();  // Construct the transport

    // Attempt to send the email via the SMTP transport
    match mailer.send(&email) { 
        // If email was sent successfully, print confirmation message
        Ok(_) => println!("Email sent successfully!"), 
        // If there was an error sending the email, print the error
        Err(e) => eprintln!("Could not send email: {:?}", e), 
    }

    Ok(())
}

Note: your_mailtrap _host will vary depending on your purpose. For example, if you’re using Mailtrap Email Testing, then the Host is sandbox.smtp.mailbox.io

Run your application Use the cargo run command to run your application. Assuming the setup is correct, rust will send the email to specified recipients.

How to send HTML email with Rust?

To send an HTML email, we’ll reuse and modify the lettre script with STARTTLS.

Simply, you need to set the content type of the email body to text/html. This can be done by using the message::SinglePart and message::MultiPart modules to construct the email body properly.

Here’s the modified code:

use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
use lettre::message::{Mailbox, MultiPart, SinglePart};

fn main() ->  std::result::Result<(), Box<dyn std::error::Error>> {

    // Define the HTML content
    let html_content = r#"
        <html>
            <body>
                <h1>Hello!</h1>
                <p>This is a <strong>test email</strong> from Rust!</p>
            </body>
        </html>
    "#;

    let from_email = "Your Name <sender@example.com>".parse::<Mailbox>().unwrap();
    let to_email = "Recipient Name <recipient@example.com>".parse::<Mailbox>().unwrap();

    // Define the email with HTML part
    let email = Message::builder()
        .from(from_email)
        .to(to_email)
        .subject("Rust Email")
        .multipart(
            MultiPart::alternative().singlepart(SinglePart::html(html_content.to_string())),
        )
        .unwrap();

    // Set up the SMTP client credentials
    let creds = Credentials::new("username".to_string(), "password".to_string());

    // Open a remote connection to the SMTP server with STARTTLS
    let mailer = SmtpTransport::starttls_relay("your_mailtrap_host.io")
        .unwrap()
        .credentials(creds)
        .build();

    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
        Err(e) => eprintln!("Could not send email: {:?}", e),
    }

    Ok(())
}

Notes on code modifications:

The html_content variable holds the HTML content of the email.
The Message::builder() is used to set up the headers of the email.
The multipart() method is used to create a MultiPart email, which can contain both text and HTML parts. In this case, we’re only adding an HTML part using SinglePart::html(html_content.to_string())

How to send an email with attachments in Rust?

Again, we’ll reuse and modify the script above to include attachments.

This code demonstrates how to send an email with attachments using the lettre crate in Rust and the Mailtrap SMTP server.

use lettre::transport::smtp::authentication::Credentials;
use lettre::{Message, SmtpTransport, Transport};
use lettre::message::{Mailbox, MultiPart, SinglePart, Attachment, Body};
use std::fs;

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {


    let image = fs::read("picture.png")?;
    let image_body = Body::new(image);

    let from_email = "Your Name <sender@example.com>".parse::<Mailbox>().unwrap();
    let to_email = "Recipient Name <recipient-email@example.com>".parse::<Mailbox>().unwrap();

    let email = Message::builder()
                    .from(from_email)
                    .to(to_email)
                    .subject("Hello")
                    .multipart(
                        MultiPart::mixed()
                            .multipart(
                                MultiPart::alternative()
                                    .singlepart(SinglePart::plain(String::from("Hello, world! :)")))
                                    .multipart(
                                        MultiPart::related()
                                            .singlepart(SinglePart::html(String::from(
                                                "<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>",
                                            )))
                                            .singlepart(
                                                Attachment::new_inline(String::from("123"))
                                                    .body(image_body, "image/png".parse().unwrap()),
                                            ),
                                    ),
                            )
                            .singlepart(Attachment::new(String::from("example.com")).body(
                                String::from("fn main() { println!(\"Hello, World!\") }"),
                                "text/plain".parse().unwrap(),
                            )),
                    )?;

    let creds = Credentials::new("username".to_string(), "password".to_string());

    // Open a remote connection to the SMTP server with STARTTLS
    let mailer = SmtpTransport::starttls_relay("your_mailtrap_hosting.io").unwrap()
        .credentials(creds)
        .build();

    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
        Err(e) => eprintln!("Could not send email: {:?}", e),
    }

    Ok(())
}

Notes on code modifications:

The code uses the fs::read function from the std library to read the contents of the "picture.png" file into a byte vector. This byte vector is then wrapped in a Body object, which represents the body of the image attachment.
In this example, a multipart email is created using MultiPart::mixed(). This multipart email consists of two parts: an alternative multipart (containing a plain text part and a related multipart) and a single-part attachment.
The alternative multipart holds both a plain text part (SinglePart::plain) and a related multipart. The related multipart contains an HTML part (SinglePart::html) with an embedded image attachment (Attachment::new_inline).
The single-part attachment contains a source code file called "example.com".

When using the script, you need to replace the "picture.png", with the file path you’re using.

Sending email to multiple recipients using Rust

You can send to multiple recipients by chaining .to(),.cc(), and.bcc()methods. Each recipient is added by parsing a string that contains the email address and optionally the name of the recipient.

Check the updated sending script.

// [dependencies]
// lettre="0.10"

use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
use lettre::message::{Mailbox, MultiPart, SinglePart};

fn main() ->  std::result::Result<(), Box<dyn std::error::Error>> {

    // Define the HTML content
    let html_content = r#"
        <html>
            <body>
                <h1>Hello!</h1>
                <p>This is a <strong>test email</strong> from Rust!</p>
            </body>
        </html>
    "#;

    let from_email = "Your Name <sender@example.com>".parse::<Mailbox>().unwrap();
    let to_email = "Recipient Name <receiver@example.com>".parse::<Mailbox>().unwrap();

    // Define the email with HTML part
    let email = Message::builder()
        .from(from_email)
        .to(to_email) 
        // You can also add CC and BCC recipients
        .cc("Recipient CC <recipient.cc@example.com>".parse::<Mailbox>().unwrap())
        .bcc("Recipient BCC <recipient.bcc@example.com>".parse::<Mailbox>().unwrap())
        .subject("Rust Email")
        .multipart(
            MultiPart::alternative().singlepart(SinglePart::html(html_content.to_string())),
        )
        .unwrap();

    // Set up the SMTP client credentials
    let creds = Credentials::new("username".to_string(), "password".to_string());

    // Open a remote connection to the SMTP server with STARTTLS
    let mailer = SmtpTransport::starttls_relay("your_mailtrap_hosting.io")
        .unwrap()
        .credentials(creds)
        .build();

    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
        Err(e) => eprintln!("Could not send email: {:?}", e),
    }

    Ok(())
}

How to send emails using Rust and Mailtrap API?

To send emails using the Mailtrap Email Sending API in Rust, use an HTTP client library to make a POST request to the API endpoint.

The commonly used HTTP client library in Rust is reqwest, and I chose it because it’s among the easiest to implement.

Now, start by adding the necessary dependencies. Add reqwest and tokio to your Cargo.toml because reqwest is an async library:

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
serde_json = "1.0"
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

Here’s an exemplary script to send emails with Rust and Mailtrap API.

use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let api_url = "https://send.api.mailtrap.io/api/send";
    let api_key = "your_api_key";
    let email_payload = json!({
        "from": {"email" : "your_verified_domain"},
        "to": [{"email": "receiver@example.com"}],
        "subject": "Test Email",
        "text": "This is a test email using Rust and Mailtrap API!",
    });

    let client = reqwest::Client::new();
    let response = client
        .post(api_url)
        .header("Content-Type", "application/json")
        .header("Api-Token", api_key)
        .body(email_payload.to_string()) // Serialize the JSON payload to a string
        .send()
        .await?;

    if response.status().is_success() {
        println!("Email sent successfully!");
    } else {
        println!("Failed to send email. Status: {:?}", response.status());

        // Print the response body for additional information
        let body = response.text().await?;
        println!("Response body: {}", body);
    }

    Ok(())
}

Notes on the Mailtrap API method:

The email_payload variable contains a JSON object that represents the email data.
A client instance is created using reqwest::Client::new(). This client will be used to make the POST request to the Mailtrap API.
The client.post(api_url) method creates a POST request to the specified endpoint URL. The headers are set using the .header() method, including the Content-Type header as "application/json" and the API-Token header as the Mailtrap API key.
The email payload is serialized to a string using email_payload.to_string() and set as the request body using the .body() method.
The send()method sends the request and returns a future that resolves to a Result<Response, reqwest::Error> The await keyword is used to await the completion of the request and get the response.
The response status is checked using the .status() method. If the status indicates success (2xx) a success message is printed. Otherwise, an error message is printed along with the response status.
Any errors that occur during the request or response handling are propagated by returning a Result<(), reqwest::Error> from the main() function. Error handling in Rust typically involves propagating the error upwards in the call stack by returning it from the function.

Before running this code, ensure that you have the reqwest and tokio crates added to your Cargo.toml file with the appropriate versions and features enabled.

Send emails using `sendmail` crate

The sendmail crate sends emails by interfacing with the sendmail command available on many Unix-like systems. This means that the system where your Rust application is running must have a sendmail-compatible program installed and properly configured.

The quick tutorial below assumes you have a proper sendmail-compatible program installed and configured. Otherwise, the method won’t work.

If you need a tutorial on setting up sendmail on Ubuntu, check the one in the link.

Add sendmail command to the Cargo.toml:

[dependencies]
sendmail = "2.0"

Use the script below to send your email:

extern crate sendmail;
use sendmail::email;

fn main() {

    // Configure email body and header
    // Send the email
    match email::send(
        // From Address
        "sender@example.com",
        // To Address
        &["receiver@example.com"],
        // Subject
        "Subject - Hello World!",
        // Body
        "<html><body><h1>I am the body. Hello Wolrd!<br/><br/>And I accept html.</h1></body></html>"
    ) {
        Ok(_) => println!("Email sent successfully!"),
        Err(e) => eprintln!("Could not send email: {:?}", e),
    }
}

Keynotes on using the sendmail crate:

sendmail(&email) is used to send the email. This function takes the email object and sends it using the system’s sendmail command.
As the method relies on the system-level sendmail command, it’s less “portable” than the lettre which can work across different platforms without system-specific tools.

Rust email testing: reasons and how-tos

There are five reasons to consider email testing with Rust:

Verification of Logic: Ensure that your email-sending logic works as expected under various conditions.
Content Accuracy: Make sure that the content of the emails, including subject, body (both text and HTML), and attachments, is correct.
Error Handling: Test how your application handles failures, such as network issues or incorrect credentials.
Performance: Understand how your email sending performs under load. This is especially important if you’re sending large volumes of email.
Security: Ensure that your email-sending process is secure and that sensitive information is handled correctly.

Also, there are three types of tests you can run: integration, unit, and end-to-end testing. Check the details below.

Integration testing with Mailtrap Testing SMTP

Use Mailtrap Email Testing for integration tests. It gives you a safe environment to inspect and debug your emails without the risk of spamming your recipients.

Here’s an exemplary code for Mailtrap users.

Note: Run this application with ‘cargo test’ command to see the result.

// Example of integration test with a fake SMTP server
fn send_test_email() -> Result<(), Box<dyn std::error::Error>> {
        // Build the email
    let email = EmailBuilder::new()
        // Addresses can be specified by the tuple (email, alias)
        .to(("recipient.email@example.com", "Recipient Name"))
        .from(("your.email@example.com", "Your Name"))
        .subject("Rust Email")
        .body("Hello, this is a test email from Rust!")
        .build()?;

    // Send the email
    match sendmail(&email) {
        Ok(_) => println!("Email sent successfully!"),
        Err(e) => eprintln!("Could not send email: {:?}", e),
    }

    Ok(())

}

#[test]
fn test_email_integration() {
    // Start a fake SMTP server before running the test
    // ...

    let result = send_test_email();
    assert!(result.is_ok());

    // Check the fake SMTP server for the sent email
    // ...
}

Important Note: The code above doesn’t contain an exemplary email template.

As mentioned this integration test is for Mailtrap users, if you’re not a user, you can sign up here. We offer a free plan where you can check things out at a rate of 100 emails a month with a throughput of 5 emails per 10 seconds.

Here’s a quick overview of what you get with Mailtrap Email Testing:

Fake SMTP Server
HTML/CSS check
Spam score check
API for QA automation
Integrations in 20+ languages (Ruby, Python, PHP, Node.js, .Net, etc.)
Emails preview
Multiple inboxes for different projects and stages
User management
SSO

Integration testing with Mailtrap Testing API

We’ll follow a similar approach used for Mailtrap Email Sending API. Only, this time the endpoints and details are specific to the testing API.

Again, you need the reqwest and tokio crates in the Cargo.toml file to may asynchronous HTTP requests.

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
serde_json = "1.0"
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

And here’s a exemplary API testing script.

use reqwest;
use serde_json::json;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_url = "https://sandbox.api.mailtrap.io/api/send/inbox_id"; // Replace 'inbox_id' with your actual Mailtrap inbox ID
    let api_token = "api_token"; // Replace with your actual Mailtrap API token

    let client = reqwest::Client::new();

    let payload = json!({
        "to": [
            {
                "email": "receiver@gmail.com",
                "name": "receiver name"
            }
        ],
        "from": {
            "email": "your.domain.link",
            "name": "Example Sales Team"
        },
        "subject": "Your Example Order Confirmation",
        "text": "Congratulations on your order no. 1234",
        "category": "API Test"
    });

    let response = client.post(api_url)
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .header("Api-Token", api_token)
        .json(&payload)
        .send()
        .await?;

    if response.status().is_success() {
        println!("Email sent successfully!");
    } else {
        println!("Failed to send email. Status: {:?}", response.status());

        // Print the response body for additional information
        let body = response.text().await?;
        println!("Response body: {}", body);
    }


    Ok(())
}

Keynotes about the API testing script:

Replace "inbox_id" with your actual Mailtrap inbox ID (integer).
Replace "your_api_token" with your actual Mailtrap API token.
The payload is constructed using serde_json::json! macro to create a JSON object.
The reqwest::Client is used to make a POST request to the Mailtrap Testing API endpoint. The response is checked for success, and the response body is printed out.

Lastly, you should run the code within an async environment since reqwest is an asynchronous library. The #[tokio::main] attribute macro is used to set up an asynchronous runtime for the main function.

Unit testing

Unit testing allows you to mock the components that send emails. Rust libraries designed for that are mockall or mockito, and they create mock objects in the tests.

The below is a simplified version of how you might mock an email sender.

use mockall::predicate::*;
use mockall::Sequence;
use mockall::automock;

#[automock]
trait EmailSender {
    fn send_email(&self, recipient: &str, subject: &str, body: &str) -> Result<(), String>;
}

struct MyComponent<T: EmailSender> {
    email_sender: T,
}

impl<T: EmailSender> MyComponent<T> {
    pub fn new(email_sender: T) -> Self {
        MyComponent { email_sender }
    }

    pub fn do_something(&self) -> Result<(), String> {
        // Code that uses the email sender component
        let recipient = "recipeint@example.com";
        let subject = "Test Subject";
        let body = "Test Body";

        self.email_sender.send_email(recipient, subject, body)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_do_something() {
        let mut email_sender = MockEmailSender::new();

        let recipient = "recipient@example.com";
        let subject = "Test Subject";
        let body = "Test Body";

        // Set up expectations for the mock object
        email_sender.expect_send_email()
            .once()
            .withf(move |r, s, b| r == recipient && s == subject && b == body)
            .returning(|_, _, _| Ok(()));

        let my_component = MyComponent::new(email_sender);
        let result = my_component.do_something();

        assert!(result.is_ok());
    }
}

Key notes

The #[automock] attribute is used before the EmailSender trait definition. This attribute generates an implementation of the trait with all its methods implemented as mock methods. It allows you to set expectations on the behavior of the mock object during testing.
Using the expect_send_email method on the email_sender mock object, you set expectations for the send_email method of the mock object.
In the exemplary script, the method should be called once (once()) and with the expected recipient, subject, and body values. We use the withf method to define a closure that checks if the passed arguments match the expected ones.
The returning method is used to define the return value of the send_email method, which in this case is Ok(())
I created an instance of MyComponent by passing the mocked email_sender object. Then, we call the do_something method on the instance and store the result in the result variable.

End-to-end testing

To run end-to-end tests, you might actually send production (not sandbox) emails to a controlled set of email addresses. Then, you could use a specific API or service to confirm that the emails were received and contain the right content.

There’s no exemplary code here as it depends on the type of emails you want to test, what services you’re using, and your overall approach. So, it’s a topic on its own and won’t be covered in detail here.

However, if you run integration testing, end-to-end might not be necessary.

Trust Rust

Rust’s versatility extends to email communication, providing developers with powerful tools to send and test emails effectively. Whether through SMTP or API integration, the language’s safety features and performance make it an excellent choice for managing email-related tasks in modern applications.

Thank you for reading this article! Follow Mailtrap blog and discover more about sending emails using Rust and SMTP

Forem: Veljko Ristic

How to Set Up, Configure, and Send Emails using Yahoo SMTP Server

What is Yahoo SMTP?

Why should you use Yahoo as an SMTP server?

How to configure Yahoo SMTP server settings?

How to configure Yahoo POP3 settings?

How to configure Yahoo IMAP settings?

Troubleshooting Yahoo SMTP server configuration

Yahoo SMTP limitations: when not to use Yahoo as a SMTP server

What is a reliable alternative to Yahoo SMTP?

Wrapping up

Setting up GoDaddy SMTP to Send Emails

What is a GoDaddy SMTP server?

Why should you use GoDaddy SMTP server?

How to configure GoDaddy SMTP server settings?

How to configure GoDaddy POP3 settings?

How to configure Godaddy IMAP settings?

Troubleshooting GoDaddy SMTP server configuration

GoDaddy SMTP limitations or when not to use GoDaddy as a SMTP server

Consider an alternative – using Mailtrap SMTP Service

Wrapping up

How to Validate Emails in PHP: regex, filter_var(), and API Explained

PHP email validation function: filter_var()

Validating emails with FILTER_VALIDATE_EMAIL

Regular expression for email validation in PHP

Email validation in PHP using API

Email validation as part of email testing

Creating a WordPress Contact Form – Complete Guide

How to create a contact form in WordPress with a plugin?

How to create a simple contact form in WordPress without a plugin?

Create a callback function with validations and a captcha

How to Set up PHP Form Validation – Detailed Tutorial

Choosing a PHP form validation method

AJAX validation

JavaScript validation

Database validation

How to validate a form in PHP using script

Step 1 – Create an HTML form

Step 2 – Sanitize and validate Input

Step 3 – Display Errors

Pro Tips

How to validate a form in PHP using AJAX

Step1 – Create an HTML form

Step 2 – Use Javascript for AJAX submission

Step 3 – Handle form validation in PHP

How to validate a form in PHP using JavaScript

Step 1 – Create an HTML form

Step 2 – Implement JavaScript validation

PHP form validation: more use cases

CAPTCHA

Salesforce Apps to Keep Under Your Radar

Best Salesforce Apps: A Quick Overview

Salesforce Apps for Email Synchronization

Cirrus Insight

Key features

Our two cents

Ebsta

Key features

Our two cents

Salesforce Apps for Email Analytics

Full Circle Insights

Key features

Our two cents

Salesforce Apps for Feedback and User Experience Management

Zonka Feedback

Key features

Our two cents

Survicate

Key features

Our two cents

Jotform

Key Features

Our Two Cents

Salesforce Apps for Email Security and Compliance

OwnBackup

Key features

Our two cents

Cloud Compliance

Key features

Our two cents

Validating emails with `FILTER_VALIDATE_EMAIL`

Send emails using `lettre` crate

Send emails using `sendmail` crate