How to Send Emails in Python (Django, Flask, FastAPI - 2026)
Python's standard library has smtplib for sending emails. It works. It's also verbose, handles errors poorly, and leaves you managing SMTP connections, TLS, and deliverability yourself.
This guide covers the practical approach: using email API providers that handle delivery infrastructure so you can focus on your app. Working examples for Django, Flask, FastAPI, and standalone scripts. We also have dedicated, in-depth guides for Django, Flask, and FastAPI. All code uses type hints and modern Python patterns.
smtplib vs API Providers
Here's the difference in practice:
# smtplib: you manage SMTP, TLS, MIME encoding, retries
import smtplib
from email.mime.text import MIMEText
msg = MIMEText("<p>Hello</p>", "html")
msg["Subject"] = "Hello"
msg["From"] = "you@gmail.com"
msg["To"] = "user@example.com"
with smtplib.SMTP("smtp.gmail.com", 587) as server:
server.starttls()
server.login("you@gmail.com", "app-password")
server.send_message(msg)# API provider: one HTTP call, they handle the rest
import requests
requests.post(
"https://api.sequenzy.com/v1/transactional/send",
headers={"Authorization": "Bearer sq_your_key"},
json={"to": "user@example.com", "subject": "Hello", "body": "<p>Hello</p>"},
)Use smtplib if you're talking to an internal SMTP server. Use an API provider for everything else.
Pick a Provider
- Sequenzy is built for SaaS. Transactional emails, marketing campaigns, automated sequences, subscriber management from one API. Has native Stripe integration. If you're building a SaaS product, this keeps everything in one place.
- Resend is developer-friendly with a clean API. Good docs, solid deliverability. They have one-off broadcast campaigns but no automations or sequences.
- SendGrid is the enterprise option. Feature-rich, sometimes complex. Good for high volume.
| Python email approach | Best fit | Libraries to reach for | Watch out for |
|---|---|---|---|
| Direct HTTP API call | Scripts, CLIs, small services, FastAPI endpoints | httpx or requests | Add timeouts and explicit exception handling |
| Framework email backend | Django apps that already use send_mail() | Custom Django backend or provider SDK | Keep previews/tests aligned with the backend |
| Background task worker | Billing receipts, onboarding, imports, batch notifications | Celery, RQ, Dramatiq, arq | Pass IDs to jobs, not large rendered payloads |
| Provider automation | SaaS lifecycle and marketing sequences | Subscriber/event API | Keep event names stable across app versions |
Install and Configure
Add your API key to .env:
| Setup concern | Django | Flask | FastAPI |
|---|---|---|---|
| Config | settings.py plus environment variables | App config object loaded at startup | Pydantic settings or environment variables |
| Dependency shape | Custom email backend or service module | Blueprint-safe service factory | Async client dependency or app state |
| Background sending | Celery with Redis/RabbitMQ | RQ, Celery, or a hosted queue | Celery/arq for real jobs; BackgroundTasks for tiny work |
| Template rendering | Django templates with text and HTML variants | Jinja templates in the app context | Jinja2Templates or provider-side templates |
| Testing | locmem backend or mocked provider client | Mock service factory | Mock dependency override |
Create a reusable email client:
Send Your First Email
python send_test.pySend from Django
Django has a built-in email system, but it uses SMTP by default. Here's how to use an API provider instead.
Option 1: Custom Email Backend
Create a backend that routes Django's send_mail() through your API provider:
Add to settings.py:
Now Django's built-in send_mail() uses your provider:
from django.core.mail import send_mail
send_mail(
subject="Welcome to our app",
message="",
from_email=None, # uses DEFAULT_FROM_EMAIL
recipient_list=["user@example.com"],
html_message="<h1>Welcome!</h1><p>Your account is ready.</p>",
)Option 2: Direct API Calls in Views
If you prefer calling the API directly (skip Django's email abstraction):
Send from Flask
Send from FastAPI
FastAPI is async, so use httpx.AsyncClient for non-blocking email sends.
HTML Email Templates with Jinja2
Use Jinja2 templates to keep your email HTML separate from your Python code. This works with any framework.
pip install jinja2<!-- templates/emails/welcome.html -->
<!DOCTYPE html>
<html>
<body style="font-family: sans-serif; background: #f6f9fc; padding: 40px 0;">
<div style="max-width: 480px; margin: 0 auto; background: #fff; padding: 40px; border-radius: 8px;">
<h1 style="font-size: 24px; margin-bottom: 16px;">Welcome, {{ name }}</h1>
<p style="font-size: 16px; line-height: 1.6; color: #374151;">
Your account is ready. Click below to get started.
</p>
<a href="{{ login_url }}"
style="display:inline-block; background:#f97316; color:#fff; padding:12px 24px; border-radius:6px; text-decoration:none; font-weight:600; margin-top:16px;">
Go to Dashboard
</a>
</div>
</body>
</html># email_templates.py
from pathlib import Path
from jinja2 import Environment, FileSystemLoader
templates_dir = Path(__file__).parent / "templates" / "emails"
env = Environment(loader=FileSystemLoader(str(templates_dir)), autoescape=True)
def render_welcome(name: str, login_url: str) -> str:
template = env.get_template("welcome.html")
return template.render(name=name, login_url=login_url)
def render_password_reset(reset_url: str) -> str:
template = env.get_template("password_reset.html")
return template.render(reset_url=reset_url)Then use it with any provider:
Background Email Sending with Celery
Don't send emails in your request handler. Use Celery to process them in the background.
pip install celery redis# tasks.py
from celery import Celery
from email_client import send_email
app = Celery("tasks", broker=os.environ.get("REDIS_URL", "redis://localhost:6379"))
@app.task(bind=True, max_retries=3, default_retry_delay=60)
def send_email_task(self, to: str, subject: str, body: str):
try:
return send_email(to=to, subject=subject, body=body)
except Exception as exc:
self.retry(exc=exc)Queue from your view:
# In your Django view or Flask route
from tasks import send_email_task
send_email_task.delay(
to="user@example.com",
subject="Welcome",
body="<h1>Welcome!</h1>",
)
# Returns immediately, email sends in the backgroundError Handling
Add a retry decorator:
import time
from functools import wraps
def with_retry(max_retries: int = 3):
def decorator(fn):
@wraps(fn)
def wrapper(*args, **kwargs):
for attempt in range(max_retries + 1):
try:
return fn(*args, **kwargs)
except Exception:
if attempt == max_retries:
raise
time.sleep(2 ** attempt)
return wrapper
return decorator
@with_retry(max_retries=3)
def send_email_safe(to: str, subject: str, body: str) -> dict:
return send_email(to=to, subject=subject, body=body)Going to Production
1. Verify Your Domain
Add SPF, DKIM, and DMARC DNS records through your provider's dashboard. See our email authentication guide for the full walkthrough. Without this, your emails land in spam.
2. Use a Dedicated Sending Domain
Send from mail.yourapp.com, not your root domain. Protects your main domain's reputation.
3. Use Environment Variables
Never hardcode API keys. Use python-dotenv for local development:
pip install python-dotenvfrom dotenv import load_dotenv
load_dotenv() # Loads .env file into os.environ4. Rate Limit Email Endpoints
from collections import defaultdict
import time
email_timestamps: dict[str, list[float]] = defaultdict(list)
def can_send_email(to: str, max_per_hour: int = 10) -> bool:
now = time.time()
hour_ago = now - 3600
timestamps = [t for t in email_timestamps[to] if t > hour_ago]
if len(timestamps) >= max_per_hour:
return False
timestamps.append(now)
email_timestamps[to] = timestamps
return TrueBeyond Transactional: Marketing and Automation
Once you're sending transactional emails, you'll want onboarding sequences, marketing campaigns, and lifecycle automation. Most teams wire together a transactional provider with Mailchimp or ConvertKit. Two dashboards, two billing systems, subscriber sync headaches.
Sequenzy handles both from one API. Transactional sends, marketing campaigns, automated sequences, subscriber segments, and native Stripe integration.
import httpx
# Add a subscriber when they sign up
client.post("/subscribers", json={
"email": "user@example.com",
"firstName": "Jane",
"tags": ["signed-up"],
"customAttributes": {"plan": "free", "source": "organic"},
})
# Tag them when they upgrade
client.post("/subscribers/tags", json={
"email": "user@example.com",
"tag": "customer",
})
# Track events to trigger sequences
client.post("/subscribers/events", json={
"email": "user@example.com",
"event": "onboarding.completed",
"properties": {"completedSteps": 5},
})Set up sequences in the Sequenzy dashboard, and your Python app triggers them based on user actions.
Wrapping Up
Here's what we covered:
- smtplib vs API providers and when to use each
- Django, Flask, and FastAPI examples for sending emails
- Jinja2 templates for maintainable email HTML
- Celery background tasks to keep responses fast
- Error handling with logging and retries
- Production checklist: domain verification, env variables, rate limiting
The code in this guide is production-ready. Pick your framework and provider, copy the patterns, and start sending.
Frequently Asked Questions
Should I use Python's built-in smtplib or a dedicated email API?
Use a dedicated API for production. Python's smtplib connects directly to SMTP and requires you to handle authentication, TLS, retries, and error codes yourself. Dedicated providers like Sequenzy, Resend, or SendGrid wrap all of this in a clean SDK and add deliverability tracking.
How do I send HTML emails from Django?
Use Django's send_mail() with the html_message parameter, or use EmailMultiAlternatives to send both HTML and plain text versions. For better templates, use Django's template engine to render HTML from .html template files before passing to the send function.
How do I send emails asynchronously in Python?
Use Celery with Redis or RabbitMQ as a broker. Decorate your email-sending function with @celery.task and call it with .delay(). This offloads email sending to a background worker so your API response isn't blocked. For simpler setups, use asyncio with an async-compatible email SDK.
What's the best way to handle email templates in Python?
Use Jinja2 templates for dynamic HTML emails. Store templates as .html files, render them with variables at send time. This separates email content from logic and makes templates easy to update. Django's built-in template engine works similarly.
How do I avoid emails going to spam when sending from Python?
Configure SPF, DKIM, and DMARC DNS records for your sending domain. Our deliverability guide covers this in detail. Use a dedicated email provider instead of sending directly from your server. Send from a consistent "from" address, and include a plain text version alongside HTML.
Can I send bulk emails from a Flask or FastAPI application?
Don't send bulk emails in the request/response cycle. Use a background task queue (Celery, Dramatiq, or Huey) to process bulk sends. This prevents request timeouts and gives you retry handling. Most providers also offer batch endpoints for sending to multiple recipients in a single API call.
How do I test email sending in Python without sending real emails?
Use unittest.mock to mock the email provider's SDK in tests. Django has a built-in locmem email backend that captures emails in memory. For integration testing, use your provider's sandbox mode or tools like Mailpit to capture emails locally.
How do I handle email attachments in Python?
Most email SDKs accept attachments as base64-encoded strings or file paths. Read the file, encode it with base64.b64encode(), and pass it with the MIME type and filename. Keep attachments under 10MB to avoid deliverability issues.
Is asyncio better than Celery for email sending?
Asyncio is lighter and works well for sending a few emails without blocking. Celery is better for production systems where you need retry logic, rate limiting, scheduled sends, and monitoring. Use asyncio for simple transactional emails and Celery for anything at scale.
How do I store email API keys in Python securely?
Use environment variables loaded with python-dotenv or your framework's settings. Never hardcode keys in source files. In production, use your platform's secrets manager (AWS Secrets Manager, GCP Secret Manager, or your PaaS's environment config). Add .env to .gitignore.