Forem: SendLayer

How to Automate Email Sending in Codex Using an MCP Server

David Ozokoye — Wed, 01 Apr 2026 10:46:10 +0000

Do you want to send emails directly from the terminal in your Codex environment?

As an email deliverability expert building automated systems, I've wasted countless hours on email workflows. Testing transactional emails meant constantly switching between my IDE and email clients. This friction adds up quickly across every project.

After testing SendLayer's MCP server integration, I discovered a better approach. You can now send email with Codex using simple natural-language commands. No app switching or manual formatting is required.

In this tutorial, I'll show you how to automate email sending with OpenAI's Codex in under 5 minutes.

What is SendLayer MCP?
MCP tools available in SendLayer
Prerequisites
How to connect SendLayer MCP to OpenAI Codex
Step 1: Create your SendLayer account
Step 2: Retrieve your API key
Step 3: Store your API key as an environment variable
Step 4: Add SendLayer MCP to your Codex config.toml
Step 5: Verify the connection
How to send your first email from Codex
Real-world automation use cases
Project-scoped vs global MCP configuration
Troubleshooting
Frequently asked questions

What is SendLayer MCP?

SendLayer MCP is a hosted server that connects AI tools to SendLayer's email delivery API. It uses the Model Context Protocol (MCP). MCP is a standard that lets AI tools call external services using plain-language instructions.

You don't write API code. You just tell Codex what to send, and SendLayer MCP handles the request.

MCP tools available in SendLayer

Tool	What it does
`send-email`	Sends a message (plain text or HTML) with CC/BCC, reply-to, tags, and attachments
`get-events`	Queries email delivery events with optional filters
`list-webhooks`	Shows all registered webhooks on your account
`create-webhook`	Sets up a new webhook endpoint
`delete-webhook`	Removes a webhook by its ID

Prerequisites

Before getting started, you'll need:

OpenAI Codex installed (CLI or VS Code extension — both work)
Your SendLayer API key (we'll grab it in Step 2 below)
A terminal with access to your shell environment

Start your free trial at SendLayer

All 5 tools are available as soon as you connect the MCP server.

How to connect SendLayer MCP to OpenAI Codex

The whole setup takes 4 steps. No local installation is needed. SendLayer MCP is a hosted HTTP server, so Codex connects to it directly over the web.

Step 1: Create your SendLayer account

To begin creating a new SendLayer account, head over to the pricing page and select your preferred plan by clicking on the Get Started button.

If you'd prefer to start with a free trial, click the Take SendLayer for a free trial (send up to 200 emails) link at the bottom of the pricing table.

After selecting your preferred plan, you'll be redirected to the checkout page. Here, you'll need to provide your name and create a unique password.

Authorize your sending domain

Once you've created your account, you'll need to authorize your first domain. For this, click the Add Domain button at the top of the page.

Next, enter your domain and click the Add Domain button.

Once you've added your domain, SendLayer automatically detects your domain host and generates 5 different DNS records unique to your domain.

If SendLayer doesn't detect your domain host, you'll see the general DNS configuration for your domain.

You can click the choose your domain host link to select your domain host from the available options.

You'll need to add these DNS records to your domain's DNS records.

Step 2: Retrieve your API key

After verifying your DNS, you'll need your API key to authenticate the MCP server connection.

For this, log in to your SendLayer account. Once there, go to Settings from the sidebar menu and select the API Keys tab.

Click the copy icon next to your key to copy it to your clipboard.

Step 3: Store your API key as an environment variable

One thing I like about Codex is that it enforces best practices. It suggests storing sensitive credentials as environment variables. That way you won't accidentally commit it to version control platforms like GitHub.

Before adding the MCP server, we'll need to export the SendLayer API key as an environment variable. To do so, open your terminal and run:

export SENDLAYER_API_KEY="your-api-key-here"

Pro Tip: Never hardcode your API key in config.toml. Anyone with access to that file could use your SendLayer account.

This would add the environment variable only to the current terminal session. This means, you'll need to export it again each time you open a new terminal.

To make this permanent across sessions, add the export SENDLAYER_API_KEY line to your ~/.bashrc or ~/.zshrc file, then reload it. Here's how to do it:

Navigate to the ~ directory:

cd ~

After that, use the command below to edit the bash config:

nano ~/.zshrc

This will open up the bash config file. Go ahead and add the export line to the file.

export SENDLAYER_API_KEY="your-api-key-here"

Then press Ctrl+O and press Enter to save your changes.

Once done, reload the terminal:

source ~/.zshrc

Pro Tip: Verify the variable is set before continuing. Run printenv SENDLAYER_API_KEY. It should print your key.

Step 4: Add SendLayer MCP to your Codex config.toml

To add a new MCP server, open your terminal and paste the command below:

codex mcp add sendlayer --url https://mcp.sendlayer.com --bearer-token-env-var SENDLAYER_API_KEY

This will retrieve the API key from the environment variable at runtime.

Codex stores MCP server settings in a config.toml file. The global version lives at ~/.codex/config.toml.

You can alternatively add the MCP server configuration directly into the config.toml file.

To do so, open the file using nano ~/.codex/config.toml. Then add this block:

[mcp_servers.sendlayer]
url = "https://mcp.sendlayer.com"
bearer_token_env_var = "SENDLAYER_API_KEY"

That's all the config you need. The url points to SendLayer's hosted MCP server. The bearer_token_env_var field tells Codex to read your API key from the environment at runtime.

Note: The bearer_token_env_var field holds the variable name, not the actual key value. Codex looks up the key from your environment when it runs.

Step 5: Verify the connection

Open your terminal and run:

codex mcp list

You should see sendlayer in the list of active MCP servers.

If you're running Codex in the terminal UI, you can also type /mcp to view active servers. Once sendlayer appears in either view, you're connected and ready to send.

How to send your first email from Codex

Open Codex and switch to Agent mode. You don't need to write any email code or call any APIs directly.

Sending a plain text email

Type a prompt like this:

Send an email to john@example.com with the subject "Build complete" and the body "The latest build finished without errors."

Codex will call the SendLayer MCP send-email tool and deliver the message. The whole thing takes a few seconds.

Sending an HTML email

The send-email tool supports HTML bodies too. Ask Codex to compose one for you:

Send an HTML email to jane@example.com with the subject "Weekly Report". The body should have a heading "Your Weekly Summary" and a bullet list with these items: 142 new signups, $8,400 in revenue, 3 support tickets resolved.

Describe the structure you want in your Codex prompt. It'll compose and send the HTML without any extra setup on your end.

Real-world automation use cases

Now that you know the basics, let's explore practical automation scenarios. Here are three that work well in practice.

Build failure notifications

Ask Codex to scan your CI output and alert the team if anything went wrong:

Read the last 30 lines of build.log. If there are any errors, send an email to devteam@example.com with the subject "Build Failed" and include the error details in the message body.

This replaces a custom notification script with a single prompt. Codex reads the log, checks for failures, and sends the alert.

Automated report delivery

Codex can generate a summary from your data and email it directly:

Read report.csv and summarize total sales broken down by region. Email the summary to manager@example.com with the subject "Weekly Sales Report" and today's date in the subject line. CC accounts@example.com to the email.

You get a formatted report delivered to the recipient's inbox, including the CC email address, without writing any Python or setting up a cron job.

Subscription renewal reminders

Point Codex at a user list and let it handle the filtering and sending:

Read users.json. Find everyone whose subscription expires within the next 7 days. Send each of them a reminder email through SendLayer with the subject "Your subscription is expiring soon."

Codex filters the list, drafts a message for each user, and sends each email. No email library required.

SendLayer also handles transactional emails like password reset emails and order confirmations. All are sendable through the same MCP tool.

Once your automations are running, you can optimize your automated email workflows to improve open rates and deliverability.

Project-scoped vs global MCP configuration

Codex supports 2 locations for config.toml, and which one you use depends on your workflow.

Config type	File path	When to use
Global	`~/.codex/config.toml`	Personal projects and solo work
Project-scoped	`.codex/config.toml` in your repo	Team workflows with a shared MCP setup

Note: Project-scoped configs only load in trusted projects. Codex will prompt you to trust a project before reading its local config.

The config block is the same either way:

[mcp_servers.sendlayer]
url = "https://mcp.sendlayer.com"
bearer_token_env_var = "SENDLAYER_API_KEY"

Use global config if you're working solo and want SendLayer available in every Codex session. Use project-scoped config if your whole team should share the same MCP setup. Just make sure each developer sets SENDLAYER_API_KEY in their own shell profile.

Pro Tip: For team setups, commit .codex/config.toml to version control. Keep SENDLAYER_API_KEY out of it. Each developer sets the variable in their own ~/.bashrc or ~/.zshrc.

Troubleshooting

When I first set this up, a couple of issues came up that are easy to miss. Here are the 3 most common problems and how to fix them.

SendLayer MCP doesn't appear in `codex mcp list`

This usually means Codex can't find your config.toml or the file has a syntax error. Check that:

The file is at ~/.codex/config.toml (or .codex/config.toml in a trusted project)
The [mcp_servers.sendlayer] block uses the exact TOML syntax shown above
There are no stray characters or missing quotes

API key not found at runtime

If Codex can't authenticate with SendLayer, the most likely cause is that SENDLAYER_API_KEY isn't set in the current shell session.

Run printenv SENDLAYER_API_KEY to check. If it's empty, add the export command to your shell profile and run source ~/.zshrc.

Emails aren't reaching the inbox

If the send-email tool runs without errors but emails don't arrive, check your SendLayer account for domain authentication. SendLayer requires your sending domain to have DNS records (SPF, DKIM) set up before emails can be delivered.

For more information, see the authorizing your domain guide.

From email not specified

SendLayer requires a valid from email that uses the same domain as the one you authorized when setting up your account.

In some cases, the MCP server might automatically set one based on your authorized domain, for example, no-reply@example.com. Otherwise, specify a sender domain by updating your email prompt to include the desired sender.

Frequently asked questions

These are answers to some of the top questions we see regarding automating email sending in Codex.

Does SendLayer MCP work with Codex CLI and the Codex VS Code extension?

Yes. Both Codex CLI and the VS Code extension share the same config.toml file. Once you add SendLayer MCP to your config, it's automatically available in both environments.

How do I keep my SendLayer API key secure in Codex?

Store your key as an environment variable and reference it with bearer_token_env_var in your config. Never paste the raw key into config.toml. That file might end up in version control, where others could access it.

Is SendLayer MCP free to use?

Yes! The MCP server doesn't require an additional subscription to use. Once you have an active SendLayer account, you can connect the MCP server with your API key.

Wrapping up

That's it! You can now send transactional emails with Codex and the SendLayer MCP server.

Drop a comment below if you have questions or share how you're implementing email automation in your Codex projects!

Ready to implement this in your workflow? Start your free trial at SendLayer and send your first 200 emails free.

How to Automate Transactional Email Sending with Claude Code Using MCP

David Ozokoye — Wed, 01 Apr 2026 10:11:53 +0000

If you're a developer using Claude Code, you've probably wanted a faster way to send emails without leaving your AI workspace.

Whether you're building automation workflows, sending test emails, or notifying your team about script results, manually switching between your IDE and email client breaks your focus.

In this tutorial, I'll show you how to automate email sending directly from Claude Code using SendLayer's MCP server.

What is MCP and why use it?
How to automate email sending with Claude Code
Prerequisites
Step 1: Create your SendLayer account
Step 2: Get your SendLayer API key
Step 3: Install SendLayer MCP in Claude Code
Step 4: Send your first email
Sending different email types
Real-world use cases: Automating transactional emails
Troubleshooting common issues
Frequently asked questions

What is MCP and why use it?

MCP (Model Context Protocol) is a standard that lets AI tools like Claude Code interact with external services. Think of it as a bridge that connects your AI assistant to real-world tools such as email providers, databases, and APIs.

SendLayer's MCP server lets you send transactional emails, manage webhooks, and track email events directly from Claude Code with simple prompts.

How to automate email sending with Claude Code

Prerequisites

Before getting started, you'll need to ensure:

You have an active Claude Pro account or higher
You have Claude Code installed on your machine. See Anthropic's guide to get started
You're comfortable with basic command line operations

You'll also need a SendLayer account to connect with the MCP server. SendLayer is a transactional email service that offers reliable email delivery and excellent domain-reputation protection.

The best part? SendLayer offers a free trial that lets you send up to 200 emails. Paid plans start at just $5 per month, making it affordable whether you're testing during development or scaling to thousands of emails.

Start your free trial at SendLayer

Step 1: Create your SendLayer account

To begin creating a new SendLayer account, head over to the pricing page and select your preferred plan by clicking on the Get Started button.

If you'd prefer to start with a free trial, click the Try our SendLayer free trial (send up to 200 emails) link at the bottom of the pricing table.

After choosing a plan, you'll be redirected to the checkout page. Here, you'll need to provide your name and create a unique password.

Authorize your sending domain

Once you've created your account, you'll need to authorize your first domain. To do so, start by clicking the Add Domain button.

Next, enter your domain in the text field and click the Add Domain button.

Once you've added your domain, SendLayer automatically detects your domain host and generates 5 different DNS records unique to your domain.

If SendLayer doesn't detect your domain host, you'll see the general DNS configuration for your domain.

You can click the choose your domain host link to select your domain host from the available options.

You'll need to add these DNS records to your domain host.

Step 2: Get your SendLayer API key

To authenticate the MCP server connection, you'll need your SendLayer API key.

To do this, log in to your SendLayer account and navigate to Settings in the sidebar menu. Then select the API Keys tab.

You'll see your API key displayed. Click the copy icon to copy it to your clipboard. Keep this handy as you'll need it in the next step.

If you don't have an active API key, click the Create New API Key button to generate one.

Step 3: Install SendLayer MCP in Claude Code

SendLayer offers a hosted MCP server, which means you don't need to install anything locally. The setup takes less than 2 minutes.

Open your terminal and run the following command:

claude mcp add --scope user --transport http sendlayer-mcp https://mcp.sendlayer.com --header "Authorization: Bearer YOUR_SENDLAYER_API_KEY"

Make sure to replace YOUR_SENDLAYER_API_KEY with your actual SendLayer API key that you copied in the previous step.

After running this command, Claude Code will configure the MCP server and establish the connection to SendLayer.

Verifying the connection

To verify that the MCP server is properly connected, you can ask Claude Code to list available tools:

List all available MCP tools

You should see SendLayer tools in the response, including:

send-email
get-events
list-webhooks
create-webhook
delete-webhook

Step 4: Send your first email

Now that SendLayer MCP is configured, let's send your first email using Claude Code.

The beauty of MCP is that you don't need to write code. Simply open Claude Code and use natural language to describe what you want.

Here's an example prompt:

Send an email to johndoe@example.com with the subject "Welcome to SendLayer" and message "Thanks for signing up! We're excited to have you."

When you enter this prompt, Claude Code will:

Interpret your request
Connect to SendLayer's MCP server
Call the send-email tool with the appropriate parameters
Display a confirmation when the email is sent

Behind the scenes, Claude generates a structured request like this:

{ 
   "from": "noreply@yourdomain.com", 
   "to": "johndoe@example.com", 
   "subject": "Welcome to SendLayer", 
   "text": "Thanks for signing up! We're excited to have you." 
}

You should receive the test email in your inbox shortly after.

Important: The sender email must be from a domain you've authorized in SendLayer. For instance, if you authorized example.com, your sender email should be something like hello@example.com or noreply@example.com.

Sending different email types

SendLayer MCP supports various email types beyond plain text. Here's how to send different formats:

HTML emails

To send an HTML email with formatting, links, and styling, simply specify that in your prompt:

Send an HTML email to customer@example.com with subject "Order Confirmation" and message that includes a bolded heading "Thank you for your order!" and a blue button that says "View Order" linking to https://example.com/orders

Claude Code will generate the appropriate HTML structure and send it through SendLayer's MCP server.

Emails with multiple recipients

You can send emails to multiple recipients by listing them in your prompt:

Send an email to john@example.com and jane@example.com with subject "Team Meeting" and message "Our weekly standup is scheduled for tomorrow at 10 AM."

Claude Code automatically handles the recipient list and ensures each person receives the email.

Emails with attachments

You can also attach files to your emails through natural language commands:

Send an email to partner@example.com with subject "Q4 Report" and message "Please find the attached report" with attachment @report.pdf

You can directly reference the file you want to attach using the '@' command. The MCP encodes the file before sending the email.

Real-world use cases: Automating transactional emails

Now that you know how to send emails with Claude Code, let's explore practical scenarios where this integration becomes invaluable for developers and businesses.

Automated deployment notifications

When deploying applications, keeping your team informed is crucial. With Claude Code and SendLayer MCP, you can set up instant deployment notifications without writing complex scripts.

Example prompt:

Send an email to devteam@company.com with subject "Production Deployment Successful" and an HTML message that includes: deployment time (current time), application version 2.4.1, environment: Production, status: Success with a green checkmark, and deployed by: John Smith

Claude Code automatically formats a professional HTML email with all the deployment details, saving you from writing deployment notification code manually.

Automated error monitoring alerts

Critical errors need immediate attention. Instead of configuring complex monitoring tools, you can use Claude Code to send error notifications directly from your logs.

Example prompt:

Read the error log file at /var/logs/app-errors.log, identify any critical errors from the last hour, and send an urgent email to oncall@company.com with subject "CRITICAL: Application Error Detected" including the error details, timestamp, and affected component

This allows you to create intelligent alerting systems that parse logs and notify the right people automatically.

eCommerce order confirmations

eCommerce businesses need to send order confirmations instantly. Claude Code can generate detailed, branded order confirmation emails based on order data.

Example prompt:

Send an order confirmation email to customer@example.com with subject "Order #12345 Confirmed" that includes: order number 12345, order date (today), 2 items ordered (Blue T-Shirt - $29.99, Running Shoes - $89.99), subtotal $119.98, shipping $9.99, total $129.97, estimated delivery in 3-5 business days, and a "Track Order" button linking to https://store.example.com/track/12345

Claude Code interprets your natural-language instructions and creates a properly formatted HTML email with all order details clearly organized.

Automated daily/weekly reports

Sending regular reports to stakeholders becomes effortless with Claude Code. You can even combine data analysis with email sending in one conversation.

Example prompt:

Analyze the sales data in /data/weekly-sales.csv, calculate total revenue, number of orders, and average order value. Then send a professional HTML email to management@company.com with subject "Weekly Sales Report - [Current Week]" including these metrics in a formatted table, a brief summary paragraph, and attach the CSV file. CC john@example.com to the email

This eliminates the need for separate reporting tools and manual email composition.

Pro Tip: You can combine multiple Claude Code capabilities in a single conversation. For example, ask Claude to read a database export, filter for active subscriptions expiring in 7 days, and automatically send renewal reminder emails to all those users.

Troubleshooting common issues

Here are solutions to common problems you might encounter:

Error: Invalid API key

The 'invalid API key' issue indicates that the API key used to connect the MCP server is incorrect or improperly formatted.

To resolve this issue, double-check your API key in the SendLayer dashboard. Ensure there are no extra spaces or characters when copying. After updating your API key, re-run the claude mcp add command with the correct key.

Emails going to spam

This error often occurs if your domain is not properly authenticated. SendLayer provides 5 DNS records that improve your domain reputation and verify ownership. If any of the DNS records is missing, it might lead to emails going to spam.

To resolve this error, verify that all DNS records are properly added in your domain host. You can also add custom rules to Claude Code with spam trigger words to avoid when drafting an email.

Finally, if your domain is relatively new, I recommend warming it up gradually to build your email reputation.

Frequently asked questions

These are answers to some of the top questions we see about sending emails from Claude Code via MCP.

Is SendLayer MCP free to use?

The MCP server itself is free to use. However, you need an active SendLayer account to authenticate the MCP server connection.

Can I use SendLayer MCP with other AI tools?

Yes! SendLayer's MCP server works with multiple AI tools, including Cursor, Windsurf, and Gemini-CLI. The setup process is similar across all platforms. See our developer docs for more details on setting up the MCP server.

Is it safe to store my API key in the MCP configuration?

The API key is stored in a local configuration file on your machine, not in Claude Code's cloud. However, you should never commit this configuration file to version control. Always use environment variables or secure secret management for production applications.

Wrapping up

That's it! You now know how to automate email sending with Claude Code using SendLayer's MCP server.

Have questions or want to share how you're using Claude Code with SendLayer? Drop a comment below—I'd love to hear about your automation workflows!

Ready to implement this in your projects? Start your free trial at SendLayer and send your first 200 emails free.

How to Design Email Templates in React.js

David Ozokoye — Mon, 09 Mar 2026 05:33:31 +0000

I still remember the first time my team asked me to build an HTML email template. Three hours later, I was drowning in nested tables and wondering why my CSS wasn't working. If you've ever built HTML email templates, you know exactly what I'm talking about.

What if you could build React email templates the same way you build modern web applications?

In this guide, I'll show you how to build professional email templates in React.js with live code examples. You'll also learn how to integrate with SendLayer to send emails in production.

By the end of this tutorial, you'll have a working email template built with React.Email, integrated with SendLayer, and ready to send to your users. Let's dive in.

How to design email templates in React.js
How to set up React.Email in your project
How to build your first email template
Styling email templates
How to send emails in React using HTML templates
Best practices
Frequently asked questions

How to design email templates in React.js

Prerequisites

Before we dive in, make sure you have:

Node.js installed (version 18.x or higher recommended). Download it here
Basic knowledge of React and JSX
A code editor (I recommend Visual Studio Code)
A SendLayer account for sending emails

SendLayer is an email API service that makes sending transactional emails reliable and secure. One feature I particularly like is the domain reputation protection. SendLayer creates a subdomain specifically for email activities, which keeps your main domain's reputation safe.

You can start with a free trial that lets you send up to 200 emails for free.

Start your free trial at SendLayer

How to set up React.Email in your project

There are two ways to set up React.Email: automatic setup for new projects or manual setup for existing projects.

Method 1: Automatic setup (recommended for new projects)

The fastest way to get started is using the create-email command. Open your terminal and run:

npx create-email@latest

This command will:

Create a new directory with React.Email pre-configured
Set up a basic folder structure
Include sample email templates

After the installation completes, navigate to the project directory:

cd your-project-name

Then run the command below to install all dependencies:

npm install

Method 2: Manual setup (for existing projects)

If you're adding React Email to your existing React.js project, you'll need to install the packages manually.

To do so, run the command below:

npm install react-email @react-email/components -E 
npm install @react-email/preview-server -D -E

Adding the -E flag ensures you install the exact version specified, preventing automatic minor/patch updates that could cause compatibility issues.

Configure the preview server

After installing the packages, open the project in your code editor. You'll need to update your project's package.json file to include the following scripts:

{
  "scripts": {
    "dev": "email dev",
    "build": "email build",
    "start": "email start"
  }
}

Here's what each script does:

npm run dev – Start the preview server with hot reload
npm run build – Build email templates for production
npm run start – Serve built templates

Project structure

React.Email uses a simple folder structure. Typically, you'll want to store all email templates in the email/ directory. Start by creating an emails directory in your project root.

Here's an overview of how the npx installation option organizes the generated templates:

your-project/
├── emails/
│   ├── welcome.tsx
│   ├── password-reset.tsx
│   └── components/
│       ├── header.tsx
│       └── footer.tsx
├── package.json
└── README.md

This organization keeps your email templates separate from your main application code and makes them easy to manage.

How to build your first email template

Let's build a simple welcome email using the React Email template builder.

Within the emails folder, create a new file called welcome.tsx. After that, add the following snippets to the file:

import { 
  Html, 
  Head, 
  Body, 
  Container, 
  Section,
  Text, 
  Button,
  Img,
  Hr,
  Tailwind,
  Preview
} from '@react-email/components';

interface WelcomeEmailProps {
  userName: string;
  verificationUrl: string;
}

export const WelcomeEmail = ({ 
  userName, 
  verificationUrl 
}: WelcomeEmailProps) => {
  return (
    <Html>
      <Head />
      <Tailwind>
        <Body className="mx-auto my-auto bg-gray-50 px-2 font-sans">
          <Preview>Welcome to SendLayer - Verify your email</Preview>
          <Container className="mx-auto my-[40px] max-w-[600px] rounded-lg border border-solid border-gray-200 overflow-hidden">
            <Section className="bg-[#09092b] py-10 text-center">
              <Img 
                src="/static/logo.svg" 
                alt="Brand Logo" 
                width="250"
                className="mx-auto my-0"
              />
            </Section>

            <Section className="bg-white px-8 py-10">
              <Text className="text-[28px] font-bold text-[#09092b] leading-tight m-0 mb-5">
                Welcome, {userName}!
              </Text>

              <Text className="text-[16px] text-[#53536b] leading-[24px] m-0 mb-6">
                Thanks for signing up. We're excited to have you on board.
                To get started, please verify your email address by clicking
                the button below.
              </Text>

              <Section className="text-center">
                <Button 
                    href={verificationUrl}
                    className="bg-[#211ea6] rounded-md px-8 py-3 text-center text-[16px] font-semibold text-white no-underline"
                >
                    Verify Email Address
                </Button>
              </Section>
            </Section>

            <Hr className="mx-8 my-0 w-auto border border-solid border-[#ffd62e]" />

            <Section className="bg-white px-8 py-6">
              <Text className="text-[13px] text-[#53536b] leading-[20px] text-center m-0">
                If you didn't sign up for this account, you can safely ignore this email.
              </Text>
            </Section>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
};

export default WelcomeEmail;

Code breakdown

This TypeScript code creates a reusable welcome email template using React Email components with Tailwind CSS for styling.

First, we import components from React email/components (@react-email/components), including the Tailwind wrapper for utility class styling and Preview for setting the email preview text that appears in inbox listings.

The WelcomeEmailProps interface defines TypeScript types for the component's props: userName for personalization and verificationUrl for the email verification link.

The Tailwind component wraps the email body, allowing us to use Tailwind utility classes instead of inline styles. The Preview component sets the preview text that appears in email clients before opening the message.

Preview your email

To see your email template in action, start the development server:

npm run dev

Open your browser and navigate to http://localhost:3000. You'll see a live preview of your email template.

Any changes you make to the code will automatically update in the browser thanks to hot module replacement.

The preview server shows how your email will look on different screen sizes, making it easy to test responsive designs.

To add multiple templates, place the template files in the emails folder. After adding them, they'll appear on the sidebar when previewing the email templates.

Styling email templates

React.Email supports multiple styling approaches. Let's explore the most common methods.

Using inline styles

Inline styles are the most reliable way to style emails since most email clients strip <style> tags. React.Email makes this easy with React's style prop:

<Text style={{
  fontSize: '16px',
  lineHeight: '24px',
  color: '#333',
  marginBottom: '16px'
}}>
  Your content here
</Text>

Styling with Tailwind CSS

React.Email also supports Tailwind CSS through a special <Tailwind> component that automatically converts Tailwind classes to inline styles:

import { Tailwind, Button } from '@react-email/components';

export const Email = () => {
  return (
    <Tailwind
      config={{
        theme: {
          extend: {
            colors: {
              brand: '#007bff',
            },
          },
        },
      }}
    >
      <Button 
        href="https://example.com" 
        className="bg-brand text-white px-6 py-3 rounded"
      >
        Click Here
      </Button>
    </Tailwind>
  );
};

Pro Tip: While Tailwind classes are convenient during development, remember that React.Email converts them to inline styles for email compatibility. Not all Tailwind utilities work in emails. We recommend sticking to basic properties like colors, padding, margins, and text styles.

How to send emails in React using HTML templates

Once you've designed your email template, you'll need to convert it to HTML and send it through an email service provider.

Using the render utility

React.Email provides a render() function that converts your React components to HTML. After importing the email template, you'll need to add it as a parameter to the render() function. Here's an example:

import { render } from '@react-email/render';
import { WelcomeEmail } from './emails/welcome';

const emailHtml = await render(
  <WelcomeEmail 
    userName="John Doe" 
    verificationUrl="https://example.com/verify?token=abc123"
  />
);

Integrate email API

Now let's send the email using SendLayer's Node.js SDK. First, install the SDK:

npm install sendlayer

After installing the package, create a function to send your email. Create a sendWelcomeEmail.ts file within the utils directory and add the following snippets:

import { SendLayer } from 'sendlayer';
import { render } from '@react-email/render';
import { WelcomeEmail } from './emails/welcome';

const sendlayer = new SendLayer(process.env.SENDLAYER_API_KEY);

async function sendWelcomeEmail(userName: string, userEmail: string) {
  // Render the React email template to HTML
  const emailHtml = await render(
    <WelcomeEmail 
      userName={userName}
      verificationUrl={`https://example.com/verify?email=${userEmail}`}
    />
  );

  try {
    // Send the email using SendLayer
    const response = await sendlayer.Emails.send({
      from: {
        email: 'welcome@example.com',
        name: 'Your Company'
      },
      to: {
        email: userEmail,
        name: userName
      },
      subject: 'Welcome to Our Platform!',
      html: emailHtml
    });

    console.log('Email sent successfully! Message ID:', response);
  } catch (error) {
    console.error('Failed to send email:', error);
  }
}

// Usage
sendWelcomeEmail('John Doe', 'john@example.com');

Code breakdown

This TypeScript code demonstrates how to send the React Email template we created using SendLayer's API.

First, we import the SendLayer client, the render function from React Email to convert components to HTML, and our custom WelcomeEmail template. To initialize the SendLayer package, you'll need an API key stored as an environment variable.

The sendWelcomeEmail function takes a username and email address as parameters. It uses the render function to convert the React component into HTML. It passes the user's name and a dynamically generated verification URL as props.

Inside the try-catch block, we call sendlayer.Emails.send() with the email configuration object containing the sender details, recipient information, subject line, and the rendered React email template HTML content.

Start your free trial at SendLayer

How to retrieve your SendLayer API key

To get your API key, log in to your SendLayer account. Once you're logged in, click the Settings menu and select the API Keys tab.

Then click the copy icon next to Default API key to copy it.

After copying your API key, return to your code editor and create a .env.local file. Then paste the following snippet into the file.

SENDLAYER_API_KEY=your-api-key

Important: The sender email domain must match the domain you've authorized in your SendLayer account. For example, if you authorized example.com, your sender email should be welcome@example.com or any address using that domain.

For more details on using SendLayer's Node.js SDK, check out our comprehensive Node.js guide.

Send a test email

In a real-world scenario, this component would ideally be connected to your site's registration page. Then the function will trigger on successful registration via the handleSubmit event handler.

However, for the tutorial, I'll keep things simple and show you how to test your email templates. To send a test email, open your terminal and run the command below:

npx tsx utils/sendWelcomeEmail.ts

You should get a success notification and the message ID logged in the console. Go ahead and check the recipient's inbox for the email message.

Congratulations! You've built a responsive email template and successfully sent a test email to a Gmail recipient.

Best practices

Here are some best practices I've learned from building email templates in React:

Design principles

Keep it simple: Focus on one primary call-to-action per email
Use clear hierarchy: Make important information stand out with headings and spacing
Mobile-first approach: Most people read emails on mobile devices
Brand consistency: Use your brand colors, fonts, and logo

Technical best practices

Organize your code: Create reusable components for headers, footers, and buttons:

// emails/components/EmailHeader.tsx
export const EmailHeader = ({ logoUrl }: { logoUrl: string }) => {
  return (
    <Section style={{ padding: '20px 0', textAlign: 'center' }}>
      <Img src={logoUrl} alt="Company Logo" width={150} />
    </Section>
  );
};

Use environment variables: Never hardcode sensitive information like API keys on your codebase. This exposes your keys on version control platforms like GitHub. I recommend using environment variables to store sensitive credentials:

# .env.local 
SENDLAYER_API_KEY=your_api_key_here 
SENDER_EMAIL=welcome@example.com

Pro Tip: Make sure to include the env file in your .gitignore file so you don't accidentally push it.

Frequently asked questions

These are answers to some of the top questions we see about creating email templates in React.

Does React.Email work with all email clients?

React.Email components are tested across major email clients, including Gmail, Outlook, Apple Mail, and Yahoo. However, email clients vary in their CSS support. Always test your emails in multiple clients before sending to large audiences.

How do I add attachments to emails?

The render() function only creates HTML. To add attachments, use your email provider's attachment features. Here's an example with SendLayer:

await sendlayer.Emails.send({
  from: { email: 'sender@example.com', name: 'Your Company' },
  to: { email: 'recipient@example.com', name: 'John Doe' },
  subject: 'Your Invoice',
  html: emailHtml,
  attachments: [{
    path: 'path/to/invoice.pdf',
    type: 'application/pdf'
  }]
});

Can I use custom React hooks in email templates?

No. React.Email templates are rendered to static HTML, so React hooks like useState, useEffect, or custom hooks won't work. Email templates should only use props to receive dynamic data.

Wrapping up

In this comprehensive tutorial, we've walked through everything you need to design professional email templates in React.js.

Have questions or want to share your implementation? Drop a comment below. I'd love to hear how you're building email templates in your React projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first email in minutes.

How to send emails directly from Cursor (3-min setup)

David Ozokoye — Sun, 15 Feb 2026 10:43:11 +0000

As a developer with over 5 years of experience building web applications, I've lost count of the hours wasted switching between my IDE and email clients just to test transactional emails.

The typical workflow? You've used AI in Cursor to generate a report summary, debug code, or create documentation. Now you need to email it to your team. Often, you'll need to switch apps, copy content, and format everything manually. This context switching costs developers up to 23 minutes of focus time per interruption.

After testing SendLayer's MCP server integration, I discovered you can send emails directly from Cursor IDE using simple natural language commands—no coding required.

This guide shows you how to set it up in under 5 minutes. I've tested it with 50+ emails across various scenarios, and it's transformed our development workflow.

What is MCP?
How to send emails in Cursor IDE using SendLayer MCP
- Step 1: Create your SendLayer account
- Step 2: Retrieve your API key
- Step 3: Install SendLayer MCP on Cursor
- Step 4: Send a test email
Troubleshooting common issues
Frequently asked questions

What is MCP?

MCP (Model Context Protocol) enables AI tools to communicate with external libraries or packages. Think of it like an API, but for AI models. It provides context for LLMs and data sources, allowing them access to tools.

With MCP, you can extend Cursor's capabilities beyond code editing. For instance, you can send emails, query databases, or interact with APIs using simple natural language commands. The AI handles all the technical details behind the scenes.

SendLayer's MCP server specifically enables you to send transactional emails, manage webhooks, and retrieve email events directly from Cursor AI—all without writing API integration code manually.

How to send emails in Cursor IDE using SendLayer MCP

This section covers the steps to configure Cursor for email sending.

Prerequisites

To follow along with this guide, you'll need to ensure:

Cursor IDE is installed on your machine.
You have an active SendLayer API key. I'll show you how to generate one for your account.

SendLayer is an email API for securely sending transactional emails. One of the features I like about SendLayer is the domain reputation feature. SendLayer creates a subdomain specifically to handle email activities. This protects your main domain reputation.

You can get started with a free plan that lets you send up to 200 emails. The pricing is also affordable, starting at $5 monthly and scales depending on your business needs.

Start your free trial at SendLayer

Step 1: Create your SendLayer account

To begin creating a new SendLayer account, head over to our pricing page and select your preferred plan by clicking on the Get Started button.

If you'd prefer to start with a free trial, click the Take SendLayer for a free trial (send up to 200 emails) link at the bottom of the pricing table.

After you've selected your preferred plan, you'll be redirected to our checkout page. Here, you'll need to provide your name and create a unique password.

Authorize your sending domain

Once you've created your account, you'll need to authorize your first domain. To do so, start by clicking the orange Add Domain button at the top of the page.

On the next page, you'll be prompted to add a new domain. Enter your domain and click the Add Domain button.

Once you've added your domain, SendLayer will automatically detect your domain host and generate 5 different DNS records unique to your domain.

If SendLayer doesn't detect your domain host, you'll see the general DNS configuration for your domain.

You can click the choose your domain host link to select your domain host from the available options.

You'll need to add these DNS records to your domain host.

Step 2: Retrieve your API key

After verifying your DNS, you'll need your API key to authenticate the MCP server connection. Here's how to get it:

Start by logging in to your SendLayer account. Once there, navigate to Settings from the sidebar menu and select the API Keys tab.

You'll see your API Key. Go ahead and click the copy icon to copy your API key. Keep this API key handy—you'll need it in the next section.

If you don't have an active API key, click the Create New API Key button to generate a new one.

Step 3: Install SendLayer MCP on Cursor

SendLayer offers a hosted MCP server, which means you don't need to install anything locally. The setup process is straightforward and takes less than 2 minutes.

Method 1: One-click installation (recommended)

The easiest way to install SendLayer MCP in Cursor is by using the direct installation link.

To install it, click the button below to open the MCP server installation page in Cursor:

This will open a configuration screen in Cursor. On the configuration screen, enter your SendLayer API key in the designated field and click Install.

That's it! The MCP server is now connected to Cursor.

Method 2: Manual installation

If you prefer manual configuration or the direct link doesn't work, follow these steps:

Start by opening the Cursor editor. Once there, press Cmd + Shift + J on macOS (or Ctrl + Shift + J on Windows) to open Cursor settings.

Alternatively, you can access the settings panel by clicking Cursor at the top of your screen and navigating to Settings » Cursor Settings.

In the settings panel, select Tools & MCP from the left sidebar. Then click New MCP server.

Cursor will open your mcp.json file. Go ahead and add the following configuration to the file:

{
  "mcpServers": {
    "sendlayer": {
      "type": "url",
      "url": "https://mcp.sendlayer.com",
      "headers": {
        "x-sendlayer-api-key": "YOUR_SENDLAYER_API_KEY"
      }
    }
  }
}

Make sure to replace YOUR_SENDLAYER_API_KEY with your actual SendLayer API key.

After adding the configuration, save the file and restart Cursor AI for the changes to take effect.

To verify that the MCP server is connected, you'll see a toggle next to the MCP server you just enabled.

Step 4: Send a test email

Now that SendLayer MCP is configured, let's send your first email using Cursor AI.

One of the best features of MCP is that you don't need to write any code. Simply open Cursor's Agent mode and describe what you want to do in plain English.

Example prompt:

Send an email to johndoe@example.com with subject "Welcome to SendLayer!" and message "Thanks for signing up for our newsletter"

When you enter this prompt, Cursor AI will:

Interpret your request
Connect to SendLayer's MCP server
Call the send-email tool with the appropriate parameters
Display a confirmation message when the email is sent

Behind the scenes, Cursor generates a structured request like this:

{
  "from": "paulie@example.com",
  "to": "johndoe@example.com",
  "subject": "Welcome to SendLayer!",
  "text": "Thanks for signing up for our newsletter"
}

You should also receive the test email when you check the recipient's inbox.

Important considerations

When sending emails through SendLayer MCP, keep the following in mind:

Sender Domain: The sender email must be from a domain you've authorized in SendLayer. For instance, if you authorized example.com, your sender email should be something like hello@example.com.
Test Mode: During development, test emails with your own email address first to ensure everything is working correctly.
Agent Mode: Make sure you're using Cursor's Agent mode (not just the code completion feature) to send email commands.

Sending HTML emails

Plain text emails work great for simple notifications, but you'll often want to send HTML emails with formatting, links, and styling.

SendLayer MCP supports HTML email content. Here's how to send an HTML email:

Example Prompt:

Send an HTML email to customer@example.com with subject "Order Confirmation" containing a bold heading "Thank you for your order" and a blue button linking to https://example.com/orders

Cursor AI will generate the appropriate HTML structure:

<html>
  <body>
    <h1><b>Thank you for your order</b></h1>
    <a href="https://example.com/orders" style="background-color: blue; color: white; padding: 10px 20px; text-decoration: none; display: inline-block; border-radius: 5px;">
      View Order
    </a>
  </body>
</html>

The MCP server automatically handles the HTML formatting and sends it via SendLayer's API.

Pro Tip: The SendLayer MCP server includes additional features that let you manage webhooks and track email events. See our API documentation for additional details.

Troubleshooting common issues

Here are solutions to common problems you might encounter:

Error: Invalid API key

Cause: This issue often occurs if your API key is incorrect or improperly formatted.

Solution: To resolve this error:

Double-check your API key in the SendLayer dashboard
Ensure there are no extra spaces or characters
Update the mcp.json file with the correct key
Restart Cursor AI

MCP server not responding

Cause: The MCP server isn't properly configured, or Cursor can't reach it.

Solution: To resolve this error:

Verify your internet connection
Check that the MCP server URL is correct: https://mcp.sendlayer.com
Restart Cursor AI
Try the manual installation method if you used the quick install

Frequently asked questions

These are answers to some of the top questions we see about using an MCP server to send emails in Cursor AI.

Is SendLayer MCP free to use?

Yes, the MCP server is free to use. However, you'll need an active SendLayer account to access the available tools. The good news is that SendLayer also offers a free tier that includes 200 emails per month. This is perfect for development and testing. Paid plans are available for higher sending volumes.

What email events can I track?

SendLayer provides comprehensive email tracking, including delivery status, opens, clicks, bounces, and spam complaints. You can query these events using the get-events tool in the MCP server.

How do I send emails in Cursor AI using SendLayer?

You'll first need to install SendLayer's MCP server in Cursor by using the one-click installation link or manual configuration. Then use natural-language prompts in Agent mode, such as "Send an email to user@example.com with subject 'Hello' and message 'Welcome'" to send emails.

Wrapping up

In this tutorial, we've covered everything you need to know about sending emails directly from Cursor IDE using SendLayer's MCP server.

Have questions or want to share how you're using SendLayer MCP in your workflow? Drop a comment below—I'd love to hear about your use cases!

Ready to implement this in your development workflow? Start your free trial at SendLayer and send your first email from Cursor in minutes.

Building a secure password reset system in Django

David Ozokoye — Sun, 15 Feb 2026 04:11:58 +0000

If you're building a Django application with user authentication, you'll need a way for users to reset their passwords when they forget them.

Fortunately, Django comes with a built-in password reset system that handles the heavy lifting for you.

In this tutorial, I'll show you how to implement a complete password reset workflow in your Django application.

By the end of this guide, you'll have a fully functional password reset system that sends secure emails to users and allows them to reset their passwords safely.

Understanding Django's built-in password reset system
How to implement password reset in Django
- Step 1: Configure email backend for password reset
- Step 2: Set up Django password reset URLs
- Step 3: Create custom templates
- Step 4: Test your password reset implementation
Troubleshoot common issues
Django password reset security best practices
Frequently asked questions

Understanding Django's built-in password reset system

Django's django.contrib.auth module provides everything you need for password reset functionality. The system uses four main class-based views that handle the entire workflow:

PasswordResetView – Displays the form where users enter their email address.
PasswordResetDoneView – Confirms that the reset email has been sent.
PasswordResetConfirmView – Validates the reset link and displays the new password form.
PasswordResetCompleteView – Confirms successful password change.

Here's how the workflow works from a user's perspective:

The beauty of this system is that Django handles token generation, validation, and security for you. The tokens are time-sensitive (valid for 3 days by default) and can only be used once.

Note: Django doesn't reveal whether an email exists in the system when a reset is requested. This security feature prevents potential attackers from discovering valid email addresses.

How to implement password reset in Django

Prerequisites

Before we dive in, make sure you have:

Django installed on your machine. I recommend using v5.x or higher.
Basic knowledge of Django's URL routing and templates.
A working Django project (if you need to create one, check Django's official documentation)
An email service for sending emails. I'll use SendLayer for this tutorial.

SendLayer offers reliable email delivery for your Django applications. If you're looking to test your emails, SendLayer offers a generous free plan that lets you send up to 200 emails.

They also offer an affordable pricing plan that scales depending on your business needs.

Start your free trial at SendLayer

Step 1: Configure email backend for password reset

Before getting started, you'll need to configure Django to send emails. There are two main approaches: a console backend for development and SMTP for production.

Development setup: Console email backend

For local development, the console backend prints emails to your terminal rather than sending them. This is perfect for testing.

To use the console backend, open your settings.py file, and add the following snippet to it:

# settings.py

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

With this configuration, when you trigger a password change, the email content (including the reset link) will appear in your terminal.

Production setup: SMTP configuration

For production, you'll need an actual email service. I'll show you how to configure SendLayer's SMTP server, but the process is similar for other providers.

First, add your SMTP settings to settings.py:

# settings.py

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.sendlayer.net'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = 'your-smtp-username'
EMAIL_HOST_PASSWORD = 'your-smtp-password'
DEFAULT_FROM_EMAIL = 'noreply@yourdomain.com'

Pro Tip: Do not store sensitive information such as usernames and passwords in your codebase. Use environment variables instead.

Here's how to secure sensitive credentials on your project:

Start by creating a .env file in your project's root directory. Then add your SMTP credentials.

EMAIL_HOST_USER = 'your-sendlayer-username'
EMAIL_HOST_PASSWORD = 'your-sendlayer-password'

Important: Add .env to your .gitignore file to prevent committing sensitive credentials to version control.

After that, you'll need to install a third-party library using the command below:

pip install python-decouple

Next, return to your settings.py file and import the config module from decouple.

from decouple import config

The config method lets you access the SMTP username and password you specified in the .env file. Here's the updated email configuration settings:

# settings.py

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.sendlayer.net'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = config('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = config('EMAIL_HOST_PASSWORD')
DEFAULT_FROM_EMAIL = 'noreply@yourdomain.com'

Note: If you're using SendLayer, your sender email must match the domain you've authorized in your SendLayer account. For example, if you authorized example.com, your sender email should be noreply@example.com.

Getting your SendLayer SMTP credentials

Here's how to retrieve your SMTP server details on SendLayer. Start by logging into your account area. Once there, navigate to Settings » SMTP Credentials tab.

You'll find your SMTP credentials. The SMTP host and port number are the same for all users.

Go ahead and copy the username and password. Then return to the .env file and update the dummy details with your actual credentials.

Step 2: Set up Django password reset URLs

Now, let's configure the URL patterns for our password change flow. Django's built-in views make this straightforward.

In your urls.py, add the following patterns:

# urls.py
from django.contrib.auth import views as auth_views
from django.urls import path

urlpatterns = [
    path('password-reset/', 
         auth_views.PasswordResetView.as_view(
             template_name='registration/password_reset_form.html'
         ),
         name='password_reset'),

    path('password-reset/done/', 
         auth_views.PasswordResetDoneView.as_view(
             template_name='registration/password_reset_done.html'
         ),
         name='password_reset_done'),

    path('reset/<uidb64>/<token>/', 
         auth_views.PasswordResetConfirmView.as_view(
             template_name='registration/password_reset_confirm.html'
         ),
         name='password_reset_confirm'),

    path('reset/done/', 
         auth_views.PasswordResetCompleteView.as_view(
             template_name='registration/password_reset_complete.html'
         ),
         name='password_reset_complete'),
]

Code breakdown

In the code above, we first import the authentication views from django.contrib.auth. Then we define the URL patterns for each password reset view.

The line auth_views.PasswordResetView.as_view() contains the logic for the password reset form and email notification. It accepts template_name as a parameter. This is where you specify the path to your password change form.

Each reset URL pattern follows the same format. First, you define the path, then specify the specific view, and map the template to handle it.

Understanding the URL parameters

The reset confirmation URL includes two parameters:

uidb64: The user's ID encoded in base64 format
token: A secure, time-sensitive token that validates the reset request

These parameters ensure that only the intended user can reset their password, and only within the valid timeframe.

Step 3: Create custom templates

For a Django custom password reset experience that matches your application's branding, you'll need to create custom templates.

Based on the URL pattern we defined above, Django will look for the password change templates in a registration folder within your templates directory. Let's create all the necessary templates.

First, make sure your TEMPLATES setting in settings.py includes your templates directory:

# settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Now create the following directory structure:

project/
├── templates/
│   └── registration/
│       ├── password_reset_form.html
│       ├── password_reset_email.html
│       ├── password_reset_subject.txt
│       ├── password_reset_done.html
│       ├── password_reset_confirm.html
│       └── password_reset_complete.html

Template 1: Password reset request form

File: templates/registration/password_reset_form.html

Note: This section assumes you already have a base.html template.

{% extends 'base.html' %}

{% block content %}
<div class="container">
    <h2>Forgot Your Password?</h2>
    <p>Enter your email address below, and we'll send you a link to reset your password.</p>

    <form method="post">
        {% csrf_token %}

        {% if form.errors %}
        <div class="alert alert-danger">
            {% for field in form %}
                {% for error in field.errors %}
                    <p>{{ error }}</p>
                {% endfor %}
            {% endfor %}
        </div>
        {% endif %}

        <div class="form-group">
            <label for="{{ form.email.id_for_label }}">Email Address</label>
            {{ form.email }}
        </div>

        <button type="submit" class="btn btn-primary">Send Reset Link</button>
    </form>

    <p class="mt-3">
        <a href="{% url 'login' %}">Back to Login</a>
    </p>
</div>
{% endblock %}

This template displays the initial password reset request form. It includes {% csrf_token %} for security and loops through any form errors to display validation messages. The form renders Django's email field and submits via POST to trigger the reset link email.

Template 2: Email content

This is the actual email content that's sent to users when they request a password reset. You can customize the content to match your brand.

File: templates/registration/password_reset_email.html

{% autoescape off %}
Hello,

You recently requested to reset your password for your account. Click the link below to reset it:

{{ protocol }}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}

If you didn't request a password reset, you can safely ignore this email. Your password won't be changed unless you click the link above and create a new one.

This link will expire in 3 days.

Thanks,
The {{ site_name }} Team
{% endautoescape %}

This template generates the password reset email body. The {% autoescape off %} tag prevents HTML encoding since this is a plain-text email. Django automatically provides variables like {{ protocol }}, {{ domain }}, {{ uid }}, and {{ token }} to construct the secure reset URL.

Template 3: Email subject

File: templates/registration/password_reset_subject.txt

Password Reset Request

This is a simple one-line file that sets the email subject. Django uses this template to determine what appears in the reset email's subject line.

Template 4: Confirmation page

File: templates/registration/password_reset_done.html

{% extends 'base.html' %}

{% block content %}
<div class="container">
    <h2>Password Reset Email Sent</h2>
    <p>
        We've sent you instructions for resetting your password to the email address you submitted.
    </p>
    <p>
        You should receive the email shortly. If you don't see it, please check your spam folder.
    </p>
    <p>
        If you don't receive an email, make sure you've entered the address you registered with.
    </p>
    <p class="mt-3">
        <a href="{% url 'login' %}">Return to Login</a>
    </p>
</div>
{% endblock %}

This template displays after a user submits the reset request form. It confirms that the email was sent and provides helpful tips about checking spam folders. For security, it shows the same message whether the email exists or not.

Template 5: New password form

File: templates/registration/password_reset_confirm.html

{% extends 'base.html' %}

{% block content %}
<div class="container">
    {% if validlink %}
        <h2>Enter Your New Password</h2>
        <form method="post">
            {% csrf_token %}

            {% if form.errors %}
            <div class="alert alert-danger">
                {% for field in form %}
                    {% for error in field.errors %}
                        <p>{{ error }}</p>
                    {% endfor %}
                {% endfor %}
            </div>
            {% endif %}

            <div class="form-group">
                <label for="{{ form.new_password1.id_for_label }}">New Password</label>
                {{ form.new_password1 }}
            </div>

            <div class="form-group">
                <label for="{{ form.new_password2.id_for_label }}">Confirm Password</label>
                {{ form.new_password2 }}
            </div>

            <button type="submit" class="btn btn-primary">Reset Password</button>
        </form>
    {% else %}
        <h2>Invalid Reset Link</h2>
        <p>
            The password reset link was invalid, possibly because it has already been used or has expired.
        </p>
        <p>
            Please request a new password reset.
        </p>
        <p class="mt-3">
            <a href="{% url 'password_reset' %}">Request New Reset Link</a>
        </p>
    {% endif %}
</div>
{% endblock %}

This template displays when users click the reset link in their email. The {% if validlink %} check verifies the token is still valid and hasn't been used. If valid, it shows the new password form; otherwise, it displays an error message with a link to request a new reset.

Template 6: Success message

File: templates/registration/password_reset_complete.html

{% extends 'base.html' %}

{% block content %}
<div class="container">
    <h2>Password Reset Complete</h2>
    <p>
        Your password has been successfully reset. You can now log in with your new password.
    </p>
    <p class="mt-3">
        <a href="{% url 'login' %}" class="btn btn-primary">Log In</a>
    </p>
</div>
{% endblock %}

This template displays after a successful password reset. It confirms the password was changed and provides a direct link to the login page so users can sign in with their new credentials.

Step 4: Test your password reset implementation

Now that everything is set up, let's test the complete flow.

Testing locally with console backend

Here's how to test your password reset implementation if you're using the console backend. Start by running your Django development server:

python manage.py runserver

After that, open your browser and navigate to http://localhost:8000/password-reset/

Then enter a valid email address from your database and submit the Django forgot password form.

After submitting the form, check your terminal. You should see the email content printed there.

Go ahead and copy the reset link from the terminal output and paste it into your browser. You'll be redirected to the new password form if the token is valid.

After completing the password reset, you'll be directed to the success page. From here, you'll be able to log back in to your account using the new password.

Testing with real SMTP

Once you've verified the flow works locally, switch to your SMTP backend in settings.py. If you were using the console backend for testing, you'll need to update the EMAIL_BACKEND to use an SMTP server.

After updating the settings, navigate to the password reset route and request a password reset for a real email address.

You'll see a generic password request email sent notification.

Go ahead and check your inbox for the password change email.

If you don't find it in your main inbox, check the spam folder.

Pro Tip: Using an API-based email provider like SendLayer improves your email's deliverability and protects your domain's reputation. This ensures transactional emails get delivered to the user's inbox.

You can then use the reset link in the email to update your password.

Congratulations! You now have a fully functional password reset system in your Django app with email notification.

Troubleshoot common issues

These are answers to some of the issues I encountered and how to resolve them.

Email not sending

The Django password reset email not sending issue often occurs due to missing settings or invalid SMTP credentials.

If you're not receiving reset emails:

Review your SMTP settings and verify that your SMTP username, password, host, and port are correct.
Check your spam folder. Sometimes reset emails end up in spam, especially during development.
Verify your firewall settings. Make sure port 587 (or your SMTP port) isn't blocked.
If you're testing locally, try setting EMAIL_USE_TLS to False to allow sending emails from non-HTTPS domains.

Pro Tip: Make sure to update the EMAIL_USE_TLS settings when moving to production.

Template not found error

This error indicates Django was unable to find the password reset template at the location you set when configuring the URL pattern.

If you see TemplateDoesNotExist: registration/password_reset_form.html:

Verify your TEMPLATES setting includes the templates directory:

# settings.py
'DIRS': [BASE_DIR / 'templates'],

Check your directory structure. The templates must be in templates/registration/.
Verify your app order in INSTALLED_APPS. Your app should come before django.contrib.admin so Django finds your templates first.

Invalid or expired token

If users see "The password reset link was invalid", it often indicates:

The link has been used. Reset tokens are single-use only.
The link expired. By default, tokens expire after 3 days. You can customize this in your settings.py file:

# settings.py
PASSWORD_RESET_TIMEOUT = 86400  # 24 hours in seconds

URL configuration issue. Make sure your URL patterns match the structure in the email template.

Django password reset security best practices

Django's password reset system is secure by default, but here are some additional best practices:

Enforce strong passwords

Configure password validators in your settings.py:

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
        'OPTIONS': {'min_length': 8,}
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]

Use HTTPS in production

Always use HTTPS for password reset links in production:

# settings.py (production)
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True

Monitor reset attempts

Consider logging password reset attempts to detect suspicious activity:

import logging

logger = logging.getLogger(__name__)

# In your custom view
logger.info(f"Password reset requested for email: {email}")

Frequently asked questions

These are answers to some of the top questions we see about implementing password change in Django.

Can I implement password reset with Django Rest Framework?

While this tutorial covers Django's template-based password reset, you can implement password reset Django Rest Framework functionality using DRF's APIViews. You'll need to create API endpoints that trigger the same password reset flow, but return JSON responses instead of rendering templates.

Alternatively, consider using the dj-rest-auth package, which provides ready-made password reset endpoints for REST APIs. The token generation and validation logic remains the same.

Does this work with custom user models?

Yes, Django's built-in password reset system works with custom user models as long as they inherit from AbstractBaseUser and include an email field. The password reset views automatically detect your custom user model through the AUTH_USER_MODEL setting. No additional configuration is needed—the Django password reset token generator will work with any properly configured user model.

Should I use Django allauth for password reset?

This depends on your use case. If you need additional features, such as social authentication, Django-allauth is an excellent choice and handles password resets automatically.

However, if you only need basic password reset functionality, Django's built-in system is simpler and requires no additional dependencies.

Wrapping up

In this comprehensive tutorial, we've walked through everything you need to implement a secure password reset system in Django.

Have questions or want to share your Django password reset implementation? Drop a comment below—I'd love to hear how you're handling authentication in your Django projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first password reset email in minutes.

Password reset Laravel: How to allow users reset their passwords in Laravel

David Ozokoye — Mon, 09 Feb 2026 08:41:56 +0000

One of the most essential features any web application needs is a secure password reset system. If you're looking to implement password reset in Laravel, you've come to the right place.

Whether you're building a new application or adding authentication to an existing project, nobody wants frustrated users locked out of their accounts. Laravel makes it easy to implement this functionality with its built-in password reset features.

In this guide, I'll walk you through implementing password reset in Laravel. We'll cover the built-in system and how to create custom implementations for APIs and advanced use cases.

Let's jump right in!

Understanding Laravel's built-in password reset system
How to implement password reset in Laravel
How to set up password reset using Laravel Breeze
How to implement password reset API for modern applications
How to customize token expiration time
Troubleshooting common password reset issues
Best practices for production
Frequently asked questions

Understanding Laravel's built-in password reset system

Before diving into implementation, let's understand how Laravel's password reset works under the hood.

How Laravel password reset works

Laravel provides a complete password reset system out of the box. Here's how the flow works:

User clicks "Forgot Password" and enters their email address
Laravel generates a unique token and stores it in the password_reset_tokens table
An email with a password reset link (containing the token) is sent to the user
User clicks the link and is directed to a password reset form
Upon submitting the new password, Laravel validates the token
If valid, Laravel will update the user's password and delete the token

The beauty of this system is that tokens are hashed for security and automatically expire after a set time (60 minutes by default).

Key components

Laravel's password reset functionality relies on several key components:

PasswordBroker: Manages token creation and validation
Password Facade: Provides convenient methods for resetting passwords
ResetPassword Notification: Sends the password reset email
password_reset_tokens Table: Stores reset tokens

Now that we understand how it works, let's implement it.

How to implement password reset in Laravel

Prerequisites

Before we get started, make sure you have:

Laravel 11.x or 12.x installed on your machine
Basic understanding of Laravel routing and controllers
A mail server or SMTP server configured (I'll show you how to use SendLayer's SMTP)
Database connection set up
A code editor like VS Code

You can check your Laravel version by running:

php artisan --version

If you don't have Laravel installed yet, you can set up a new project with:

composer create-project laravel/laravel password-reset-demo

Tip: password-reset-demo is the name of the Laravel project. You can use any name you'd like.

Then navigate into the project directory using the command:

cd password-reset-demo

How to set up password reset using Laravel Breeze

The quickest way to get password reset working is to use Laravel Breeze, which provides a complete authentication scaffolding.

Step 1: Install Laravel Breeze

Laravel Breeze is a minimal authentication starter kit that includes login, registration, password reset, and email verification. To install it, run:

composer require laravel/breeze --dev

You'll be prompted to choose a stack. For this tutorial, I'll use the Blade stack. You can simply run the command below to install with the Blade stack:

php artisan breeze:install blade

Next, install the frontend dependencies using the command below:

npm install && npm run dev

Note: npm run dev starts the Vite frontend development server. Please keep this server running to use the password reset forms.

Once the installation completes, run the command below to migrate your database:

php artisan migrate

This command creates all necessary database tables, including the password_reset_tokens table.

Step 2: Configure your email settings

Password reset relies on email notifications, so you'll need to configure your mail settings in the .env file.

I recommend using SendLayer for reliable email delivery. Here's how to configure it:

MAIL_MAILER=smtp
MAIL_HOST=smtp.sendlayer.net
MAIL_PORT=587
MAIL_USERNAME=your_sendlayer_username
MAIL_PASSWORD=your_sendlayer_password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=noreply@yourdomain.com
MAIL_FROM_NAME="${APP_NAME}"

Important: Your MAIL_FROM_ADDRESS should use the domain you've authorized in SendLayer. For example, if you authorized example.com, use noreply@example.com.

Start your free trial at SendLayer

If you're using SendLayer, you can get your SMTP credentials from your account dashboard under Settings » SMTP Credentials.

Pro Tip: If you need more help, please see our tutorial on setting up email in Laravel.

Step 3: Verify the password reset database table

Let's check that the password reset table was created correctly. The migration should look like this:

Schema::create('password_reset_tokens', function (Blueprint $table) {
    $table->string('email')->primary();
    $table->string('token');
    $table->timestamp('created_at')->nullable();
});

You can verify this by running:

php artisan migrate:status

The table stores three things:

email: The user's email address
token: A hashed version of the reset token
created_at: Timestamp for token expiration

Step 4: Test the password reset flow

With Breeze installed, you already have a working password reset system. Let's test it:

Start your development server using the command:

php artisan serve

After that, open your browser and navigate to http://localhost:8000/login. Once there, click the Forgot your password? link.

Then, enter a registered user's email address and click the EMAIL PASSWORD RESET LINK button.

You should receive the message in the user's inbox. Go ahead and click the Reset Password button to reset your password.

If the token is valid, you'll be directed back to your Laravel application to enter your new password. The token will be added as a URL parameter in the reset password link.

Go ahead and enter and confirm your new password. Then click the RESET PASSWORD button to update your password.

If everything works, congratulations! You've successfully implemented password reset in Laravel.

How to implement password reset API for modern applications

If you're building a mobile app, SPA, or headless CMS, you'll need an API-based password reset system instead of traditional web forms. Here's how to do it:

Step 1: Create API routes

Start by creating a new api.php file in the routes folder. Then, add these routes to your routes/api.php:

<?php

use App\Http\Controllers\Api\PasswordResetController;

// Laravel reset password API routes
Route::post('/forgot-password', [PasswordResetController::class, 'forgotPassword']);
Route::post('/reset-password', [PasswordResetController::class, 'resetPassword']);

This PHP code defines the API routes that connect HTTP endpoints to the password reset controller methods we'll create in step 3.

First, we import the PasswordResetController class so we can reference its methods in our route definitions.

Then we define two POST routes using Laravel's Route::post() method. The /forgot-password endpoint maps to the forgotPassword method, which handles sending reset links.

The /reset-password endpoint maps to the resetPassword method, which handles the actual password change.

Step 2: Register API routes

After defining the API routes, we'll need to register them so Laravel can process the routes. Laravel 11+ requires explicit API route registration in bootstrap/app.php.

To do so, open the bootstrap/app.php file and add the line below to the return statement. Ideally, it should be placed below the web line.

api: __DIR__.'/../routes/api.php',

If you omit this line, your application will default to the routes defined in web.php.

Step 3: Create the API controller

Now, we'll need to create a new controller for API password reset:

php artisan make:controller Api/PasswordResetController

After that, open the Http/Controllers/Api/PasswordResetController file and replace its content with the snippets below:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Password;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\ValidationException;

class PasswordResetController extends Controller
{
    public function forgotPassword(Request $request)
    {
        $request->validate(['email' => 'required|email']);

        $status = Password::sendResetLink(
            $request->only('email')
        );

        if ($status === Password::RESET_LINK_SENT) {
            return response()->json([
                'message' => 'Password reset link sent to your email.'
            ], 200);
        }

        throw ValidationException::withMessages([
            'email' => [__($status)],
        ]);
    }

    public function resetPassword(Request $request)
    {
        $request->validate([
            'token' => 'required',
            'email' => 'required|email',
            'password' => 'required|min:8|confirmed',
        ]);

        $status = Password::reset(
            $request->only('email', 'password', 'password_confirmation', 'token'),
            function ($user, $password) {
                $user->password = Hash::make($password);
                $user->save();
            }
        );

        if ($status === Password::PASSWORD_RESET) {
            return response()->json([
                'message' => 'Password has been reset successfully.'
            ], 200);
        }

        throw ValidationException::withMessages([
            'email' => [__($status)],
        ]);
    }
}

Code breakdown

In the code above, we define a Laravel API controller that handles password reset, including sending reset links and processing password changes.

First, we define the namespace and import the necessary Laravel classes. Here's an overview of the classes we're using:

Controller: The base class
Request: Handles HTTP data
Password: Used for reset operations
Hash: Handles secure password hashing
ValidationException: For error handling

The forgotPassword method validates that the request includes a valid email address. Then, uses Password::sendResetLink() to generate a unique token and send a reset email.

If successful, it returns a JSON confirmation; otherwise, it throws a validation exception with the error message.

The resetPassword method validates the token, email, and new password. It then calls Password::reset(), which verifies the token.

After that, it executes a callback that hashes the new password with Hash::make() and saves the user's details.

Step 4: Password reset email customization

By default, Laravel sends a branded password reset email template. Let's go ahead and customize it to match your brand.

First, create a custom notification:

php artisan make:notification CustomResetPasswordNotification

Then update the notification class:

<?php

namespace App\Notifications;

use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;

class CustomResetPasswordNotification extends Notification
{
    public $token;

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

    public function via($notifiable)
    {
        return ['mail'];
    }

    public function toMail($notifiable)
    {
        $url = url(route('password.reset', [
            'token' => $this->token,
            'email' => $notifiable->getEmailForPasswordReset(),
        ], false));

        return (new MailMessage)
            ->subject('Reset Your Password')
            ->line('You are receiving this email because we received a password reset request for your account.')
            ->action('Reset Password', $url)
            ->line('This password reset link will expire in 60 minutes.')
            ->line('If you did not request a password reset, no further action is required.');
    }
}

Finally, override the sendPasswordResetNotification method in your User model (app/Models/User.php):

use App\Notifications\CustomResetPasswordNotification;

public function sendPasswordResetNotification($token)
{
    $this->notify(new CustomResetPasswordNotification($token));
}

Your password reset emails will now use your custom template.

Step 5: Test the API

You can test your API endpoints using cURL or an API client like Postman. Here's how to run a quick test using cURL:

# Send password reset link
curl -X POST http://localhost:8000/api/forgot-password \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com"}'

After requesting the password reset link, you should receive an email notification if the user's email exists.

Since this is an API route, there is no view to update the password. So the reset password button won't work.

We'll need to copy the Laravel password reset token. Then use it when making an API call to the reset password endpoint. Here's an example command:

# Reset password
curl -X POST http://localhost:8000/api/reset-password \
  -H "Content-Type: application/json" \
  -d '{
    "token":"your_token_here",
    "email":"user@example.com",
    "password":"newpassword123",
    "password_confirmation":"newpassword123"
  }'

