Forem: Denys

Send Emails with Windsurf and Mailtrap

Denys — Thu, 28 Aug 2025 11:15:21 +0000

Learn how to seamlessly integrate Mailtrap with Windsurf to send transactional emails using simple AI prompts.

This article provides a comprehensive guide based on Mailtrap's official tutorial on how to send emails in Windsurf.

Before we start

Required accounts

Windsurf account - to access the AI-powered development environment
Mailtrap account - to send emails
Node.js - latest version installed for MCP server functionality

Prerequisites setup

Verify your email sending domain - Mailtrap requires domain verification before you can send emails. This process takes approximately 5 minutes and ensures optimal deliverability rates. Follow Mailtrap's domain setup guide for detailed instructions.
Get your API Token - Navigate to your Mailtrap dashboard and obtain an API token with appropriate permissions for your sending domain and email operations.
Install Windsurf - Download and install the latest version of Windsurf from windsurf.com to ensure compatibility with all MCP features.
Update Node.js - Ensure you have the latest Node.js version installed, as the Mailtrap MCP server runs as a Node.js command line utility.

Important Note: The integration uses Mailtrap's MCP server, which provides a seamless interface between Windsurf's AI capabilities and Mailtrap's email infrastructure.

Configure Mailtrap Integration with Windsurf

Step 1: Add Mailtrap MCP to Windsurf

Begin by configuring the MCP server connection in Windsurf:

Open Windsurf Settings
- Launch Windsurf application
- Navigate to Settings → Windsurf Settings
- This will open the main configuration panel
Access MCP Configuration
- Look for the Manage MCPs button in the settings panel
- Click on it to open the mcp.config.json file
- This file controls all Model Context Protocol integrations
Add Mailtrap MCP Configuration

Insert the following configuration into your mcp.config.json file:

{
  "mcpServers": {
    "mailtrap": {
      "command": "npx",
      "args": ["-y", "mcp-mailtrap"],
      "env": {
        "MAILTRAP_API_TOKEN": "your_mailtrap_api_token",
        "DEFAULT_FROM_EMAIL": "your_sender@example.com"
      }
    }
  }
}

This configuration establishes the connection between Windsurf and Mailtrap's email services through the MCP protocol.

Step 2: Configure Mailtrap API Credentials

Replace the placeholder values in your configuration with your actual Mailtrap credentials:

MAILTRAP_API_TOKEN Configuration
- Navigate to your Mailtrap dashboard
- Go to Sending Domains → Integration → API
- Copy your API token from the credentials tab
- Ensure the token has appropriate permissions for email sending
DEFAULT_FROM_EMAIL Setup
- Use an email address from your verified sending domain
- The domain must match exactly with your verified domain in Mailtrap
- Format: sender@your-verified-domain.com
Verify Domain Matching
- Check your Sending Domains tab in Mailtrap
- Ensure the email domain you're using is verified and active
- Mismatched domains will result in delivery failures

Important: After updating your credentials, restart Windsurf to ensure all changes take effect properly. This prevents any caching issues with the MCP server connection.

Step 3: Enable Mailtrap MCP in Windsurf

Activate the Mailtrap integration within your Windsurf workspace:

Open Cascade Sidebar
- Locate the Cascade panel in the upper-right corner of Windsurf
- This is where you'll interact with AI assistance and MCP servers
Enable Mailtrap MCP Server
- Look for Customizations section in the Cascade sidebar
- Find the Mailtrap MCP server in the available integrations
- Toggle it to enabled status
Verify Connection Status
- The enabled MCP server should show as connected
- You may see a green indicator or status message
- If connection fails, double-check your API credentials

Send Your First Email with Windsurf and Mailtrap

Step 1: Basic email sending

With your integration configured, you can now send emails using natural language prompts. Example Prompt:
Send an email to john.doe@example.com with the subject 'Welcome to our service' and a message thanking them for signing up.
Windsurf will interpret this prompt and execute the email sending through Mailtrap automatically.

Step 2: Advanced email features

Leverage more sophisticated email functionality with detailed prompts. HTML Email Example:
Send an HTML email to customer@example.com with the subject 'Monthly Newsletter' including a header with our company logo, a welcome message, and a call-to-action button linking to our website.
Multiple Recipients Example:
Send a notification email to team@company.com and manager@company.com with the subject 'Project Update' and a status report about the current development progress.

Step 3: Verify Email Delivery

After sending emails through Windsurf, confirm successful delivery:

Check Windsurf Confirmation
- Windsurf will display a success message after email execution
- Review the prompt response for any error messages
Monitor Mailtrap Dashboard
- Navigate to Email Logs in your Mailtrap account
- Verify the email appears in the sent logs
- Check delivery status and any bounce notifications
Test Email Receipt
- Check the recipient's inbox for successful delivery
- Verify email formatting and content accuracy

Windsurf Email Integration Best Practices

Environment Management

Store sensitive API tokens securely in the MCP configuration
Regularly rotate your Mailtrap API tokens
Never commit API credentials to version control systems

Domain Verification

Always use verified sending domains to ensure high deliverability
Monitor your domain reputation through Mailtrap analytics
Keep DNS records updated and properly configured

Sender Reputation

Use consistent sender addresses from verified domains
Monitor bounce rates and spam complaints in Mailtrap dashboard
Maintain clean recipient lists to avoid delivery issues

Content Quality

Craft clear, relevant subject lines to improve open rates
Use proper HTML structure for formatted emails
Include both HTML and plain text versions when possible
Avoid spam trigger words and excessive promotional content

Prompt Engineering

Start with simple email prompts and gradually increase complexity
Be specific about recipient, subject, and message content
Use descriptive language for HTML formatting requirements
Test prompts iteratively to refine email output

Summing up

This comprehensive guide demonstrates how to integrate Mailtrap Email Delivery Platform with Windsurf using MCP server. The integration enables developers to send transactional emails through natural language prompts without complex coding.

Send Emails with Lovable and Mailtrap

Denys — Thu, 21 Aug 2025 08:23:41 +0000

Learn how to integrate Mailtrap with your Lovable application to send transactional emails, manage contacts, and create powerful email workflows without writing complex code.

Lovable is a platform that allows you to create everything from contact forms to whole websites and apps, all by using simple prompts. Combined with Mailtrap's robust email infrastructure, you can build sophisticated email functionality into your applications with ease.

This article is based on Mailtrap's official tutorial on how to send email using Lovable and Lovable’s tutorial.

Before we start

Required accounts

Lovable account - to create contact forms and generate logic
Mailtrap account - to send emails and manage contacts
Supabase account - to securely store API keys and manage your database

Prerequisites setup

Verify your email sending domain - Mailtrap allows you to send emails only from a verified domain. Follow this guide to set up domain verification.
Get your API Token - Ensure your API Token has admin access level to your domain and contacts.
Create Custom Fields (if needed) - Set up Custom fields in Mailtrap if your forms have additional inputs you want to save.
Find your Account ID - You'll need this for creating contacts in Mailtrap. Find it in your Account Management section.

Important Note: The prompts provided are based on our experience with Lovable and GPT-5 as of August 2025. Since both Lovable and LLM models constantly evolve, you may need to adjust these prompts for your specific needs.

Configure Mailtrap SMTP/Email API with Lovable

Step 1: Set up basic email sending

Start with this prompt in Lovable to create a simple email sending functionality:

- Email should be sent via Mailtrap.io, as I have an account there.
- My Mailtrap verified domain is [your-domain.com]
- I want to send emails from hello@[your-domain.com]
- Save my Mailtrap API key in MAILTRAP_API_KEY secret.
- Include and use Mailtrap NodeJS SDK https://www.npmjs.com/package/mailtrap to send emails. Use the latest available version of the npm package.

This basic setup will configure Mailtrap integration and prepare your environment for email sending.

Step 2: Manage Mailtrap Contacts automatically

Enhance your setup to automatically add form submissions to Mailtrap Contacts:

- Pass all my new users/form submissions to Mailtrap contacts.
- Use the latest version of Mailtrap NodeJS SDK to add contacts.
- My MAILTRAP_ACCOUNT_ID env variable.
- Use the same Token I use for production mode of Mailtrap, as it can also create Contacts.
- Pass the name from my form to name field in Mailtrap. Add users to MAILTRAP_LIST_ID.
- Create contacts table in Supabase with columns: id (UUID, primary key), name (text), email (text), message (text), created_at (timestamp), mailtrap_contact_id (text)
- Apply Supabase Row-Level Security (RLS) to restrict access to only authenticated users.
- Save form contacts info from submissions in DB and use Mailtrap NodeJS SDK to create a contact in Mailtrap.
- Save Mailtrap contact_id to mailtrap_contact_id column in contacts table.

Step 3: Locate Your Mailtrap List ID (Optional)

If you want to add contacts to a specific list in Mailtrap:

