Verify emails in Java with Verifly

Email verification on the JVM

Java backends — Spring Boot services, batch processors, enterprise integrations — collect email addresses constantly, and the JVM's built-in tools stop at syntax. Validating with a regex or with Jakarta's @Email constraint confirms an address is well-formed, but a well-formed address is routinely a dead mailbox, a disposable throwaway domain, or a role inbox like support@ that nobody reads. Those slip past validation and turn into hard bounces that erode your sending reputation.

Verifly closes that gap with one HTTP request, and since Java 11 you do not need Apache HttpClient or OkHttp to make it. The built-in java.net.http.HttpClient sends the request; you set a Bearer header, get back a JSON body, and parse it with Jackson or Gson (or any JSON library your project already uses) into a result of deliverable, undeliverable, or risky plus disposable, role, catch-all, and smtp flags. Deserialize into a small record or POJO and the verdict becomes an ordinary switch expression in your service.

Pay-as-you-go pricing fits both a high-throughput microservice and an occasional data-cleanup job — from $2 per 1,000 checks down to $0.60 per 1,000 at volume, with no license or seat to negotiate. Self-register for 100 free credits with no card and no captcha, keep the vf_ key in your application config or a secret store, and reuse it across every service.

Batch-verify a list of emails in Java

For more than a single address, POST the whole set to /verify/batch rather than sending a request per element. Serialize an emails array into the JSON body and read back a results array in order, then stream over it with the Java Streams API to filter and collect. This keeps connection overhead down and cost predictable inside a batch job.

String body = """
    {"emails":["ada@example.com","info@some-domain.com","noreply@disposable.tld"]}
    """;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://verifly.email/api/v1/verify/batch"))
    .header("Authorization", "Bearer vf_YOUR_KEY")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

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

// Parse res.body() with Jackson/Gson into a results list, e.g.:
// record Row(String email, String result, boolean disposable, boolean role) {}
// List<Row> results = mapper.readValue(res.body(), Payload.class).results();
// results.stream()
//        .filter(r -> r.result().equals("deliverable"))
//        .forEach(r -> System.out.println("keep: " + r.email()));

Validate at signup in Spring Boot

The most valuable place to verify in a Java web app is the registration endpoint. Build the HttpClient with a connect timeout and give the request its own timeout so a slow probe never blocks the thread, and catch exceptions to fail open so a transient outage never rejects a legitimate signup. Reject disposable addresses and warn on undeliverable ones before you persist the entity.

boolean emailOk(String email) {
    HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(4))
        .build();
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create("https://verifly.email/api/v1/verify?email="
            + URLEncoder.encode(email, StandardCharsets.UTF_8)))
        .header("Authorization", "Bearer vf_YOUR_KEY")
        .timeout(Duration.ofSeconds(8))
        .GET()
        .build();
    try {
        HttpResponse<String> res =
            client.send(req, HttpResponse.BodyHandlers.ofString());
        JsonNode data = new ObjectMapper().readTree(res.body());
        if (data.path("disposable").asBoolean()) return false;
        return !"undeliverable".equals(data.path("result").asText());
    } catch (Exception e) {
        return true; // fail open on network error
    }
}