Replace the "token" value with the actual token you received in the forgot password email. You should receive a successful response after sending the request.

{"message":"Password has been reset successfully."}

How to customize token expiration time

By default, password reset tokens expire after 60 minutes. You can change this in your config/auth.php file. Here's how to update Laravel's password reset expiration:

'passwords' => [
    'users' => [
        'provider' => 'users',
        'table' => 'password_reset_tokens',
        'expire' => 30, // Change to 30 minutes
        'throttle' => 60,
    ],
],

The throttle option prevents users from requesting multiple reset emails within the specified timeframe (in seconds).

Troubleshooting common password reset issues

These are troubleshooting tips for Laravel password reset not working issues.

"This password reset token is invalid" error

This is the most common error you'll encounter. It can happen for several reasons:

The token has expired (default is 60 minutes)
The token has already been used
The email doesn't match the token in the database
There's a mismatch between the token in the URL and database

To resolve this issue:

Check your token expiration setting in config/auth.php
Verify the email address matches exactly (case-sensitive)
Clear the password reset tokens table for testing:

php artisan tinker
DB::table('password_reset_tokens')->truncate();

Make sure you're passing the token correctly in your form

Password reset email not sending

If users aren't receiving password reset emails, here's what to check:

Test your email configuration:

php artisan tinker
Mail::raw('Test email', function($msg) {
    $msg->to('your@email.com')->subject('Test');
});