Go to your List by clicking on it in Mailtrap
Check the URL - it will look like: https://mailtrap.io/contacts?filters=%5B%7B%22name%22:%22list_id%22,%22operator%22:%22equal%22,%22value%22:%5B23%5D%7D%5D
Use URL Decoder to decode the URL
Find your list ID in the decoded URL (in this example, it's 23)

Build a landing page in Lovable

Step 1. Connect to Supabase

In your Lovable project, click the Supabase icon in the upper-right corner
Enter your project name, password, and choose your preferred region
Click "Create new project" to establish the connection ### Step 2. Create a landing page Use this comprehensive prompt to build a complete SaaS landing page with email functionality:

Create a SaaS landing page with a contact form that collects the full name, email address, and message.

My SaaS is called [YourCompanyName], which helps customers [your value proposition]. Our form will capture leads who want to learn more about our services.

My landing page should have this structure:
- Hero section describing benefits with a button that scrolls to the form
- Testimonials/social proof/case studies section  
- Contact form
- About section
- Contact Info section
- Links to social networks

Make sure this form works like this:
- Add browser validation for the email input in the form, so only a valid email will pass
- Add minimum length of 50 characters for message field, and maximum length of 100 characters for Name input
- As a customer submits a form:
  - Send an email with form content to my email MAILTRAP_MY_EMAIL secret variable
  - Emails should be sent from form-submissions@[your-verified-domain.com] (MAILTRAP_FROM_EMAIL)
  - Create a contact in Mailtrap (name, email)
  - Pass value from form's "Full name" input to Mailtrap's custom field name
  - Add form submission info to Supabase contacts table
  - Display submission confirmation to visitor
  - Apply Supabase Row-Level Security (RLS) to restrict access to authenticated users

- Email should be sent via Mailtrap using:
  - My Mailtrap account MAILTRAP_ACCOUNT_ID (store in Supabase Secrets)  
  - Mailtrap NodeJS SDK for creating contacts and sending emails
  - Save Mailtrap API key in MAILTRAP_API_KEY secret

Plan step-by-step, verify results after each step. Write code in Typescript, generate atomic files in the Supabase Edge function for easier debugging.

Step 3. Configure your Mailtrap secrets

After Lovable creates your application, add these secrets in your Supabase project:

MAILTRAP_ACCOUNT_ID=your_account_id
MAILTRAP_API_KEY=your_api_key

MAILTRAP_MY_EMAIL=your-email@example.com
MAILTRAP_FROM_EMAIL=form-submissions@your-verified-domain.com

Test your Mailtrap SMTP/Email API integration

Submit a test form on your landing page
Check for confirmation message display
Verify the contact appears in your Mailtrap Contacts
Confirm you receive the notification email
Review the entry in your Mailtrap Email Logs

Lovable email sending best practices

Security

Always store sensitive information in Supabase Secrets, never in code
Enable Row-Level Security (RLS) on all database tables
Regularly rotate your API keys

Email deliverability

Use a verified domain for all outgoing emails
Monitor your sender reputation in Mailtrap
Keep your contact lists clean and up-to-date

User experience

Provide clear feedback when forms are submitted
Include proper validation messages
Consider adding loading states during submission

Performance

Use Supabase Edge Functions for server-side logic
Implement proper error handling
Consider rate limiting for form submissions

Pro Tips

Avoid Supabase email limits: to bypass Supabase's hourly email sending limits, configure your Supabase project's SMTP settings to use Mailtrap. Follow this integration guide for detailed instructions.
Prompt optimization: Start with basic functionality and iteratively improve your prompts. Lovable works best when you build features step-by-step rather than trying to create everything at once.

What's Next?

Now that you have basic email functionality set up, consider expanding your application with:

User Authentication: Add login/signup flows with email verification
Email templates: Create branded email templates for different types of messages. You can use Mailtrap's free email builder for that.
Advanced analytics: Track email open rates, click-through rates, and conversions
Multi-step forms: Break complex forms into smaller steps for better user experience
A/B Testing: Test different email subject lines and content to optimize engagement

With Lovable and Mailtrap working together, you have a powerful foundation for building email-driven applications that can scale with your business needs.

How to Send Emails in VS Code with Mailtrap MCP Server

Denys — Fri, 08 Aug 2025 09:01:35 +0000

Besides having an AI editor to help you develop projects, VS Code can now also generate and send emails in your stead.

To do this, you simply need to integrate VS Code with Mailtrap MCP and you’ll be able to send emails with a single prompt. And yes, this works for both Windows and macOS.

First, we’ll set up the MCP server, and then we’ll send emails.

Before we start: Mailtrap MCP server is implemented as a Node.js command line utility, so please install the latest Node.js version alongside the freshest version of VS Code editor.

Setup Mailtrap MCP Server

First, we’ll set up and configure an MCP Server in VS Code. So, open your VS Code editor, navigate to Settings, and use the search bar to find the Mcp tab. Then, tick the Chat> Mcp: Enabled option and click on Edit in settings.json.

This will open the settings.json file, which is used by VS Code to store the user settings and the MCP servers that you can make requests to. So, delete everything you find inside it and insert the following code snippet there:

{
  "mcp": {
    "servers": {
      "mailtrap": {
        "command": "npx",
        "args": ["-y", "mcp-mailtrap"],
        "env": {
          "MAILTRAP_API_TOKEN": "your_mailtrap_api_token",
          "DEFAULT_FROM_EMAIL": "your_sender@example.com"
        }
      }
    }
  }
}

Here, we have added a new Mailtrap MCP configuration in the servers property, located inside the mcp property. However, if you have mcp-server-time in the servers configuration, you can either remove it, or install the mcp_server_time package to avoid errors when MCPs are loaded. If you want to install, you can do that by using the pip package manager (you will need Python installed).

pip install mcp_server_time

Essentially, VS Code can now use Mailtrap Email API to send emails. All there’s left to do is log in to your Mailtrap account, navigate to Sending Domains → Integration → API, find your credentials, and replace the following values:

MAILTRAP_API_TOKEN – Used to authenticate API requests, which you can copy/paste from the credentials tab.
DEFAULT_FROM_EMAIL – Make sure the email’s domain matches your own domain from the Sending Domains tab in Mailtrap.

Note: Although you shouldn’t face any issues, I still recommend reloading VS Code to make sure everything is being set up correctly.

Send emails with Mailtrap Email MCP Server

To send an email, open the AI Pane of the VS Code editor in the upper-right corner. Then, in the opened pane, make sure Agent mode is selected, which allows VS Code to perform actions for us.

Next, open the list of available tools and select Mailtrap. If you see similar MCPs from other code editors (for instance, Cursor), make sure to uncheck them.

Finally, let’s try to send a plain-text email. You can test with the prompt below, but feel free to come up with your own prompts and experiment since the possibilities are aplenty. 🙂

Send an email to john.doe@example.com with the subject ‘Hi John!’ and a message that wishes John a great day.

VS Code will then identify the right MCP server for your request, and suggest running the right tool in this case, send-email.

As soon as you’re ready, click Continue.

The plain-text email should be sent successfully, and the VS Code Copilot AI will notify you about.

You can verify it by checking the Email Logs tab of your Mailtrap dashboard.

Wrapping it up

With the Mailtrap MCP server, you can send emails from your AI IDE without having to write a single line of code or leave your editor. This includes:

Plain-text emails
HTML emails
Emailing multiple recipients

If you want to learn more on how to send emails from VS code, check out the full version of this article on Mailtrap Blog.

How to Set up Email Verification in PHP via a Verification Token: Complete Guide

Denys — Fri, 09 Aug 2024 14:44:47 +0000

Email verification is the process of ensuring an email address exists and can receive emails. Whereas, email validation checks if the address is properly formatted; that is - written according to specific standards (e.g. UTF-8).

In this article, I’ll talk about PHP email verification and how to use it for web development and user authentication via a verification token. The article involves a few micro tutorials, including:

PHPMailer configuration with Mailtrap
A simple HTML form creation
Basic email address verification
Generating and storing tokens and credentials in an SQL database
Sending email verification with a verification token
Email testing as related to verification

So, let’s get to it.

Setting up email sending

To send verification emails, you can use PHP's built-in mail() function or a library like PHPMailer, which offers more features and better reliability.

Since I want to make the tutorial as safe and production-ready as possible, I’ll be using ‘PHPMailer’. Check the code to install PHPMailer via Composer:

composer require phpmailer/phpmailer
Why use Mailtrap API/SMTP?

It’s an email delivery platform to test, send, and control your emails in one place. And, among other things, you get the following:

Ready-made configuration settings for various languages, PHP & Laravel included.

SMTP and API with SDKs in major languages, ofc, PHP included.

Industry-best analytics.

27/7 Human support, and fast track procedure for urgent cases.

All that allows you to bootstrap the email verification process, and keep it safe and stable for all.

Moving on to the settings to configure PHPMailer with Mailtrap:


$phpmailer = new PHPMailer();
$phpmailer->isSMTP();
$phpmailer->Host = 'live.smtp.mailtrap.io';
$phpmailer->SMTPAuth = true;
$phpmailer->Port = 587;
$phpmailer->Username = 'api';
$phpmailer->Password = 'YOUR_MAILTRAP_PASSWORD';

Here’s the PHPMailer setup:

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'vendor/autoload.php';

function sendVerificationEmail($email, $verificationCode) {
    $mail = new PHPMailer(true);

    try {
        // Server settings
        $mail->isSMTP();
        $mail->Host = 'live.smtp.mailtrap.io';
        $mail->SMTPAuth = true;
        $mail->Username = 'api';
        $mail->Password = 'YOUR_MAILTRAP_PASSWORD';
        $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
        $mail->Port = 587;

        // Recipients
        $mail->setFrom('youremail@example.com', 'Your Website');
        $mail->addAddress($email);

        // Content
        $mail->isHTML(false);
        $mail->Subject = 'Email Verification';
        $mail->Body    = "Your verification code is: $verificationCode";

        $mail->send();
        return true;
    } catch (Exception $e) {
        return false;
    }
}

Note that the code above doesn’t send the verification token (click here to jump to the code snippet with the verification token). It’s only an example of how to set up Mailtrap SMTP and define the verification function. Here’s a quick breakdown of key points:

PHPMailer and Exception classes get imported.
sendVerificationEmail($email, $verificationCode) is the function definition.
A new PHPMailer object is created.
The try-catch block handles exceptions during email sending.
The server settings are set to Mailtrap as per the exemplary configuration.
The email content is set to isHTML(false) for plain text.

Tips:

The email content can be refactored to HTML.
Due to throughput limitations, you should avoid using gmail.com as a signup form SMTP relay. But if you really want to create a mailer PHP file and send via Gmail, check this tutorial.

Creating a registration form

The below is a simple registration form, it contains the header and user account information (username, email, and password).

It doesn’t have any CSS stylesheet or div class since this is only an example.

However, I’d advise you to include these on production and align them with the design language of your brand. Otherwise, your form may look unprofessional and users would be reluctant to engage with it.

<!DOCTYPE html>
<html>
<head>
    <title>Register</title>
</head>
<body>
    <form action="register.php" method="post">
        <label>Username:</label>
        <input type="text" name="username" required>
        <br>
        <label>Email:</label>
        <input type="email" name="email" required>
        <br>
        <label>Password:</label>
        <input type="password" name="password" required>
        <br>
        <input type="submit" name="register" value="Register">
    </form>
</body>
</html>

Bonus Pro Tip - Consider using JavaScript with your forms

If you want a full tutorial on how to create a PHP contact form that includes reCaptcha, check the video below ⬇️.

JS can validate user input in real time, providing immediate feedback on errors without needing to reload the page.
By catching errors on the client side, JS can reduce the number of invalid requests sent to the server, thereby reducing server load and improving performance for each session.
Using AJAX, JS can send and receive data from the server without reloading the page, providing a smoother user experience.

Now, I’ll move to email address verification.

Email address verification

Here’s a simple script to check for the domain and the MX record. It basically allows you to verify email by performing an MX lookup.

<?php

// This method checks if the domain part of the email address has a functioning mail server.

$email = "user@example.com";

list($user, $domain) = explode(separator:"@", $email)

if (filter_var($email, filter:FILTER_VALIDATE_EMAIL) && getmxrr($domain, &hosts: $mxhosts)){
    echo "Valid email address with a valid mail server" . PHP_EOL;
} else {
    echo "Invalid email address or no valid mail server found" . PHP_EOL;
}

However, the script doesn’t send email for user activation and authentication. Also, it doesn’t store any data in MySQL.

For that, I’ll do the following in the next sections:

Generate a verification token
Create a PHP MySQL schema to store the credentials from the registration form
Send the verification email with the token
Verify the verification token

Tip: Similar logic can be applied to a logout/login form.

Generating verification token

A verification token is a unique string generated for each user during registration. This token is included in the verification email and there are two methods to generate it.

Method 1

The first method leverages the bin2hex command to create a random token with the parameter set to (random_bytes(50)).

$token = bin2hex(random_bytes(50));

Method 2

Alternatively, you can generate the token with the script below. And I’ll be using that script in the email-sending script.

<?php
function generateVerificationCode($length = 6) {
    $characters = '0123456789';
    $code = '';
    for ($i = 0; $i < $length; $i++) {
        $code .= $characters[rand(0, strlen($characters) - 1)];
    }
    return $code;
}
?>

Storing verification token

Before sending the verification email, it’s vital to ensure you properly handle and store user data. I’ll use a simple SQL schema to create the users table and store the generated token in the database along with the user's registration information.

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL,
    password VARCHAR(255) NOT NULL,
    token VARCHAR(255) DEFAULT NULL,
    is_verified TINYINT(1) DEFAULT 0
);

Quick breakdown:

The script above creates a users table with the following columns:

id - Unique identifier for each user, automatically incremented.
username - The user's username; it cannot be null.
email - The user's email address; it cannot be null.
password - The user's password (hashed); it cannot be null.
token - A verification token, which can be null.
is_verified - A flag indicating whether the user is verified (0 for not verified, 1 for verified), with a default value of 0.

Sending verification token

Overall, the script below is amalgamation of everything previously discussed in the article and it’s designed to:

Generate a random numeric verification code.
Send the verification email to a specified email address using PHPMailer.
Configure the email server settings.
Handle potential errors.
Provide feedback on whether the email was successfully sent.

Note that the script is geared towards Mailtrap users and it leverages the SMTP method.

<?php

require 'vendor/autoload.php';

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\SMTP
use PHPMailer\PHPMailer\Exception;

//Function to generate a random verification code
1 usage
function generateVerificationCode($length = 6) {
    $characters = '0123456789';
    $code = '';
    for ($i = 0; $i < $length; $i++) {
        $code .= $characters[rand(0, strlen($characters) - 1)];
    }
    return $code;
}

// Function to send a verification email using PHPMailer
1 usage
function sendVerificationEmail($email, $verificationCode) {
    $mail = new PHPMailer (exception: true);

    try {
        // Server settings
        $mail ->SMTPDebug = SMTP::DEBUG_OFF; // Set to DEBUG_SERVER for debugging
        $mail ->isSMTP();
        $mail ->Host = 'live.smtp.mailtrap.io'; // Mailtrap SMTP server host 
        $mail ->SMTPAuth = true;
        $mail ->Username = 'api'; // Your Mailtrap SMTP username
        $mail ->Password = 'YOUR_MAILTRAP_PASSWORD'; // Your Mailtrap SMTP password
        $mail ->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; // Enable TLS encryption
        $email ->Port = 587; // TCP port to connect to

        //Recipients
        $mail->setFrom(address:'mailtrapclub@gmail.com', name:"John Doe"); //Sender's email and name
        $mail->addAddress($email); // Recipient's email

        //Content
        $mail->isHTML(isHTML:false); //Set to true if sending HTML email
        $mail->Subject = 'Email Verification';
        $mail->Body = "Your verification code is: $verificationCode";

        $mail->send();
        return true;
    }catch (Exception $e) {
        return false;
    }
}

//Example usage
$email = "mailtrapclub+test@gmail.com"
$verificationCode = generateVerificationCode();

if (sendVerificationEmail($email,$verificationCode)){
    echo "A verification email has been sent to $email. Please check your inbox and enter the code to verrify your email." . PHP_EOL;
} else {
    echo "Failed to send the verification email. Please try again later." . PHP_EOL;
}

Verifying verification token

Yeah, the title is a bit circular, but that’s exactly what you need. The script below enables the “verification of verification” flow 😀 that moves like this:

A user hits the verification link.
The token gets validated.
The user’s email is marked as verified in the database.

<?php
$servername = "localhost";
$username = "root";
$password = "";
$dbname = "user_verification";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

if (isset($_GET['token'])) {
    $token = $_GET['token'];

    $stmt = $conn->prepare("SELECT * FROM users WHERE token=? LIMIT 1");    $stmt->bind_param("s", $token);    $stmt->execute();
    $result = $stmt->get_result();
    if ($result->num_rows > 0) {
        $user = $result->fetch_assoc();        $stmt->close();
        $stmt = $conn->prepare("UPDATE users SET is_verified=1, token=NULL WHERE id=?");        $stmt->bind_param("i", $user['id']);

        if ($stmt->execute() === TRUE) {
            echo "Email verification successful!";
        } else {
            echo "Error: " . $conn->error;
        }        $stmt->close();
    } else {
        echo "Invalid token!";
    }
}

$conn->close();
?>

We appreciate you chose this article to know more about php email verification. To continue reading the article and discover more articles on related topics, follow Mailrap Blog!

How to Validate Emails in Laravel: Quick and Simple Steps

Denys — Wed, 15 May 2024 06:42:27 +0000

The process of email validation in Laravel is simpler than you might think. By the end of this article, you’ll know how to set up your own email validation system.

First off, let’s clarify something important: email validation focuses solely on the format of the email, meaning how it’s written.

This differs from email verification, which goes beyond format to validate the email’s usage and authenticity. If you’re interested in the step-by-step Laravel email verification, check out our video tutorial:

While you can also perform validation on the client side, such as in a Laravel contact form, in this article, I’ll strictly focus on server-side techniques.

Laravel email validation rule

In Laravel, I use a robust validation system that simplifies workflows and ensures data integrity. My go-to tools are Laravel’s Validator facade and Form request classes, which handle data validation effectively.

These tools ensure that data meets predefined criteria before processing, helping maintain quality and consistency.

Using Validator facade

Using the Validator facade directly within your controllers allows quick, inline validation, making it ideal for simpler or less frequent validation scenarios.

