How to Send Email with Django Using SMTP Server: 7 Easy Steps

In the world of web development, sending emails is a crucial feature for many applications, whether it’s for account verification, password recovery, or transactional updates. If you’re working with Django, a powerful Python-based web framework, integrating email functionality can be seamless.

In this guide, we’ll explore how to send email with Django using SMTP server. By leveraging Django’s built-in email utilities and configuring an SMTP server, you can efficiently manage and send emails directly from your application. Let’s dive into the steps to set up this essential feature!

Why Use an SMTP Server with Django?

SMTP (Simple Mail Transfer Protocol) is the industry standard for sending email with Django and across the internet. It allows applications to deliver messages reliably and securely. Using an SMTP server with Django ensures that your emails are delivered promptly, even when dealing with large-scale email distributions. While Django has built-in email functionalities, configuring an SMTP server enables advanced features like better authentication and encryption.

Key Considerations

Before we dive into the steps, keep the following best practices in mind:

• Never Spam: Avoid sending unsolicited emails, as it can harm your reputation and violate anti-spam regulations.
• Use a Dedicated Gmail Account: Never use your personal Gmail account for application emails to ensure privacy and separation of concerns.
• Avoid Storing Passwords in Code: Use environment variables or configuration files to keep sensitive information secure and prevent exposure of credentials.
• Enable Two-Factor Authentication: This enhances the security of your Gmail account, protecting it from unauthorized access.
• Consider Upgrading to a Transactional Email Service: For production, use a domain-specific email service designed for scale and reliability, offering features like better deliverability and analytics.

How to Send Email with Django Using SMTP Server: Step-by-Step Guide

Step 1: Create a Gmail Account

Create a new Gmail account specifically for your Django project. This ensures that your personal email remains secure and unaffected by application-related activities. Using a dedicated account also allows you to monitor project-related email activities more efficiently.

Step 2: Enable Two-Factor Authentication (2FA)

1. Go to My Google Account.
2. Enable Two-Factor Authentication for added security.
3. Add multiple 2FA methods, such as backup codes, an authenticator app, or a security key. These options provide extra layers of protection, ensuring the integrity of your email account.

Step 3: Generate an App Password

1. In My Google Account, search for “App Passwords.”
2. Generate a new App Password specifically for your Django project.
3. Copy the App Password and store it securely. Use it to configure your environment variables, ensuring seamless integration with Django.

App Passwords are useful because they allow you to bypass Gmail’s regular login while maintaining security. They’re easy to revoke and recreate, making them ideal for application use.

Step 4: Update Django Settings

In your settings.py file, configure the email backend and SMTP settings:

from decouple import config

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = config("EMAIL_HOST", cast=str, default="smtp.gmail.com")
EMAIL_PORT = config("EMAIL_PORT", cast=int, default=587)  # Use 587 for TLS
EMAIL_HOST_USER = config("EMAIL_HOST_USER", cast=str, default=None)
EMAIL_HOST_PASSWORD = config("EMAIL_HOST_PASSWORD", cast=str, default=None)
EMAIL_USE_TLS = config("EMAIL_USE_TLS", cast=bool, default=True)  # For TLS
EMAIL_USE_SSL = config("EMAIL_USE_SSL", cast=bool, default=False)  # For SSL, set to True and use port 465

Ensure sensitive credentials like EMAIL_HOST_PASSWORD are stored securely in an .env file or environment variables. Example .env file:

EMAIL_HOST="smtp.gmail.com"
EMAIL_PORT=587
EMAIL_HOST_USER="yourprojectemail@gmail.com"
EMAIL_HOST_PASSWORD="your-app-password"
EMAIL_USE_TLS=True

Install the Python package python-decouple to manage environment variables if you haven’t already:

pip install python-decouple

Using environment variables ensures that sensitive information is not hardcoded into your application, reducing the risk of accidental exposure or unauthorized access.

Step 5: Configure Managers and Admins

Add the following configuration to settings.py to specify the administrators:

ADMIN_USER_NAME = config("ADMIN_USER_NAME", default="Admin")
ADMIN_USER_EMAIL = config("ADMIN_USER_EMAIL", default=None)

MANAGERS = []
ADMINS = []
if ADMIN_USER_NAME and ADMIN_USER_EMAIL:
    ADMINS.append((ADMIN_USER_NAME, ADMIN_USER_EMAIL))
    MANAGERS = ADMINS

Update the .env file with the admin email:

ADMIN_USER_EMAIL="admin@example.com"

Configuring administrators allows Django to send critical error notifications and management-related emails. This setup is particularly useful in production environments to ensure timely issue resolution.

Step 6: Test Email Functionality

Use Django’s sendtestemail command to verify your email configuration:

python manage.py sendtestemail --admins

Alternatively, test using the Django shell:

python manage.py shell

Then, execute the following commands:

from django.core.mail import send_mail
from django.conf import settings

send_mail(
    subject="Test Email",
    message="This is a test email sent from Django.",
    from_email=settings.EMAIL_HOST_USER,
    recipient_list=[settings.ADMIN_USER_EMAIL],
    fail_silently=False,
)

Testing your email configuration ensures everything is set up correctly before deploying to production. If any issues arise, debugging them early prevents disruptions.

Step 7: Debugging and Logs

If the email fails to send, check your Gmail account for any security alerts or blocked sign-in attempts. You can also inspect Django’s logs for more details. Common issues include incorrect credentials, blocked sign-ins due to security settings, or network configuration errors.

Enable Django’s logging framework to capture detailed information about email activities:

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

Moving to Production

While Gmail works well for testing, consider transitioning to a production-grade transactional email service like SendGrid, Mailgun, or Amazon SES. These services provide better deliverability, scalability, and monitoring tools, making them ideal for sending email with Django. They also help you manage higher volumes of emails and offer APIs for advanced email features.

To integrate such services, replace Gmail’s SMTP configurations with those provided by your chosen email service. Most providers offer detailed documentation and SDKs to facilitate integration.

Final Thoughts

Learning how to send email with Django using SMTP server is an essential skill for developers building dynamic web applications. Whether you need to send account verification links, password reset emails, or transactional notifications, Django’s built-in email utilities make the process seamless.

By following this guide, you’ll be able to configure sending email with Django using an SMTP server successfully. Whether you’re testing with Gmail or using a production-ready service, understanding the setup process is a valuable skill for any Django developer. Adding email functionality enhances user engagement and provides a professional touch to your application, making it a must-have feature for modern web projects.

For more details and advanced configurations, refer to the official Django documentation.