DEV Community: Linh Fish Dev

Django: Send Email with send_mail() in 5 Minutes — Configure SMTP the Right Way

Linh Fish Dev — Sat, 07 Nov 2026 15:12:36 +0000

Django already ships with send_mail() — configure SMTP once in settings.py and you can send email with a single call. Use it for welcome emails after registration, order confirmations, password resets, or system notifications. No extra library to install, and no hand-rolled SMTP code with smtplib.

The Problem

Many new projects call send_mail() right away without configuring anything, assuming Django “just knows” where to send mail. In reality Django defaults to an SMTP backend pointing at localhost:25 — most dev machines have no mail server, so the request hangs and then fails with ConnectionRefusedError, and users who just registered wait forever for a welcome email that never arrives. Another common mistake is hardcoding the email password straight into settings.py and accidentally committing it to Git — the mailbox gets exposed and abused to send spam.

from django.core.mail import send_mail

send_mail(
    "Chao mung ban den voi MyShop",
    "Cam on ban da dang ky tai khoan.",
    "noreply@example.com",
    ["khach@example.com"],
    fail_silently=False,
)
# ConnectionRefusedError: [Errno 111] Connection refused (localhost:25)

The Solution

The right approach is to move the configuration into environment variables and let Django handle the SMTP part. In settings.py, declare the SMTP backend with its host, port, and credentials — the password comes from an environment variable, never written directly into the code. For local development, switch to the console backend so mail is printed to the terminal instead of actually sent, and you never risk emailing real users by accident.

import os

EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
EMAIL_HOST = "smtp.gmail.com"
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = os.environ["EMAIL_HOST_USER"]
EMAIL_HOST_PASSWORD = os.environ["EMAIL_HOST_PASSWORD"]
DEFAULT_FROM_EMAIL = "MyShop <noreply@example.com>"

# Dev local: in mail ra terminal thay vi gui that
# EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"

After that, anywhere in your code — a view, a signal, or a management command — one send_mail() call with four arguments is enough: subject, plain-text body, sender address, and the list of recipients. The function returns the number of emails sent successfully, usually 1; if SMTP fails and fail_silently=False (the default), Django raises an exception so you can handle it instead of silently swallowing the error. For a nicer HTML version, pass html_message — Django automatically attaches the plain-text body as a fallback for old mail clients.

from django.core.mail import send_mail

sent = send_mail(
    "Don hang #123 da duoc xac nhan",
    "Don hang #123 cua ban da duoc xac nhan.",
    "noreply@example.com",
    ["khach@example.com"],
    html_message="<h1>Don hang #123</h1><p>Cam on ban da mua hang.</p>",
)
print(sent)  # 1

Apply It to Your Project

Wire send_mail() into the right touchpoints: a welcome email after user registration (combined with the post_save signal), a confirmation email after an order is created, a password-reset email. Sending over SMTP usually takes 1–3 seconds, so don’t call it directly in a view if you don’t want users waiting — push it to a background task or run it after the transaction commits successfully, and always log failures so you can resend later.

Frequently Asked Questions

Can I send email with Gmail?

Yes. Use host smtp.gmail.com, port 587, enable TLS, and use an App Password instead of your main password — Gmail has blocked sign-in with regular passwords since 2022. Remember to turn on two-step verification before creating an App Password.

How do I test sending email without actually sending it?

Set EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' in your dev settings — mail will be printed to the terminal instead of leaving your machine. To assert on mail in tests, use the locmem backend and inspect django.core.mail.outbox.

Can send_mail() send to many people at once?

Yes — pass a list of addresses to recipient_list and they all receive the same email. If you need to send a bulk batch where each person gets different content, use send_mass_mail() to open a single SMTP connection instead of reopening one per email.

What if my emails keep landing in spam?

Check three things: the sender address must belong to a domain you own, that domain must have SPF/DKIM/DMARC configured, and the content should avoid spam-like wording. Also, sending from a low-reputation SMTP account is more likely to get filtered — consider a dedicated email-sending service when your volume grows.

💬 Have you tried this in your own project? If you hit an error or know a shorter way to do it, leave a comment below — I read every one and will fold the best ideas into the post.

References

Django documentation — Sending email: https://docs.djangoproject.com/en/stable/topics/email/
Django documentation — django.core.mail: https://docs.djangoproject.com/en/stable/topics/email/#send-mail

Originally published at linhfish.dev.

Python: Call Multiple APIs in Parallel with asyncio.gather and Semaphore in 10 Minutes

Linh Fish Dev — Sat, 07 Nov 2026 10:03:43 +0000

When you need to call dozens of APIs — syncing data, crawling prices, firing webhooks — a sequential for loop adds up the waiting time of every request: 20 requests × 1 second = 20 seconds. asyncio.gather runs many coroutines concurrently inside a single event loop, while asyncio.Semaphore limits how many requests fly at the same time so you don't overwhelm the partner API. This technique applies to every I/O-bound task (HTTP calls, file reads, database queries) and only needs the httpx library.