****_Note: The code examples in this article are based on Laravel 10. While many of these techniques will be applicable to other versions, some specifics may differ. _

To use the Validator facade, follow these steps:

Import the Validator

Add the Validator facade at the beginning of your controller file to enable Laravel’s built-in validation features.

use Illuminate\Support\Facades\Validator;

This will allow you to access Laravel’s built-in validation features directly within your controller.

Create Validation Rules

Define specific validation rules for the data you process within your controller method.

$rules = [
    'email' => 'required|email',
    'name' => 'required|string|max:255',
];

These rules determine what data is acceptable, ensuring that your application only processes correctly formatted data.

Apply Validation

Apply the defined rules to the incoming data using the Validator facade.

$validator = Validator::make($request->all(), $rules);

This code will check the validity of the data against your predefined rules.

Handle Validation Failure

Lastly, determine the response if the validation fails.

if ($validator->fails()) {
    return redirect('form')->withErrors($validator)->withInput();
}

This will redirect users to the form with error messages and their data, helping them correct inputs.

Using Form Request Classes

Laravel’s form request classes help keep your controller code clean by separating the validation logic into dedicated classes.

Here are the steps to effectively use them for email validation:

Generate a Form Request Class

Using Laravel’s Artisan command line tool, create a new form request class:

php artisan make:request EmailValidationRequest

This command generates a new class in the App_Http__Requests_ directory, a PHP file where you can define all your custom validation rules.

Define Validation Rules in the Request Class

Open your newly created EmailValidationRequest class to add your own validation rules.

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class EmailValidationRequest extends FormRequest
{
    public function authorize()
    {
        return true; // Always return true unless you have specific authorization logic
    }

    public function rules()
    {
        return [
            'email' => 'required|email',
        ];
    }
}

This method requires the email field to be valid, ensuring data adheres to rules for consistent and maintainable validation checks.

Apply the Request Class in Your Controller

Lastly, incorporate the EmailValidationRequest in your controller method.

public function store(EmailValidationRequest $request)

This automates validation, redirecting with errors on failure and keeping your controller focused on core logic.

Regular expression for email validation in Laravel

When working with Laravel, the standard email validation rule, which primarily checks for a valid email format, doesn’t fit every scenario.

For instance, it’s unsuitable when you exclude emails from disposable domains that are technically valid but not desired for a user registration process.

This is why I rely on regular expressions (regex), a flexible alternative that offers customized validation and deals with complex scenarios.

Creating an effective regex means knowing which patterns to include or exclude to ensure it’s flexible and lenient. Here’s an example of a regex pattern:

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

This pattern checks for:

A start with one or more alphanumeric characters, including dots, underscores, and percent, plus, & minus signs.
An @ symbol.
A domain name consisting of one or more alphanumeric characters, including hyphens and dots.
A domain extension of at least two alphabetic characters.

To add a custom regex to Laravel’s validation system, directly include it in the controller’s rules array:

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

public function store(Request $request)
{
    $rules = [
        'email' => ['required', 'regex:/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/'],
    ];

    $validator = Validator::make($request->all(), $rules);

    if ($validator->fails()) {
        return back()->withErrors($validator)->withInput();
    }

    // Email is valid, proceed with the next steps
}

This setup ensures that the input email adheres strictly to the defined regex pattern, embedding it into the validation rules for robust control over email formats unique to your application’s needs.

Email validation in Laravel using API

Standard validation rules, custom regular expressions, and regex are great, but API-based solutions are sometimes the right way to achieve the highest accuracy and security.

There are several services available, such as Hunter, ZeroBounce, and NeverBounce, which offer APIs to perform advanced email checks.

Such API-based validation is helpful when you need real-time, comprehensive checks and especially useful when:

Confirming domain authenticity to prevent emails from unauthorized or spoofed domains.
Verifying that an email address is not only valid but also active.
Enhancing security by ensuring that only valid email addresses are allowed.

To demonstrate how to integrate API-based email validation into your Laravel applications, I’ll use ZeroBounce, a tool that I found helpful for such cases.

Sign Up

C*onfigure API Key*

Add the API key to your .env file for security.

ZEROBOUNCE_API_KEY=your_api_key_here

Set Up HTTP Client

Implement the HTTP client to send requests to the ZeroBounce API.

use Illuminate\Support\Facades\Http;

public function validateEmailWithZeroBounce($email)
{
    $apiKey = env('ZEROBOUNCE_API_KEY');
    $response = Http::get("https://api.zerobounce.net/v2/validate?api_key={$apiKey}&email={$email}");

    return $response->json();
}

This function sends a GET request to ZeroBounce, which checks the email address for validity and deliverability, returning a JSON response.

Utilize the Validation Function

Use the validation function in your web application to check if emails are valid.

public function registerNewUser(Request $request)
{
    $emailCheck = $this->validateEmailWithZeroBounce($request->email);

    if ($emailCheck['status'] == 'valid' && $emailCheck['smtp_valid'] == true) {
        // Proceed with user registration
    } else {
        return back()->withErrors(['email' => 'Invalid or non-deliverable email address.']);
    }
}

This validation method uses the ZeroBounce API response to determine whether to proceed with a new user registration based on the email’s validity and deliverability.

Email validation in Laravel using the email-validator library

In Laravel, you can easily implement email validation using the egulias/EmailValidator library. Here’s a brief guide on how to do it:

Install the Library

First, you need to install the egulias/EmailValidator library via Composer.

Open your terminal, navigate to your Laravel project directory, and run the following command:

Once the library is installed, you can use it in your Laravel application for email validation within the controller or form request validation.

Controller Validation

In your controller, use the validate method provided by Laravel to validate the email input against the egulias/EmailValidator library. Here’s an example:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Egulias\EmailValidator\Validation\EmailValidation;

class UserController extends Controller
{
    public function store(Request $request)
    {
        $request->validate([
            'email' => ['required', 'email', function ($attribute, $value, $fail) {
                $validator = new EmailValidation();
                if (!$validator->isValid($value)) {
                    $fail('The '.$attribute.' is invalid.');
                }
            }],
        ]);

        // Process valid email
    }
}

This snippet validates email addresses using a custom rule, utilizing a closure with the isValid method from the egulias/EmailValidator library.

Using Form Request Validation

Alternatively, you can create a custom form request and define the email validation rules there.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;
use Egulias\EmailValidator\Validation\EmailValidation;

class StoreUserRequest extends FormRequest
{
    public function authorize()
    {
        return true;
    }

    public function rules()
    {
        return [
            'email' => ['required', 'email', function ($attribute, $value, $fail) {
                $validator = new EmailValidation();
                if (!$validator->isValid($value)) {
                    $fail('The '.$attribute.' is invalid.');
                }
            }],
        ];
    }
}

Then, in your controller, type-hint the custom form request:

use App\Http\Requests\StoreUserRequest;

public function store(StoreUserRequest $request)
{
    // Process valid email
}

Email validation as a part of email testing

A solid validation mechanism is, without a doubt, a must for well-maintained email contacts and improving overall deliverability.

However, it’s not enough if you’re not testing your emails before sending them. This step is crucial for your emails to land where they should—right in your recipients’ inboxes… Besides, we all aim for high deliverability rates.

This is why I always find myself relying on Mailtrap Email Testing—a part of the more extensive Mailtrap Email Delivery Platform.

Mailtrap Email Testing allows you to review and troubleshoot emails across staging, development, and QA environments without cluttering your recipients’ inboxes. You can also check the support for HTML and CSS templates with the most popular mailbox providers.

Test Emails with Mailtrap for Free

Furthermore, it also enables you to assess the Spam Scores of your emails and check whether your IP is listed on any blacklists.

Additionally, you can create, edit, and test your HTML email templates and then switch to the production environment when you’re ready to send.

You can further streamline your testing process by leveraging Mailtrap’s Email Testing API. This will help identify and resolve code issues early and ensure that your emails are perfect when they are sent.

This is merely a snapshot of what Mailtrap Email Testing is capable of. Check out the video below for a more detailed exploration of its features. And, of course, try the tool yourself to let its performance do the talking.

How Mailtrap Email Testing Works – Getting Started Guide

Summing up

Email validation in Laravel is crucial for anyone who wants to build a reliable and effective email communication system. From simple Laravel validation rules to more sophisticated API checks, I encourage you to try all these methods to discover which suits your needs best.

Experimenting with these techniques and incorporating Mailtrap’s Email Testing into your workflow can significantly enhance your email delivery success.

For those eager to master the art of email management with Laravel, explore our articles on the topic, which are designed to broaden your understanding and enhance your skills! 😉

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

Developer’s Guide on JavaScript Email Validation: Client & Server-Side Methods Covered

Denys — Fri, 03 May 2024 07:02:48 +0000

In web development, email validation in JavaScript rules the game. Be it form validation, or a sign-up sequence email validation, you need to be sure users type the right thing.

Here, I cover JavaScript email validation front-end and back-end (server-side). And this “full-stack” tutorial is geared towards beginners, but there are also nuggets of wisdom for more advanced users.

As always, there are JavaScript code snippets you can easily copy-paste to your project.

Validate emails with basic JS function

Email validation serves multiple purposes:

Ensures data integrity in your database
Improves user experience by catching typos early
It’s the first line of defense against common types of form submission spam

Plus, an incorrectly formatted email address can lead to failed communication, resulting in a poor user experience and potential loss of users or customers.

In this section, I’ll cover a basic validation step – checking for the presence of the ‘@’ symbol. See the function below:

function isValidEmail(email) {
  return email.includes('@');
}

The isValidEmail function takes a single argument email and uses the includes method to check if the @ symbol is present. It returns true if the symbol is found, indicating a potentially valid email address, and false otherwise.

Of course, the method has its limitations due to its simplicity. But there’s a silver lining, understanding the limitations helps set the scene for more complex validation methods in the following sections. Here’s what the limitations are:

Limited use: It checks only for the presence of the “@” symbol, meaning that “example@” would be considered valid, despite being incomplete.
No domain name verification: It does not verify if the email’s domain part (e.g., gmail.com, yahoo.com) is valid or exists. The same goes for the top level domain (TDL)
Local part nuances: The local part of an email address (the first part before the “@”) can contain dots, plus signs, and other special characters, which this method does not account for.
False positives/negatives: Because of its simplicity, it might allow many invalid addresses or block potentially valid but unusual email formats.

Tip: You can apply the basic validation as the first step, but don’t rely solely on it.

JavaScript regular expression for email validation

Regular expressions (regex) are tools for pattern matching and text manipulation.

They enable you to define a search pattern that can be used to perform various text operations such as search, replace, and validation. Here’s a simple example of a regex:
A-za-z0-9

The a-za-z section matches any letter from A to Z (uppercase and lowercase)
The 0-9 section matches digits from 0 to 9

Note that the above is just for shows, you need a more complex regex for email validation.

To catch an invalid email address, a regex can be designed to match the general structure of an address, ensuring it conforms to standard email formatting rules.

A widely accepted pattern that adheres to most email validation standards is as follows:

const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

It covers:

The presence of an “@” symbol, separating the local part from the domain part.
The presence of a domain part with at least one dot, indicating a domain extension.
No leading, trailing, or consecutive whitespace characters within the email address. Here’s how you can use the above regex pattern within a JavaScript function to validate email addresses:

function validateEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

The validateEmail function takes an email address as input and returns true if the email matches the regex pattern, indicating a valid email format, or false otherwise.

The common regex pitfalls and how to avoid them

As said, regex isn’t bulletproof, unless you make it a mile-long, attempting to cover all edge cases. So, check what to keep in mind:

Complexity: Email address standards are complex, and no regex can validate every possible valid email address. For instance, the official specification allows for quoted strings and comments in email addresses, which are rarely used and often not considered in regex patterns.
Performance: Overly complex regex patterns can be slow and inefficient, especially when processing large volumes of data.
Readability: Complex regex patterns can be difficult to read and maintain, making it hard to understand what is being validated.

How to avoid the pitfalls?

[

Suggested] Consider using built-in validation functions or third-party libraries for more complex validation needs, as they may handle edge cases and performance issues. You can jump on lib validation and server-side validation by clicking on these links.
Stick to simple and well-understood patterns for most use cases, understanding that some edge cases will be missed.
Test the regex thoroughly with a wide range of email addresses to ensure it meets your specific needs.

Tip: regexp can be used to define more specialized filters, note that it’s not common in email validation.

Email validation in HTML using JavaScript

Email validation within an HTML form helps ensure data integrity and enhances user experience.

Real-time feedback within modern web apps guides users to correct errors immediately, rather than after form submission. It helps avoid user frustration that might lead to form abandonment.

This immediate feedback implementation can be achieved by listening to user input events and validating them on the fly.

I’ll be using the oninput or onchange HTML event attributes trigger real-time email validation functions.

oninput event triggers every time the user types or deletes something in the input field, providing immediate feedback.
onchange event triggers after the element loses focus, which is useful for final validation before submission.

In this JavaScript tutorial, I’ll use the oninput event trigger and integrate regex-based validation. It’s a simple doctype html registration form without form name, textarea, CSS styles, div class, li class, etc. Nonetheless, if you add them the address validation logic is still the same.

Check the steps below:

Create a basic HTML form with an email input field:

<form id="registrationForm">
  <label for="emailInput">Email:</label>
  <input type="email" id="emailInput" oninput="validateEmailInput()">
  <span id="emailFeedback" style="color: red;"></span>
</form>

Implement the validateEmailInput function that uses the regex pattern for email validation:

