Verify emails server-side in Django

Why Django's EmailValidator can't catch bounces

Django's EmailField and EmailValidator confirm that a string is shaped like an email address. They do not open a connection to the mail server, so they cannot tell you whether the mailbox behind that address actually accepts mail. A user can register with a flawlessly formatted address that has no inbox, and every activation link, password reset, and notification you send will hard-bounce.

A steady stream of bounces erodes your sending domain's standing with the big mailbox providers, which quietly pushes even your legitimate transactional email toward spam folders. Public signup and registration endpoints also attract disposable inboxes and throwaway abuse accounts, so rejecting those domains at validation time keeps your auth_user table lean and your metrics real.

Verifly performs a live SMTP mailbox check and returns a deliverable / undeliverable / risky verdict along with disposable, role, and catch-all flags. Because the API is a simple authenticated GET, it fits naturally inside a form's clean_email method, a DRF serializer validator, or an async Celery task.

Reject undeliverable emails in a Django form

1. Grab a free Verifly key at verifly.email/api/v1/autonomous/register — 100 credits, no card, no captcha.
2. Store it as VERIFLY_API_KEY in settings (read from an environment variable, never hard-coded).
3. Override clean_email on your registration form and call Verifly there.
4. Raise forms.ValidationError for undeliverable or disposable results so the message binds to the email field.
5. Fail open on a network error or non-200 so a verifier outage never blocks a real signup.

import requests
from django import forms
from django.conf import settings


class SignupForm(forms.Form):
    email = forms.EmailField()

    def clean_email(self):
        email = self.cleaned_data['email']
        try:
            res = requests.get(
                'https://verifly.email/api/v1/verify',
                params={'email': email},
                headers={'Authorization': f'Bearer {settings.VERIFLY_API_KEY}'},
                timeout=15,
            )
            res.raise_for_status()
        except requests.RequestException:
            return email  # fail open: don't block signup on a verifier outage

        data = res.json()
        if data.get('result') == 'undeliverable' or data.get('disposable'):
            raise forms.ValidationError('Please use a real, deliverable email address.')
        return email

The same check in a DRF serializer

If your signup is an API endpoint built on Django REST Framework, put the identical logic in a field-level validate_email method on the serializer. Raising serializers.ValidationError returns a clean 400 with the error attached to the email field, exactly like any other validation failure, so your frontend handles it with no special casing.

import requests
from django.conf import settings
from rest_framework import serializers


class SignupSerializer(serializers.Serializer):
    email = serializers.EmailField()
    password = serializers.CharField(write_only=True)

    def validate_email(self, value):
        try:
            res = requests.get(
                'https://verifly.email/api/v1/verify',
                params={'email': value},
                headers={'Authorization': f'Bearer {settings.VERIFLY_API_KEY}'},
                timeout=15,
            )
            res.raise_for_status()
        except requests.RequestException:
            return value

        if res.json().get('result') == 'undeliverable':
            raise serializers.ValidationError('This email address is not deliverable.')
        return value