Verify emails in FastAPI with Verifly

Async email verification in FastAPI

FastAPI is async by design, and email verification is an I/O-bound network call — a perfect match. Pydantic's EmailStr already validates that an address is well-formed, but that is only syntax: user@dead-domain.com passes EmailStr and still bounces. The mailbox's real status lives behind an SMTP handshake, and Verifly performs that handshake for you over one HTTPS request that you can await without blocking the event loop.

Because Verifly is a plain REST API, httpx is the idiomatic client — its AsyncClient mirrors requests but returns awaitables. You await a GET to /api/v1/verify with a Bearer key and read a JSON verdict with a result field of deliverable, undeliverable, or risky plus boolean flags for disposable, role, catch_all, and smtp. Put the check just before you persist the user so you never create an account on a dead or throwaway address.

For performance, do not open a fresh AsyncClient per request in production — create one on startup and reuse it via a dependency or app state, which keeps the connection pool warm. Pricing is pay-as-you-go from $2 per 1,000 checks down to $0.60 per 1,000 at volume. Self-register for 100 free credits with no card at the autonomous register endpoint.

Reuse one AsyncClient with a dependency

Creating an httpx.AsyncClient per request adds handshake overhead and wastes connections. Instead, build a single client during the FastAPI lifespan and inject it with Depends. Wrap the verification in a try/except so a transient httpx error fails open — you would rather admit a rare unverified address than 500 a legitimate signup on a network blip.

import httpx
from contextlib import asynccontextmanager
from fastapi import Depends, FastAPI

@asynccontextmanager
async def lifespan(app: FastAPI):
    app.state.http = httpx.AsyncClient(timeout=8)
    yield
    await app.state.http.aclose()

app = FastAPI(lifespan=lifespan)

async def get_client(request) -> httpx.AsyncClient:
    return request.app.state.http

async def email_ok(email: str, client: httpx.AsyncClient) -> bool:
    try:
        r = await client.get(
            "https://verifly.email/api/v1/verify",
            params={"email": email},
            headers={"Authorization": "Bearer vf_YOUR_KEY"},
        )
        data = r.json()
    except httpx.HTTPError:
        return True  # fail open: never block signup on a network error
    return data["result"] != "undeliverable" and not data.get("disposable")

Batch-verify a list in an async route

For cleaning a list rather than a single signup, do not gather many single calls — POST them together to /api/v1/verify/batch. It accepts a JSON body with an emails array and returns a results array in the same order, so a single awaited request handles the whole list. Reuse the shared AsyncClient and filter the results down to deliverable addresses.

from fastapi import Depends, FastAPI
import httpx

@app.post("/admin/clean")
async def clean(emails: list[str], client: httpx.AsyncClient = Depends(get_client)):
    r = await client.post(
        "https://verifly.email/api/v1/verify/batch",
        json={"emails": emails},
        headers={"Authorization": "Bearer vf_YOUR_KEY"},
    )
    results = r.json()["results"]
    kept = [x["email"] for x in results
            if x["result"] == "deliverable" and not x.get("disposable")]
    return {"kept": kept, "total": len(results)}