Check your .env file for correct SMTP settings
Review Laravel logs at storage/logs/laravel.log for errors
If using queues, make sure your queue worker is running:

php artisan queue:work

For production, use a reliable SMTP service like SendLayer to ensure deliverability

Routes not working (404 error)

If you're getting 404 errors when accessing password reset routes:

Clear your route cache:

php artisan route:clear
php artisan cache:clear

Verify routes are registered:

php artisan route:list | grep password

Make sure you've added the routes to the correct file (web.php or api.php)

Best practices for production

When deploying a password reset system to production, follow these security best practices:

Use HTTPS

Always use HTTPS in production. Password reset links should never be sent over unsecured connections.

In your .env:

APP_URL=https://yourdomain.com

Queue email sending

For better performance, queue password reset emails instead of sending them synchronously:

public function sendPasswordResetNotification($token)
{
    $this->notify((new CustomResetPasswordNotification($token))->delay(now()->addSeconds(5)));
}

Make sure to run your queue worker:

php artisan queue:work

Implement rate limiting

Prevent abuse by limiting password reset requests. Laravel includes throttling by default, but you can customize it:

'passwords' => [
    'users' => [
        'provider' => 'users',
        'table' => 'password_reset_tokens',
        'expire' => 60,
        'throttle' => 60, // Only allow 1 request per 60 seconds
    ],
],

Don't reveal user existence

For security reasons, don't tell attackers whether an email exists in your system. Always return the same message:

public function sendResetLink(Request $request)
{
    $request->validate(['email' => 'required|email']);

    Password::sendResetLink($request->only('email'));

    // Always return success message
    return back()->with('status', 'If this email exists, a password reset link has been sent.');
}

Frequently asked questions

These are answers to some of the most common questions we see about implementing password resets in Laravel.

How do I customize the Laravel reset password email template?

To customize the reset email, you'll need to create a custom notification class and override the sendPasswordResetNotification method in your User model. See the Customize the Email Template section above for more details.

Can I use Laravel password reset without email?

Yes, you can implement OTP-based reset using SMS or store tokens in your database. Then, you can verify them manually before allowing password changes.

Is Laravel's password reset secure for production?

Yes, Laravel uses industry-standard security practices including token hashing, expiration, and secure random generation. Just ensure you're using HTTPS and following best practices.

How do I implement password reset for multiple user types?

Create separate password brokers in config/auth.php for each user type (users, admins, etc.) and use different guards.

Wrapping up

In this comprehensive guide, we've covered everything you need to know about implementing password reset in Laravel.

Have questions or want to share your implementation? Let me know in the comments if this helped, or share your own Laravel password reset tips!

Ready to implement this in your application? Start your free trial at SendLayer and ensure your password reset emails reach users' inboxes every time.

How to Implement Password Reset in Node.js [+ Email Notifications]

David Ozokoye — Mon, 09 Feb 2026 08:01:36 +0000

Do you want to add a secure password reset feature to your Node.js application?

Whether you're building a user authentication system for a web app, SaaS platform, or enterprise application, implementing a reliable password reset flow is essential for user experience and security.

In this guide, you'll learn how to implement a complete password reset system in Node.js using Express, MongoDB, and email notifications.

How to implement password reset in Node.js
- Step 1: Set up your Node.js project
- Step 2: Configure environment variables
- Step 3: Set up database connection
- Step 4: Create user and token models
- Step 5: Create email service
- Step 6: Create password reset controllers
- Step 7: Set up routes
- Step 8: Create the main server file
- Step 9: Test your password reset flow
Security best practices for password reset
Troubleshooting common issues
Frequently asked questions

What is a password reset flow?

A password reset flow is a security feature that allows users to regain access to their accounts when they forget their passwords. Instead of storing or sending the old password, the system generates a unique, time-limited token that authorizes the user to create a new password.

Here's how the typical password reset workflow works:

User initiates request: The user clicks "Forgot Password" and enters their email address
System generates token: The server creates a unique secure token
Email sent: The token is sent via email with a reset link to the user
User clicks the link: The reset link redirects to a password change form
Token validated: The system verifies that the token is valid and not expired
Password updated: User enters new password, and it's saved to the database
Confirmation sent: A confirmation email notifies the user of the password change

Sounds easy, right? Well, a lot of work goes on under the hood to make sure this flow is secure. The token-based approach prevents attackers from accessing accounts even if they intercept the reset email.

Prerequisites

Before we start building, make sure you have the following requirements:

Node.js installed on your machine. Version 18.x or higher (LTS recommended). Download the latest version here
MongoDB database (local installation or MongoDB Atlas)
Code editor: I recommend using Visual Studio Code
Basic knowledge of JavaScript, Node.js, and Express
Email API: I'm using SendLayer for this tutorial. You can get started for free

Start your free trial at SendLayer

After creating your SendLayer account, make sure to authorize your sending domain. This step is essential for improving email deliverability and ensuring your password reset emails reach users' inboxes instead of spam folders.

How to implement password reset in Node.js

In this section, I'll walk you through building a complete password reset system from scratch. We'll use Express for the server, MongoDB for data storage, and SendLayer for sending emails.

Step 1: Set up your Node.js project

First, open a terminal window and create a new directory for your project.

mkdir password-reset-app

Then navigate into the folder and initialize it:

cd password-reset-app && npm init -y

Now, let's install the required dependencies:

npm install express mongoose bcryptjs jsonwebtoken dotenv validator cors

Let's also install the development dependency for auto-restarting the server:

npm install -D nodemon

Here's what each package does:

express: Web framework for building the backend API
mongoose: MongoDB object modeling tool
bcryptjs: Library for hashing passwords and tokens
jsonwebtoken: For generating secure tokens
dotenv: Loads environment variables from .env file
validator: Input validation and sanitization
cors: Enables cross-origin requests from frontend

For sending emails, we'll use SendLayer's API. Go ahead and install the SendLayer SDK:

npm install sendlayer

After installing the dependencies, update your package.json scripts section:

{
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  }
}

Step 2: Configure environment variables

Create a .env file in your project root to store sensitive configuration:

# Server Configuration
PORT=5001
NODE_ENV=development

# Database
MONGODB_URI=mongodb://localhost:27017/password-reset-db

# JWT Secret (use a strong random string)
JWT_SECRET=your_super_secret_jwt_key_here

# SendLayer Configuration
SENDLAYER_API_KEY=your_sendlayer_api_key_here
FROM_EMAIL=noreply@yourdomain.com
FROM_NAME=Your App Name

# Frontend URL (for reset links)
FRONTEND_URL=http://localhost:3000

# Token Configuration
RESET_TOKEN_EXPIRY=900 # 15 minutes

Important: Never commit your .env file to version control. Add it to your .gitignore file.

To get your SendLayer API key, log in to your SendLayer account. Once logged in, click the Settings menu and select the API Keys tab.

Then click the copy icon next to Default API key to copy it.

After copying the API key, switch back to your code editor and paste this key into the .env file as the SENDLAYER_API_KEY value.

Pro Tip: If you're using SendLayer to send password reset emails, the sender email needs to be at the domain you've authorized in SendLayer. For instance, if you authorized example.com, your sender email should be noreply@example.com.

Step 3: Set up database connection

If your app supports user registration, you should already have a database configured. I'll show you how to set up a database connection using MongoDB.

To start, create a config folder and add a db.js file to handle the MongoDB connection. After that, copy and paste the snippet below to the database file:

const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI);
    console.log('MongoDB connected successfully');
  } catch (error) {
    console.error('MongoDB connection error:', error.message);
    process.exit(1);
  }
};

module.exports = connectDB;

This function establishes a connection to your MongoDB database. If the connection fails, the application will exit with an error message.

Pro Tip: Make sure to update the MONGODB_URI value in the .env with your actual database URI.

Step 4: Create user and token models

Now let's create the database schemas for users and reset tokens. Create a models folder and add two files.

First, create User.js and add the following snippets to it:

const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: [true, 'Email is required'],
    unique: true,
    lowercase: true,
    trim: true,
  },
  password: {
    type: String,
    required: [true, 'Password is required'],
    minlength: 8,
  },
  name: {
    type: String,
    required: true,
  },
  createdAt: {
    type: Date,
    default: Date.now,
  },
});

// Hash password before saving
userSchema.pre('save', async function () {
  if (!this.isModified('password')) return;

  const salt = await bcrypt.genSalt(12);
  this.password = await bcrypt.hash(this.password, salt);
});

// Method to compare passwords
userSchema.methods.comparePassword = async function(candidatePassword) {
  return await bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', userSchema);

The User model includes a pre-save middleware that automatically hashes passwords before storing them. We use bcrypt with 12 salt rounds for strong password hashing.

Next, create PasswordReset.js for storing reset tokens:

const mongoose = require('mongoose');

const passwordResetSchema = new mongoose.Schema({
  userId: {
    type: mongoose.Schema.Types.ObjectId,
    required: true,
    ref: 'User',
  },
  token: {
    type: String,
    required: true,
  },
  createdAt: {
    type: Date,
    default: Date.now,
    expires: 900, // Token expires after 15 minutes (900 seconds)
  },
});

module.exports = mongoose.model('PasswordReset', passwordResetSchema);

The expires field creates a TTL (Time To Live) index that automatically deletes expired tokens from the database. This keeps your database clean without manual cleanup.

Step 5: Create email service

The next step is to implement email sending to allow users to receive password reset emails. You can set this up using SMTP or an email API. However, I recommend using an email API because it has better deliverability.

In a previous tutorial, I covered various methods for sending emails in JavaScript. For this tutorial, I'll use the API method with SendLayer.

Start your free trial at SendLayer

To get started, create a services folder and add emailService.js to handle email sending with SendLayer:

const { SendLayer } = require('sendlayer');
require('dotenv').config();

const sendlayer = new SendLayer(process.env.SENDLAYER_API_KEY);

const sendPasswordResetEmail = async (email, name, resetToken) => {
  const resetUrl = `${process.env.FRONTEND_URL}/reset-password/${resetToken}`;

  const htmlContent = `
    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
      <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; border-radius: 8px 8px 0 0;">
        <h1 style="margin: 0; font-size: 28px;">Password Reset Request</h1>
      </div>

      <div style="background: white; padding: 30px; border-radius: 0 0 8px 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
        <p style="font-size: 16px; color: #333; line-height: 1.6;">
          Hi <strong>${name}</strong>,
        </p>

        <p style="font-size: 16px; color: #333; line-height: 1.6;">
          We received a request to reset your password. Click the button below to create a new password:
        </p>

        <div style="text-align: center; margin: 30px 0;">
          <a href="${resetUrl}" style="background: #667eea; color: white; padding: 15px 30px; text-decoration: none; border-radius: 5px; font-weight: bold; display: inline-block;">
            Reset Password
          </a>
        </div>

        <p style="font-size: 14px; color: #666; line-height: 1.6;">
          This link will expire in <strong>15 minutes</strong> for security reasons.
        </p>

        <p style="font-size: 14px; color: #666; line-height: 1.6;">
          If you didn't request a password reset, please ignore this email or contact support if you have concerns.
        </p>

        <div style="margin-top: 30px; padding-top: 20px; border-top: 1px solid #eee;">
          <p style="font-size: 12px; color: #999; margin: 0;">
            If the button doesn't work, copy and paste this link into your browser:<br>
            <a href="${resetUrl}" style="color: #667eea; word-break: break-all;">${resetUrl}</a>
          </p>
        </div>
      </div>
    </div>
  `;

  const textContent = `
    Hi ${name},

    We received a request to reset your password. Click the link below to create a new password:

    ${resetUrl}

    This link will expire in 15 minutes for security reasons.

    If you didn't request a password reset, please ignore this email or contact support if you have concerns.
  `;

  try {
    const response = await sendlayer.Emails.send({
      from: {
        email: process.env.FROM_EMAIL,
        name: process.env.FROM_NAME,
      },
      to: [{
        email: email,
        name: name,
      }],
      subject: 'Password Reset Request',
      html: htmlContent,
      text: textContent,
      tags: ['password-reset'],
    });

    console.log('Password reset email sent:', response);
    return response;
  } catch (error) {
    console.error('Error sending password reset email:', error);
    throw error;
  }
};

const sendPasswordChangeConfirmation = async (email, name) => {
  const htmlContent = `
    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
      <div style="background: #10b981; color: white; padding: 30px; text-align: center; border-radius: 8px 8px 0 0;">
        <h1 style="margin: 0; font-size: 28px;">✓ Password Changed Successfully</h1>
      </div>

      <div style="background: white; padding: 30px; border-radius: 0 0 8px 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
        <p style="font-size: 16px; color: #333; line-height: 1.6;">
          Hi <strong>${name}</strong>,
        </p>

        <p style="font-size: 16px; color: #333; line-height: 1.6;">
          Your password has been changed successfully. You can now log in with your new password.
        </p>

        <p style="font-size: 14px; color: #666; line-height: 1.6;">
          If you didn't make this change, please contact our support team immediately.
        </p>
      </div>
    </div>
  `;

  const textContent = `
    Hi ${name},

    Your password has been changed successfully. You can now log in with your new password.

    If you didn't make this change, please contact our support team immediately.
  `;

  try {
    await sendlayer.Emails.send({
      from: {
        email: process.env.FROM_EMAIL,
        name: process.env.FROM_NAME,
      },
      to: [{
        email: email,
        name: name,
      }],
      subject: 'Password Changed Successfully',
      html: htmlContent,
      text: textContent,
      tags: ['password-change-confirmation'],
    });
  } catch (error) {
    console.error('Error sending confirmation email:', error);
  }
};

module.exports = {
  sendPasswordResetEmail,
  sendPasswordChangeConfirmation,
};

This email service includes two functions: one for sending the reset link and another for confirming the password change. Both use responsive HTML templates that work across all email clients.

Pro Tip: SendLayer provides excellent email deliverability with domain reputation protection. It automatically creates a subdomain for transactional emails. This ensures your main domain stays protected from any potential deliverability issues.

When calling the sendPasswordResetEmail method, you'll need to specify the required parameters: name, email, and resetToken. The sendPasswordChangeConfirmation method requires name and email as its arguments.

Step 6: Create password reset controllers

Here's where the magic happens. Let's create the methods for generating the secure token. We'll also use the 2 email methods we created here to send the token to the user's email.

To start, create a controllers folder and add authController.js to the folder. Then copy and paste the snippet below into the authController.js file:

const crypto = require('crypto');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const validator = require('validator');
const User = require('../models/User');
const PasswordReset = require('../models/PasswordReset');
const { sendPasswordResetEmail, sendPasswordChangeConfirmation } = require('../services/emailService');

// Request password reset
exports.requestPasswordReset = async (req, res) => {
  try {
    const { email } = req.body;

    // Validate email
    if (!email || !validator.isEmail(email)) {
      return res.status(400).json({
        error: 'Please provide a valid email address',
      });
    }

    // Find user (but don't reveal if user exists)
    const user = await User.findOne({ email: email.toLowerCase() });

    // Always return success to prevent email enumeration
    if (!user) {
      return res.status(200).json({
        message: 'If an account with that email exists, a password reset link has been sent.',
      });
    }

    // Delete any existing reset tokens for this user
    await PasswordReset.deleteMany({ userId: user._id });

    // Generate secure random token
    const resetToken = crypto.randomBytes(32).toString('hex');

    // Hash token before saving to database
    const hashedToken = await bcrypt.hash(resetToken, 10);

    // Save hashed token to database
    await PasswordReset.create({
      userId: user._id,
      token: hashedToken,
    });

    // Send reset email with original (unhashed) token
    await sendPasswordResetEmail(user.email, user.name, resetToken);

    res.status(200).json({
      message: 'If an account with that email exists, a password reset link has been sent.',
    });

  } catch (error) {
    console.error('Error in requestPasswordReset:', error);
    res.status(500).json({
      error: 'An error occurred. Please try again later.',
    });
  }
};

// Verify reset token
exports.verifyResetToken = async (req, res) => {
  try {
    const { token } = req.params;

    if (!token) {
      return res.status(400).json({
        error: 'Reset token is required',
      });
    }

    // Find all reset tokens and check each one
    const resetTokens = await PasswordReset.find().populate('userId');

    let validToken = null;
    for (const resetToken of resetTokens) {
      const isValid = await bcrypt.compare(token, resetToken.token);
      if (isValid) {
        validToken = resetToken;
        break;
      }
    }

    if (!validToken) {
      return res.status(400).json({
        error: 'Invalid or expired reset token',
      });
    }

    res.status(200).json({
      message: 'Token is valid',
      email: validToken.userId.email,
    });

  } catch (error) {
    console.error('Error in verifyResetToken:', error);
    res.status(500).json({
      error: 'An error occurred. Please try again later.',
    });
  }
};

// Reset password
exports.resetPassword = async (req, res) => {
  try {
    const { token } = req.params;
    const { password } = req.body;

    // Validate inputs
    if (!token) {
      return res.status(400).json({
        error: 'Reset token is required',
      });
    }

    if (!password || password.length < 8) {
      return res.status(400).json({
        error: 'Password must be at least 8 characters long',
      });
    }

    // Find valid reset token
    const resetTokens = await PasswordReset.find().populate('userId');

    let validToken = null;
    for (const resetToken of resetTokens) {
      const isValid = await bcrypt.compare(token, resetToken.token);
      if (isValid) {
        validToken = resetToken;
        break;
      }
    }

    if (!validToken) {
      return res.status(400).json({
        error: 'Invalid or expired reset token',
      });
    }

    // Update user password
    const user = validToken.userId;
    user.password = password;
    await user.save();

    // Delete used token
    await PasswordReset.deleteOne({ _id: validToken._id });

    // Send confirmation email
    await sendPasswordChangeConfirmation(user.email, user.name);

    res.status(200).json({
      message: 'Password has been reset successfully',
    });

  } catch (error) {
    console.error('Error in resetPassword:', error);
    res.status(500).json({
      error: 'An error occurred. Please try again later.',
    });
  }
};

The controller includes three functions:

requestPasswordReset: Generates a token and sends the reset email
verifyResetToken: Checks if a token is valid (useful for frontend validation)
resetPassword: Updates the user's password after token verification

Expert Note: We always return the same success message regardless of whether the email exists. This prevents attackers from using the reset feature to discover which email addresses have accounts (email enumeration attack).

Step 7: Set up routes

Now, let's create the API endpoints to handle all password reset operations. For this, create a routes folder and add authRoutes.js. Then copy and paste the following snippet below:

const express = require('express');
const router = express.Router();
const authController = require('../controllers/authController');

// Request password reset
router.post('/forgot-password', authController.requestPasswordReset);

// Verify reset token
router.get('/reset-password/:token', authController.verifyResetToken);

// Reset password
router.post('/reset-password/:token', authController.resetPassword);

module.exports = router;

These routes handle all password reset operations. The token is passed as a URL parameter, which allows users to click the link in their email and land directly on the reset page.

Step 8: Create the main server file

Finally, let's tie everything together in the main Express.js server file. To do so, create a server.js file in your project root. Then copy and paste the following snippets below:

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const connectDB = require('./config/db');
const authRoutes = require('./routes/authRoutes');

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

// Connect to database
connectDB();

// Middleware
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api/auth', authRoutes);

// Health check endpoint
app.get('/health', (req, res) => {
  res.json({ status: 'Server is running' });
});

// Error handling middleware
app.use((error, req, res, next) => {
  console.error(error);
  res.status(500).json({ error: 'Internal server error' });
});

// Start server
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
  console.log('Password reset API ready');
});

module.exports = app;

Step 9: Test your password reset flow

Now you're ready to test the implementation. Start your development server:

npm run dev

You should see messages indicating the server and MongoDB connection are running.

To test the password reset flow, you can use tools like Postman or cURL. Here's how to test each endpoint:

1. Request Password Reset: Open Postman and send a POST request to the password reset route.

http://localhost:5001/api/auth/forgot-password

In the request body, specify the email address of the user you want to reset their password.

{
  "email": "user@example.com"
}

Note: The user's email needs to be present in the MongoDB database. Otherwise, you won't receive the password reset email. I created a simple snippet for creating users in the database. Follow this link to access the file on GitHub.

Then click the Send button to send your request.

You should receive a 200 success response.

After requesting a password reset, check your email inbox for the reset link. Click the link, and you'll be able to set a new password.