function validateEmailInput() {
  const emailInput = document.getElementById('emailInput').value;
  const feedbackElement = document.getElementById('emailFeedback');
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  if (emailRegex.test(emailInput)) {
    feedbackElement.textContent = ""; // Email is valid
  } else {
    feedbackElement.textContent = "Please enter a valid email address.";
  }
}

Pro Tips:

Performance and UX: For a better user experience, ensure the validation feedback is clear and not overly intrusive. Real-time validation should not distract or annoy the user.
Accessibility: When designing real-time feedback, consider accessibility. Ensure that feedback is accessible to users of assistive technologies.
Fallbacks: Remember that client-side validation is not a substitute for server-side validation. Always validate data on the server to ensure security and data integrity. I’ll talk about that in detail in later sections.
Avoid using ‘onclick’ attribute for better UX.

If you’re interested in a full HTML5 email validation tutorial, check the linked article.

JavaScript email validation with jQuery

jQuery is a fast, small, and feature-rich JavaScript library, and it can help a lot with the following:

HTML document traversal and manipulation
Event handling
Animation

Also, it has one of the easiest-to-use APIs that work across different browsers.

But, in the context of validation, jQuery’s greatest strength is the ability to abstract complex tasks into methods that can be called with just a few lines of code.

To put it plainly, it simplifies selecting and manipulating elements and attaching event listeners. In turn, it’s a great choice for email validation within web apps, so here’s how to use it.

Again, we’re starting with a basic HTML form

<form id="registrationForm">
  <label for="emailInput">Email:</label>
  <input type="email" id="emailInput">
  <span id="emailFeedback" style="color: red;"></span>
</form>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>

Use jQuery to select the input field and bind an input event to perform validation

$(document).ready(function() {
  $('#emailInput').on('input', function() {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (emailRegex.test($(this).val())) {
      $('#emailFeedback').text(''); // Email is valid
    } else {
      $('#emailFeedback').text('Please enter a valid email address.');
    }
  });
});

Using ‘`validator`’ for email validation

validator is a lightweight JavaScript library that offers a range of string validation and sanitazation functions. It is designed to be simple, efficient, and flexible, making it an excellent tool for various validation scenarios, including email validation.

For me, the main highlights include:

Clean and simple function calls: Each validation type, like checking if a string is an email, is performed through a straightforward function call, which makes the code easy to understand and maintain.
Supports both client and server-side: validator can be used in both browser and Node.js environments, ensuring versatility in deployment.
No dependencies: It operates independently without reliance on other libraries, making it a lightweight choice for projects.
Reduces boilerplate code: While it doesn’t provide a declarative setup for validation rules, the simplicity of its function calls can still help reduce the complexity in code, focusing purely on the validation logic.

With all the goodies listed, I’ll now show you how to implement it.

Include validator in your project. If you’re working in a browser environment, you can add it directly with a script tag.

<script src="https://unpkg.com/validator@latest/validator.min.js"></script>

Define the validation rules and the custom error message for email validation.

const form = document.getElementById('registrationForm');
form.addEventListener('submit', function(event) {
  event.preventDefault();

  const email = form.elements.email.value;
  let errorMessages = [];

  // Email validation
  if (!validator.isEmail(email)) {  // Checks if the email is in a valid format
    errorMessages.push('Invalid email format.');
  }

  // Display error messages or submit the form
  if (errorMessages.length > 0) {
    const errorMessage = errorMessages.join(', ');
    document.getElementById('emailFeedback').textContent = errorMessage;
  } else {
    // No errors, proceed with form submission or further processing
    document.getElementById('emailFeedback').textContent = '';
    // form.submit(); Uncomment this line if you wish to submit the form upon validation
  }
});

As always, you’ll need an HTML form with an input field for the email and a place to display the validation error message:

<form id="registrationForm">
  <label for="emailInput">Email:</label>
  <input type="email" name="email" id="emailInput">
  <span id="emailFeedback" style="color: red;"></span>
  <button type="submit">Submit</button>
</form>

Server-side validation using Ajax

Server-side validation acts as the final checkpoint before data is processed or stored. It offers a layer of protection against invalid or malicious data that might bypass client-side checks.

To that, Ajax (Asynchronous JavaScript and XML) allows web pages to be updated asynchronously by exchanging data with a web server in the background. It means you can validate form data on the server without reloading the web page, offering a seamless experience to the users.

Here’s how to implement it:

Here’s an example of how you might set up an Ajax call using vanilla JavaScript to validate an email address against the server.

function validateEmailServerSide(email) {
  fetch('/validate-email', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email: email })
  })
  .then(response => {
    if (!response.ok) {
      throw new Error('Network response was not ok');
    }
    return response.json();
  })
  .then(data => {
    if (data.isValid) {
      alert('Email is valid!');
    } else {
      alert('Email is invalid!');
    }
  })
  .catch(error => {
    console.error('There was a problem with your fetch operation:', error);
  });
}

This function sends the email to a server endpoint (/validate-email) via a POST request and processes the response.

On the server side, you can set up a simple Node.js server using Express to handle the validation request.

const express = require('express');
const app = express();
const port = 3000;

// Middleware to parse JSON bodies
app.use(express.json());

