Email Verification API Python 2026
Integration Guide with Code Examples

import requests

API_KEY = "YOUR_BOUNCEZERO_API_KEY"
BASE_URL = "https://api.bouncezero.io/api/v1"

def verify_email(email: str) -> dict:
    """Verify a single email address and return the full result."""
    response = requests.post(
        f"{BASE_URL}/verify",
        json={"email": email},
        headers={"X-API-Key": API_KEY},
        timeout=10
    )
    response.raise_for_status()
    return response.json()

def is_safe_to_send(email: str) -> bool:
    """Return True only if the email is valid and not an unresolved catch-all."""
    result = verify_email(email)
    if result["classification"] != "valid":
        return False  # invalid, disposable, spamtrap, risky or unverifiable
    meta = result.get("metadata") or {}
    # Unresolved catch-all is reported valid: keep only high-confidence ones
    if meta.get("catch_all_unresolved") and result.get("score", 0) < 70:
        return False
    return True

# Usage
if is_safe_to_send("[email protected]"):
    print("Safe to send")
else:
    print("Suppress this email")

import asyncio
import httpx

API_KEY = "YOUR_BOUNCEZERO_API_KEY"
BASE_URL = "https://api.bouncezero.io/api/v1"
CONCURRENCY = 10  # max concurrent requests (respect rate limits)

async def verify_email_async(client: httpx.AsyncClient, email: str) -> dict:
    response = await client.post(
        f"{BASE_URL}/verify",
        json={"email": email},
        headers={"X-API-Key": API_KEY},
    )
    response.raise_for_status()
    data = response.json()
    return {"email": email, **data}

async def verify_batch(emails: list[str]) -> list[dict]:
    sem = asyncio.Semaphore(CONCURRENCY)

    async def bounded_verify(client, email):
        async with sem:
            try:
                return await verify_email_async(client, email)
            except Exception as e:
                return {"email": email, "classification": "error", "error": str(e)}

    async with httpx.AsyncClient(timeout=15) as client:
        tasks = [bounded_verify(client, email) for email in emails]
        return await asyncio.gather(*tasks)

# Usage
emails = ["[email protected]", "[email protected]", "[email protected]"]
results = asyncio.run(verify_batch(emails))

for r in results:
    status = r.get("classification", "error")
    print(f"{r['email']}: {status}")

import csv
import asyncio
import httpx

API_KEY = "YOUR_BOUNCEZERO_API_KEY"

async def verify_csv(input_path: str, output_path: str):
    # Read emails from CSV
    emails = []
    with open(input_path, newline="") as f:
        reader = csv.DictReader(f)
        fieldnames = reader.fieldnames or []
        rows = list(reader)
        for row in rows:
            emails.append(row.get("email", ""))

    # Verify all emails
    from verify_email_async import verify_batch  # import from section 2
    results = await verify_batch(emails)
    result_map = {r["email"]: r for r in results}

    # Write enriched CSV
    out_fields = list(fieldnames) + ["bz_result", "bz_score", "bz_internal"]
    with open(output_path, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=out_fields)
        writer.writeheader()
        for row in rows:
            email = row.get("email", "")
            res = result_map.get(email, {})
            row["bz_result"] = res.get("classification", "")
            row["bz_score"] = res.get("score", "")
            row["bz_internal"] = (res.get("metadata") or {}).get("internal_classification", "")
            writer.writerow(row)

    print(f"Written {len(rows)} rows to {output_path}")

asyncio.run(verify_csv("leads.csv", "leads_verified.csv"))

from flask import Flask, request, jsonify
import requests, os

app = Flask(__name__)
API_KEY = os.environ["BOUNCEZERO_API_KEY"]

@app.route("/register", methods=["POST"])
def register():
    email = request.json.get("email", "").strip()

    # Verify email before creating account
    try:
        res = requests.post(
            "https://api.bouncezero.io/api/v1/verify",
            json={"email": email},
            headers={"X-API-Key": API_KEY},
            timeout=5
        ).json()
    except Exception:
        # Fail open: allow registration if API is unavailable
        res = {}

    internal = (res.get("metadata") or {}).get("internal_classification")
    if internal == "disposable":
        return jsonify({"error": "Disposable emails are not allowed."}), 422
    if res.get("classification") == "invalid" and not (res.get("metadata") or {}).get("refunded"):
        return jsonify({"error": "Invalid email address."}), 422
    # metadata.refunded = could not be verified: fail open like a timeout

    # Create user account...
    return jsonify({"status": "ok"}), 201