Email Verification API
.NET / C# 2026

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpClient<BounceZeroService>(client =>
{
    client.BaseAddress = new Uri("https://api.bouncezero.io/");
    client.DefaultRequestHeaders.Add(
        "X-API-Key",
        builder.Configuration["BounceZero:ApiKey"]
    );
    client.Timeout = TimeSpan.FromSeconds(10);
});

// appsettings.json
// "BounceZero": { "ApiKey": "YOUR_API_KEY" }

// BounceZeroService.cs
using System.Net.Http.Json;

public record VerifyResult(
    string Email,
    string Result,
    bool IsDisposable,
    bool IsRoleAddress,
    double CatchAllScore,
    bool MxFound,
    bool FreeProvider,
    int SmtpCode
);

public class BounceZeroService(HttpClient http)
{
    public async Task<VerifyResult?> VerifyAsync(
        string email,
        CancellationToken ct = default)
    {
        var url = $"v1/verify?email={Uri.EscapeDataString(email)}";
        return await http.GetFromJsonAsync<VerifyResult>(url, ct);
    }

    public bool IsAcceptable(VerifyResult result) =>
        result.Result != "invalid" &&
        !result.IsDisposable &&
        (result.Result != "unknown" || result.CatchAllScore >= 0.5);
}

// Program.cs (continued)
app.MapPost("/api/signup", async (
    SignupRequest req,
    BounceZeroService bz,
    CancellationToken ct) =>
{
    try
    {
        var verification = await bz.VerifyAsync(req.Email, ct);

        if (verification is not null && !bz.IsAcceptable(verification))
        {
            return Results.UnprocessableEntity(new
            {
                error = "invalid_email",
                message = "Please use a valid work email address."
            });
        }
    }
    catch (Exception)
    {
        // fail-open: API unavailable > allow the signup
    }

    // proceed with account creation...
    return Results.Ok(new { status = "created" });
});

record SignupRequest(string Email, string Name);

// EmailVerificationWorker.cs
public class EmailVerificationWorker(
    IServiceScopeFactory scopeFactory,
    Channel<string> queue) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        await foreach (var email in queue.Reader.ReadAllAsync(ct))
        {
            await using var scope  = scopeFactory.CreateAsyncScope();
            var bz  = scope.ServiceProvider.GetRequiredService<BounceZeroService>();
            var db  = scope.ServiceProvider.GetRequiredService<AppDbContext>();

            try
            {
                var result = await bz.VerifyAsync(email, ct);
                var user   = await db.Users.FirstAsync(u => u.Email == email, ct);

                user.EmailVerified  = result?.Result == "valid";
                user.IsDisposable   = result?.IsDisposable ?? false;
                user.VerifiedAt     = DateTimeOffset.UtcNow;
                await db.SaveChangesAsync(ct);
            }
            catch (Exception ex)
            {
                // log and move on - don't block the queue
            }
        }
    }
}

// Register in Program.cs:
// builder.Services.AddSingleton(Channel.CreateBounded<string>(1000));
// builder.Services.AddHostedService<EmailVerificationWorker>();