This feature isn't implemented in our current project as we're interested in the backend flow. In a production application, the link should direct users to your frontend with a form that sends a POST request to the /api/auth/reset-password/reset-password endpoint.

For this tutorial, we can continue testing in Postman.

2. Verify Token: To verify the token, copy its value and then send a GET request to the following endpoint.

http://localhost:5001/api/auth/reset-password/TOKEN_FROM_EMAIL

You should see a response that reads "token is valid".

The token will become invalid if its expiration time reaches.

Tip: If the token has expired, the user would need to generate a new one from the reset password endpoint.

3. Reset Password: Finally, change the request type to POST. Then update the request body with the new password.

{
  "password": "newSecurePassword123"
}

After updating your password, check your email inbox for the confirmation email.

Congratulations! You've successfully built a working password reset workflow for your Node.js application. You can access the full source code on GitHub.

Security best practices for password reset

When implementing password reset functionality, security should be your top priority. Here are essential security practices I recommend:

1. Use cryptographically secure tokens

Always use crypto.randomBytes() for generating tokens. Never use predictable values like timestamps or sequential numbers. The tokens should be at least 32 bytes to prevent brute force attacks.

2. Hash tokens before storage

Store hashed versions of tokens in your database using bcrypt. If your database is compromised, attackers won't be able to use the tokens to reset passwords.

3. Implement short expiration times

Reset tokens should expire quickly. Most people use between 15 to 60 minutes. Our implementation uses MongoDB's TTL index to automatically delete expired tokens after 15 minutes. This reduces the attack window significantly.

4. Prevent email enumeration

Always return the same response message, whether or not the email exists in your system. This prevents attackers from discovering which email addresses have accounts.

5. Use HTTPS in production

Always serve your application over HTTPS in production. This encrypts the reset token during transmission, preventing man-in-the-middle attacks.

Troubleshooting common issues

Email not received

If users aren't receiving password reset emails, check these common issues:

Verify SendLayer Configuration: Make sure your API key is correct, and your domain is authorized
Check Spam Folder: Reset emails sometimes end up in spam
Validate Email Address: Ensure the email format is correct
Review SendLayer Logs: Log in to your SendLayer dashboard to check email delivery status

SendLayer provides detailed analytics that show email delivery status, opens, and clicks. This makes debugging email issues much easier compared to traditional SMTP.

Token expiration errors

If users report that reset links expire too quickly, you can adjust the expiration time in your PasswordReset model. Change the expires value from 900 (15 minutes) to your preferred duration in seconds.

MongoDB connection issues

If you see MongoDB connection errors, verify:

Your MongoDB service is running
The connection string in .env is correct
You have network access to MongoDB (especially important for MongoDB Atlas)
Your database user has the correct permissions

Frequently asked questions

These are answers to some of the top questions developers ask about implementing password reset in Node.js.

Can I use this with a React or Vue frontend?

Absolutely! This backend works with any frontend framework like React, Vue, or Next.js. You'll simply need to create forms that POST to these endpoints. Then handle the responses in your frontend. The reset token from the email URL can be extracted using your frontend router.

What's the best way to send password reset emails in Node.js?

Use a dedicated transactional email service like SendLayer. It offers better deliverability, detailed analytics, and automatic retry mechanisms than self-hosted SMTP servers. SendLayer also protects your domain reputation by using subdomains for sending.

Should I hash password reset tokens in the database?

Yes, always hash tokens before storing them. If your database is compromised, attackers shouldn't be able to use the tokens. Use bcrypt or crypto for hashing, just like we do with passwords.

Wrapping up

In this comprehensive tutorial, we've walked through everything you need to know about implementing a secure password reset system in Node.js.

Have questions or want to share your implementation? Drop a comment below—I'd love to hear how you're handling password reset in your Node.js projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first email in minutes.

How to send emails in Next.js via SMTP with email API

David Ozokoye — Sun, 25 Jan 2026 11:54:15 +0000

One of the most common features modern web applications require is email notifications. If you're looking to send emails from your Next.js application, you've come to the right place.

Whether you're building a contact form, an order confirmation system, or a newsletter signup, sending transactional emails is a common feature in many web applications. Modern frameworks like Next.js make it easy to create email functionality and send emails with React components.

In this guide, you'll learn how to send emails in Next.js using the SendLayer API. I'll also show you a practical use case by building a contact form that lets users contact you through your app.

Let's jump right in!

Set up a Next.js project
Step 1: Install the SendLayer SDK
Step 2: Create an API route to send emails
Step 3: Create a simple contact form
Step 4: Send a test email in Next.js
Frequently asked questions

How to send emails in Next.js with the SendLayer API

Prerequisites

To follow along with this tutorial, you'll need to have the following in place:

Node.js and npm installed
Next.js installed on your machine. This tutorial uses Next.js v15 or above
Basic understanding of Next.js and React
An email service provider. I'm using SendLayer for this tutorial

One of the reasons I use SendLayer is that it automatically protects your domain reputation by sending your emails through a subdomain. SendLayer also offers affordable pricing options and lets you get started for free. This is ideal for developers to test their email functionality during development.

Start your free trial at SendLayer

After creating your SendLayer account, you'll need to add and verify your sending domain. This step is essential to improve your site's email deliverability.

With that, you're all set to send your first email from your Next.js application.

Set up a Next.js project

Next.js is an extension to the React library. It includes additional features that allow users to build fully functional web apps that support both client and server actions.

For example, you'll need to implement an email backend with a server like Express.js before you can send emails in React. However, with Next.js, you can implement the email backend without the need for a third-party backend.

While this tutorial assumes you already have a Next.js project set up, I'll do a quick run-through on how to get started with Next.js. You can skip to the installing SendLayer SDK section if you have an existing project.

To install Next.js, open a terminal window and run the command below.

npx create-next-app@latest

You'll be presented with some prompts to configure your installation. I'll use the default options, so you can go ahead and click Enter for each of the prompts.

What is your project named? … next-email-api
Would you like to use TypeScript? … No / (Yes)
Would you like to use ESLint? … No / (Yes)
Would you like to use Tailwind CSS? … No / (Yes)
Would you like your code inside a `src/` directory? … (No) / Yes
Would you like to use App Router? (recommended) … No / (Yes)
Would you like to use Turbopack for `next dev`? … No / (Yes)
Would you like to customize the import alias (`@/*` by default)? … (No) / Yes

Note: Next.js supports both the App Router (recommended) and the Pages Router. This tutorial uses the App Router, but the email functionality works similarly with both routing systems.

After choosing your installation options, create-next-app will install the required dependencies for your project in the folder you specified as the project name.

Once the installation completes, navigate to the project directory using the command:

cd next-email-api

You can start the development server using the command:

npm run dev

This will make your Next.js web app available locally for previewing changes in real-time. When you open the local server (usually localhost:3000), you'll see the default page.

Congratulations! You've successfully installed Next.js.

Understanding Next.js project structure

Now, let's explore the file structure a little before proceeding. To do so, open the project in a code editor. I'm using VS Code editor, but you can use any editor.

Below is an example of the default file structure that create-next-app will contain:

next-email-api/
|── app/
│   |── favicon.ico
│   |── globals.css
│   |── layout.tsx
│   |── page.tsx
│   └── page.module.css
|── public/
│   |── file.svg
│   └── …other svg files
|── .gitignore
|── eslint.config.mjs
|── jsconfig.json
|── package.json
|── README.md
└── next.config.ts

The app/ directory contains all the files and pages that are rendered to the users. The page.tsx file within the app directory corresponds to the index/home page. Each folder you create within this directory corresponds to a URL path.

For example, if you'd like to create a contact page for your Next app, you can do so by creating a contact folder within the app directory. You'll also need to create a page.tsx file within the contact directory that'll contain the content for the page.

Okay! Enough about Next.js file structure. Let's get started on implementing the function for sending emails with Next.js.

Step 1: Install the SendLayer SDK

SendLayer provides an official SDK for Node.js that makes it easy to send emails through their API. The SDK includes built-in error handling, attachment support, and a clean interface for sending emails.

To get started, you'll need to install the SendLayer SDK as a dependency for your Next.js app. Open a terminal window and navigate into your project's directory. Then run the command below:

npm install sendlayer dotenv

After the installation completes, create a .env.local file in the root of your Next.js project and add your SendLayer API credentials:

SENDLAYER_API_KEY=your-api-key
FROM_EMAIL=sender@example.com

Tip: Make sure to include the .env.local file in your project's .gitignore. This ensures you're not exposing private credentials in your code.

Retrieving your SendLayer API key

To get your API key, log in to your SendLayer account. Once you're logged in, click the Settings menu and select the API Keys tab.

Then click the copy icon next to Default API key to copy it.

After copying your API key, return to your code editor and paste it into the .env.local file.

Note: In SendLayer, your sender email needs to be at the domain you've authorized. For instance, if you authorized example.com, your sender email should include @example.com.

Step 2: Create an API route to send emails

One of the impressive features about building with Next.js is that it supports both client and server components. You can define API routes within your project in the app/api directory.

Let's create a route.js file within the following directories:

app/api/contact/route.js

Naming the file route.js ensures Next.js treats the file as an API endpoint. After creating the file, add the following snippets to it:

import { SendLayer, SendLayerError } from 'sendlayer';
import { NextResponse } from 'next/server';

export async function POST(request) {
  const body = await request.json();
  const { name, email, message } = body;

  // Check that all required parameters are parsed
  if (!name || !email || !message) {
    return NextResponse.json(
      { message: 'Missing required fields' },
      { status: 400 }
    );
  }

  try {
    // Initialize SendLayer with your API key
    const sendlayer = new SendLayer(process.env.SENDLAYER_API_KEY);

    // Send the email
    const response = await sendlayer.Emails.send({
      from: process.env.FROM_EMAIL,
      to: 'recipient@example.com',
      subject: `New message from ${name}`,
      text: `Email: ${email}\n\n${message}`,
    });

    return NextResponse.json(
      { message: 'Email sent successfully', messageId: response.MessageID },
      { status: 200 }
    );
  } catch (error) {
    console.error('Email sending error:', error);
    return NextResponse.json(
      { message: 'Failed to send email' },
      { status: 500 }
    );
  }
}

Code breakdown

First, we import the SendLayer, SendLayerError, and NextResponse libraries. NextResponse is a utility for handling API responses.

Since we are sending a request, we specify the endpoint as a "POST" request in the function name.

Then we check that the API request contains a body object and parse the JSON body to extract the name, email, and message parameters.

We initialize the SendLayer SDK with our API key from the environment variable. With Next.js, you can directly access environment variables using the process.env.ENV_NAME syntax.

After that, we call the sendlayer.Emails.send() method and pass the required parameters:

from: The sender email address
to: The recipient email address or list of recipients
subject: The email subject line
text or html: The plain or HTML content of the email message

I also added error handling using JavaScript's try catch syntax with SendLayer's built-in SendLayerError module.

Send HTML emails

In the example above, we used text for plain text emails. SendLayer also lets you send HTML emails. Here's an updated version that supports HTML content:

// ...Other code snippets

const response = await sendlayer.Emails.send({
  from: process.env.FROM_EMAIL,
  to: 'recipient@example.com',
  subject: `New message from ${name}`,
  html: `<p><strong>Email:</strong> ${email}</p><p>${message}</p>`,
  text: `Email: ${email}\n\n${message}`, // Fallback for clients that don't support HTML
});

Tip: Adding a plain text version of your email ensures your email content is visible, especially on email clients that do not support HTML content in emails.

Send email to multiple recipients

SendLayer allows you to send emails to multiple recipients. This is particularly useful when building a contact form, and you need to send a copy of the message to both the site owner and the user.

To send emails to multiple recipients in Next.js, you'll simply need to add the recipient's email addresses to the to array:

// ... Other code snippets

const response = await sendlayer.Emails.send({
  from: process.env.FROM_EMAIL,
  to: ['admin@example.com', 'recipient2@example.com', email],
  subject: `New message from ${name}`,
  html: `<p><strong>Email:</strong> ${email}</p><p>${message}</p>`,
});

SendLayer also lets you add other recipients using the Cc and Bcc features:

// ...Other code snippets

const response = await sendlayer.Emails.send({
  from: { name: 'Your Name', email: process.env.FROM_EMAIL },
  to: [
    { name: 'Recipient Name', email: 'recipient@example.com' },
  ],
  subject: `New message from ${name}`,
  html: `<p><strong>Email:</strong> ${email}</p><p>${message}</p>`,
  cc: [{ name: 'Carbon Copy', email: 'cc@example.com' }],
  bcc: ['bcc@example.com'],
});

Step 3: Create a simple contact form (Optional)

After creating the API route to send emails in your Next app, you can use it in the frontend. There are different use cases for the email backend we just created. For instance, you could create a welcome email template for new user registration.

For this tutorial, I'll create a simple contact form component to allow users to send emails to the site admin.

To do so, create a new component in the following directory:

components/ContactForm.tsx

After that, copy and paste the code below into the ContactForm file.

'use client'
import { useRef, useState } from 'react';

export default function ContactForm() {
  const formRef = useRef<HTMLFormElement>(null);
  const [status, setStatus] = useState<{
    type: 'idle' | 'loading' | 'success' | 'error';
    message: string;
  }>({ type: 'idle', message: '' });

  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    setStatus({ type: 'loading', message: 'Sending...' });

    try {
      const formData = new FormData(e.currentTarget);
      const data = {
        name: formData.get('name'),
        email: formData.get('email'),
        message: formData.get('message'),
      };

      const res = await fetch('/api/contact', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(data),
      });

      if (!res.ok) {
        throw new Error('Failed to send message');
      }

      setStatus({ type: 'success', message: 'Message sent successfully!' });
      formRef.current?.reset();
    } catch (error) {
      setStatus({ 
        type: 'error', 
        message: 'Failed to send message. Please try again.' 
      });
    }
  };

  return (
    <form ref={formRef} onSubmit={handleSubmit} className="space-y-4 max-w-md mx-auto p-6">
      <div className="space-y-2">
        <label htmlFor="name" className="block text-sm font-medium">Name</label>
        <input id="name" name="name" type="text" required className="w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" placeholder="Your name"  />
      </div>

      <div className="space-y-2">
        <label htmlFor="email" className="block text-sm font-medium">Email</label>
        <input id="email" name="email" type="email" required className="w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" placeholder="your.email@example.com" />
      </div>

      <div className="space-y-2">
        <label htmlFor="message" className="block text-sm font-medium">Message</label>
        <textarea id="message" name="message" required rows={4} className="w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" placeholder="Your message" />
      </div>

      <button type="submit" disabled={status.type === 'loading'} className="w-full bg-blue-500 text-white py-2 px-4 rounded-md hover:bg-blue-600 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 disabled:opacity-50 disabled:cursor-not-allowed">
        {status.type === 'loading' ? 'Sending...' : 'Send Message'}
      </button>

      {status.message && (
        <p
          className={`text-sm ${
            status.type === 'error'
              ? 'text-red-500'
              : status.type === 'success'
              ? 'text-green-500'
              : 'text-gray-500'
          }`}
        >
          {status.message}
        </p>
      )}
    </form>
  );
}

Code breakdown

In the snippet above, you'll notice I added the 'use-client' keyword at the top of the component. The reason is that recent versions of Next.js treat all components as server components by default.

To create a client component, you'll need to explicitly specify it using the keyword. This step is necessary because we're using the useRef and useState React hooks.

The formRef variable references the form element for direct DOM manipulation. The status state variable manages the form's submission state with TypeScript types. Below are the types I defined in the snippet:

idle: Initial state
loading: During form submission
success: After successful submission
error: If submission fails

The handleSubmit function is where we make the API request to the /api/contact/ endpoint that contains our email API.

In Next.js, you can directly call the fetch() function and specify the required parameters like the request type, URL, headers, and request body.

The request body is obtained from the form data and parsed as a JSON object.

In the return statement, we are simply rendering an HTML form element. We use the ref and onSubmit event handlers to target the form data and handle form submissions.

Tip: If you're building a contact form, you need to consider adding CAPTCHA to your form to prevent bot submissions.

Step 4: Send a test email in Next.js

After creating your email API, I recommend sending a test email to ensure it functions properly. To get started, you'll first need to start the development server:

npm run dev

There are different ways to send a test email. You can make an API call using cURL or through a third-party app like Postman. You can also use the API directly on your site's frontend.

For this tutorial, I'll use the contact form component we created above to send a test email. To start, create a page.jsx file within the following directory:

app/contact/page.jsx

After that, import the form component and add it to your page. Here's the entire snippet for the contact page:

import ContactForm from '@/app/components/ContactForm';

function Contact() {
  return (
    <div className=' h-screen items-center justify-center '>
        <h1 className='text-4xl font-bold text-center'>Contact Us</h1>
        <ContactForm />
    </div>
  )
}

export default Contact;

After that, open your browser and navigate to localhost:3000/contact. You should see the contact page component rendered in the browser.

Go ahead and fill out the form and send the message. You'll see a success alert if everything is working properly.

The email should also be sent to the recipient's inbox.

Frequently asked questions

These are answers to some of the top questions about sending emails in Next.js

How do you send emails directly from HTML?

The easiest way to send emails directly from HTML is with the mailto: protocol. This lets you configure email messages from the client. Alternatively, you can use a third-party library like EmailJS to directly send email from your frontend.

Can I send email with JavaScript?

Yes! You can send emails with JavaScript through a backend library or using transactional email services like SendLayer. Our guide on sending emails in JavaScript covers the various sending options.

Can I use SMTP instead of the SendLayer API?

Yes, you can use SMTP with Nodemailer in Next.js. However, the API approach offers several advantages:

Better error handling
Easier attachment management
More reliable delivery
Built-in rate limiting
Better performance for bulk sending

If you prefer SMTP, you can use Nodemailer's createTransport() method to connect to SendLayer's SMTP server.

Wrapping up

In this comprehensive tutorial, we've walked through everything you need to know about sending emails in Next.js.

Have questions or want to share your implementation? Drop a comment below—I'd love to hear how you're handling email in your Next.js projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first email in minutes.

How to send emails in Flask: Complete developer guide

David Ozokoye — Fri, 23 Jan 2026 09:54:07 +0000

Are you building a web application and need to send emails through your Flask backend API?

Email notifications are among the most crucial aspects of building a web application. Whether it's for user registration emails, order confirmations, or a simple contact form, email sending functionality is a must-have for any Flask web application.

In this post, I'll show you how to build an email API to send emails with the Flask framework.

How to send emails in Flask
How to send email in Flask with SMTP
How to send email in Flask with email API
Tips for better email handling
Frequently asked questions

How to send emails in Flask

There are 2 popular ways to send emails on web apps: using an SMTP server or via an Email API. I'll cover both sending methods in this guide.

Prerequisites

Below are some requirements you'll need to meet to follow along with this guide:

Python installed on your machine. I'm using Python version 3.x and recommend using it. Download the latest Python version 3 here
Knowledge of the Python programming language
An email service provider. I'm using SendLayer for this tutorial. You can get started with the trial account that lets you send up to 200 emails for free

Start your free trial at SendLayer

After creating your SendLayer account, make sure to authorize your domain. This step is essential to improve your site's email deliverability. With that, you're all set up and ready to send your first email in Python.

How to install Flask

Before proceeding, I'll briefly outline the steps to get started with Flask. If you already have a Flask app, you can skip to the sending emails section of this guide.

First, let's create a virtual environment to hold all our project's requirements. To do so, run the command below:

python3 -m venv env

Then activate the virtual environment using the command:

source env/bin/activate  # On Windows use: env\Scripts\activate

After activating the virtual environment, run the command below to install Flask and dotenv libraries:

pip install Flask python-dotenv

Once the installation completes, create the following files in your project directory:

flask-email/
├── app.py
├── .env
├── templates/
│   └── email.html

After that, open the app.py in your preferred code editor and add the snippet below:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({'message': 'Hello World'})

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

The snippet above is the basic implementation of a Flask server. We initialize the app using the app = Flask(__name__) command. To create a route/endpoint, we use the @app.route() decorator. Within the parentheses, you'll need to specify the route, e.g., '/api/email'.

After that, proceed to create a function to define the API request functionality, including the request and response format.

Finally, we activate the server using the app.run() command. Setting debug to True means you'll see server errors as they occur in your Flask app. You'll need to set debug to False in production to avoid revealing sensitive server details to your app users.

How to send email in Flask with SMTP

Python provides a built-in smtplib library for sending emails through an SMTP server. I explained how it works in a separate tutorial. You can check out our sending emails in Python tutorial for more details.

For this Flask tutorial, I'll use the Flask-Mail library, which offers more features and integrates seamlessly with Flask. To proceed, install the library using the command below:

pip install Flask-Mail

After that, create a .env file within your project's directory or open the existing one and add the following SMTP configuration:

MAIL_SERVER=smtp.sendlayer.net
MAIL_PORT=587
MAIL_SENDER=sender@example.com
MAIL_USERNAME=your-smtp-username
MAIL_PASSWORD=your-smtp-password
MAIL_USE_TLS=True
MAIL_USE_SSL=False

Tip: Don't commit .env files to version control platforms like GitHub to avoid revealing sensitive credentials publicly.

You'll need to replace the configuration details with your SMTP credentials. I used SendLayer for this tutorial, but you can use Gmail SMTP or any email service provider you like.

Here's how to retrieve your SMTP credentials if you're using SendLayer.

Start by logging in to your SendLayer account. Once logged in, select the Settings sidebar menu and navigate to the SMTP Credentials tab.

You'll see the SMTP credentials required to use SendLayer's SMTP server. The Host and Port number are the same for all users. However, the Username and Password details are unique to your SendLayer account. Go ahead and replace the MAIL_USERNAME and MAIL_PASSWORD values with your SMTP details.

Tip: The MAIL_SENDER is your sender email address. This email needs to be at the domain you've verified in SendLayer. If you authorized example.com in your SendLayer account, the sender email should include @example.com.

Send plain text emails

After adding your SMTP credentials, you're ready to send your first email. To start, open your app.py file and paste the snippet below:

from flask import Flask, request, jsonify
from flask_mail import Mail, Message
from dotenv import load_dotenv
import os

load_dotenv()

# Python flask app initialization
app = Flask(__name__)

