Email Verification API
Java Integration Guide 2026

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

public class BounceZeroClient {

    private static final String BASE_URL = "https://api.bouncezero.io/v1/verify";
    private static final String API_KEY  = System.getenv("BOUNCEZERO_API_KEY");

    private final HttpClient http = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();

    public VerifyResult verify(String email) throws Exception {
        String encoded = URLEncoder.encode(email, StandardCharsets.UTF_8);
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "?email=" + encoded))
            .header("X-API-Key", API_KEY)
            .GET()
            .timeout(Duration.ofSeconds(15))
            .build();

        HttpResponse<String> res = http.send(req, HttpResponse.BodyHandlers.ofString());

        if (res.statusCode() != 200) {
            throw new RuntimeException("BounceZero API error: " + res.statusCode());
        }
        return VerifyResult.fromJson(res.body());
    }
}

public record VerifyResult(
    String status,   // "valid" | "invalid" | "risky" | "unknown"
    int    score,    // 0-100
    String reason,
    boolean isDisposable,
    boolean isRole,
    boolean isCatchAll
) {
    public static VerifyResult fromJson(String json) {
        // Use Jackson, Gson, or org.json - pattern shown with simple parsing
        // Example using Jackson ObjectMapper (add com.fasterxml.jackson.core:jackson-databind):
        // ObjectMapper mapper = new ObjectMapper();
        // return mapper.readValue(json, VerifyResult.class);
        throw new UnsupportedOperationException("wire your JSON library here");
    }
}

import java.util.*;
import java.util.concurrent.*;

public class BulkVerifier {

    private static final int THREADS = 5; // adjust to your rate limit

    public Map<String, VerifyResult> verifyAll(List<String> emails) throws Exception {
        BounceZeroClient client = new BounceZeroClient();
        ExecutorService pool = Executors.newFixedThreadPool(THREADS);
        Map<String, Future<VerifyResult>> futures = new LinkedHashMap<>();

        for (String email : emails) {
            futures.put(email, pool.submit(() -> client.verify(email)));
        }

        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.MINUTES);

        Map<String, VerifyResult> results = new LinkedHashMap<>();
        for (Map.Entry<String, Future<VerifyResult>> entry : futures.entrySet()) {
            try {
                results.put(entry.getKey(), entry.getValue().get());
            } catch (ExecutionException e) {
                // fail-open: treat API errors as unknown
                System.err.println("Error verifying " + entry.getKey() + ": " + e.getCause().getMessage());
                results.put(entry.getKey(), new VerifyResult("unknown", 50, "api_error", false, false, false));
            }
        }
        return results;
    }
}

// BounceZeroConfig.java
@Configuration
public class BounceZeroConfig {
    @Bean
    public BounceZeroClient bounceZeroClient() {
        return new BounceZeroClient(); // singleton - shares HttpClient connection pool
    }
}

// RegistrationService.java
@Service
public class RegistrationService {

    private final BounceZeroClient emailVerifier;

    public RegistrationService(BounceZeroClient emailVerifier) {
        this.emailVerifier = emailVerifier;
    }

    public RegistrationResult register(String email, String password) {
        VerifyResult vr;
        try {
            vr = emailVerifier.verify(email);
        } catch (Exception e) {
            // fail-open: don't block signup if verification service is unreachable
            vr = new VerifyResult("unknown", 50, "timeout", false, false, false);
        }

        if ("invalid".equals(vr.status())) {
            return RegistrationResult.rejected("Email address is invalid or does not exist.");
        }
        if (vr.isDisposable()) {
            return RegistrationResult.rejected("Disposable email addresses are not allowed.");
        }
        if ("risky".equals(vr.status())) {
            // flag for review rather than hard block
            return createAccountWithRiskyFlag(email, password);
        }

        return createAccount(email, password);
    }
}