Introduction
Email is an important part of many web applications.
Whether you are building a user registration system, e-commerce platform, booking application, SaaS product, or business website, you will probably need to send emails for different events.
Common examples include:
- Welcome emails
- Email verification
- Password reset emails
- Order confirmations
- Appointment notifications
- Payment receipts
- Account alerts
- Contact form notifications
- Marketing emails
Fortunately, Django provides built-in email functionality that makes it relatively easy to send emails from a web application.
In this guide, we’ll learn how to send emails in Django, how Django email configuration works, how to use SMTP, how to create HTML emails, and how to handle email sending efficiently in production.
Why Send Emails from Django?
Email allows your Django application to communicate with users even when they are not actively using your website.
For example, when someone creates an account, your application can automatically send a welcome email.
Similarly, an online booking platform can send confirmation details after a booking is completed.
A typical workflow looks like this:
User Action → Django → Email Service → User’s Inbox
Django handles the application logic, while an email server or email provider delivers the message.
How Django Email Works
Django includes a built-in email system that provides a convenient interface for sending messages.
Instead of directly communicating with an SMTP server throughout your application code, you can use Django’s email utilities.
A basic email flow looks like this:
- A user performs an action.
- Django processes the request.
- Your application creates an email.
- Django passes the email to the configured email backend.
- The email backend communicates with the email server.
- The email is delivered to the recipient.
This keeps email-related functionality relatively separate from the rest of your application.
Configure Email in Django
Before sending emails, you need to configure Django’s email backend.
For development and production, Django can work with different email backends and SMTP services.
Common configuration options include:
- Email backend
- SMTP host
- SMTP port
- SMTP username
- SMTP password
- TLS or SSL settings
- Default sender email
The exact configuration depends on the email provider you choose.
For example, you might use:
- Gmail SMTP
- Microsoft email services
- Amazon SES
- SendGrid
- Mailgun
- Brevo
- Another transactional email provider
For production applications, dedicated transactional email services are generally preferable to using a personal mailbox.
Django Email Backend
The Django email backend determines how Django sends emails.
Django provides several email backends for different situations.
SMTP Email Backend
The SMTP backend is commonly used when you want Django to send emails through an external SMTP server.
It is suitable for both development and production when configured correctly.
Console Email Backend
During development, you may not want to send real emails.
Django’s console email backend can display email content in the terminal instead of actually delivering the message.
This is useful when testing email functionality locally.
File-Based Email Backend
Django also supports storing generated emails as files.
This can be useful for development and testing when you want to inspect the complete email content without sending it.
Sending a Simple Email in Django
Django provides a send_mail() utility for straightforward email messages.
The basic concept is simple:
Subject → Message → Sender → Recipient
You don’t need a large amount of code to send a basic text email.
For example, after a successful registration, your application could trigger a welcome email.
The important part is not the amount of code but correctly configuring your email backend and keeping sensitive credentials secure.
Sending HTML Emails in Django
Plain-text emails are useful, but modern applications often require more visually appealing emails.
Django supports HTML email messages, allowing you to create emails containing:
- Headings
- Buttons
- Links
- Images
- Tables
- Branding
- Custom layouts
For example, a booking confirmation email might contain:
Booking Confirmed
Customer: John Doe
Date: August 25, 2026
Booking ID: #12345
View Booking
This creates a much better user experience than sending a large block of plain text.
Why Use Django Email Templates?
Instead of placing large amounts of HTML directly inside Python code, it is better to create separate Django templates.
For example, you might organize your email templates like:
- Welcome email
- Verification email
- Password reset email
- Order confirmation
- Booking confirmation
- Notification email
This keeps your Python code cleaner and makes email designs easier to maintain.
It also allows developers and designers to work on email templates without modifying application logic.
Using Dynamic Data in Email Templates
Email templates often need information from your database.
For example, a welcome email might contain:
- User’s name
- Account information
- Verification URL
A booking confirmation could contain:
- Customer name
- Booking date
- Service name
- Appointment time
- Booking ID
Django templates make it possible to pass this information dynamically into an email.
This allows one email template to be reused for many users.
Email Verification in Django
Email verification is one of the most common Django email use cases.
A typical registration flow is:
- User creates an account.
- Django creates the user.
- Django generates a verification token or secure verification mechanism.
- Django sends a verification email.
- User clicks the verification link.
- Django validates the request.
- The account becomes verified.
Email verification helps confirm that users have access to the email address they provided.
Password Reset Emails
Django also provides functionality for password reset workflows.
A typical password reset process is:
Forgot Password → Enter Email → Receive Email → Click Secure Link → Set New Password
The reset email usually contains a time-sensitive or otherwise protected link.
For security reasons, password reset links should not expose sensitive information and should be designed to expire or become invalid after use.
Sending Emails After User Actions
Emails are often triggered by events inside an application.
For example:
User Registration
Registration → Create Account → Send Welcome Email
Booking
Booking → Save Booking → Send Confirmation
Payment
Payment Success → Update Order → Send Receipt
Password Reset
Reset Request → Generate Link → Send Email
This event-based approach makes email functionality a natural part of the application workflow.
Don’t Make Users Wait for Email Sending
One important consideration is email performance.
Sending an email involves communication with an external email server. Network requests can take time or fail temporarily.
If your Django view sends the email synchronously, the user may have to wait until the email operation completes.
For a small application this may be acceptable, but high-traffic applications should consider background processing.
This is where tools such as Celery become useful.
Instead of:
User → Django → Send Email → Response
You can use:
User → Django → Queue Email Task → Response
Then:
Celery Worker → Send Email
This allows Django to respond quickly while the email is processed in the background.
Django Email with Celery
If your application already uses Celery, email sending is a common background task.
For example, when a booking is created:
- Django saves the booking.
- Django queues an email task.
- The user receives an immediate response.
- Celery processes the email.
- The email service delivers the message.
This approach is especially useful for:
- High-volume emails
- Booking notifications
- Reports
- Large transactional workflows
- Emails triggered by multiple application events
For more information, see our guide on Django Celery and background tasks.
Choosing an Email Provider
Django does not require you to use a particular email provider.
Your choice should depend on your application’s requirements.
Gmail SMTP
Gmail can be useful for development and smaller applications.
However, production applications should carefully consider sending limits, authentication requirements, and account policies.
Amazon SES
Amazon Simple Email Service is designed for sending transactional and bulk emails at scale.
It can be a good option for applications already using AWS.
SendGrid
SendGrid provides APIs and SMTP-based email delivery services.
It is commonly used for transactional emails and application notifications.
Mailgun
Mailgun provides tools for transactional email delivery and email management.
Brevo
Brevo offers transactional email services along with other communication features.
The best choice depends on your application’s email volume, deliverability requirements, budget, and infrastructure.
SMTP vs Email API
There are two common approaches for sending application emails.
SMTP
SMTP is the traditional email delivery protocol.
Django can connect to an SMTP server and send messages through it.
Advantages include:
- Familiar technology
- Simple Django integration
- Supported by many providers
Email APIs
Many modern email providers also offer APIs.
Your Django application sends an HTTP request to the provider, and the provider handles delivery.
API-based email services can provide additional functionality such as:
- Delivery tracking
- Bounce management
- Analytics
- Templates
- Webhooks
- Better observability
For larger production applications, an email API can be worth considering.
Keep Email Credentials Secure
Email configuration contains sensitive information.
SMTP passwords, API keys, and other credentials should never be hard-coded directly into your Django source code.
Instead, store secrets in environment variables or a secure secrets-management system.
For example, your configuration can read values from environment variables rather than storing credentials directly in settings.py.
This is particularly important when your project is stored in Git repositories.
Use Environment-Specific Email Settings
Your development and production environments may require different email configurations.
For example:
Development
Use the console email backend so developers can inspect emails locally.
Staging
Use a test email provider or restricted email account.
Production
Use a reliable transactional email provider.
This approach reduces the risk of accidentally sending test emails to real customers.
Email Security Best Practices
Email functionality should be designed with security in mind.
Don’t Expose Sensitive Information
Avoid putting passwords, authentication secrets, or other sensitive information directly inside emails.
Use Secure Links
Verification and password-reset links should use HTTPS in production.
Validate Email Addresses
Validate user-provided email addresses before attempting to send messages.
Protect Email Credentials
Store SMTP passwords and API keys securely.
Avoid Email Header Injection
Never blindly insert untrusted user input into email headers such as subject or recipient fields.
Django provides abstractions that help with safe email handling, but developers should still validate user input.
Email Deliverability Matters
Successfully sending an email doesn’t necessarily mean it will reach the user’s inbox.
Emails can end up in:
- Spam folders
- Promotions tabs
- Quarantine systems
- Rejected mail queues
For production applications, email deliverability is an important consideration.
You should configure appropriate email authentication mechanisms such as:
- SPF
- DKIM
- DMARC
These records help email providers verify that your application is authorized to send messages from your domain.
Email Testing in Django
Testing email functionality is an important part of Django development.
You should test:
- Whether emails are triggered correctly
- Recipient addresses
- Subject lines
- Template rendering
- Dynamic data
- Verification links
- Password reset workflows
- Failure scenarios
Django provides tools that make it possible to inspect emails during automated tests without sending real messages.
This makes email-related functionality much easier to test safely.
Organizing Email Code in Django
As your application grows, email functionality can become difficult to maintain if everything is placed inside views.
Instead, consider separating responsibilities.
For example:
Views
Handle HTTP requests and application flow.
Services
Handle business operations such as creating an order or booking.
Email Layer
Handles email creation and delivery.
Templates
Handle the visual content of emails.
Celery Tasks
Handle asynchronous email delivery.
This structure can make large Django projects easier to maintain.
Common Django Email Mistakes
Sending Emails Directly Inside Complex Views
Large views that contain database operations, business logic, and email logic can become difficult to maintain.
Keep responsibilities separated where possible.
Hard-Coding Credentials
Never commit SMTP passwords or API keys to source control.
Using Production Email Settings Locally
Accidentally sending hundreds of test emails is an avoidable problem.
Use a development email backend or test provider.
Ignoring Delivery Failures
An email request can fail because of network problems, provider issues, invalid addresses, or configuration errors.
Production systems should consider logging and retry strategies.
Sending Everything Synchronously
For important or high-volume email operations, background processing can improve response times and reliability.
Django Email Best Practices
For a production-ready Django application:
- Use a reliable transactional email provider.
- Store credentials securely.
- Keep email templates separate from Python logic.
- Use HTML and plain-text versions where appropriate.
- Test email workflows automatically.
- Configure SPF, DKIM, and DMARC for your domain.
- Monitor email delivery and failures.
- Use background tasks for slow or high-volume email operations.
- Avoid exposing sensitive information in emails.
- Keep development and production email configurations separate.
Conclusion
Learning how to send emails in Django is an important skill for Django developers because email is part of almost every modern web application.
Django provides built-in email functionality that makes it easy to send simple messages, while templates allow developers to create professional HTML emails. For production applications, SMTP providers and transactional email APIs can provide reliable delivery and additional features.
As your application grows, combining Django’s email functionality with Celery background tasks can make email delivery faster and more reliable by moving email processing away from the main request-response cycle.
Whether you need a simple welcome email or a complete notification system, Django provides the flexibility to build a reliable email workflow.
Frequently Asked Questions
How do I send an email in Django?
Django provides built-in email utilities such as send_mail() that allow applications to send emails through a configured email backend.
Can Django send HTML emails?
Yes. Django supports HTML emails, and you can use Django templates to create reusable and dynamic email layouts.
Which SMTP server is best for Django?
There is no single best option. Gmail can work for development and small projects, while transactional email providers such as Amazon SES, SendGrid, Mailgun, and Brevo are commonly considered for production applications.
Can Django send emails asynchronously?
Yes. Django can be integrated with background task systems such as Celery to send emails asynchronously.
How can I test emails in Django?
Django provides development and testing email backends that allow you to inspect generated emails without necessarily sending them to real recipients.
Should I use SMTP or an email API?
Both approaches can work. SMTP is simple and widely supported, while email APIs often provide additional features such as delivery tracking, analytics, webhooks, and bounce management.