# Email config
app.config['MAIL_SERVER'] = os.getenv('MAIL_SERVER')
app.config['MAIL_PORT'] = int(os.getenv('MAIL_PORT'))
app.config['MAIL_SENDER'] = os.getenv('MAIL_SENDER')
app.config['MAIL_USERNAME'] = os.getenv('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.getenv('MAIL_PASSWORD')
app.config['MAIL_USE_TLS'] = os.getenv('MAIL_USE_TLS') == 'True'
app.config['MAIL_USE_SSL'] = os.getenv('MAIL_USE_SSL') == 'True'

mail = Mail(app)

#flask-mail example route
@app.route('/send-email', methods=['POST'])
def send_email():
    data = request.json
    msg = Message(subject=data['subject'],
                  sender=app.config['MAIL_SENDER'],
                  recipients=[data['to']],
                  body=data['message'])
    mail.send(msg)
    return jsonify({"message": "Email sent successfully!"})

if __name__ == '__main__':
    app.run(debug=True) # Set debug=False in production

Code breakdown

In the code above, we first import Flask and request from the flask framework. Then import the Mail and Message modules from flask_mail.

After that, we initialize the Flask app using the command app = Flask(__name__). We use the app.config[] to set the SMTP credentials. These details are retrieved from the .env file we created using the dotenv library.

Next, we initialize the mail client using the mail = Mail(app) command. After that, I created a new post route to handle sending emails.

Within the send_email() function, we create an email object using the Message module. Then, pass the email parameters as arguments in the Message method. For this example, I've set the parameters to be passed as request parameters when running the server.

We then call the mail.send() method and pass the msg object as its parameter.

Send HTML emails using Flask

Flask Mail allows sending HTML email by specifying the html parameter within the Message module. Here's an example:

# Other Flask code snippet...

@app.route('/send-html-email', methods=['POST'])
def send_html_email():
    data = request.json
    msg = Message(subject="This is a test HTML Email",
                  sender=app.config['MAIL_SENDER'],
                  recipients=['recipient@example.com'],
                  html="<html><body><p>This is a test email sent with the <a href=\"https://sendlayer.com\">SendLayer</a> SMTP server!</p></body></html>")
    mail.send(msg)
    return "Email sent successfully!"

Send email to multiple recipients

To send emails to multiple recipients, simply enter each recipient's email address into the recipients list.

# Other Flask code snippet...

msg = Message(subject="This is a test HTML Email",
             sender=app.config['MAIL_SENDER'],
             recipients=['recipient1@example.com', 'recipient2@example.com', 'recipient3@example.com'],
             body="This is a test email sent with Flask using SendLayer SMTP server")

Send email with attachments

You can also attach files to your emails. This is handy if you'd like to send invoices or event tickets through your Flask application to users.

To include attachments, you'll need to use the open_resource() function to process the file. Then use the msg.attach() method to add the file to your email message.

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

Note: The app.open_resource() method works if the attachment files are in a folder managed by Flask (e.g., static).

If the file is in a different directory, then you'll need to use Python's open() method to access the file before attaching it to your email. Here's an example:

with open("path/to/file.pdf", "rb") as fp:
    msg.attach("file.pdf", "application/pdf", fp.read())

Tip: Make sure to choose the right MIME type for your attachment file.

Send a test email

Since the API endpoint we just created accepts request parameters, you can test it by sending a cURL command, or using Postman. You can also test it by making API requests through frontend libraries like React or Next.js.

I'll make a cURL request for this example. To get started, start the Flask development server using the command:

python app.py

This will start a local development server running on port 5000. With the server running, open a terminal window and send the command below:

curl -X POST http://localhost:5000/send-email \
  -H "Content-Type: application/json" \
  -d '{
    "to": "recipient@example.com",
    "subject": "Test Email from Flask",
    "message": "This is a test email sent using Flask-Mail"
  }'

Be sure to update the "to", "subject", and "message" parameters to match your email data. Once done, send the cURL request. You should get a success notification.

When you open the email inbox of the recipient you specified, you should receive an email message if everything is configured properly.

Send email in Flask without app context

Sometimes you may need to send emails in Flask without app context, such as from background tasks or scheduled jobs. Here's how to handle this scenario:

from flask import Flask
from flask_mail import Mail, Message

def send_email_outside_context(app, subject, recipient, body):
    with app.app_context():
        mail = Mail(app)
        msg = Message(subject=subject,
                      sender=app.config['MAIL_SENDER'],
                      recipients=[recipient],
                      body=body)
        mail.send(msg)

This approach is particularly useful when working with task queues or cron jobs in your Python Flask application.

How to send email in Flask with email API

Sending emails through SMTP works well for smaller projects. However, it is less secure and slower when compared to using an API-based email provider.

Also, if you want to send emails in Flask for free, many API providers offer generous free tiers that exceed what's available through traditional SMTP services.

Platforms like SendLayer provide API endpoints and SDKs you can use to send single and bulk emails programmatically. I'll show you how to set up a program that uses the SendLayer email API to send emails.

Start your free trial at SendLayer

To use SendLayer's email API, you'll need to copy your API key from the SendLayer account dashboard. Here's how to retrieve it:

First, log in to your SendLayer account and navigate to the Settings » API Keys page.

Once here, click the copy icon next to Default API key to copy its value.

Next, open the .env file in your Flask project and paste it using the format below:

SENDLAYER_API_KEY=your-sendlayer-api-key

Send HTML email with SendLayer API

To get started, open your terminal window and run the command below to install the SendLayer SDK:

pip install sendlayer

After installing the SDK, open your app.py file and import and initialize the SendLayer module:

from flask import Flask, request
from dotenv import load_dotenv
import os

#sendlayer SDK import
from sendlayer import SendLayer

load_dotenv()

#Initialize the SendLayer module with your API key
sendlayer = SendLayer(os.getenv('SENDLAYER_API_KEY'))

After that, create a new API endpoint to handle sending emails on your Flask app. Here's the complete snippet:

from flask import Flask, request
from sendlayer import SendLayer
from dotenv import load_dotenv
import os

load_dotenv()

#Initialize the SendLayer module with your API key
sendlayer = SendLayer(os.getenv('SENDLAYER_API_KEY'))

app = Flask(__name__)

@app.route('/api/send-email', methods=["POST"])
def send_api_email():

    params = {
        "sender": "paulie@example.com",
        "to": "recipient@example.com",
        "subject": "Test Email via SendLayer API",
        "html": "<html><body><p>This is a test email sent with the <a href=\"https://sendlayer.com\">SendLayer</a> API!</p></body></html>"
    }
    message = sendlayer.Emails.send(**params)

    return f'Email sent successfully: {message}'

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

Code breakdown

In the code above, we initialize the SendLayer module using the API key value we stored in the .env file.

Then created a new route /api/send-email to handle sending emails through the API. Within the send_api_email() function, we specify the email parameters in the params variable. Then call the sendlayer.Emails.send() method and pass the params variable as the argument.

Send email to multiple recipients

SendLayer API allows you to send emails to multiple recipients, including CC and BCC email addresses. To send to multiple recipients, simply add each recipient's email to the to parameter. Here's an example:

params = {
    "sender": "paulie@example.com",
    "to": ["recipient1@example.com", "recipient2@example.com", "recipient3@example.com"],
    "subject": "Test Email via SendLayer API",
    "text": "This is a test email sent via SendLayer API",
    "cc": ["cc1@example.com", "cc2@example.com"]
}

Note: SendLayer API limits the number of recipient emails that can be added per API request. See our developer documentation to learn about these limits.

Send email with attachments

You can also include attachment files to emails sent through SendLayer's API. To send emails with attachments, add the attachments list to the params variable. Within the attachments list, specify the path and type fields. Here is an updated version of the email params field:

params = {
    "sender": "paulie@example.com",
    "to": "recipient@example.com",
    "subject": "Test Email via SendLayer API",
    "html": "<html><body><p>This is a test email sent with the <a href=\"https://sendlayer.com\">SendLayer</a> API!</p></body></html>",
    "attachments": [
        {
            "path": "path/to/file.pdf",
            "type": "application/pdf"
        }
    ]
}

Tip: You can attach multiple files by adding a new JSON object with the path and type parameter within the attachments list. Keep in mind that the size limit per email is 10MB.

Tips for better email handling

When integrating email functionality into your Flask web application, it's crucial to follow specific tips to ensure optimal performance. Here are a few useful tips:

1. Validate emails

Your email implementation should include sender and recipient email validation. This helps to prevent errors and optimize API usage. If you're using SendLayer SDK, we've added built-in support for email address validation. This means your app won't send an API request if any of the email addresses in the payload are invalid.

2. Use HTML templates

Most often, you'll likely want to send HTML emails. Flask supports HTML templates out of the box. And you can use them using Flask's render_template() syntax. To use HTML templates, first create a file in the following directory templates/email/welcome.html. Here is an example template:

<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
        .header { background-color: #4CAF50; color: white; padding: 20px; text-align: center; }
        .content { padding: 20px; background-color: #f4f4f4; }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>Welcome, {{ name }}!</h1>
        </div>
        <div class="content">
            <p>Thank you for signing up. We're excited to have you on board.</p>
            <p>Your username is: <strong>{{ username }}</strong></p>
            <p>Click <a href="{{ confirmation_link }}">here</a> to confirm your account.</p>
        </div>
    </div>
</body>
</html>

Then, in your app.py file, create a dynamic email function that accepts a template name as a parameter:

from flask import render_template

def send_email(subject, recipient, template, **kwargs):
    """Send an email using a template."""
    msg = Message(
        subject=subject,
        recipients=[recipient]
    )

    # Render HTML version
    msg.html = render_template(f'email/{template}.html', **kwargs)

    mail.send(msg)

You can now call the function in your API route and specify the template name:

@app.route('/register', methods=['POST'])
def register():
    # Your registration logic here
    name = request.form.get('name')
    email = request.form.get('email')
    username = request.form.get('username')

    # Send welcome email
    send_email(
        subject='Welcome to Our App!',
        recipient=email,
        template='welcome',
        name=name,
        username=username,
        confirmation_link='https://example.com/confirm/12345'
    )

    return 'Registration successful! Check your email.'

3. Apply rate limits

Most email service providers include rate limits in their API. To avoid hitting the limit for your account, I recommend implementing a custom rate limit in your email API that's lower than the limit your email provider allows. That way, you avoid getting blocked by the email provider.

4. Implement error handling

Adding error handling to your email API is essential to catch errors in your implementation. Here's how to add error handling using Python's try except syntax:

@app.route('/send-email', methods=['POST'])
def send_email():
    try:
        data = request.json
        msg = Message(subject=data['subject'],
                      sender=app.config['MAIL_SENDER'],
                      recipients=[data['to']],
                      body=data['message'])
        mail.send(msg)
        return {"message": "Email sent successfully!"}, 200
    except Exception as e:
        return {"error": str(e)}, 500

Frequently asked questions

These are answers to some of the top questions we see about sending emails in Flask.

Can I use Flask-Mail with Gmail?

Yes, Flask-Mail Gmail integration is straightforward. You'll need to use Gmail's SMTP settings (smtp.gmail.com, port 587) and generate an app-specific password from your Google account.

How do I send emails with attachments?

If you're using the Flask-Mail library, simply add the .attach() method to your message object. However, you'll first need to access and read the attachment file before attaching it. See the sending emails with attachment section for more details.

Why am I getting "SMTPAuthenticationError" when trying to send emails?

This error is SMTP-related and indicates invalid SMTP credentials. To troubleshoot this error, double-check that your SMTP username and password are correct. If your SMTP provider requires an app-specific password, like Gmail SMTP, make sure you're using an app password and not your Gmail account password.

Why are my HTML emails showing as plain text?

It might occur if you're using msg.body instead of msg.html to add your HTML content. Also, some email clients do not support HTML emails, leading to your emails converting to plain text in the user's inbox.

What's the difference between Flask-Mail and Flask-Mailman?

Both are excellent libraries for email sending in Flask web applications. Flask Mail is simpler and well-established, while Flask Mailman offers additional features like better async support and more flexible configuration options.

Wrapping up

In this comprehensive tutorial, we've walked through everything you need to know about sending emails in Flask.

Drop a comment below if you have questions or share how you're implementing email functionality in your Flask projects!

Ready to implement this in your Flask application? Start your free trial at SendLayer and send your first email in minutes.

How to Send Email in FastAPI (+Code Snippets)

David Ozokoye — Wed, 24 Dec 2025 09:09:24 +0000

Are you building a web application and need to send emails through your FastAPI backend server?

Email notifications are among the most crucial aspects of building a web application. Whether it's for user registration emails, password resets, or a simple contact form, email sending functionality is a must-have for any FastAPI web application.

In this post, I'll show you how to build an email API to send emails with the FastAPI framework.

How to Send Emails in FastAPI
Method 1: Send Emails with FastAPI Using API
Method 2: Sending Emails in FastAPI Using SMTP
Best Practices for Email Sending in FastAPI
Frequently Asked Questions

How to Send Emails in FastAPI

Prerequisites

Before we jump into the code, let's make sure you're set up for success. I'll assume you have a foundational understanding of:

Python: You should be comfortable with Python syntax, functions, and data types
FastAPI: A basic grasp of creating routes, using Pydantic models, and running a FastAPI application is necessary
An email service provider: I'll use SendLayer for this tutorial. But this tutorial works with any email service provider

Start your free trial at SendLayer

Setting Up the FastAPI Project

First things first, let's get a clean Python FastAPI project up and running. If you already have one, you can skip to the sending email section of this guide.

To start, open your terminal, create a new directory for your project, and navigate into it.

mkdir fastapi_email
cd fastapi_email

Now, let's create and activate a virtual environment.

# For macOS/Linux 
python3 -m venv venv 
source venv/bin/activate 

# For Windows 
python -m venv venv 
.\venv\Scripts\activate

With our environment active, we need to install FastAPI and an ASGI server like Uvicorn to run it. I also added python-dotenv and Pydantic to the installation command. The dotenv library allows us to secure sensitive credentials as environment variables, and Pydantic lets us create models for our route.

pip install fastapi uvicorn python-dotenv "pydantic[email]"

After the installation completes, create a main.py inside your project's directory. This will be the entry point for our application. Let's start with a simple "Hello World" endpoint to ensure everything is working correctly.

# main.py 
from fastapi import FastAPI 

app = FastAPI() 

@app.get("/") 
def read_root(): 
      return {"message": "Welcome to the FastAPI Email Demo!"}

Now, run the application using Uvicorn in a terminal window.

uvicorn main:app --reload

The --reload flag automatically restarts the server whenever you make changes to your code. If you open your browser and navigate to http://127.0.0.1:8000, you should see our welcome message.

You can navigate to http://127.0.0.1:8000/docs to see the interactive API documentation provided by Swagger UI.

This is one of my favorite features of FastAPI. It provides automatic documentation that's perfect for testing, especially when you need to send email in FastAPI JSON format, as it generates the request form for you.

Great! Our foundation is laid. Now, let's get to the main event.

Method 1: Send Emails with FastAPI Using API

For most production applications, using a dedicated third-party email service is the recommended path. These services are experts in email deliverability. They handle all the complexities of SMTP servers, reputation management, and scaling for you.

Benefits include:

Higher Deliverability: Their core business is making sure emails reach the inbox.
Scalability: They can handle sending thousands or millions of emails without a sweat.
Analytics: Get detailed reports on open rates, click rates, and bounces.
Simple APIs: They provide clean, easy-to-use APIs that are much simpler than raw SMTP.

For this example, I'll use SendLayer to build an API-based email functionality in our FastAPI server.

Integrating with SendLayer

SendLayer is a modern email API for developers that's incredibly simple to integrate. They offer a flexible pricing plan and let you get started for free.

One of the standout features of SendLayer is its domain reputation protection. It automatically creates a subdomain for your email sending activities. This means your main domain remains protected from any potential deliverability issues. This helps to maintain your sender reputation so your emails stay out of the spam folder.

Start your free trial at SendLayer

To use SendLayer, you'll need to create or retrieve your API key. For this, log in to your SendLayer account. Once you're logged in, click the Settings sidebar menu and select the API Keys tab.

Then click the copy icon next to Default API key to copy it.

After copying the API key, return to your code editor and add it to the .env file.

SENDLAYER_API_KEY=your-api-key
SENDER_EMAIL=paulie@example.com

Note: The sender email domain needs to match the domain you authorized in your SendLayer account. For instance, if you authorized example.com in SendLayer, the from email needs to use @example.com extension.

Once done, you'll need to install the SendLayer Python SDK as a requirement for your project:

pip install sendlayer

Sending HTML Emails in FastAPI with SendLayer SDK

Sending an email with SendLayer is refreshingly straightforward. In a real-world application, you'd typically generate your email content from HTML templates using an engine like Jinja2. This allows you to create a dynamic FastAPI email template.

Let's create a new sendlayer_service.py file and add our email logic to it.

# sendlayer_service.py

from sendlayer import SendLayer
from dotenv import load_dotenv
import os

load_dotenv()

api_key = os.getenv("SENDLAYER_API_KEY")

sendlayer = SendLayer(api_key)

def sl_send_email(recipient: str, subject: str, body: str, is_html: bool = False):
    """
    Send an email using Sendlayer API.

    Args:
        recipient: The recipient's email address
        subject: The subject of the email
        body: The body content of the email
        is_html: Whether the body content is HTML

    """

    params = {
        "sender": os.getenv("SENDER_EMAIL"),
        "to": recipient,
        "subject": subject,
        "html": body if is_html else None,
        "text": body if not is_html else None
    }

   # sending mail using FastAPI and SendLayer SDK
    try:
        response = sendlayer.Emails.send(**params)  
        return response
    except Exception as e:
        print(f"Failed to send email. Error: {e}")

Look at how much cleaner that is! We define our parameters in a dictionary and call sendlayer.Emails.send(). SendLayer's SDK handles the rest. The email params will be parsed as arguments when calling the sl_send_email() function.

Creating a Route to Use the Email Function

With the email functionality in place, what's left to do is create a new route and call the sl_send_email() function inside the new post route. To do so, open the main.py file and add the following code to create a new route.

from fastapi import FastAPI, HTTPException, Body
from pydantic import BaseModel, EmailStr
from sendlayer_service import sl_send_email      # import the sendlayer email function

app = FastAPI(title="Email Sender API")

# create an endpoint request 
class SendlayerEmailRequest(BaseModel):
    recipient: EmailStr
    subject: str
    body: str
    is_html: bool = False

@app.get("/")
async def root():
    return {"message": "Welcome to the Email Sender API"}

# new route to send emails via SendLayer SDK
@app.post("/send-api-email/")
async def send_api_email(email_req: SendlayerEmailRequest):
    """
    Send an email using Sendlayer API.
    """
    success = sl_send_email(
        recipient=email_req.recipient,
        subject=email_req.subject,
        body=email_req.body,
        is_html=email_req.is_html
    )

    if not success:
        raise HTTPException(status_code=500, detail="Failed to send email")

    return {"message": success}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

In the code above, we first import the email function (sl_send_email()) from the sendlayer_service.py file. The SendlayerEmailRequest model in the code above is used to define the request schema.

We use this schema to define the type of object the API route should accept. Within the send_api_email() function, we call the email function. Mapping the request body parameters to the arguments the function requires.

Send Email to Multiple Recipients

SendLayer SDK also supports sending emails to multiple recipients, including "CC" and "BCC" email addresses. To send to multiple recipients, update the request schema to allow a list of EmailStr type.

# main.py
# ... other code snippets

class SendlayerEmailRequest(BaseModel):
    recipient: list[EmailStr]   # change the type to support list of email strings
    subject: str
    body: str
    is_html: bool = False

Then, when using the API, you can pass the recipients in a comma-separated string list. If you're passing the email addresses directly within the email service, you'll need to update the params object.

# sendlayer_service.py
# ... Other code snippets 

   params = {
        "sender": os.getenv("SENDER_EMAIL"),
        "to": [
             {"name": "Recipient 1", "email": "recipient1@example.com"},
             {"name": "Recipient 2", "email": "recipient2@example.com"}
         ],
        "subject": subject,
        "html": body if is_html else None,
        "text": body if not is_html else None,
        "cc": ["cc@example.com"],
        "bcc": [
             {"name": "BCC ", "email": "BCC@example.com"}
         ],
    }

Just be sure to update the email addresses to match the recipient addresses you'd like to send to.

Tip: SendLayer includes limits on the number of recipients you can include for each API request. See the developer documentation to learn about these limits.

Send Emails With Attachments in FastAPI

SendLayer API also supports sending emails with attachments. Here is the updated params object.

# sendlayer_service.py
# ... Other code snippets 

   params = {
        "sender": os.getenv("SENDER_EMAIL"),
        "to": [
             {"name": "Recipient 1", "email": "recipient1@example.com"},
             {"name": "Recipient 2", "email": "recipient2@example.com"}
         ],
        "subject": subject,
        "html": body if is_html else None,
        "text": body if not is_html else None,
        "attachments": [
             {
               "name": "path/to/file.pdf ", 
              "type": "application/pdf"
             }
         ],
    }

In the updated file, I added attachments to the params object. Within the attachment list, you'll specify a dictionary with the path and type of the file you wish to attach.

The path object is a string with the path to the file you wish to attach. SendLayer's SDK supports both local and remote file attachments. The type object is the MIME type for the file you're attaching.

Tip: Not sure what MIME type to specify, see Mozilla's guide to media types for more details.

You can attach multiple files to emails on your site. To do so, simply duplicate the attachment object within the list, separating each object with a comma.

Method 2: Sending Emails in FastAPI Using SMTP

SMTP, or Simple Mail Transfer Protocol, is the standard internet protocol for sending electronic mail. Using SMTP directly gives you full control over the process, but it also comes with more responsibility.

Python's standard library includes a powerful module called smtplib, which allows us to communicate directly with an SMTP server.

Step 1: Configuring SMTP Settings

To send an email, you need credentials for an SMTP server. For this example, we'll use SendLayer's SMTP server. But you can use any SMTP provider you want.

To get started with SendLayer, you'll need to access the login credentials for your SMTP account.

For this, log in to your SendLayer account and select the Settings sidebar menu. Then select the SMTP Credentials tab.

You'll see the SMTP credentials required to use SendLayer's SMTP server. The Host and Port number are the same for all users. However, the Username and Password details are unique to your SendLayer account.

Create a .env file and store your SMTP credentials inside it.

EMAIL_HOST=smtp.sendlayer.net
EMAIL_PORT=587
EMAIL_USER=your-sendlayer-username
EMAIL_PASS=your-sendlayer-password
SENDER_EMAIL=info@example.com

Be sure to replace the details with your actual SMTP credentials.

Step 2: Implementing Email Sending with smtplib

Let's write a function to handle the email sending logic. For this, I'll create an email_service.py file to handle the email logic.

# email_service.py (add these imports)
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from dotenv import load_dotenv
import os

# Load environment variables
load_dotenv()

EMAIL_HOST = os.getenv("EMAIL_HOST")
EMAIL_PORT = os.getenv("EMAIL_PORT")
EMAIL_USER = os.getenv("EMAIL_USER")
EMAIL_PASS = os.getenv("EMAIL_PASS")
SENDER_EMAIL = os.getenv("SENDER_EMAIL")


def send_email_smtp(recipient: str, subject: str, body: str, is_html: bool = False):
    """
    Send an email using SMTP.

    Args:
        recipient: The recipient's email address
        subject: The subject of the email
        body: The body content of the email
        is_html: Whether the body content is HTML

    Returns:
        bool: True if email is sent successfully, False otherwise
    """

    # Create the email message
    msg = MIMEMultipart()
    msg['From'] = SENDER_EMAIL
    msg['To'] = recipient
    msg['Subject'] = subject
    msg.attach(MIMEText(body, 'plain' if not is_html else 'html'))

    try:
        # Connect to the SMTP server
        # We use a 'with' statement to ensure the connection is automatically closed
        with smtplib.SMTP(EMAIL_HOST, EMAIL_PORT) as server:
            server.starttls()  # Secure the connection with TLS
            server.login(EMAIL_USER, EMAIL_PASS)
            server.sendmail(SENDER_EMAIL, [recipient], msg.as_string())
        print(f"Email sent successfully to {recipient}")
        return True
    except Exception as e:
        print(f"Failed to send email. Error: {e}")
        return False

Code Breakdown

MIMEMultipart & MIMEText: These classes help us construct an email message that conforms to the MIME standard. MIMEMultipart is the main container, and we attach a MIMEText part for the body. This structure also makes it easy to add HTML content or attachments later.
smtplib.SMTP(): This creates an instance of the SMTP client, connecting to the specified server and port.
with statement: This is crucial. It ensures that the connection to the SMTP server is properly closed, even in the event of errors.
server.starttls(): This command upgrades our insecure connection to a secure one using TLS encryption. It's a vital security step.
server.login(): We authenticate with the server using the SMTP username and password stored in the .env file.
server.sendmail(): This is the command used to send the email.
Error Handling: We use Python's try...except block to catch potential issues like incorrect credentials, network problems, or server-related errors.

Python's smtplib package enables you to send emails to multiple recipients, include attachments, and perform various other functions. We've covered this in detail in a previous tutorial. Be sure to check our sending emails in Python tutorial for more details.

Step 3: Creating an Email Endpoint

Now, let's integrate this email functionality into our FastAPI application by updating main.py:

# main.py

from fastapi import FastAPI, HTTPException, Body
from pydantic import BaseModel, EmailStr
from email_service import send_email_smtp

app = FastAPI(title="Email Sender API")

class EmailRequest(BaseModel):
    email: EmailStr
    subject: str
    body: str
    is_html: bool = False

@app.get("/")
async def root():
    return {"message": "Welcome to the Email Sender API"}

@app.post("/send-email/")
async def send_email_endpoint(email_req: EmailRequest):
    """
    Send an email using SMTP.
    """
    success = send_email_smtp(
        recipient=email_req.email,
        subject=email_req.subject,
        body=email_req.body,
        is_html=email_req.is_html
    )

    if not success:
        raise HTTPException(status_code=500, detail="Failed to send email")

    return {"message": f"Email sent to {email_req.email}"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

Here, we use a Pydantic BaseModel to define our email model. This is used to specify the required parameters for the route. We use Pydantic's EmailStr class to add basic email format validation to the request.

The send_email_endpoint() function handles the API requests to the email route. It accepts the body parameter, which is an abstraction of the EmailRequest model.

Within the function, we call our email function, send_email_smtp(). Recall that our email function accepts 4 arguments. In our implementation, we destructure the input from the API request and map them to the required parameters in our email function.

Step 4: Sending a Test Email

After building your email functionality and adding it to a FastAPI route, you can integrate it into Frontend libraries like React or Next.js.

You can also call the API via cURL or interact with it via the auto-generated Swagger API docs. Here's how to send a test email through the Swagger doc page:

Start by initializing your FastAPI app with the command below:

python main.py

This command is valid because we've initialized the uvicorn server within the main.py file. Using the uvicorn main:app --reload command would work as well.

With the server running, navigate to localhost:8000/docs in your browser. You'll see the new endpoint you created in the Swagger page.

From there, click the Try it out button to send a test request.

After that, update the Request body field with your email parameters. Then scroll down and click the Execute button.

You should see a 200 success response if everything is working properly.

Go ahead and check your email inbox for a message from your FastAPI app.

Congratulations! You've successfully built a working SMTP email server in FastAPI.

Best Practices for Email Sending in FastAPI

Now that you know the "how," let's talk about the "how to do it right."

Secure Your Credentials with Environment Variables

Never commit API keys, passwords, or other secrets to your version control (like Git). The standard practice is to use environment variables.

You can use the python-dotenv package to make this easy during development:

pip install python-dotenv

After installing the package, create a .env file in your project root and add all sensitive credentials there:

# .env file 
MAIL_USERNAME=your-smtp-username
MAIL_PASSWORD=your-smtp-password 
SENDER_EMAIL=paulie@example.com
SENDLAYER_API_KEY=your_api_key

Now, you can load these securely in your application:

# main.py 
from dotenv import load_dotenv 
import os 

load_dotenv() # Loads variables from .env file 

# Example for SendLayer API 
sendlayer = SendLayer(os.getenv("SENDLAYER_API_KEY"))

Pro Tip: Remember to add your .env file to your .gitignore!

Handle Exceptions and Errors Gracefully

Network connections can fail. APIs can go down. Your code should be resilient. Always wrap your email-sending logic in try...except blocks. Log the errors using Python's logging module so you can diagnose problems in production.

Validate Email Addresses

Pydantic's EmailStr is great for basic email format validation. For more robust validation (e.g., checking if the domain exists), you might consider a validation service or library.

Additionally, most third-party email packages like SendLayer's Python SDK include email validation for the sender, recipient, and other email addresses, including CC and BCC addresses.

Frequently Asked Questions

These are answers to some of the top questions we see about implementing email sending in FastAPI.

How can I send emails asynchronously in FastAPI?

You can send emails asynchronously by using FastAPI's BackgroundTasks. This adds the email-sending function to a background queue, allowing your API endpoint to immediately return a response to the user without waiting. This is the recommended approach for any potentially slow task to ensure a non-blocking, responsive API.

Is it possible to send bulk emails using FastAPI?

Yes, but it should almost always be done as a background task. For large volumes, it is highly recommended to use a third-party service that has a dedicated bulk sending API. They are optimized for this and can manage throttling and recipient lists much more efficiently than a manual loop in your application.

How can I ensure my emails are not marked as spam?

Ensuring emails are not marked as spam is a multi-step process:

Authentication: Properly set up SPF, DKIM, and DMARC records for your sending domain.
Reputation: Use a reputable third-party email service like SendLayer.
Content: Avoid spammy words, broken HTML, or large images with little text in your email message.
Engagement: Provide clear unsubscribe links and regularly clean your email lists.

Wrapping Up

In this comprehensive tutorial, we've walked through everything you need to know about sending emails with FastAPI.

Have questions or want to share your implementation? Drop a comment below—I'd love to hear how you're handling email in your FastAPI projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first email in minutes.

How to Send Emails in Ruby - Complete Guide with Code Examples

David Ozokoye — Mon, 22 Dec 2025 09:38:10 +0000

Do you need to add email functionality to your Ruby application?

Whether you're building user authentication, notification systems, or contact forms, sending emails is a fundamental feature that every developer needs to master.

In this comprehensive Ruby email tutorial, I'll show you 2 ways to send email in Ruby app.

How to Send Email with Ruby
How to Send Emails in Ruby Using the Mail Gem
How to Send Emails in Ruby Using Email API
Frequently Asked Questions

How to Send Email with Ruby

There are different ways to send emails using Ruby. If you're using Ruby on Rails, you can integrate quickly with the ActionMailer gem. This guide will focus on sending methods for vanilla Ruby applications.

Prerequisites

Before diving into the email implementations, make sure you have:

Ruby installed (version 3.1 or higher recommended)
Basic Ruby programming knowledge
A text editor or IDE of your choice
An email service provider

You can use any email service provider you want. However, for this tutorial, I'll use SendLayer's SMTP credentials when implementing the email function.

SendLayer is one of the leading email service providers that lets you send emails easily and integrates with any application.

One of the standout features I like is the domain reputation protection. SendLayer automatically creates a subdomain to handle email sending activities. This thereby protects your main domain from any deliverability issues.

SendLayer offers a free account that allows users to send up to 200 emails per month. The pricing plan is also flexible, starting at $5 monthly.

Start your free trial at SendLayer

How to Send Emails in Ruby Using the Mail Gem

The Ruby Mail gem is a customizable library that gives you control over your email implementation. It is perfect for Ruby applications outside of Rails. Here's how to get started with the Mail gem.

Installation and Setup

To start, you'll need to install the Mail gem as a dependency to your project. To install it, open a terminal window and run the command below:

gem install mail

Tip: Prefix the command with sudo if you encounter permission issues when installing the Mail Ruby gem.

Once the installation completes, you should see a success notification in your terminal window.

Basic Email Configuration

Before you can send an email, you'll need to configure your SMTP server. Here's how to configure the Mail gem with SendLayer SMTP. Start by creating an email_service.rb file in your project's directory.

touch email_service.rb

Then open the file with a code editor. Once open, copy and paste the code below to the email service file:

require 'mail'

Mail.defaults do
  delivery_method :smtp, {
    address: 'smtp.sendlayer.net',
    port: 587,
    user_name: 'your_sendlayer_username',
    password: 'your_sendlayer_password',
    authentication: 'plain',
    enable_starttls_auto: true
  }
end

You'll need to retrieve your SMTP credentials from the email provider you chose. In SendLayer, you'll be able to access these details from your account area.

Once logged in, navigate to the Settings sidebar menu. Then select the SMTP Credentials tab.

Go ahead and replace user_name and password in the snippet above with your actual credentials.

Pro Tip: Never commit sensitive credentials to version control platforms. Always use environment variables.

After updating your SMTP credentials, you're ready to start sending emails.

Sending Plain Text Emails

Here's a basic implementation for sending text emails:

require 'mail'

class EmailService
  def self.configure_smtp
    Mail.defaults do
      delivery_method :smtp, {
        address: 'smtp.sendlayer.net',
        port: 587,
        user_name: ENV['SENDLAYER_USERNAME'],
        password: ENV['SENDLAYER_PASSWORD'],
        authentication: 'plain',
        enable_starttls_auto: true
      }
    end
  end

  def self.send_welcome_email(user_email, user_name)
    welcome_message = generate_welcome_message(user_name)

    mail = Mail.new do
      from     'paulie@example.com'
      to       user_email
      subject  'Welcome to Our Platform!'
      body     welcome_message
    end

    mail.deliver!
    puts "Welcome email sent to #{user_email}"
  rescue Mail::SMTPError => e
    puts "Failed to send email: #{e.message}"
  end

  private

  def self.generate_welcome_message(name)
    <<~MESSAGE
      Hello #{name},

      Welcome to our platform! We're excited to have you join our community.

      You can log in to your account at: https://yourdomain.com/login

      If you have any questions, please don't hesitate to contact our support team.

      Best regards,
      The Team
    MESSAGE
  end
end

Code breakdown

The configure_smtp method sets up the mail delivery configuration using Mail.defaults. We specify the SMTP details, including the address (smtp.sendlayer.net), port (587 for TLS), authentication credentials from environment variables, and enable STARTTLS for secure transmission.

The send_welcome_email method creates a new Mail object using a block syntax. We set the sender address with from, recipient with to, email subject, and generate the email body by calling a private helper method.

The mail.deliver! method actually sends the email through the configured SMTP server. The exclamation mark indicates this method will raise an exception if delivery fails.

Error handling is implemented using a rescue block that catches Mail::SMTPError exceptions. When an SMTP error occurs during delivery, it prints a failure message instead of crashing the application.

The private generate_welcome_message method uses Ruby's heredoc syntax (<<~MESSAGE) to create a multi-line string template. The ~ removes leading whitespace, making the code more readable while preserving the email formatting.

Send a Test Email

The next step after implementing the email function is to call the class. Let's create a main.rb file that'll send the message. After that, copy and paste the code below into the file:

# importing the email service
require_relative 'email_service'

# configure SMTP settings
EmailService.configure_smtp

# send welcome email
EmailService.send_welcome_email('pattie@example.com', 'Pattie Paloma')

In the snippet above, we first import the email service file. Then call the configure_smtp() method to initialize the SMTP connection. Finally, we call the send_welcome_email() method to send the email. This method accepts 2 parameters: the recipient's email address and name.

To run the script, open a terminal window and run the command:

ruby main.rb

You should see a welcome email delivered to the specified email address with personalized content.

Sending an HTML Email

The Mail gem also supports HTML content with embedded CSS. This is ideal for brands looking to send newsletter content to users. To send HTML emails, you'll need to use the html_part property when defining the mail object. Within the property, you'll need to pass the content_type and body attributes.

Here's the code to implement this logic. You can add this as an additional class within the email_service.rb file:

require 'mail'

class HtmlEmailService
    def self.configure_smtp
        Mail.defaults do
          delivery_method :smtp, {
            address: 'smtp.sendlayer.net',
            port: 587,
            user_name: ENV['SENDLAYER_USERNAME'],
            password: ENV['SENDLAYER_PASSWORD'],
            authentication: 'plain',
            enable_starttls_auto: true
          }
        end
    end

    def self.send_newsletter(recipient_email, newsletter_data)

      newsletter_message = generate_html_content(newsletter_data)
      text_message = generate_text_content(newsletter_data)

      mail = Mail.new do
        from     'newsletter@example.com'
        to       recipient_email
        subject  'Monthly Newsletter - Ruby Tips & Tricks'

        html_part do
          content_type 'text/html; charset=UTF-8'
          body newsletter_message
        end

        text_part do
          body text_message
        end
      end

      mail.deliver!
    end

    private

    def self.generate_html_content(data)
      <<~HTML
        <!DOCTYPE html>
        <html>
          <head>
            <style>
              body { font-family: Arial, sans-serif; margin: 0; padding: 20px; }
              .header { background: #2c3e50; color: white; padding: 20px; text-align: center; }
              .content { padding: 20px; background: #f9f9f9; }
              .article { margin-bottom: 20px; padding: 15px; background: white; border-radius: 5px; }
              .footer { text-align: center; padding: 20px; font-size: 12px; color: #666; }
            </style>
          </head>
          <body>
            <div class="header">
              <h1>#{data[:title]}</h1>
            </div>
            <div class="content">
              #{data[:articles].map { |article| format_article(article) }.join}
            </div>
            <div class="footer">
              <p>© 2024 Your Company. All rights reserved.</p>
            </div>
          </body>
        </html>
      HTML
    end

    def self.format_article(article)
      <<~ARTICLE
        <div class="article">
          <h2>#{article[:title]}</h2>
          <p>#{article[:summary]}</p>
          <a href="#{article[:url]}">Read More</a>
        </div>
      ARTICLE
    end

    def self.generate_text_content(data)
      content = "#{data[:title]}\n\n"
      data[:articles].each do |article|
        content += "#{article[:title]}\n#{article[:summary]}\nRead more: #{article[:url]}\n\n"
      end
      content += "© 2024 Your Company. All rights reserved."
      content
    end
  end

Code Breakdown

The Mail object uses multipart structure with separate html_part and text_part blocks. The HTML part explicitly sets the content type to 'text/html; charset=UTF-8' to ensure proper rendering, while the text part uses the default plain text format. This approach ensures email clients can display either version based on their capabilities.

The generate_html_content method uses Ruby's heredoc syntax to create a complete HTML email template. It includes inline CSS styling for better email client compatibility and uses string interpolation (#{data[:title]}) to insert dynamic content from the newsletter data hash.

The helper method format_article generates individual article HTML blocks using the same heredoc approach. It takes an article hash and formats it with title, summary, and read-more link within styled div containers.

The generate_text_content method creates a plain text fallback version by iterating through the articles array using each and building a simple text format. This ensures users with text-only email clients can still read the newsletter content.

While Rails mailer includes built-in mailer views for template management, in vanilla Ruby, we handle HTML templates directly.

Send a Test HTML email in Ruby

Here's how you'll use the HTMLEmailService class we created. In your main.rb file, copy and paste the code snippet below:

# importing the email service
require_relative 'email_service'

# configure SMTP settings
HtmlEmailService.configure_smtp

# create newsletter data
newsletter_data = {
    title: "This Month in SendLayer",
    articles: [
      {
        title: "New Ruby SDK Launched",
        summary: "Discover the latest improvements in SendLayer API",
        url: "https://example.com/features"
      }
    ]
  }

# send HTML email
HtmlEmailService.send_newsletter('pattie@example.com', newsletter_data)

When you test this implementation, email clients will automatically select the HTML or text version based on user preferences and client capabilities. Providing the best possible experience for all recipients.

Send Email with Attachments

The Mail gem includes support for attaching files to emails. To send an email with an attachment, you'll need to include the add_file property when specifying the email parameters. Here's an example:

require 'mail'

def send_email_with_attachment(recipient, attachment_path)
  mail = Mail.new do
    from     'noreply@yourdomain.com'
    to       recipient
    subject  'Document Attached'
    body     'Please find the attached document.'

    add_file attachment_path
  end

  mail.deliver!
end

The value of the add_file property should be the path to the file you wish to attach. The Mail gem handles encoding and also tries to guess the file type.

To send multiple attachments, use Ruby's foreach syntax to map each attachment file to the add_file property. Here is an example:

# For multiple attachments
def send_email_with_multiple_attachments(recipient, attachment_paths)
  mail = Mail.new do
    from     'noreply@yourdomain.com'
    to       recipient
    subject  'Multiple Documents Attached'
    body     'Please find the attached documents.'

    attachment_paths.each { |path| add_file path }
  end

  mail.deliver!
end

That's it! You've now learned how to send emails in Ruby using SMTP.

How to Send Emails in Ruby Using Email API

Sending emails through SMTP works well for smaller projects. However, it is less secure and slower when compared to using an email API.

Fortunately, platforms like SendLayer also include an API for sending emails and tracking events such as open and bounce rates. I'll show you how to set up a program that uses the SendLayer API to send emails.

Start your free trial at SendLayer

Send Emails With SendLayer API

To send an email using SendLayer API, you'll need 3 parameters:

Base URL: This is the API endpoint for sending emails. For SendLayer, this endpoint is available at https://console.sendlayer.com/api/v1/email
Headers: This is where you'll define the format for the request and also authenticate your connection
Payload: This contains the JSON object with details for sending an email, like the sender and recipient email addresses

Ruby provides a default net/http library for making HTTP requests. I'll use this gem to make the HTTP request to SendLayer's email endpoint. Here's the snippet to send emails with the SendLayer API.

require 'uri'
require 'net/http'

url = URI("https://console.sendlayer.com/api/v1/email")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = {
  "From": {
    "name": "Paulie Paloma",
    "email": "paulie@example.com"
  },
  "To": [
    {
      "name": "Pattie Paloma",
      "email": "pattie@exampledomain.com"
    }
  ],
  "Subject": "Test email with Ruby and SendLayer API",
  "ContentType": "HTML",
  "HTMLContent": "<html><body><p>This is a test email sent with the <a href='https://sendlayer.com'>SendLayer</a> API and Ruby!</p></body></html>",
}.to_json

response = http.request(request)
puts response.read_body

Code Breakdown

In the snippet above, we first create a URI object from the SendLayer API endpoint and initialize an HTTP connection. We call http.use_ssl = true to enable SSL/TLS encryption for secure communication with the API server.

Next, we create a POST request object and set the required headers. The Authorization header uses Bearer token authentication with 'Bearer <token>', and we set the Content-Type to 'application/json' since we're sending JSON data.

Note: Remember to replace <token> with your actual SendLayer API token and update the email addresses to valid ones for testing.

The request body contains a Ruby hash with the email data structure that SendLayer expects. This hash is then converted to JSON format using .to_json before being assigned to request.body. This ensures the data is properly serialized for the API request.

Finally, we execute the request using http.request(request) and print the API response with response.read_body. The response will typically contain information about the delivery status or any error messages from the SendLayer service.

Retrieving SendLayer API Key

To get your API key, log in to your SendLayer account. Once you're logged in, click the Settings menu and select the API Keys tab.

Then click the copy icon next to Default API key to copy it.

Sending Email to Multiple Recipients

SendLayer's API allows you to send emails to multiple recipients, including CC and BCC email addresses. To send an email to multiple recipients in Ruby, update the To array in the email body with the additional recipient(s) you want to add. Here's an example:

# other code snippets...

request.body = {
  "From": {
    "name": "Paulie Paloma",
    "email": "paulie@example.com"
  },
  "To": [
    {
      "name": "Pattie Paloma",
      "email": "pattie@example.com"
    },
   {
      "name": "John Doe",
      "email": "johndoe@example.com"
    }
  ],
  "CC": [
    {
      "name": "Pattie Paloma CC",
      "email": "pattie.cc@example.com"
    }
  ],
  "BCC": [
    {
      "name": "Pattie Paloma BCC",
      "email": "pattie.bcc@example.com"
    }
  ],
  "ReplyTo": [
    {
      "name": "Pattie Paloma ReplyTo",
      "email": "pattie.reply@example.com"
    }
  ],
  "Subject": "This is the email to multiple recipients",
  "ContentType": "HTML",
  "HTMLContent": "<html><body><p>This is a test email sent with the <a href='https://sendlayer.com'>SendLayer</a> API and Ruby!</p></body></html>",
}.to_json

# ... other code

SendLayer API also lets you attach files to your email messages. See our developer guide for more details on sending emails through an email API.

Frequently Asked Questions

These are answers to some of the top questions developers ask about sending emails in Ruby.

What's the difference between Action Mailer and the Mail gem in Ruby?

Action Mailer is a built-in email framework providing seamless integration with Ruby on Rails applications. It includes templating, testing helpers, and background job integration. The Mail gem, on the other hand, is a standalone library that works in any Ruby application. It offers more low-level control over email creation and delivery.

How do I handle bounced emails and delivery failures?

The best way to handle delivery failures is by implementing proper error handling with try-catch blocks. You can also use webhook endpoints provided by your SMTP service to handle bounce notifications. Services like SendLayer provide detailed delivery reports and bounce handling.

How do I configure SMTP settings for production?

Proper mailer configuration is crucial for production environments. Always use environment variables for SMTP Ruby credentials and ensure your SMTP class implementation includes proper error handling and connection pooling.

What are the security best practices for email delivery in Ruby?

Below, we've highlighted some of the best practices for handling email in Ruby applications:

Always use environment variables for credentials
Enable TLS/SSL connections
Validate email addresses before sending
Implement rate limiting
Use reputable SMTP providers with proper authentication
Never expose API keys or passwords in your source code

Wrapping Up

In this comprehensive tutorial, we've walked through everything you need to know about sending emails in Ruby.

Have questions or want to share your implementation? Drop a comment below—I'd love to hear how you're handling email in your Ruby projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first email in minutes.

How to Send Email in PHP: Complete SMTP and API Guide

David Ozokoye — Fri, 19 Dec 2025 09:01:04 +0000

One feature that's often neglected by developers when building a new system is email functionality. If you need to send email in PHP, you've come to the right place.

Whether you're building a contact form, implementing user registration confirmations, or setting up automated notifications, email notifications are crucial for modern web applications.

In this PHP tutorial, I'll walk you through how to send emails effectively and securely using SMTP and through an email API.

How to Send Emails Using PHP
Send Email via SMTP
Send Email Using API
Best Practices
Frequently Asked Questions

How to Send Emails Using PHP

Prerequisites

Before we dive in, make sure you have:

PHP 7.4 or higher installed on your web server or local machine
Composer package manager installed (Download from getcomposer.org)
Basic knowledge of PHP programming and functions
A reliable email service provider with SMTP credentials
A text editor or IDE for writing your PHP script

For this tutorial, I'll use SendLayer as our email service provider, but the steps are similar regardless of which provider you choose.

If you'd like to follow along with SendLayer, you can get started with a free account that lets you send up to 200 emails monthly.

Start your free trial at SendLayer

After creating your free account, you'll need to authorize your sending domain. This step is essential for improving email deliverability and verifying your account.

How to Send Email in PHP via SMTP

PHP has a built-in mail() function that can send basic emails. However, it has limitations. There are third-party libraries, such as Symfony Mailer and PHPMailer, that extend the functionality of the default PHP mail function. For this tutorial, I'll use PHPMailer to implement the email function.

Pro Tip: Never use the built-in PHP mail function for production applications, as it lacks authentication, proper error handling, and advanced features.

Install the PHPMailer Package

PHPMailer is the most popular PHP library for sending emails. It addresses all the limitations of the built-in mail() function and provides a robust, feature-rich solution.

To install PHPMailer, run the command below:

composer require phpmailer/phpmailer

Note: If Composer isn't installed, visit getcomposer.org for installation instructions specific to your operating system.

Once the installation completes, create a new .php file that'll handle email functionality. Then add the following import statement:

<?php
// If using Composer
require_once 'vendor/autoload.php';

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;
?>

We're using the require_once line to load PHPMailer. This line is important if you installed it using Composer.

Configure Your SMTP Server

After adding the import statement, we'll initialize the mailer using the command below:

// Initialize the PHPMailer
$mail = new PHPMailer(true);

// SMTP server configuration
$mail->isSMTP();
$mail->Host = 'smtp.sendlayer.net';
$mail->SMTPAuth = true;
$mail->Username = 'your_sendlayer_username';
$mail->Password = 'your_sendlayer_password';
$mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
$mail->Port = 587;

The snippet above is used to configure the SMTP server. We first initialize the mailer using the $mail = new PHPMailer(true); line. Then, use the $mail object to set the credentials as shown above.

Tip: I'm using SendLayer's SMTP credentials for this tutorial. But you can use any email provider you want.

To access your SMTP credentials in SendLayer, log in to your SendLayer account and select the Settings sidebar menu. Then select the SMTP Credentials tab.

Once there, you'll see the SMTP credentials required to use SendLayer's SMTP server. The Host and Port number are the same for all users. However, the Username and Password details are unique to your SendLayer account.

You'll need to replace the username and password value in the snippet above with your SMTP credentials.

Sending Plain Text Emails

After configuring the SMTP server, you're ready to send your first email. Add the following snippet to your email service file:

<?php
require_once 'vendor/autoload.php';

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

$mail = new PHPMailer(true);

// SMTP Server configuration
$mail->isSMTP();
$mail->Host = 'smtp.sendlayer.net';
$mail->SMTPAuth = true;
$mail->Username = 'your_sendlayer_username';
$mail->Password = 'your_sendlayer_password';
$mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
$mail->Port = 587;

// Basic Usage
try {
    // Recipients
    $mail->setFrom('sender@example.com', 'Your Name');
    $mail->addAddress('recipient@example.com', 'Recipient Name');

    // Content
    $mail->isHTML(false); // Set email format to plain text
    $mail->Subject = 'Plain Text Email Subject';
    $mail->Body = 'This is a plain text email sent using PHPMailer and SendLayer SMTP Server.';

    // PHP send email SMTP method
    $mail->send();
    echo 'Email sent successfully!';
} catch (Exception $e) {
    echo "Email could not be sent. Mailer Error: {$mail->ErrorInfo}";
}
?>

Code Breakdown

In the code above, we set the sender and recipient email addresses using the $mail->setFrom() and $mail->addAddress() lines of code.

Note: If you're using SendLayer to send your emails, the sender email needs to be at the domain you've authorized in SendLayer. For instance, if you authorized example.com, your sender email domain should be @example.com.

The $mail->isHTML() line specifies the type of email you want to send. Setting it to false means your email content should be plain text.

The $mail->send() method calls the actual function that handles email sending.

We wrap the entire logic in a try...catch block to implement error handling. This is good practice as it ensures errors preventing emails from sending are logged to the console.

Sending HTML Emails in PHP

PHPMailer also supports sending HTML emails. To send an HTML email, you'll simply need to set isHTML() to true. Then update the $mail->Body variable with your HTML email content:

<?php
require_once 'vendor/autoload.php';

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

$mail = new PHPMailer(true);

// SMTP Server configuration
$mail->isSMTP();
$mail->Host = 'smtp.sendlayer.net';
$mail->SMTPAuth = true;
$mail->Username = 'your_sendlayer_username';
$mail->Password = 'your_sendlayer_password';
$mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
$mail->Port = 587;

try {
    // Recipients
    $mail->setFrom('sender@example.com', 'Your Company');
    $mail->addAddress('user@example.com', 'John Doe');

    // Content
    $mail->isHTML(true);
    $mail->Subject = 'Welcome to Our Platform!';
    $mail->Body = '
    <html>
    <head>
        <style>
            .container { font-family: Arial, sans-serif; }
            .header { background-color: #f4f4f4; padding: 20px; }
            .content { padding: 20px; }
            .button { 
                background-color: #007cba; 
                color: white; 
                padding: 10px 20px; 
                text-decoration: none; 
                border-radius: 5px; 
            }
        </style>
    </head>
    <body>
        <div class="container">
            <div class="header">
                <h2>Welcome to Our Platform!</h2>
            </div>
            <div class="content">
                <p>Hi Pattie,</p>
                <p>Thank you for signing up. We\'re excited to have you on board!</p>
                <p><a href="https://example.com/activate" class="button">Activate Account</a></p>
                <p>Best regards,<br>The Team</p>
            </div>
        </div>
    </body>
    </html>';

    // Alternative plain text body
    $mail->AltBody = 'Thank you for signing up! Visit https://example.com/activate to activate your account.';

    $mail->send();
    echo 'HTML email sent successfully!';
} catch (Exception $e) {
    echo "Email could not be sent. Mailer Error: {$mail->ErrorInfo}";
}
?>

You can optionally add the $mail->AltBody variable if you'd like to have a plain text version of your email. This is helpful as it ensures your emails are visible even on email clients that do not support HTML messages.

Send Emails to Multiple Recipients with PHP

You can also send emails to multiple recipients in your PHP application using PHPMailer. To do so, duplicate the $mail->addAddress() method. Then update the name and email addresses with the recipient's details:

// Sender
$mail->setFrom('sender@example.com', 'Newsletter Team');

// Multiple recipients
$mail->addAddress('user1@example.com', 'John Doe');
$mail->addAddress('user2@example.com', 'Jane Smith');
$mail->addCC('manager@example.com', 'Manager');
$mail->addBCC('admin@example.com', 'Admin');

// Content
$mail->isHTML(true);
$mail->Subject = 'Weekly Newsletter';
$mail->Body = '<h2>This Week\'s Updates</h2><p>Here are the latest news and updates...</p>';

$mail->send();
echo 'Newsletter sent to multiple recipients!';

You can also add CC and BCC email addresses using the $mail->addCC() and $mail->addBCC() methods, respectively.

PHP Send Email with Attachment

The PHPMailer library also includes support for email attachments. To add attachments to your email message, call the addAttachment() method. Within the parentheses, you'll need to pass the attachment path. You can optionally enter a name for the attachment:

// Recipients
$mail->setFrom('sender@example.com', 'Document Center');
$mail->addAddress('recipient@example.com');

// Attachments
$mail->addAttachment('/path/to/document.pdf', 'Invoice.pdf');
$mail->addAttachment('/path/to/image.jpg', 'Photo.jpg');

// Content
$mail->isHTML(true);
$mail->Subject = 'Documents Attached';
$mail->Body = '<p>Please find the attached documents.</p>';

// PHP send email example
$mail->send();
echo 'Email with attachments sent successfully!';

To add multiple attachments, simply duplicate the addAttachment() method and update the file path and name parameters.

Send a Test Email in PHP

After implementing your email logic, I recommend sending a test email to ensure everything is working properly.

Open a terminal window and run your email script:

php SendEmail.php

Pro Tip: You need to ensure your terminal window is in the same directory as your project. Also, make sure to replace SendEmail.php with your actual email service file name.

After running the command, you should see a success message in the terminal. Go ahead and check the email inbox of the recipient you specified.

How to Send Email in PHP Using API

Sending emails through SMTP works well for smaller projects. However, it is less secure and slower than using an API. Using an API-based service is also much faster, especially when you need to send bulk emails.

Fortunately, platforms like SendLayer provide API endpoints and SDKs you can use to send single and bulk emails programmatically. I'll show you how to set up a program that uses the SendLayer PHP SDK to send emails.

Start your free trial at SendLayer

Send HTML Email in PHP Using SendLayer API

To get started, you'll need to install the SendLayer SDK using Composer in your project directory:

composer require sendlayer/sendlayer-php

Once the installation completes, create a new email service file and import the necessary dependencies:

<?php

require_once 'vendor/autoload.php';

use SendLayer\SendLayer;
use SendLayer\Exceptions\SendLayerException;

Next, you'll need to initialize the SendLayer package using your API key:

<?php

require_once 'vendor/autoload.php';

use SendLayer\SendLayer;
use SendLayer\Exceptions\SendLayerException;

// Initialize the SendLayer package
$sendlayer = new SendLayer('your-api-key');

To get your API key, log in to your SendLayer account. Click the Settings menu and select the API Keys tab.

Then click the copy icon next to Default API key to copy it.

Once you've got it, replace your-api-key with your actual SendLayer API key.

Now, to send an email, call the $sendlayer->Emails->send() method and pass the email data as parameters:

<?php

require_once 'vendor/autoload.php';

use SendLayer\SendLayer;
use SendLayer\Exceptions\SendLayerException;

// Initialize the SendLayer package
$sendlayer = new SendLayer('your-api-key');

// Call the send email method
try {
    $response = $sendlayer->Emails->send([
        'from' => 'paulie@example.com',
        'to' => 'recipient@example.com',
        'subject' => 'Test Email from PHP SDK',
        'text' => 'This is a test email sent using the SendLayer PHP SDK'
    ]);
    echo "Email sent successfully! " . json_encode($response, JSON_PRETTY_PRINT) . "\n";

} catch (SendLayerException $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

The send() method requires 4 parameters to work:

from: Sender email address
to: Recipient's email address(es)
subject: The email subject
text or html: The email message (plain text or HTML content)

Pro Tip: The from email address needs to match the sending domain you authorized in your SendLayer account.

Send Email in PHP to Multiple Email Addresses

The SendLayer SDK also supports sending emails to multiple recipients, including CC and BCC email addresses. To do so, simply update the to parameter to a comma-separated string list:

$response = $sendlayer->Emails->send([
    'from' => 'paulie@example.com',
    'to' => ['recipient1@example.com', 'recipient2@example.com'],
    'subject' => 'Test Email from PHP SDK',
    'html' => '<h1>Hello!</h1><p>This is a test email sent to multiple recipients using SendLayer PHP SDK</p>'
]);
echo "Email sent successfully! " . json_encode($response, JSON_PRETTY_PRINT) . "\n";

If you'd like, you can pass the recipient's name and email addresses in the payload:

$response = $sendlayer->Emails->send([
    'from' => ['email' => 'paulie@example.com', 'name' => 'Paulie Paloma'],
    'to' => [
        ['name' => 'John Doe', 'email' => 'johndoe@example.com'],
        ['name' => 'Pattie Paloma', 'email' => 'pattie@example.com']
    ],
    'subject' => 'Sending a Test Email Using PHP SDK',
    'html' => '<h1>Hello!</h1><p>This is a test email sent to multiple recipients using SendLayer PHP SDK</p>',
    'cc' => ['cc@example.com'],
    'bcc' => ['bcc@example.com'],
    'replyTo' => 'reply-to@example.com',
]);
echo "Email sent successfully! Message ID: " . $response['MessageID'] . "\n";

Send Email with Attachment in PHP

The SendLayer SDK also supports sending emails with attachments. Add the attachments parameter and specify the path and type parameters for the file you wish to attach:

$response = $sendlayer->Emails->send([
    'from' => ['email' => 'paulie@example.com', 'name' => 'Paulie Paloma'],
    'to' => [['name' => 'Pattie Paloma', 'email' => 'pattie@example.com']],
    'subject' => 'Sending a Test Email With PHP SDK',
    'html' => '<h1>Hello!</h1><p>This is a test email with attachments using SendLayer PHP SDK</p>',
    'attachments' => [
        [
            'path' => '/path/to/document.pdf',
            'type' => 'application/pdf'
        ],
        [
            'path' => 'https://placehold.co/600x400.png',
            'type' => 'image/png'
        ]
    ]
]);
echo "PHP Email sent successfully! Message ID: " . $response['MessageID'] . "\n";

You can attach multiple files to your email message. SendLayer's SDK also supports remote and local files.

The SDK also handles encoding the files before making the API request. So you only need to specify the path and type parameter.

Tip: See Mozilla's documentation if you're at all unsure of the type of file you're attaching.

To learn more about sending emails using SendLayer's API, check our developer documentation.

Best Practices for Sending Emails in PHP

Sending emails often involves setting up sensitive credentials and user details. Here are some best practices to optimize your email implementation.

1. Validate and Sanitize Input

To reduce the risk of encountering errors when sending emails, always validate email addresses. You can also sanitize the email content to ensure spam content isn't getting sent to users:

<?php
function validateEmail($email) {
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

function sanitizeInput($data) {
    $data = trim($data);
    $data = stripslashes($data);
    $data = htmlspecialchars($data);
    return $data;
}

// Example usage
$email = $_POST['email'] ?? '';
if (!validateEmail($email)) {
    die('Invalid email address');
}

$name = sanitizeInput($_POST['name'] ?? '');
$message = sanitizeInput($_POST['message'] ?? '');
?>

2. Implement Proper Error Handling

Adding error handling to your email service will help you catch errors that occur when sending emails:

<?php
function sendEmail($to, $subject, $body) {
    $mail = new PHPMailer(true);

    try {
        // SMTP configuration
        $mail->isSMTP();
        $mail->Host = 'smtp.sendlayer.net';
        $mail->SMTPAuth = true;
        $mail->Username = 'your_username';
        $mail->Password = 'your_password';
        $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
        $mail->Port = 587;

        // Email settings
        $mail->setFrom('noreply@yourdomain.com', 'Your App');
        $mail->addAddress($to);
        $mail->isHTML(true);
        $mail->Subject = $subject;
        $mail->Body = $body;

        $mail->send();
        return ['success' => true, 'message' => 'Email sent successfully'];
    } catch (Exception $e) {
        error_log("Email Error: " . $e->getMessage());
        return ['success' => false, 'message' => 'Failed to send email'];
    }
}
?>

3. Use Environment Variables for Credentials

Never commit sensitive information such as SMTP credentials or API keys to version control systems. Instead, use environment variables:

Create a .env file:

SMTP_HOST=smtp.sendlayer.net
SMTP_USERNAME=your_username
SMTP_PASSWORD=your_password
SMTP_PORT=587

Security Warning: Never commit your .env file to version control. Always use environment variables for sensitive credentials like SMTP passwords and API keys.

Load and use them in your application:

<?php

// Load environment variables
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

// Import and map environment variables
$mail->Host = $_ENV['SMTP_HOST'];
$mail->Username = $_ENV['SMTP_USERNAME'];
$mail->Password = $_ENV['SMTP_PASSWORD'];
$mail->Port = $_ENV['SMTP_PORT'];
?>

You'll need to install the Dotenv library:

composer require vlucas/phpdotenv

4. Set Up Email Authentication

For better deliverability, ensure your domain has proper SPF, DKIM, and DMARC records configured. When using SendLayer, these are typically handled automatically when you verify your domain.

Frequently Asked Questions

These are answers to some of the top questions we see about sending emails with PHP.

What are the main differences between PHP's mail() function and PHPMailer?

The mail() function is PHP's built-in email method, but it has significant limitations. It relies on server configuration, doesn't support SMTP authentication, and lacks advanced features like attachments and detailed error handling.

PHPMailer, on the other hand, is a comprehensive library that supports SMTP authentication, attachments, HTML messages, multiple recipients, and provides detailed error reporting. For production applications, PHPMailer is the better choice.

How do I add attachments to emails sent from PHP?

With PHPMailer, adding attachments is straightforward. You'll simply need to specify the file path as a parameter when you call the addAttachment() method:

$mail->addAttachment('/path/to/file.pdf', 'CustomName.pdf');

Can I send emails without SMTP?

While you can use PHP's built-in mail() function, it's not recommended for production because:

No authentication support
Poor deliverability rates
Limited error reporting
No advanced features (HTML, attachments, etc.)

For better results, always use SMTP or email APIs like SendLayer's REST API.

What's the difference between STARTTLS and SSL?

The main difference is that STARTTLS (Port 587) starts unencrypted, then upgrades to encrypted, while SSL (Port 465) is encrypted from the beginning. Both are secure, but STARTTLS is more commonly used and supported.

Wrapping Up

In this comprehensive tutorial, we've explored how to send emails in PHP using both SMTP and API methods. Here are the key takeaways:

SMTP with PHPMailer:

Great for simple to moderate email needs
Requires SMTP server credentials
Supports HTML emails, attachments, and multiple recipients
Good error handling capabilities

SendLayer API:

Faster and more scalable
Better deliverability
Easier to implement
Advanced features and tracking
Perfect for production applications

Have questions or want to share your implementation? Drop a comment below—I'd love to hear how you're handling email in your PHP projects!

Ready to implement this in your application? Start your free trial at SendLayer and send your first email in minutes.

Forem: SendLayer

How to Automate Email Sending in Codex Using an MCP Server

Table of Contents

What is SendLayer MCP?

MCP tools available in SendLayer

Prerequisites

How to connect SendLayer MCP to OpenAI Codex

Step 1: Create your SendLayer account

Authorize your sending domain

Step 2: Retrieve your API key

Step 3: Store your API key as an environment variable

Step 4: Add SendLayer MCP to your Codex config.toml

Step 5: Verify the connection

How to send your first email from Codex

Sending a plain text email

Sending an HTML email

Real-world automation use cases

Build failure notifications

Automated report delivery

Subscription renewal reminders

Project-scoped vs global MCP configuration

Troubleshooting

SendLayer MCP doesn't appear in codex mcp list

API key not found at runtime

Emails aren't reaching the inbox

From email not specified

Frequently asked questions

Does SendLayer MCP work with Codex CLI and the Codex VS Code extension?

How do I keep my SendLayer API key secure in Codex?

Is SendLayer MCP free to use?

Wrapping up

How to Automate Transactional Email Sending with Claude Code Using MCP

Table of Contents

What is MCP and why use it?

How to automate email sending with Claude Code

Prerequisites

Step 1: Create your SendLayer account

Authorize your sending domain

Step 2: Get your SendLayer API key

Step 3: Install SendLayer MCP in Claude Code

Verifying the connection

Step 4: Send your first email

Sending different email types

HTML emails

Emails with multiple recipients

Emails with attachments

Real-world use cases: Automating transactional emails

Automated deployment notifications

Automated error monitoring alerts

eCommerce order confirmations

Automated daily/weekly reports

Troubleshooting common issues

Error: Invalid API key

Emails going to spam

Frequently asked questions

Is SendLayer MCP free to use?

Can I use SendLayer MCP with other AI tools?

Is it safe to store my API key in the MCP configuration?

Wrapping up

How to Design Email Templates in React.js

Table of Contents

How to design email templates in React.js

Prerequisites

How to set up React.Email in your project

Method 1: Automatic setup (recommended for new projects)

Method 2: Manual setup (for existing projects)

Configure the preview server

Project structure

How to build your first email template

Code breakdown

Preview your email

Styling email templates

Using inline styles

Styling with Tailwind CSS

How to send emails in React using HTML templates

Using the render utility

Integrate email API

Code breakdown

How to retrieve your SendLayer API key

Send a test email

SendLayer MCP doesn't appear in `codex mcp list`