The Problem: a Sequential Loop Adds Up All the Waiting

Say you need to fetch info for 20 users from a partner API, each request taking about 1 second. The most "naive" code is a loop with the synchronous httpx.Client:

import time
import httpx

URLS = [f"https://api.example.com/users/{i}" for i in range(20)]

def fetch_all():
    results = []
    with httpx.Client(timeout=10) as client:
        for url in URLS:
            results.append(client.get(url).json())
    return results

t0 = time.perf_counter()
fetch_all()
print(f"finished in {time.perf_counter() - t0:.1f} seconds")

This code runs correctly, but the total time is ≈ 20 seconds because each request waits for the previous one to finish. The CPU sits idle almost the whole time — the bottleneck is I/O waiting, not processing power. With 200 records, you'd wait over 3 minutes.

The Solution: asyncio.gather + Semaphore

asyncio lets many coroutines "suspend" at I/O waiting points and hand the event loop to another coroutine. asyncio.gather(*coros) groups them and runs them concurrently, returning results in the same order you passed in. But don't fire 200 requests at once — the partner API may rate-limit you or block your IP. asyncio.Semaphore(n) is a "gate" that lets only n coroutines through at the same time:

import asyncio
import httpx

async def fetch_one(client, url, sem):
    async with sem:  # grab a ticket before calling HTTP
        resp = await client.get(url, timeout=10)
        resp.raise_for_status()
        return resp.json()

async def fetch_all_async(urls):
    sem = asyncio.Semaphore(5)  # at most 5 requests at once
    async with httpx.AsyncClient() as client:
        return await asyncio.gather(
            *(fetch_one(client, u, sem) for u in urls),
            return_exceptions=True,
        )

results = asyncio.run(fetch_all_async(URLS))

How it flows: each fetch_one grabs a "ticket" from the semaphore before calling HTTP; at most 5 requests fly together, and when one finishes another takes its place. With 20 requests × 1 second and Semaphore(5), total time drops to ≈ 4 seconds instead of 20. Measured on a local server (20 requests × 0.3 seconds): 6.19 seconds → 1.41 seconds.

Collect Errors Neatly with return_exceptions=True

By default, one failing coroutine makes gather raise the exception immediately, and you lose the results of the requests that already finished. Pass return_exceptions=True and the error comes back as a normal item in the result list — filter it afterwards:

ok = [r for r in results if not isinstance(r, Exception)]
failed = [r for r in results if isinstance(r, Exception)]
print(f"success: {len(ok)}/{len(results)}")
for e in failed:
    print("failed request:", repr(e))

This pattern shines in data-sync jobs: 98 of 100 records still get processed, and the 2 failures go to the log for a later retry — instead of the whole batch dying because of one bad request.

Apply It to Your Project

Start with Semaphore(5), then raise it gradually while watching response times and 429 codes from the partner API. Always set a timeout on every request — one request hanging forever holds its semaphore "ticket" forever and jams the whole batch. If your project already uses FastAPI, your async def endpoints can await fetch_all_async() directly without asyncio.run().

FAQ

What should I set Semaphore(n) to?

There's no magic number: start at 5–10, increase gradually, and watch for 429 codes or timeouts from the partner API. Many public APIs limit you to 5–10 requests per second.

Does gather keep the result order?

Yes. Results come back in the order you passed the coroutines in, not the order they finish. That's the difference from asyncio.as_completed().

Can one bad request kill the whole batch?

By default, yes — gather raises the first exception it meets. Use return_exceptions=True to collect errors into the list and handle them later, as shown above.

When should I NOT use asyncio?

For CPU-bound work (image processing, file compression, heavy math): the GIL prevents coroutines from truly running in parallel. Use multiprocessing or concurrent.futures.ProcessPoolExecutor for those.

💬 Have you tried this in your project? If you hit an error or know a cleaner way, leave a comment below — I read them all and will add the best ideas to this post.

References

Python docs — asyncio: https://docs.python.org/3/library/asyncio.html
httpx docs — Async API: https://www.python-httpx.org/async/

Originally published at linhfish.dev.

DEV Community: Linh Fish Dev

Django: Send Email with send_mail() in 5 Minutes — Configure SMTP the Right Way

The Problem

The Solution

Apply It to Your Project

Related Posts

Frequently Asked Questions

Can I send email with Gmail?

How do I test sending email without actually sending it?

Can send_mail() send to many people at once?

What if my emails keep landing in spam?

References

Python: Call Multiple APIs in Parallel with asyncio.gather and Semaphore in 10 Minutes

The Problem: a Sequential Loop Adds Up All the Waiting

The Solution: asyncio.gather + Semaphore

Collect Errors Neatly with return_exceptions=True

Apply It to Your Project

Related Posts

FAQ

What should I set Semaphore(n) to?

Does gather keep the result order?

Can one bad request kill the whole batch?

When should I NOT use asyncio?

References