// Route to handle email validation
app.post('/validate-email', (req, res) => {
  const { email } = req.body;
  // Simple regex for demonstration purposes
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  const isValid = emailRegex.test(email);
  // In a real scenario, you might check against a database here
  res.send({ isValid });
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

Pro Tips:

Always sanitize and validate incoming data to prevent SQL injection, cross-site scripting (XSS), and other types of attacks.
Use existing validation libraries and frameworks to simplify the validation logic syntax and ensure robustness.

Bonus section: email verification in JS

For starters, I’d like to point out the difference between email validation and email verification.

Email validation checks if an email address is formatted correctly according to standard email formatting rules (as part of RFC standards). And validation is a part of email verification; meanwhile verification is consist of emal address validation, domain validation, mx checks. Validation can be achieved through regular expressions in JavaScript, as discussed previously. The formatting rules may include:
ASCII characters (in email addresses typically hyphen, or full stop)
UTF-8 for Unicode characters
Email verification goes a step further to check if the email address exists and can receive emails on top of being formatted correctly. This usually involves querying the email server without sending an actual email.

Several services offer API-based email verification, and popular examples include Hunter, ZeroBounce, and NeverBounce.

Of course, these platforms provide detailed documentation on how to integrate their APIs into your applications.

And here, I’ll show you how to verify email address using Hunter.io API. For this exemplary integration, I’m using fetch, which should work regardless of your chosen service.

function verifyEmail(email) {
  const apiKey = 'YOUR_API_KEY'; // Replace with your actual API key
  const url = `https://api.hunter.io/v2/email-verifier?email=${email}&apiKey=${apiKey}`;

  fetch(url)
    .then(response => response.json())
    .then(({data}) => {
      if (data.status === 'valid') {
        console.log('Email is verified and active.');
      } else {
        console.log('Email cannot be verified.');
      }
    })
    .catch(error => {
      console.error('Error verifying email:', error);
    });
}

Some tips on applying email verification:

User experience: Inform users if their email address cannot be verified but avoids blocking registrations solely based on verification results to prevent excluding valid users due to temporary server issues or false negatives.
Privacy and compliance: Ensure that the email verification service complies with privacy laws and regulations, such as GDPR, to protect user data.
Cost and quotas: Be mindful of the costs associated with using third-party verification services, especially if your application verifies a large volume of email addresses. Plan accordingly to stay within budget and quota limits.

Further reading on email validation:

Important Note on using Hunter API:

Hunter.io API email verification response doesn’t directly return ‘isVerified’ field. It actually provides a data object with various email verification details.

You can do the following to destructure the data object and get the status:

.then(response => response.json())
.then(({data}) => {
if (data.status === 'valid') {
console.log('Email is verified and active.');
} else {
console.log('Email cannot be verified.');
}
})

Email Validation as a part of email testing

While email validation focuses on confirming the correctness and existence of an email address, it’s just the beginning of a comprehensive email testing strategy. Here’s the spectrum of email testing to consider:

Deliverability testing: This involves verifying that emails not only get sent but also successfully reach the recipient’s inbox, bypassing spam filters and other barriers. Deliverability issues can stem from various factors, including the sender’s reputation, the content of the email, and the configuration of email servers.
Content and layout testing: Ensuring that the email content displays correctly across different email clients and devices is crucial. This type of testing checks for formatting issues, broken links, or problematic images that could affect the user’s ability to engage with the email.
Spam and blacklist testing: This tests whether your emails are being marked as spam or if your domain has been blacklisted, which could severely impact your email deliverability rates.

Mailtrap Email Delivery Platform, with its Email Testing feature, allows you to check all of the above without spamming your recipients. It’s a sandbox where developers test and debug email functionality via a fake SMTP server.

Mailtrap Email Testing captures emails sent from your development or staging environment into a safe space to conduct comprehensive email testing. It’s also easy to integrate and we provide read-made snippets in 20+ languages (PHP, Python, C#, etc.)

And you can do the following:

Test email sending capabilities: Verify that your application correctly sends emails in various scenarios, such as registration confirmations, password resets, and notifications.
Analyze email content and formatting: Mailtrap allows you to inspect the HTML and text versions of your emails, ensuring they look and function as intended across different email clients.

Checking deliverability and spam scores: Mailtrap evaluates your emails against common spam filters, offering insights into how likely your emails are to be marked as spam and providing tips for improvement.

But as an Email Delivery Platform, we also offer Email Sending via SMTP or API. For instance, you can easily integrate it with your web or contact form and enjoy high deliverability rates by design.

If you want to know how to do contact form email validation, check out our video tutorial.

Article by
Yevhenii Odyntsov
Content @Mailtrap

We appreciate the you chose this article to know about email validation in JavaScript. If you want to find more interesting content on related topics, click here!

Telnet Basics for SMTP Testing: A Step-by-Step Guide

Denys — Thu, 14 Mar 2024 11:00:29 +0000

This guide delves into the fundamentals of using Telnet for SMTP testing. It offers a thorough walkthrough on setting it up across various operating systems and exploring alternative methods essential for network administrators.

Why Use Telnet for Email Testing?

Telnet emerges as a valuable tool if you’re exploring options for SMTP testing. Here’s a quick rundown on why it’s a solid choice:

Direct server interaction: Telnet operates over TCP (Transmission Control Protocol), enabling direct communication with mail servers. This is crucial for diagnosing connection issues and troubleshooting other various SMTP-related problems.
Manual command execution: Its interface allows for manually sending SMTP commands and receiving server responses. This hands-on approach offers deep insights into server behavior and ensures correct configuration.
Authentication process testing: It plays a key role in testing SMTP authentication processes, which are vital for the security and integrity of email communication.

Setting up Telnet: Windows, Linux, Mac

Setting up Telnet varies across different operating systems. In this section, we’ll cover installing and configuring Telnet on Windows, Mac, and various Linux distributions.

Note: Before installation, ensure your firewall permits Telnet connections to avoid any connectivity issues.

Installing Telnet on Windows

Windows users have different installation methods depending on their operating system version.

For Windows 8 and later:

Open the Command Prompt (cmd) with administrator privileges.
Type this command and press Enter:

dism /online /Enable-Feature /FeatureName:TelnetClient

Note: The dism command requires elevated permissions.

For Windows 7, Windows Server 2008 R2, Windows Server 2008, or Windows Vista:

Open the Command Prompt. Type the following command and press enter.

pkgmgr /iu:"TelnetClient"

Installing Telnet on Mac

Installing Telnet on a Mac involves using Homebrew, a popular package manager. If you don’t have it installed, follow the steps provided on the Homebrew Documentation.

Once you have Homebrew set up, open the Terminal and enter the following command:

brew install telnet

You will see output similar to the following, indicating the progress of the installation:

`==> Fetching telnet
==> Downloading https://ghcr.io/v2/homebrew/core/telnet/manifests/64

################################################################## 100.0%

==> Downloading https://ghcr.io/v2/homebrew/core/telnet/blobs/sha256:cf76f3b47cf35efd4d271adf52227e463298005ec9b1ac586b629d5ad94522cf
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sha256:cf76f3b47cf35efd4d271adf52227e463298005ec9b1ac586b629d5ad94522cf?se=2023-01-26T18%3A25%3A00Z&sig=YVwwx%2FEglPVEjx0gsrb6aN7O6e3D%2Fwk%2BPEMjjTRju7M%3D&sp=r&spr=h

################################################################## 100.0%

==> Pouring telnet--64.arm64_monterey.bottle.tar.gz
/opt/homebrew/Cellar/telnet/64: 4 files, 175.2KB
==> Running brew cleanup telnet...
Disable this behaviour by setting HOMEBREW_NO_INSTALL_CLEANUP.
Hide these hints with HOMEBREW_NO_ENV_HINTS (see man brew).`

Installing Telnet on Linux

The installation of Telnet on Linux varies based on your distribution. For all distributions, you will be prompted to enter your administrator password. Type it in, press enter, and wait for the system to complete the installation before proceeding with further commands.
Common commands for popular distributions are entered in the Terminal as follows:

Arch Linux and Manjaro:

$ sudo pacman -S inetutils

Ubuntu, Kali Linux, Debian, and Linux Mint:

$ sudo apt install telnet

Red Hat, Fedora, and CentOS:

$ sudo dnf install telnet

How to Test SMTP with Telnet?

To initiate an SMTP connection with a server via Telnet, use a command specifying the server’s address (domain name or IP address) and the port it listens on. For instance:

telnet sandbox.smtp.mailtrap.io 2525

This command attempts to connect to the SMTP server at sandbox.smtp.mailtrap.io on port number 2525.

Once the connection is successfully established, you should see a response from the SMTP server. For the above command, the response might look like:

220 sandbox.smtp.mailtrap.io ESMTP server ready

This indicates that the server is ready to accept Telnet commands. From here, you can send SMTP commands to interact with the server, such as initiating an email transmission.

Sending an Email via Telnet

Sending an email through an SMTP server using Telnet involves a series of commands and interactions. This process can be invaluable for testing and verifying the server’s capability to handle email transmission. Below are the steps to email via Telnet:

1. First, connect with your SMTP server using Telnet:

telnet sandbox.smtp.mailtrap.io 2525

2. Second, introduce yourself using the EHLO (or HELO) command:.

EHLO example.com

Note: The HELO command initiates a basic SMTP session. It does not support ESMTP extensions like STARTTLS, essential for upgrading to a secure connection using the TLS (Transport Layer Security) protocol. The server will list the supported SMTP extensions in the response, typically starting with 250.

For example, you may see:

250-sandbox.smtp.mailtrap.io 250-PIPELINING 250-SIZE 10485760 250-ETRN 250-STARTTLS 250-AUTH LOGIN PLAIN 250-ENHANCEDSTATUSCODES 250-8BITMIME 250 DSN

3. Set the email sender with the MAIL FROM command.

MAIL FROM: <sender@example.com>

4. Set the email recipient with the RCPT TO command.

RCPT TO: <recipient@example.com>

5. Compose the email starting with the DATA command, then the email content, and ending with a period (.) on a new line.

`DATA
From: sender@example.com
To: recipient@example.com
Subject: Telnet email on

This is my first plain text test email message sent using the Telnet client on Windows`
.
6. Lastly, terminate the session with the QUIT command.

Here is an example of a complete Telnet session for sending an email, including all the commands and the expected responses from the SMTP server after each command:

`telnet sandbox.smtp.mailtrap.io 2525
220 sandbox.smtp.mailtrap.io ESMTP server ready
EHLO example.com
250-sandbox.smtp.mailtrap.io Hello
250-SIZE 37748736
250-PIPELINING
250-DSN
250-ENHANCEDSTATUSCODES
250-STARTTLS
250-X-ANONYMOUSTLS
250-AUTH NTLM
250-X-EXPS GSSAPI NTLM
250-8BITMIME
250-BINARYMIME
250-CHUNKING
250 XRDST
MAIL FROM: sender@example.com
250 2.1.0 Sender OK
RCPT TO: recipient@example.com
250 2.1.5 Recipient OK
DATA
354 Start mail input; end with .
From: sender@example.com
To: recipient@example.com
Subject: Telnet email

My first test message sent via the Telnet client on Microsoft's Windows
.
250 2.0.0 Ok: queued as ABC123456789
QUIT
221 2.0.0 Service closing transmission channel`

Verifying the Email Delivery

Check Server Responses: The quickest and simplest way to verify delivery is by observing the responses from the SMTP server during the Telnet session. After you complete the email composition and send it, the server will respond to your email’s status.
Inspect Queue Confirmation: A typical positive response after sending an email via Telnet is an acknowledgment from the server that the email has been queued. For example:

250 2.0.0 Ok: queued as <the item id in the queue>

Examine Server Logs: You can examine the SMTP server’s logs beyond the immediate session. These logs typically record the server’s action, including email receipt, processing steps, and final delivery.

Telnet SMTP Testing Limitations and Challenges

While Telnet has been a longstanding tool for SMTP testing, it presents several challenges, including the lack of automated testing capabilities and difficulty handling encrypted connections, such as those requiring SSL (Secure Sockets Layer) protocols.

These limitations point to the need for a more advanced and efficient solution. A solution like Mailtrap Email Testing is part of the comprehensive Mailtrap Email Delivery Platform, including Email Sending.

Clicking on this link will redirect you to the Mailtrap blog post, where you can find more information about SMTP testing and sending.

SMTP Providers Compared: Choose the Best One for Sending Transactional and Marketing Emails

Denys — Wed, 31 Jan 2024 14:16:46 +0000

Picture this: You’ve crafted the perfect email, the content is spot-on, and you’re ready to hit Send… But wait; are you sure your emails are going to reach their destination?

The answer largely depends on the SMTP providers. These unsung heroes of email delivery work behind the scenes to ensure your messages reach their intended recipients promptly and reliably.

In this article, we’ll leap into the realm of the given providers, unveiling the top three players in the industry.

From need-to-have features to cost-effective solutions, we’ll explore the ins and outs of each provider, helping you make an informed choice.

But before we start with the nitty-gritty, let’s have a quick overview of the contenders.

Best SMTP providers: a quick summary

Mailtrap Email Delivery Platform

Mailtrap Email Delivery Platform, offers both Email Testing and Email Sending solutions. It provides a secure environment for testing emails, analyzing and fixing errors, and ensuring deliverability.

There’s a variety of features like helicopter-view dashboards, deliverability alerts, email logs, and more. Although it has a free tier that allows up to 1,000 emails per month, high-volume businesses might need to opt for the paid plans.

Try Mailtrap Now

Twilio’s SendGrid

As one of the largest SMTP providers, SendGrid offers diverse sending options and supports a wide range of email infrastructures. However, it may not be ideal for marketers requiring advanced segmentation and automation features.

SendGrid also offers varying levels of customer support depending on the plan. While it has a free plan, access to more advanced features and capabilities requires premium subscriptions. For more info on SendGrid, jump here.

Amazon SES

Amazon’s Simple Email Service (SES) is a cloud-based, cost-effective service designed for businesses of all sizes. SES’s strength lies in its scalability, but integrating it can be labor-intensive and time-consuming because it requires technical expertise.

SES lacks detailed reporting on email metrics and doesn’t provide a testing environment like Mailtrap. But there are generous free plans if your only focus is on the price.

So far so good, however, the devil is in the details. So, the following sections dive deep into the technical criteria you should know to make an educated choice. For more info on SES, jump here.

Criteria to consider when choosing an SMTP provider

A reliable SMTP (Simple Mail Transfer Protocol) provider is more than just the one with an appealing interface or a catchy name.

Choose well, and you’ll get a balance of deliverability, reputation, pricing, and customer support; all aimed at helping your emails reach the recipients without a hitch.

Now, we’ll help you figure out how to evaluate the best SMTP service providers and select the one that ticks all the right boxes.

Deliverability

Remember that perfect email from the intro? It’d be frustrating to realize that the email keeps landing in the recipient’s spam folder. Though, your frustration can be easily avoided.

If your SMTP service provider has a strong focus on email deliverability, there’s little to worry about. On that note, an ideal provider should offer:

Email authentication to be trusted by ESPs
Bounces and spam complaints monitoring
Webhooks for real-time event notification
Suppression lists to manage recipients for both transactional and marketing emails

Additionally, providers like Google’s free SMTP service and Mailrap Email Sending Free Plan are available for individuals and organizations looking for a zero-investment solution to send emails. Yet, you get all features mentioned above to help with deliverability.

But analyze your emailing requirements closely before choosing a free SMTP server as there are other limitations – number of emails, email logs retention, user management, etc.

Scalability

As your email needs grow, you’d want an SMTP provider that can scale with your business.

Consider the volume of emails you anticipate sending and whether the provider offers flexible plans or pricing tiers to accommodate your growth. Scalability is crucial to avoid hitting sending limits or facing sudden cost increases.

For example, Mailtrap Email Sending Individual 10K plan starts at 10K emails a month for $10. But you can scale up to 100K emails a month on the same plan without paying 10x the price.

Reliability

Whichever way you look at it, the r*eliability of an SMTP email delivery service is paramount*.

You need an SMTP provider that guarantees high uptime and minimal service interruptions. Downtime can lead to missed opportunities, frustrated customers, and a negative impact on your business.

Look for providers with a track record of reliability, redundant infrastructure, and robust disaster recovery mechanisms.

Sounds cool, but what does this actually mean, and how to look for it?

In the context of SMTP providers, redundant infrastructure would involve having multiple servers, network connections, and storage systems to prevent single points of failure and minimize downtime.

Knowing that, it’s worth considering a provider that offers the following:

Multiple data centers or server locations
Load balancing and failover mechanisms
Network redundancy (redundant network connections from different providers)

Tip: Mailtrap offers ActionMailer balancer you can use to further strengthen your email infrastructure if one SMTP email service fails. Check it out at GitHub.

As for the robust disaster recovery mechanisms, these involve having comprehensive plans and processes in place to recover from major disruptions, such as natural disasters, system failures, or cyber-attacks.

These mechanisms ensure that the SMTP provider can quickly restore operations and maintain service availability to minimize downtime and data loss.

Here are some examples of best practices, though a lot of providers won’t be super-explicit about the exact methodology applied due to safety reasons.

Regular data backups
The provider should perform regular backups of email data to prevent data loss in case of a disaster or system failure.
Replication and synchronization
Critical data, such as user accounts and email configurations, should be replicated and synchronized across multiple servers or data centers to ensure redundancy.
Failover and failback procedures
The provider should have documented processes for transitioning operations to backup systems during a disaster and for reverting back to the primary systems once the situation is resolved.
Testing and validation
Disaster recovery plans should be regularly tested and validated to ensure their effectiveness and identify any potential gaps or weaknesses.

Features and Integration

Depending on your specific needs, you may require features like:

In-depth email analytics
A/B testing
Customizable templates
Easy integration with CRMs or marketing automation tools.

Think about the functionalities that are essential for your email campaigns and choose a provider that offers a comprehensive suite of tools to enhance your email marketing efforts.

Support and Customer Service

Let’s face it, even the best technology can encounter glitches or require assistance. That’s why reliable customer support is crucial when selecting an SMTP provider.

Look for providers that offer responsive support channels, such as live chat, email, or phone support.

Prompt and helpful assistance can save you time and frustration, ensuring that any issues or questions are addressed swiftly. Remember, good customer service can make all the difference when you need a helping hand.

We’ve armed with all the critical criteria, so it’s time to choose the best provider.

SMTP provider #1. Mailtrap Email Delivery Platform

Mailtrap is an Email Delivery Platform that allows you to Test, Send, and Control your email infrastructure – all in one place.

It’s ideal for both businesses and individuals looking for a reliable SMTP provider with a specific focus on deliverability. So, to no surprise, some of Mailtrap’s clients include StackOverflow, PayPal, Atlassian, and Adobe.

Note that Mailtrap offers both Email Tesing and Email Sending. The testing solution is a fully integrated sandbox allowing users to capture SMTP traffic in non-production environments.

With that, you prevent unwanted emails from reaching users during the testing phase. Plus, you can analyze and fix HTML/CSS errors in your emails, ensuring they look and work as expected without spamming your audience.

On the other hand, Mailtrap Email Sending is a reliable transactional email service. It provides high-deliverability email infrastructure and effortless maintenance. The key features include:

Helicopter-view dashboards
Deliverability alerts
Email logs
Deliverability stats for all Mailbox Providers (Office 365, Outlook, Gmail, Google Workspace, and more)
Email categories
Webhooks
Email templates

Also, Mailtrap is soon to release Bulk Emails – an email marketing service you can use within the same Email Sending plan as transactional emails.

Fill out this form and take one of the first few hundred seats.

The benefits

Testing and Validation

As mentioned, you can use Mailtrap to test and validate your emails in a staging environment before sending them to actual recipients. This helps to prevent any errors or issues from affecting your users.

Error Analysis Mailtrap allows you to capture SMTP traffic and analyze your email for any HTML/CSS errors. This ensures that your emails look and work as they should when they reach your users.

** Integration** You can easily integrate Mailtrap with your application and start sending emails to your recipients’ inboxes. You just need to copy-paste SMTP credentials and verify a domain to get started. Or use our API and SDK libs.

Important Note: Testing, Sending, and Bulk [Coming Soon] Email APIs are different.

Scalable and secure cloud-based infrastructure

We took the best practices for building email infrastructure and infused them with the latest and greatest in security, load balancing, and system redundancy. Then, we brought everything to the cloud for your convenience.

But don’t take our word for it. Test it out yourself and feel free to tell us how it feels.

Monitoring Mailtrap offers unique monitoring capabilities to control your email infrastructure performance and troubleshoot unexpected sending issues easily and fast.

Pros & cons

Pros

Mailtrap effectively captures outgoing mail in non-production environments, preventing unwanted emails from reaching users during testing.
It offers comprehensive error analysis and troubleshooting features, allowing you to fix any issues before your emails reach your users.
There are clear setup instructions for many different project types, making it easy to integrate both Mailtrap Sending and Testing into your application.
Mailtrap provides a secure and reliable infrastructure for production emails. Plus, there’s a team of people to ensure our systems and IPs are spammer-free without making you fill out lengthy verification forms.

Cons

Mailtrap’s free tier has a limit of 1,000 emails per month, which may not be sufficient for businesses with high email volumes.

Pricing

As mentioned, Mailtrap offers a free tier that allows users to send up to 1,000 emails per month. This free plan is quite generous, especially since it includes webhooks, email analytics, suppression management, and more.

For businesses with higher email volumes, Mailtrap offers several paid plans with higher email limits, starting at 10K emails a month for $10.

Try Mailtrap Now

SMTP provider #2 – Twilio SendGrid

As one of the oldest and biggest SMTP providers, Twilio’s SendGrid needs little introduction. It’s an email service provider with a strong focus on the diversity of sending options with a host of different features to support email infrastructure.

But why does SendGrid take second place?

Twilio’s SMTP relay service and API, may not be the best fit for marketers looking for a comprehensive email marketing solution. More demanding users may find it’s in need of an update in areas such as advanced segmentation and automation.

Also, SendGrid has different support levels depending on your plan. On the other hand, Mailtrap provides equal support for all its users.

The benefits

Email Deliverability SendGrid’s primary focus is on ensuring your emails reach the recipients’ inbox and not their spam folders, which is a significant advantage for users focusing on this aspect.

But take this with a grain of salt.

Depending on your plan, and the shared IP assigned to you, the delivery rates might not be as high as you expect. Ideally, you should opt for a dedicated IP with SendGrid.

Analytics SendGrid offers detailed reporting functionality that allows you to track emails by category and campaign.

Now, the level of detail with SendGrid’s analytics is a blessing and a curse.

Data tables may appear overwhelming and, at the same time, you might need to keep clicking through menus to find a specific data point.

Email Editor SendGrid provides a sophisticated email editor that allows you to add tags to your emails with common customer information, such as name and location. That helps personalize each campaign individually.

And, if we’re perfectly honest, SendGrid’s drag and drop editor could be more convenient than Mailtrap’s Email Templates. Ours is mostly geared towards developers, whereas SendGrid’s could be easier to navigate for non-tech teams.

Pros & cons

Pros

SendGrid provides a useful dashboard and automatic tracking for clicks, links, and Google Analytics integration.
It offers a separate API service that uses webhooks to ensure seamless data flow between different solutions.

Cons

SendGrid’s design can be confusing. Simply put, there’s a bit of a learning curve, and in time, you get the hang of it.
As mentioned, SendGrid lacks robust segmentation and automation features, which can limit its usefulness for marketers looking to create highly tailored complex campaigns.
Lastly, if you’re on one of the lower plans, chances are you’ll be waiting for customer service quite a bit.

Pricing

SendGrid does offer a free plan, but it is notably limited compared to Mailtrap’s offering. For additional features and capabilities, SendGrid offers several paid plans. However, the full functionality of email automation is only available to premium users. The specific pricing details for these plans can be found on SendGrid’s website.

SMTP provider #3 – Amazon SES

Amazon Simple Email Service (SES) is a cloud-based email-sending service designed to send emails quickly and securely. It’s a reliable, cost-effective SMTP provider for businesses of all sizes, particularly if they’re on a budget.

However, integrating SES is labor-intensive and can be time-consuming. Typically, you need a dev experienced in email infrastructure, AWS integrations in particular. So, make sure to factor that in when considering Amazon as an option.

Nevertheless, with pay-as-you-go pricing based on the number of emails sent, it allows you to scale email sending without breaking the bank. That makes Amazon SES a strong contender, assuming you have the experience or human resources to integrate it.

The benefits

Scalability
Amazon SES can handle a high volume of emails, making it suitable for organizations with large email lists or that need to send a large number of emails on a regular basis.
Deliverability
Amazon SES uses machine learning and other techniques to help improve the deliverability of emails, increasing the likelihood that emails will be delivered to their intended recipients.
Integration
Amazon SES can be easily integrated with other AWS services and third-party applications, allowing organizations to build custom email solutions or integrate email communication into their existing systems.

But remember, these are heavily technical integrations where you might need help from an experienced developer.

Pros & cons

Pros

Low cost, especially for high email volumes.
High deliverability and scalability.

Cons

Complex setup and configuration, particularly for those who are not experienced with AWS.
It lacks detailed reporting on email opens, clicks, bounces, and other metrics.
Unlike Mailtrap, it does not provide a testing environment to catch errors before emails reach users.

Note: It’s possible to use a third-party integration to get more deliverability data from SES. Then again, it means more programming and additional cost.

Pricing

Amazon SES offers both a free tier and paid plans, with pricing varying based on the number of emails sent. The free tier allows you to send up to 62,000 emails per month when sending from an Amazon EC2 instance or AWS Lambda function.

Paid plans start at $0.10 per 1,000 emails sent.

Summing up

In the realm of SMTP providers, Mailtrap, SendGrid, and Amazon SES stand out with their distinct offerings. Mailtrap’s focus on the platform approach (Test, Send, and Control) makes it an ideal choice for developers. Plus, it provides generous free email limits for both Testing and Sending.

SendGrid handles transactional emails well and offers a free email limit of 100 emails/day.

Meanwhile, Amazon SES caters to high-volume transactional email needs, allowing up to 62,000 free emails per month on a pay-as-you-go pricing model. But you might not be able to integrate it on your own.

Whichever provider you prefer, make sure to choose the one that gives you the most optimal balance of key features, price, and deliverability.

We appreciate the you chose this article to find out the best SMTP providers. If you want to find more interesting content on related topics, follow Mailtrap blog!

Gmail and Yahoo Email Sender Requirements Update: What’s Changed?

Denys — Tue, 30 Jan 2024 06:47:19 +0000

In response to growing security and deliverability concerns, Google and Yahoo are enforcing new requirements for email senders, with a significant focus on bulk email communication.

Effective February 1, 2024, these changes transition several best practices into mandatory protocols. This guide will help you understand these new rules and how to adjust your email strategies accordingly.

Why are Google and Yahoo implementing email-sending requirements

Google and Yahoo are updating their email-sending rules to improve email security and ensure emails are delivered more effectively.

As the email landscape becomes increasingly vulnerable to threats like spam and phishing attacks, these email giants are stepping up their efforts to safeguard users.

The updates aim to:

tighten security measures
ensure email source authenticity
protect email recipients from unwanted content

By enforcing stricter standards, Google and Yahoo are aiming to improve the user experience and promote responsible email practices among senders.

So, in short, the update is good news for everyone. Bulk email senders (starting from 5,000 emails daily) just need to know how to adapt accordingly.

It’s important to note that these requirements will become standard for all email senders over time.

Detailed overview of the updates

Let’s dive deeper into the specifics of these updates, starting with a critical area: the adoption of stricter email authentication protocols.

SPF, DKIM, and DMARC authentication requirements

The most significant change comes from enhanced email authentication protocols. These protocols are designed to strengthen proven ownership of email domains and establish you as an authorized sender, making it harder for malicious actors to exploit email systems.

The new guidelines require the implementation of SPF, DKIM, and DMARC for bulk email senders.

SPF: This protocol validates emails by verifying that they are sent from authorized domains. It’s crucial for preventing email spoofing.

Learn to set up SPF for your domain in our comprehensive Sender Policy Framework guide.

DKIM: This adds a digital signature to each email, ensuring its authenticity and that it hasn’t been tampered with during transmission.

Read our dedicated article for detailed steps on implementing DomainKeys Identified Mail.

DMARC: This policy framework utilizes SPF and DKIM to provide a comprehensive email authentication approach, reporting discrepancies and non-compliance.

Explore our step-by-step Domain-based Message Authentication, Reporting, and Conformance guide for more information.

Lower spam complaint rate threshold

The next significant update is l*owering the acceptable spam complaint rate*. This change aims to reduce the volume of unwanted or irrelevant emails reaching users and enhance the overall quality of email communication.

Maintaining a spam complaint rate below 0.1% is crucial for consistent deliverability and avoiding the high-risk threshold of 0.3%.

To comply, senders must refine their:

targeting strategies
personalize content
continuously monitor feedback from recipients

Using Google Postmaster Tools can offer crucial insights into the performance of your email domain.

_For a structured approach to minimizing your spam complaint rate and ensuring compliance, read this comprehensive guide.
_

Enhanced DNS protocols and email security compliance

Furthermore, the updates include a requirement for enhanced DNS protocols and reverse DNS (rDNS) setups, which are vital for improving email traceability and reducing the risk of email fraud.

This means sending domains must have a clear and verifiable link to their corresponding IP addresses.

In addition, there is a requirement to:

comply with RFC 5322 standards
properly configure PTR records
use TLS connections

One-Click Unsubscribe Option

Lastly, the new updates introduce a requirement for a one-click unsubscribe option in emails. This change empowers recipients, giving them a straightforward way to opt out of receiving emails. From the sender’s point of view, this update is particularly helpful since it will decrease the amount of spam complaints.

But let’s be honest; incorporating an easy unsubscribe option is not just a “compliance thing” but a best email practice and the right thing to do for your audience.

For best practices on seamlessly including an unsubscribe option, check out this guide.

The role of email infrastructure in bulk email sending

Now, all of these new rules are important and, when followed, will definitely improve things for bulk email senders. However, your e*mail infrastructure remains the backbone of your email delivery process*, and having the right setup is key to meeting the new requirements and any future emerging ones.

This is exactly where Mailtrap’s Bulk Email Stream comes in useful.

This feature allows you to send bulk emails at the price of transactional. Furthermore, since the Mailtrap Email Delivery Platform accommodates marketing and transactional emails, you can handle all your sending needs with one platform. Having separate sending streams will enhance your deliverability and improve your overall email metrics. A clear stats overview for each stream enhances your ability to effectively monitor and optimize your email campaigns.

In addition, Bulk Email Stream simplifies compliance with mandatory one-click unsubscribe links and headers for bulk emails.

As well as these benefits, Bulk Email Stream offers:

Smooth and secure setup
The option to choose between an email API and an SMTP service
Actionable in-depth analytics
30-day email logs

Bulk Email Sending With Mailtrap

For any questions or clarifications regarding these email updates and how Mailtrap’s Bulk Email Stream can benefit your email delivery, don’t hesitate to get in touch with us. We’re always ready to support you!

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

Outlook Spam Filter Explained: A Step-by-Step Guide

Denys — Mon, 29 Jan 2024 17:38:25 +0000

Dealing with unwanted emails can be challenging, but the good news is that if you’re a Microsoft Outlook user, the system’s spam filter is a great help.

In this article, I’ll explain how the Outlook Junk Email Filter works, its features, and how to use it effectively. This is a practical guide for anyone using Outlook who wants to keep their inbox clean and for those that are sending emails and want to avoid being flagged as spam.

What is an Outlook spam filter?

“Junk Email Filter” is a built-in feature of the Microsoft Outlook email client, protecting users against unwanted emails. This tool is a primary defense against spam emails and effectively reduces the influx of irrelevant content.

Significantly evolving over the span of three decades, the spam filter is designed for practicality. The filter examines various aspects of incoming emails, such as the sender’s credibility, the structure of the email, and its content. By evaluating these elements, the filter categorizes emails to prioritize important messages and suppress less relevant ones.

How does the Outlook spam filter work?

The Outlook spam filter employs a combination of advanced technologies and user feedback to create a robust defense against spam. Let’s explore each component to understand how the filter maintains an organized and secure inbox.

Heuristic analysis and user feedback: This process involves examining emails for specific characteristics commonly associated with spam. These might include certain phrases, unusual sender information, suspicious attachments, or inconsistent patterns. An email combining these signs is flagged as a potential spam message.

Complementing heuristic analysis is user feedback. The system learns from this action whenever a user marks an email as spam or not. This manual flagging helps the filter adjust to the user’s personal preferences and better understand the evolving nature of spam.

Bayesian filtering and machine learning techniques: This is a specialized form of machine learning based on statistical methods. It compares the content of incoming emails with the content of emails previously marked as spam or legitimate by the user. As it gathers more data over time, this method becomes increasingly accurate, learning from the user’s past actions to make better judgments about new emails.

Beyond Bayesian filtering, the spam filter employs a variety of machine-learning techniques. These algorithms analyze large data sets to identify complex patterns and predict future behavior. They can detect new tactics spammers use, understand subtle nuances in email content, and configure the filter’s criteria for better accuracy and protection against phishing emails and other threats.

Unique features of an Outlook spam filter

“Junk Email Filter” keeps your Outlook inbox clean, but it’s not just about blocking unwanted emails. It includes several features designed to provide a more personalized and efficient user experience that helps maintain a flow of important communications without interruption.

Focused inbox: An automatic sorting feature that enhances email management by dividing your inbox into two tabs: ‘Focused’ for important emails and ‘Other’ for the others. Users can customize this feature by moving emails between tabs and training Outlook to adapt to their preferences.

Junk email filter lists: This feature allows you to control what’s considered spam by adding or blocking specific email addresses and maintaining a domains list for enhanced filtering.

Safe senders and recipients lists: Add email addresses or domains to these lists to prevent messages from trusted contacts or mailing lists from being marked as junk.

Additionally, Outlook offers a feedback loop service, letting users know when their emails are marked as spam. This feature is particularly useful for senders to understand and improve their email deliverability and to reduce false positives where legitimate emails are incorrectly classified.

Blocked senders list: By adding specific senders or domains to this list, you ensure their messages are automatically moved to the junk email folder.

Blocked top-level domains and encodings lists: If you receive unwanted emails from certain countries or regions or in different character sets, these lists block them efficiently.

How to filter junk email and spam in Outlook?

Effectively managing your spam filter settings in Outlook can significantly improve your email experience. Whether you’re using newer versions with enhanced capabilities and intuitive interfaces, older versions with basic functionalities, or the continuously updated Outlook Web App (OWA), each offers unique ways to manage junk email in your email account.

New versions

_Outlook for Microsoft Office 365, Outlook 2021, Outlook 2019. _

Access junk email settings: On the Home tab, click Junk > Junk E-mail Options.

Choose junk email protection level:
No automatic filtering: Only emails from the Blocked Senders list are moved to Junk.
Low: Filters only the most obvious spam.
High: Catches most email spam but may misidentify legitimate email messages.
Safe lists only: Only allows emails from your safe senders and safe recipients lists.

Prevent legitimate emails from being classified as junk messages: Use the safe senders and recipients tabs to add specific email addresses or domain names.
Block malicious senders: Add email addresses or domains you want to block on the blocked senders tab.
Block top-level domains and encodings: Use the International tab to block emails from specific countries or in foreign languages.

Old versions

Outlook 2007 and earlier

Access junk email settings: From the settings, select Actions > Junk E-mail > Junk E-mail.
Adjusting spam filter: In the Options tab, switch the spam filter to Low or High, depending on your needs.
Managing blocked senders list: View and edit the senders that have been blocked.
Using the international tab: Mark domains from selected countries as spam.
Handling misclassified emails: Right-click on an email to add the sender to either the Blocked Senders List or the Safe Senders List.

Web app

Accessing junk email settings: Sign in to Outlook on the web, click Settings (gear icon), then View all Outlook settings.
Configuring junk email options: Select Mail > Junk email.
Safe senders and domains: Add addresses to prevent them from being marked as junk.
Blocked senders and domains: Add addresses to ensure their emails are treated as junk.

Adjusting filters and reporting: Customize how Outlook handles junk email and reporting.

****Note*: The effectiveness of spam mail filtering can vary, and it’s always a good idea to periodically check the spam folder for legitimate emails.

How to avoid an Outlook spam filter?

To ensure your emails successfully reach their intended recipients and avoid the dreaded fate of landing in the spam folder, it’s important to have a strategic approach combined with some fundamental best practices.

Here is a quick rundown of some action points to help you achieve this:

Understand Outlook’s Spam Filter: Learn what triggers the filter, including specific keywords and formatting.
Use a Trusted Email Domain: Ensure your domain is reputable, recognized, and trusted by your audience.
Keep Sender Reputation Untarnished: Adopt email practices that support your email sender reputation, like avoiding emails to specific users, keeping complaint rates low, and regulating your sending frequency.
Craft Clear, Engaging Subject Lines: Balance clarity and engagement, avoiding vague or sensationalist language.
Promote Email Engagement: Include interactive content or calls to action to encourage responses.
Maintain a Clean Email List: Regularly remove inactive or invalid addresses and offer an easy unsubscribe option.
Track Email Performance: Use analytics to understand recipient behavior and the effectiveness of your campaigns. These are just a few methods to bypass the spam filter.

Additionally, it’s important to be aware of legal requirements like the CAN-SPAM Act when sending emails and ensure they’re compliant.

These are just a few methods to bypass the spam filter. For a more comprehensive approach, I recommend reading our article on preventing emails from landing in the spam folder.

Now, let’s dive into how reliable email infrastructure can further enhance your email deliverability. A standout choice in this area is Mailtrap Email Delivery Platform.

Mailtrap Email Sending is an efficient Email API and SMTP service with advanced monitoring features. It includes a helicopter-view dashboard, detailed reports for mailbox providers, an extended email history of up to 60 days, and timely alerts. These alerts encompass weekly comparisons and critical notifications for sudden metric drops.

Mailtrap Email Testing offers a sandbox environment where users can safely inspect and debug emails in staging, development, and QA environments. This eliminates the risk of unintentionally spamming recipients.

Additionally, with Email Testing, you can preview and analyze content for spam and validate HTML/CSS before sending emails to recipients’ inboxes.

Try Mailtrap for Free

The Spam Checker plays an important role in evaluating the spam score of your emails. Detailed analysis and actionable insights allow users to refine their email content, ensuring they adhere to best practices that maximize deliverability.

In summary, managing unwanted emails and ensuring yours don’t end up in spam folders in Outlook doesn’t have to be a headache. With the right use of the “Junk Email Filter” and understanding the dos and don’ts of email sending, you can keep a clean inbox and maintain good email deliverability rates. With these simple guidelines, you can confidently expect smooth sailing in the email world.

Thank you for reading this article! Follow Mailtrap Blog and discover even more articles about Outlook spam filters.

Telnet Basics for SMTP Testing: A Step-by-Step Guide

Denys — Tue, 23 Jan 2024 12:24:46 +0000

Why Use Telnet for Email Testing?

Telnet emerges as a valuable tool if you’re exploring options for SMTP testing. Here’s a quick rundown on why it’s a solid choice:

Direct server interaction: Telnet operates over TCP (Transmission Control Protocol), enabling direct communication with mail servers. This is crucial for diagnosing connection issues and troubleshooting other various SMTP-related problems.
Manual command execution: Its interface allows for manually sending SMTP commands and receiving server responses. This hands-on approach offers deep insights into server behavior and ensures correct configuration.
Authentication process testing: It plays a key role in testing SMTP authentication processes, which are vital for the security and integrity of email communication.

Setting up Telnet: Windows, Linux, Mac

Setting up Telnet varies across different operating systems. In this section, we’ll cover installing and configuring Telnet on Windows, Mac, and various Linux distributions.

Note: Before installation, ensure your firewall permits Telnet connections to avoid any connectivity issues.

Installing Telnet on Windows

Windows users have different installation methods depending on their operating system version.

For Windows 8 and later:

Open the Command Prompt (cmd) with administrator privileges.
Type this command and press Enter:

dism /online /Enable-Feature /FeatureName:TelnetClient

Note: The dism command requires elevated permissions.

For Windows 7, Windows Server 2008 R2, Windows Server 2008, or Windows Vista:

Open the Command Prompt.
Type the following command and press enter.

pkgmgr /iu:"TelnetClient"

Using PowerShell (Applicable to Windows 8.1, Windows 10, Windows Server 2012 R2, or later):

Open PowerShell as an administrator.
Type the following command and press enter.

Enable-WindowsOptionalFeature -Online -FeatureName TelnetClient

Installing Telnet on Mac

Installing Telnet on a Mac involves using Homebrew, a popular package manager. If you don’t have it installed, follow the steps provided on the Homebrew Documentation.

Once you have Homebrew set up, open the Terminal and enter the following command:

brew install telnet

You will see output similar to the following, indicating the progress of the installation:

==> Fetching telnet
==> Downloading https://ghcr.io/v2/homebrew/core/telnet/manifests/64
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/telnet/blobs/sha256:cf76f3b47cf35efd4d271adf52227e463298005ec9b1ac586b629d5ad94522cf
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sha256:cf76f3b47cf35efd4d271adf52227e463298005ec9b1ac586b629d5ad94522cf?se=2023-01-26T18%3A25%3A00Z&sig=YVwwx%2FEglPVEjx0gsrb6aN7O6e3D%2Fwk%2BPEMjjTRju7M%3D&sp=r&spr=h
######################################################################## 100.0%
==> Pouring telnet--64.arm64_monterey.bottle.tar.gz
 /opt/homebrew/Cellar/telnet/64: 4 files, 175.2KB
==> Running `brew cleanup telnet`...
Disable this behaviour by setting HOMEBREW_NO_INSTALL_CLEANUP.
Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`).

Installing Telnet on Linux

Arch Linux and Manjaro:

$ sudo pacman -S inetutils

Ubuntu, Kali Linux, Debian, and Linux Mint:

$ sudo apt install telnet

Red Hat, Fedora, and CentOS:

$ sudo dnf install telnet

How to Test SMTP with Telnet?
To initiate an SMTP connection with a server via Telnet, use a command specifying the server’s address (domain name or IP address) and the port it listens on. For instance:

telnet sandbox.smtp.mailtrap.io 2525

This command attempts to connect to the SMTP server at sandbox.smtp.mailtrap.io on port number 2525.

Once the connection is successfully established, you should see a response from the SMTP server. For the above command, the response might look like:

220 sandbox.smtp.mailtrap.io ESMTP server ready

This indicates that the server is ready to accept Telnet commands. From here, you can send SMTP commands to interact with the server, such as initiating an email transmission.

Sending an Email via Telnet
Sending an email through an SMTP server using Telnet involves a series of commands and interactions. This process can be invaluable for testing and verifying the server’s capability to handle email transmission. Below are the steps to email via Telnet:

1. First, connect with your SMTP server using Telnet:

telnet sandbox.smtp.mailtrap.io 2525

2. Second, introduce yourself using the EHLO (or HELO) command:.

EHLO example.com

Note: The HELO command initiates a basic SMTP session. It does not support ESMTP extensions like STARTTLS, essential for upgrading to a secure connection using the TLS (Transport Layer Security) protocol. The server will list the supported SMTP extensions in the response, typically starting with 250.

For example, you may see:

250-sandbox.smtp.mailtrap.io
250-PIPELINING
250-SIZE 10485760
250-ETRN
250-STARTTLS
250-AUTH LOGIN PLAIN
250-ENHANCEDSTATUSCODES
250-8BITMIME
250 DSN

3. Set the email sender with the MAIL FROM command.

MAIL FROM: <sender@example.com>

4. Set the email recipient with the RCPT TO command.

RCPT TO: <recipient@example.com>

5. Compose the email starting with the DATA command, then the email content, and ending with a period (.) on a new line.

DATA
From: sender@example.com
To: recipient@example.com
Subject: Telnet email on 

This is my first plain text test email message sent using the Telnet client on Windows
.

6. Lastly, terminate the session with the QUIT command.

Here is an example of a complete Telnet session for sending an email, including all the commands and the expected responses from the SMTP server after each command:

telnet sandbox.smtp.mailtrap.io 2525
220 sandbox.smtp.mailtrap.io ESMTP server ready
EHLO example.com
250-sandbox.smtp.mailtrap.io Hello 
250-SIZE 37748736
250-PIPELINING
250-DSN
250-ENHANCEDSTATUSCODES
250-STARTTLS
250-X-ANONYMOUSTLS
250-AUTH NTLM
250-X-EXPS GSSAPI NTLM
250-8BITMIME
250-BINARYMIME
250-CHUNKING
250 XRDST
MAIL FROM: <sender@example.com>
250 2.1.0 Sender OK
RCPT TO: <recipient@example.com> 
250 2.1.5 Recipient OK
DATA
354 Start mail input; end with <CRLF>.<CRLF>
From: sender@example.com
To: recipient@example.com 
Subject: Telnet email 

My first test message sent via the Telnet client on Microsoft's Windows
.
250 2.0.0 Ok: queued as ABC123456789
QUIT
221 2.0.0 Service closing transmission channel

Verifying the Email Delivery

Check Server Responses: The quickest and simplest way to verify delivery is by observing the responses from the SMTP server during the Telnet session. After you complete the email composition and send it, the server will respond to your email’s status.
Inspect Queue Confirmation: A typical positive response after sending an email via Telnet is an acknowledgment from the server that the email has been queued. For example:

250 2.0.0 Ok: queued as <the item id in the queue>

Examine Server Logs: You can examine the SMTP server’s logs beyond the immediate session. These logs typically record the server’s action, including email receipt, processing steps, and final delivery.

Telnet SMTP Testing Limitations and Challenges

Mailtrap Email Testing acts as a secure email sandbox, allowing you to inspect and debug emails in staging, development, and QA environments before sending them to recipients. Some of its key features include:

A Fake SMTP Server to enable safe and isolated email testing.
HTML/CSS Checker to ensure your emails look as intended.
Spam Score Analysis to lower the likelihood of emails being marked as spam.
Email Preview to see how your emails will look to the end-user across multiple devices.
Multiple Inboxes for managing different projects and stages.
Ready-to-use Integrations in more than 20 programming languages.

To get started with Email Testing, make sure to check out our detailed guide.

Thank you for exploring the ins and outs of SMTP testing with us in our comprehensive guide. To enhance your understanding and proficiency further, we invite you to check out Mailtrap's dedicated blog post on Telnet SMTP testing.

Sendgrid vs Mandrill vs Mailgun – How to Choose?

Denys — Wed, 03 Jan 2024 14:35:56 +0000

Are you just starting to work with email sending platforms or comparing solutions in order to switch? Which features matter the most? And how do you avoid getting lost in the wide variety of options? At Railsware we use several tools to communicate by email with our clients, candidates, Mailtrap users, and more. Let’s review some of the most popular email infrastructure services: Sendgrid, Mandrill, and Mailgun.

Types of emails: bulk and transactional

Before we move on to the detailed analysis of each service, it’s important to define their use cases.

Mailgun is an email service for developers designed for sending, receiving, and tracking emails. Sendgrid is a platform, which offers a set of options for both developers and marketers. Mandrill initially was a pure email delivery service but now it’s an add-on for the Mailchimp marketing platform. All of them offer services for both transactional and mass emails.

Bulk or mass email sending mostly relates to marketing and sales: you need to send one and the same message to a myriad of users at the same time. It can be a template with personalized data like names, locations, etc. Newsletters, special offers, and promotions are the most common examples of bulk email services usage.

The specific feature of these mass emails is the required “unsubscribe” option. Bulk emails are usually sent through SMTP servers.

Transactional emails are event-driven. Not you as a sender schedule message delivery but the user of your website or application performs some action, which triggers email sending. The user provides you with his or her email address and as a result, gets some response. It can be registration for your service (=> registration confirmation), contact or application form (=> an automated reply or an ebook), a purchase (=> order confirmation or an invoice). Another example is someone posting a comment on the blog – in this case, the author gets a notification.

Transactional emails can be sent both through SMTP relay or email API.

Bulk or transactional – it is the first high-level question you should answer when looking for the right provider. Whether you are a manager, marketer, developer, or DevOps, it’s important to think forward: is there any chance that I need additional capabilities in a month or two? What is the value I (read: my company) agree to pay for?

Email service features and parameters that really matter

Delivery speed, security, availability, and integrations are essential for transactional emails as well as spam rates, analytics, templates support, or/and design options matter for mass emails. These points are quite obvious but what hidden gems might we discover when going deeper?

Transactional emails priorities

The main three things we expect from transactional emails are deliverability, speed, and security. When we click “reset password”, we assume that the email with the cherished link will land in the primary section of our inbox in seconds. When we get the results of our medical tests, we need to be sure that this sensitive information will not become public. So, how is it provided?

Delivery infrastructure. Start your research with the delivery options. When you choose from the market leaders, most probably you can be sure that they rank for their reliability. Anyway, for better results, pay attention to the following factors:
dedicated IP addresses for different purposes, maintaining IP reputation, and IP warming. These features have a direct impact on delivery speed and lower possibility of your messages going to spam.
email authentication standards to protect domain from spoofing: SPF, DKIM, and DMARC validation.
API option. Sending emails through SMTP relay is a universal method matching most types of integration. When adding email functionality to your own application, a web API can be a more preferable option ensuring faster delivery.
Testing capabilities. You should always test your email before actually sending it. Here we are talking about the technical side, beyond the nice wording in a template and your customer needs in the center of your communication. The basic things to test are:
delivery. You can’t have a 100% guarantee of an email delivered to the particular inbox but you need to verify that your integration works correctly , “sender” and “receiver” addresses and headers look right, and so on.
content display (text and HTML). There are no unified images rendering standards for emails but you can test your message against possible issues in the most popular email clients and check if your markup looks as expected.
spam score. Additional tests for spam score and domain blacklisting will add just extra safety.
Ease of integration. It is more of your convenience but it is one of the first factors users mention about their experience with a new service. Delivery infrastructure is the “must” priority in our list but well-structured documentation with code samples and plugins availability are always a big plus.
Analytics and reports. It goes without saying that monitoring the status of your emails is important. There are lots of dedicated services but having everything in one place is just easier to use and is more reliable in most cases.
Service uptime. Technical issues always have their place to be. So don’t forget to check the status page of the service of your choice. Check the history going back at least one year: how often did the site go down? How long did it take to fix it?

Bulk emails criteria

For marketing campaigns, priorities are similar but new things should be added here.

Delivery infrastructure. The note about reliability and security is still valid: you would prefer your emails landing in a main or at least promotional folder, not spam.
Scalability. You should be able to send your campaign to 1,000,000 recipients as successfully as to 100.
List management. You should be able to upload your list of recipients quickly and easy, edit, group, and tag it. This is quite obvious. You as a sender also earn your reputation: a high percentage of bounces and unsubscribes have a negative effect. Neglecting these rules is a direct way to the spam folder. How can the email service provider help?
Email verification. You should have the option to check if the email address exists without sending a message.
Opt-out. To comply with GDPR and any other privacy rules, your recipients should be able to easily unsubscribe from your messages.
Ease of integration. The main goal of a marketing campaign is to engage with customers, so we need more options for template creation and integration. Besides, the marketing specialist should be able to launch campaigns both with or without a developer’s or designer’s help.
Analytics and reports. You need to understand your user’s behavior on a deeper level. The more data you can get, the better: open, click, read rates, unsubscribe reasons, and sharing are the basic metrics to track.
Testing. The points are the same as for transactional emails. The main difference is that all marketing campaigns contain links, images, buttons, and other elements, which need to be carefully verified. Preview on different devices and mail clients, test campaigns will help to make sure that your recipient will get your email looking as beautiful as you designed it.

Now, with the understanding of what to look for in the email service providers, let’s check what each of them offers. Also, we’ve analyzed our own experience and reviewed users feedback on different websites like Capterra, G2Crowd, and Trust Radius to define the lists of pros and cons.

Sendgrid

Sendgrid was born in 2009, and since then has evolved into a powerful email marketing service. At the end of 2018, it was acquired by Twillo, the cloud communications platform.

Sendgrid offers solutions for both transactional and bulk emails sending along with a toolset for an instant building of marketing campaigns. This way, you can integrate it with your website or application, either another platform like WordPress or Drupal, or use as an independent tool.

The Sendgrid team emphasizes proven deliverability, confident scalability, and distinct email expertise as the specific strengths.

You will find tons of content on Sendgrid website. Most probably, you will get an answer to any of your questions but it can be easy to get lost at first.

Sendgrid offers the following products.

Email API (read: transactional emails)

You get the following capabilities:

SMTP API and Web API (REST)
Delivery and security
API and IP access management
both shared IP pools and a dedicated IP
SPF, DKIM, and DMARC record creation
email activity tracking and details-by-email API.
Analytics
event webhooks
real-time activity.
Transactional templates with HTML editing.
Integrations
cURL calls and libraries for Node.js, Ruby, Python, Go, PHP, Java, and C#
3rd party plugins.
Testing
sandbox
sink domain.

Email marketing (read: bulk emails)

The most important features include:

Campaign builder with design editor (HTML and WYSIWYG) and templates.
Campaign management with flexible settings: scheduling, A/B testing, personalization.
Real-time analytics with key metrics and event webhooks for more customized tracking.
Sender authentication along with dedicated IPs and custom domain sending.
Email marketing automation, which now is in its beta.

Recently, Sendgrid has added display ads for Google, Facebook, and Instagram, which are connected to email marketing campaigns. The product is called Email Ads (now it’s in beta).

Here is a link to the Sendgrid status page where you can view the history of the incidents as well: http://status.sendgrid.com/

What users like the most

Comprehensive documentation.
Sending speed and deliverability.
Easy to set up.
Seamless integrations.
Separate API keys when using for multiple systems.
Helpful support.

What users complain about the most

Confusing marketing campaign API.
Complicated or hard to navigate UI.
Lack of documentation on the third-party plugins integrations.
Just average level of reliability for shared IPs along with difficulties with checking their state.
Poor reputation management – you won’t be notified about problems.
Insufficient data tracking options. Especially, limited time for data storage (three days only) and the necessity to buy extra storage time.
Lack of features for transactional emails like weblinks or easy native unsubscribe.

We should add that Sendgrid is one of the most popular services, in particular due to its complex solutions. This way, it has gathered a great number of reviews and as a result – complains.

Mandrill

Mandrill is a transactional email API available for Mailchimp users. It was created as an independent service but in 2016 it was acquired by Mailchimp and turned into its paid add-on. This transition has caused waves of outrage from its users as it eliminated absolutely free billing plan. But now you can get all the advantages of the integrated email marketing platform.

In terms of information, such a division for transactional and marketing email campaigns makes it easier to clarify how the service works.

Mandrill offers the following:

SMTP API and Web API (RESTful)
Delivery and security
distributed infrastructure to provide seamless emails delivery
IP management: dedicated IP addresses, warm up, and pooling along with feedback loops
SPF and DKIM authentication multiple domains.
Analytics
custom tracking and automated Google Analytics parameters
webhooks for integration with your own database
integration with your CRM with custom metadata.
Templates with HTML and automatic CSS inlining.
Powerful integrations
official APIs for curl, JSON, Python, PHP, Ruby, Node.js, and Dart
third-party plugins and modules for WordPress, Joomla, Magento, Drupal, and SPIP
inbound email routing.
Testing
test API key
testing stats.

Mandrill doesn’t show uptime statistics but has a dedicated Twitter account, which they call “Status”: https://twitter.com/mandrillapp/

As soon as you already have Mailchimp account for using Mandrill, you have the powerful email marketing platform at your disposal. See the full list of features here.

What users like the most

Reliability and high deliverability.
Easy to implement and use.
Flexible and comprehensive reporting.
Subaccounts management.
Transparent and clear IP and delivery information.
Thorough documentation.

What users complain about the most

Outdated interface.
Mailchimp dependence.
No free plan.
Difficult domain validation.
Poor support.

From our side we faced the blocking challenge when using Mandrill for transactional emails like signup confirmation or forgotten password. We haven’t received any warning or something else, so the reputation management complaints are valid for Mandrill as well. However, we had a positive experience with their support.

We also have detailed review that compares Mailtrap and Mandrill, where you can see all the features these platform have.

Mailgun

Mailgun is the email service for developers, it is what their key message says. You still can use it for both transactional and mass emails but it doesn’t offer independent functionality for marketers, like templates and media library.

Mailgun website will also offer you lots of information and enough space to get confused. Here is a list of main options. You won’t find the obvious splitting for different types of emails.

Transactional emails

SMTP relay and Web API (RESTful).
Delivery and security
SPF, DKIM, and DMARC customization
dedicated IPs
isolated sending domains
managed support and custom programs.
Analytics
various metrics, A/B testing, and tag comparison
webhooks and events
detailed log monitoring available up to 30 days.
Templates with HTML and automatic CSS inlining.
Powerful integrations
libraries for Python, Ruby, Java, Kotlin, Go, C#, PHP, Node.js, Luvit, cURL
inbound email routing
Mailgun has a number of integrations with 3rd party platforms and also recommends services which can be used to supplement its functionality.
Testing
test mode
email validation.

Special features for bulk emails

Scalability. It can handle up to 10,000,000 emails.
Email list management with email validation and segmentation.
Unsubscribe handling.
Personalization with Recipient Variables.

Here is a link to the Mailgun status page: https://status.mailgun.com/.

What users like the most

High deliverability
Great free tier
Easy integration
Effortless domain and DNS verification
Live chat support and great support overall, even for free users
Detailed error reporting
Email validation.

What users complain about the most

Outdated UI
Lack of testing options especially emails preview
Lack of IP statistics and risk when using shared IPs
Occasional delays
The complexity of the log search interface.

Sendgrid vs Mandrill vs Mailgun: basic features comparison

Pricing comparison

Sendgrid, Mandrill, and Mailgun are often compared regardless of their pretty different purpose and functionality. Let’s go to the pricing details to get the full picture. Small disclaimer here: each of these services has its own approach to pricing.

Sendgrid pricing is based not only on the sending volumes but also on features limits. Full features comparison is available on the pricing page: it is well-structured and easy to understand.

The main criteria for Mailgun pricing are the number of emails you send and the number of email validations. All features are available for all customers but more advanced plans provide some additional functionality as well. The Mailgun pricing page is minimalistic, so here is their blog post explaining how it works.

Mandrill costs depend solely on the email sending volumes. They offer you blocks of 25,000 emails. Don’t forget that a Mailchimp paid account is required as well.

Also, remember that for marketing campaigns in Sendgrid and Mailchimp, the list of subscribers matter. You will be charged not only for the number of emails you send but also for the number of subscribers you have.

Taking these attributes into account, let’s compare the costs of some basic and most demanded features.

Free emails sending, comparison

75,000 emails sending, comparison

250,000 emails sending, comparison

1,000,000 emails sending, comparison

So, which email service is right for you?

We have reviewed the two types of emails – bulk and transactional – along with the features essential for each of the tasks.

If you mostly deal with email sending through your own website or application and you don’t need the email marketing templates, then it might be reasonable to start with Mailgun. It partners with various platforms to make integrations easier. If you work with One Signal, Easy Sendy, Customer.io, Rackspace, Heroku, or Manifold, it can supplement their functionality well.

Mandrill is now indivisibly connected to Mailchimp, so if you already use this platform, you may find it rational to add their service to your list of tools.

Sendgrid offers flexible pricing and great quality as well. It was the first of these email services and is constantly improving and expanding its functionality. Check which options are pivotal for your current needs and make sure that they are included in the subscription plan of your choice.

Still, have doubts? It might be a good idea to check out customer stories. They can help you understand which type of business problems each of the providers copes with best.

Anyway, each of the services is praised for its ease of setup, so you should be able to switch between them effortlessly.

Thank you for reading this article! Find out more bulk email sending services and their features in Mailtrap blog!

Forem: Denys

Send Emails with Windsurf and Mailtrap

Before we start

Required accounts

Prerequisites setup

Configure Mailtrap Integration with Windsurf

Step 1: Add Mailtrap MCP to Windsurf

Step 2: Configure Mailtrap API Credentials

Step 3: Enable Mailtrap MCP in Windsurf

Send Your First Email with Windsurf and Mailtrap

Step 1: Basic email sending

Step 2: Advanced email features

Step 3: Verify Email Delivery

Windsurf Email Integration Best Practices

Environment Management

Domain Verification

Sender Reputation

Content Quality

Prompt Engineering

Summing up

Send Emails with Lovable and Mailtrap

Before we start

Required accounts

Prerequisites setup

Configure Mailtrap SMTP/Email API with Lovable

Step 1: Set up basic email sending

Step 2: Manage Mailtrap Contacts automatically

Step 3: Locate Your Mailtrap List ID (Optional)

Build a landing page in Lovable

Step 1. Connect to Supabase

Step 3. Configure your Mailtrap secrets

Test your Mailtrap SMTP/Email API integration

Lovable email sending best practices

Security

Email deliverability

User experience

Performance

Pro Tips

What's Next?

How to Send Emails in VS Code with Mailtrap MCP Server

Setup Mailtrap MCP Server

Send emails with Mailtrap Email MCP Server

Wrapping it up

How to Set up Email Verification in PHP via a Verification Token: Complete Guide

Setting up email sending

Creating a registration form

Email address verification

Generating verification token

Storing verification token

Sending verification token

Verifying verification token

How to Validate Emails in Laravel: Quick and Simple Steps

Laravel email validation rule

Using Validator facade

Using Form Request Classes

Regular expression for email validation in Laravel

Email validation in Laravel using API

Email validation in Laravel using the email-validator library

Using Form Request Validation

Email validation as a part of email testing

Summing up

Developer’s Guide on JavaScript Email Validation: Client & Server-Side Methods Covered

Validate emails with basic JS function

JavaScript regular expression for email validation

The common regex pitfalls and how to avoid them

Email validation in HTML using JavaScript

JavaScript email validation with jQuery

Using ‘validator’ for email validation

Server-side validation using Ajax

Bonus section: email verification in JS

Email Validation as a part of email testing

Telnet Basics for SMTP Testing: A Step-by-Step Guide

Why Use Telnet for Email Testing?

Setting up Telnet: Windows, Linux, Mac

Installing Telnet on Windows

Installing Telnet on Mac

################################################################## 100.0%

################################################################## 100.0%

Installing Telnet on Linux

How to Test SMTP with Telnet?

Using ‘`validator`’ for email validation