Integrating Fuego Email Verification API with Java
This guide will walk you through the process of integrating the Fuego Email Verification API into your Java applications. Whether you’re building a web application, a desktop app, or a backend service, this guide provides comprehensive implementation examples for Java developers.
Prerequisites
- A Fuego account with an API key
- Java 8 or higher
- Basic knowledge of Java and HTTP requests
API Endpoint
The Fuego API endpoint for email verification is:
https://app.fuegoverify.com/api/v1/verify
Authentication
Authentication is done using an API token as a query parameter:
String apiToken = "YOUR_API_TOKEN";
// Token will be added to the URL as a query parameter
Method 1: Using HttpURLConnection (Standard Library)
The standard Java library provides HttpURLConnection for making HTTP requests without any additional dependencies:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import org.json.JSONObject;
/**
* Verifies an email address using the Fuego API with standard HttpURLConnection
*/
public class EmailVerifier {
private static final String API_ENDPOINT = "https://app.fuegoverify.com/api/v1/verify";
private final String apiToken;
public EmailVerifier(String apiToken) {
this.apiToken = apiToken;
}
/**
* Verifies an email address
*
* @param email The email address to verify
* @return A JSONObject containing the verification result
* @throws IOException if there's a communication error
* @throws Exception for other errors
*/
public JSONObject verifyEmail(String email) throws IOException, Exception {
// Prepare URL with parameters
String encodedEmail = URLEncoder.encode(email, StandardCharsets.UTF_8.toString());
String encodedToken = URLEncoder.encode(apiToken, StandardCharsets.UTF_8.toString());
String urlString = API_ENDPOINT + "?email=" + encodedEmail + "&token=" + encodedToken;
URL url = new URL(urlString);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// Set request method and headers
connection.setRequestMethod("GET");
connection.setRequestProperty("Content-Type", "application/json");
connection.setConnectTimeout(30000); // 30 seconds
connection.setReadTimeout(30000); // 30 seconds
try {
// Get response code
int responseCode = connection.getResponseCode();
// Read response
BufferedReader reader;
if (responseCode >= 200 && responseCode < 300) {
reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
} else {
reader = new BufferedReader(new InputStreamReader(connection.getErrorStream()));
}
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
response.append(line);
}
reader.close();
// Parse JSON response
JSONObject jsonResponse = new JSONObject(response.toString());
// Handle errors
if (responseCode >= 400) {
String errorMessage = jsonResponse.optString("error", "Unknown error");
if (responseCode == 429) {
throw new Exception("Rate limit exceeded. Please try again later.");
} else if (responseCode == 401) {
throw new Exception("Invalid API token. Please check your credentials.");
} else {
throw new Exception("API Error (" + responseCode + "): " + errorMessage);
}
}
return jsonResponse;
} finally {
connection.disconnect();
}
}
/**
* Process the verification result
*
* @param result The JSONObject from the API response
* @return A Map containing a simplified status
*/
public Map<String, Object> handleVerificationResult(JSONObject result) {
Map<String, Object> status = new HashMap<>();
String resultStatus = result.optString("result", "unknown");
switch (resultStatus) {
case "valid":
status.put("valid", true);
status.put("message", "Email address is valid and deliverable");
break;
case "invalid":
status.put("valid", false);
status.put("message", "Email address is invalid: " +
(result.has("reason") ? result.getString("reason") : "Unknown reason"));
break;
case "risky":
status.put("valid", false);
status.put("risky", true);
status.put("message", "Email address is risky: " +
(result.has("reason") ? result.getString("reason") : "Unknown reason"));
break;
case "unknown":
status.put("valid", null);
status.put("message", "Verification result is inconclusive");
break;
default:
status.put("valid", null);
status.put("message", "Unknown verification result");
break;
}
status.put("details", result);
return status;
}
public static void main(String[] args) {
String apiToken = "YOUR_API_TOKEN";
String emailToVerify = "[email protected]";
EmailVerifier verifier = new EmailVerifier(apiToken);
try {
JSONObject result = verifier.verifyEmail(emailToVerify);
Map<String, Object> status = verifier.handleVerificationResult(result);
System.out.println(status.get("message"));
// Access domain intelligence
if (result.has("domain_insight")) {
JSONObject domainInsight = result.getJSONObject("domain_insight");
if (domainInsight.has("name")) {
System.out.println("Organization: " + domainInsight.getString("name"));
}
if (domainInsight.has("industry")) {
System.out.println("Industry: " + domainInsight.getString("industry"));
}
}
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
}
Note: This example uses the org.json library for parsing JSON. If you’re not using a build tool, you can download it here or add this Maven dependency:
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20231013</version>
</dependency>
Method 2: Using Apache HttpClient
Apache HttpClient is a popular HTTP client library that provides more robust capabilities:
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.json.JSONObject;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
/**
* Email verification using Apache HttpClient
*/
public class ApacheEmailVerifier {
private static final String API_ENDPOINT = "https://app.fuegoverify.com/api/v1/verify";
private final String apiToken;
public ApacheEmailVerifier(String apiToken) {
this.apiToken = apiToken;
}
/**
* Verifies an email address
*
* @param email The email address to verify
* @return A JSONObject containing the verification result
* @throws Exception if an error occurs
*/
public JSONObject verifyEmail(String email) throws Exception {
try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
// Build the URL with parameters
URI uri = new URIBuilder(API_ENDPOINT)
.addParameter("email", email)
.addParameter("token", apiToken)
.build();
// Create and configure the request
HttpGet request = new HttpGet(uri);
request.setHeader("Content-Type", "application/json");
// Execute request
try (CloseableHttpResponse response = httpClient.execute(request)) {
int statusCode = response.getStatusLine().getStatusCode();
HttpEntity entity = response.getEntity();
String responseBody = entity != null ? EntityUtils.toString(entity) : null;
// Parse JSON response
JSONObject jsonResponse = new JSONObject(responseBody != null ? responseBody : "{}");
// Handle errors
if (statusCode >= 400) {
String errorMessage = jsonResponse.optString("error", "Unknown error");
if (statusCode == HttpStatus.SC_TOO_MANY_REQUESTS) {
throw new Exception("Rate limit exceeded. Please try again later.");
} else if (statusCode == HttpStatus.SC_UNAUTHORIZED) {
throw new Exception("Invalid API token. Please check your credentials.");
} else {
throw new Exception("API Error (" + statusCode + "): " + errorMessage);
}
}
return jsonResponse;
}
}
}
// handleVerificationResult method can be same as in the previous example
public static void main(String[] args) {
String apiToken = "YOUR_API_TOKEN";
String emailToVerify = "[email protected]";
ApacheEmailVerifier verifier = new ApacheEmailVerifier(apiToken);
try {
JSONObject result = verifier.verifyEmail(emailToVerify);
System.out.println("Verification result: " + result.getString("result"));
if (result.getString("result").equals("valid")) {
System.out.println("Email is valid!");
} else {
System.out.println("Email is " + result.getString("result") + ": " +
(result.has("reason") ? result.getString("reason") : "No reason specified"));
}
// Access domain intelligence
if (result.has("domain_insight")) {
JSONObject domainInsight = result.getJSONObject("domain_insight");
String company = domainInsight.optString("name", "Unknown");
String industry = domainInsight.optString("industry", "Unknown");
System.out.println("Company: " + company + ", Industry: " + industry);
}
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
}
Maven dependencies for Apache HttpClient:
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.14</version>
</dependency>
Method 3: Using OkHttp
OkHttp is a modern HTTP client that’s efficient and easy to use:
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import org.json.JSONObject;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* Email verification using OkHttp
*/
public class OkHttpEmailVerifier {
private static final String API_ENDPOINT = "https://app.fuegoverify.com/api/v1/verify";
private final String apiToken;
private final OkHttpClient client;
public OkHttpEmailVerifier(String apiToken) {
this.apiToken = apiToken;
this.client = new OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.build();
}
/**
* Verifies an email address
*
* @param email The email address to verify
* @return A JSONObject containing the verification result
* @throws IOException if there's a communication error
* @throws Exception for other errors
*/
public JSONObject verifyEmail(String email) throws IOException, Exception {
// Build the URL with parameters
HttpUrl url = HttpUrl.parse(API_ENDPOINT).newBuilder()
.addQueryParameter("email", email)
.addQueryParameter("token", apiToken)
.build();
// Create request
Request request = new Request.Builder()
.url(url)
.header("Content-Type", "application/json")
.get()
.build();
// Execute request
try (Response response = client.newCall(request).execute()) {
int statusCode = response.code();
String responseBody = response.body() != null ? response.body().string() : null;
// Parse JSON response
JSONObject jsonResponse = new JSONObject(responseBody != null ? responseBody : "{}");
// Handle errors
if (!response.isSuccessful()) {
String errorMessage = jsonResponse.optString("error", "Unknown error");
if (statusCode == 429) {
throw new Exception("Rate limit exceeded. Please try again later.");
} else if (statusCode == 401) {
throw new Exception("Invalid API token. Please check your credentials.");
} else {
throw new Exception("API Error (" + statusCode + "): " + errorMessage);
}
}
return jsonResponse;
}
}
// handleVerificationResult method can be same as in the first example
public static void main(String[] args) {
String apiToken = "YOUR_API_TOKEN";
String emailToVerify = "[email protected]";
OkHttpEmailVerifier verifier = new OkHttpEmailVerifier(apiToken);
try {
JSONObject result = verifier.verifyEmail(emailToVerify);
// Process the result similar to previous examples
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
}
Maven dependency for OkHttp:
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.11.0</version>
</dependency>
Method 4: Using Spring RestTemplate
If you’re using the Spring Framework, RestTemplate is a convenient way to make HTTP requests:
import org.json.JSONObject;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
/**
* Email verification using Spring RestTemplate
*/
public class SpringEmailVerifier {
private static final String API_ENDPOINT = "https://app.fuegoverify.com/api/v1/verify";
private final String apiToken;
private final RestTemplate restTemplate;
public SpringEmailVerifier(String apiToken) {
this.apiToken = apiToken;
this.restTemplate = new RestTemplate();
}
/**
* Verifies an email address
*
* @param email The email address to verify
* @return A JSONObject containing the verification result
* @throws Exception if an error occurs
*/
public JSONObject verifyEmail(String email) throws Exception {
// Build the URL with parameters
URI uri = UriComponentsBuilder.fromUriString(API_ENDPOINT)
.queryParam("email", email)
.queryParam("token", apiToken)
.build()
.toUri();
// Set headers
HttpHeaders headers = new HttpHeaders();
headers.set("Content-Type", "application/json");
HttpEntity<?> entity = new HttpEntity<>(headers);
try {
// Execute request
ResponseEntity<String> response = restTemplate.exchange(
uri, HttpMethod.GET, entity, String.class);
// Parse JSON response
JSONObject jsonResponse = new JSONObject(response.getBody());
return jsonResponse;
} catch (HttpClientErrorException | HttpServerErrorException e) {
// Handle HTTP errors
HttpStatus statusCode = e.getStatusCode();
String responseBody = e.getResponseBodyAsString();
JSONObject errorResponse = new JSONObject(responseBody != null ? responseBody : "{}");
String errorMessage = errorResponse.optString("error", "Unknown error");
if (statusCode == HttpStatus.TOO_MANY_REQUESTS) {
throw new Exception("Rate limit exceeded. Please try again later.");
} else if (statusCode == HttpStatus.UNAUTHORIZED) {
throw new Exception("Invalid API token. Please check your credentials.");
} else {
throw new Exception("API Error (" + statusCode.value() + "): " + errorMessage);
}
}
}
// Same handleVerificationResult method as earlier examples
}
Maven dependencies for Spring:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.29</version>
</dependency>
Working with the Response
The API returns a JSON response with detailed information about the email:
{
"email": "[email protected]",
"result": "valid", // or "invalid", "risky", "unknown"
"reason": null, // reason for invalid or risky result
"role": false, // true for role-based emails like "admin@" or "support@"
"free": false, // true for free email providers like Gmail or Yahoo
"disposable": false, // true for temporary/disposable email addresses
"accept_all": false, // true if the domain accepts all emails
"did_you_mean": null, // suggestion for misspelled emails
"domain": "techcorp.com",
"user": "alex",
"success": true,
"domain_insight": {
"category": "organization",
"name": "TechCorp Inc.",
"industry": "Software Development",
"country": "US",
"ticker": "TCH",
"employees": 3500,
"description": "TechCorp Inc. is a leading software development company..."
}
}
Spring Boot Integration
Here’s how to integrate email verification into a Spring Boot application:
1. Create a Configuration Class
package com.example.demo.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ApiConfig {
@Value("${fuego.api.token}")
private String apiToken;
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
@Bean
public String apiToken() {
return apiToken;
}
}
2. Create a Service Class
package com.example.demo.service;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
@Service
public class EmailVerificationService {
private static final Logger logger = LoggerFactory.getLogger(EmailVerificationService.class);
private static final String API_ENDPOINT = "https://app.fuegoverify.com/api/v1/verify";
private final RestTemplate restTemplate;
private final String apiToken;
@Autowired
public EmailVerificationService(RestTemplate restTemplate, @Value("${fuego.api.token}") String apiToken) {
this.restTemplate = restTemplate;
this.apiToken = apiToken;
}
/**
* Verifies an email address
*
* @param email The email address to verify
* @return A Map containing the verification result
* @throws Exception if an error occurs
*/
public Map<String, Object> verifyEmail(String email) throws Exception {
// Build the URL with parameters
URI uri = UriComponentsBuilder.fromUriString(API_ENDPOINT)
.queryParam("email", email)
.queryParam("token", apiToken)
.build()
.toUri();
// Set headers
HttpHeaders headers = new HttpHeaders();
headers.set("Content-Type", "application/json");
HttpEntity<?> entity = new HttpEntity<>(headers);
try {
// Execute request
ResponseEntity<String> response = restTemplate.exchange(
uri, HttpMethod.GET, entity, String.class);
// Parse JSON response
JSONObject jsonResponse = new JSONObject(response.getBody());
// Convert to Map for easier handling in Spring
return convertJsonToMap(jsonResponse);
} catch (HttpClientErrorException | HttpServerErrorException e) {
// Handle HTTP errors
HttpStatus statusCode = e.getStatusCode();
String responseBody = e.getResponseBodyAsString();
logger.error("API error: {} - {}", statusCode, responseBody);
JSONObject errorResponse = new JSONObject(responseBody != null ? responseBody : "{}");
String errorMessage = errorResponse.optString("error", "Unknown error");
if (statusCode == HttpStatus.TOO_MANY_REQUESTS) {
throw new Exception("Rate limit exceeded. Please try again later.");
} else if (statusCode == HttpStatus.UNAUTHORIZED) {
throw new Exception("Invalid API token. Please check your credentials.");
} else {
throw new Exception("API Error (" + statusCode.value() + "): " + errorMessage);
}
} catch (Exception e) {
logger.error("Verification error", e);
throw new Exception("Failed to verify email: " + e.getMessage());
}
}
/**
* Check if an email is valid
*
* @param email The email to verify
* @return true if the email is valid, false otherwise
*/
public boolean isEmailValid(String email) {
try {
Map<String, Object> result = verifyEmail(email);
return "valid".equals(result.get("result"));
} catch (Exception e) {
logger.error("Error checking email validity", e);
return false;
}
}
/**
* Converts a JSONObject to a Map
*/
private Map<String, Object> convertJsonToMap(JSONObject json) {
Map<String, Object> map = new HashMap<>();
for (String key : json.keySet()) {
Object value = json.get(key);
if (value instanceof JSONObject) {
map.put(key, convertJsonToMap((JSONObject) value));
} else {
map.put(key, value);
}
}
return map;
}
}
3. Create a Controller
package com.example.demo.controller;
import com.example.demo.service.EmailVerificationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
@RestController
@RequestMapping("/api/email")
public class EmailVerificationController {
private final EmailVerificationService verificationService;
@Autowired
public EmailVerificationController(EmailVerificationService verificationService) {
this.verificationService = verificationService;
}
@GetMapping("/verify")
public ResponseEntity<?> verifyEmail(@RequestParam String email) {
try {
Map<String, Object> result = verificationService.verifyEmail(email);
return ResponseEntity.ok(result);
} catch (Exception e) {
return ResponseEntity.badRequest().body(Map.of("error", e.getMessage()));
}
}
@GetMapping("/valid")
public ResponseEntity<Map<String, Object>> isEmailValid(@RequestParam String email) {
boolean isValid = verificationService.isEmailValid(email);
return ResponseEntity.ok(Map.of("email", email, "valid", isValid));
}
}
4. Configure API Key
In your application.properties file:
fuego.api.token=YOUR_API_TOKEN
Custom Email Validator with Spring Boot Validation
You can create a custom email validator annotation:
package com.example.demo.validation;
import com.example.demo.service.EmailVerificationService;
import jakarta.validation.Constraint;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import jakarta.validation.Payload;
import org.springframework.beans.factory.annotation.Autowired;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ValidEmail.EmailValidator.class)
public @interface ValidEmail {
String message() default "Email is not valid or deliverable";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
class EmailValidator implements ConstraintValidator<ValidEmail, String> {
@Autowired
private EmailVerificationService verificationService;
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (value == null || value.isEmpty()) {
return true; // Let @NotNull or @NotEmpty handle this
}
// Skip API validation in tests
if (System.getProperty("spring.profiles.active", "").contains("test")) {
return true;
}
return verificationService.isEmailValid(value);
}
}
}
Using the annotation:
public class UserRegistrationDto {
@NotBlank(message = "Name is required")
private String name;
@NotBlank(message = "Email is required")
@jakarta.validation.constraints.Email(message = "Email format is invalid")
@ValidEmail
private String email;
// Getters and setters
}
Rate Limiting and Error Handling
The API has rate limits to ensure fair usage. Here’s an implementation with retry logic:
import java.io.IOException;
import java.util.Random;
/**
* Retry logic for API calls
*/
public class RetryHelper {
private static final Random random = new Random();
/**
* Execute a function with retry logic
*
* @param callable The function to execute
* @param maxRetries Maximum number of retries
* @param baseDelayMs Base delay in milliseconds
* @return The result of the function
* @throws Exception if the function fails after all retries
*/
public static <T> T withRetry(RetryableFunction<T> callable, int maxRetries, long baseDelayMs) throws Exception {
int retries = 0;
while (true) {
try {
return callable.call();
} catch (Exception e) {
retries++;
// Check if this is a rate limit error and if we have retries left
if (isRateLimitError(e) && retries <= maxRetries) {
// Calculate backoff delay with jitter
long delay = calculateBackoffDelay(retries, baseDelayMs);
System.out.println("Rate limited, retrying in " + delay + "ms (attempt " + retries + "/" + maxRetries + ")");
Thread.sleep(delay);
} else {
// Not a rate limit error or out of retries
throw e;
}
}
}
}
/**
* Check if an exception is a rate limit error
*/
private static boolean isRateLimitError(Exception e) {
String message = e.getMessage().toLowerCase();
return message.contains("rate limit") || message.contains("429");
}
/**
* Calculate backoff delay with jitter
*/
private static long calculateBackoffDelay(int retryCount, long baseDelayMs) {
// Exponential backoff: baseDelay * 2^retryCount
long delay = baseDelayMs * (1L << retryCount);
// Add jitter (0-500ms)
delay += random.nextInt(500);
// Cap at 30 seconds
return Math.min(delay, 30000);
}
/**
* Interface for functions that can be retried
*/
@FunctionalInterface
public interface RetryableFunction<T> {
T call() throws Exception;
}
// Example usage
public static void main(String[] args) {
EmailVerifier verifier = new EmailVerifier("YOUR_API_TOKEN");
try {
// Use the retry helper
JSONObject result = RetryHelper.withRetry(
() -> verifier.verifyEmail("[email protected]"),
3, // max retries
1000 // base delay in ms
);
System.out.println("Success: " + result.getString("result"));
} catch (Exception e) {
System.err.println("Failed after retries: " + e.getMessage());
}
}
}
Batch Processing
For processing multiple emails efficiently:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* Batch email verification with parallel processing
*/
public class BatchEmailVerifier {
private final EmailVerifier verifier;
private final int maxConcurrent;
private final long delayBetweenRequestsMs;
/**
* Constructor
*
* @param apiToken API token for verification
* @param maxConcurrent Maximum number of concurrent requests
* @param delayBetweenRequestsMs Delay between requests in milliseconds
*/
public BatchEmailVerifier(String apiToken, int maxConcurrent, long delayBetweenRequestsMs) {
this.verifier = new EmailVerifier(apiToken);
this.maxConcurrent = maxConcurrent;
this.delayBetweenRequestsMs = delayBetweenRequestsMs;
}
/**
* Verify a batch of emails
*
* @param emails List of emails to verify
* @return Map of email to verification result
*/
public Map<String, JSONObject> verifyBatch(List<String> emails) {
Map<String, JSONObject> results = new HashMap<>();
ExecutorService executor = Executors.newFixedThreadPool(maxConcurrent);
try {
List<Future<Map.Entry<String, JSONObject>>> futures = new ArrayList<>();
// Submit tasks to the executor
for (String email : emails) {
// Add delay to avoid rate limiting
Thread.sleep(delayBetweenRequestsMs);
Callable<Map.Entry<String, JSONObject>> task = () -> {
try {
JSONObject result = RetryHelper.withRetry(
() -> verifier.verifyEmail(email),
3, // max retries
1000 // base delay in ms
);
return Map.entry(email, result);
} catch (Exception e) {
System.err.println("Error verifying " + email + ": " + e.getMessage());
// Create an error result
JSONObject errorResult = new JSONObject();
errorResult.put("email", email);
errorResult.put("result", "error");
errorResult.put("reason", e.getMessage());
return Map.entry(email, errorResult);
}
};
futures.add(executor.submit(task));
}
// Collect results
for (Future<Map.Entry<String, JSONObject>> future : futures) {
try {
Map.Entry<String, JSONObject> entry = future.get();
results.put(entry.getKey(), entry.getValue());
} catch (InterruptedException | ExecutionException e) {
System.err.println("Error in task execution: " + e.getMessage());
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println("Batch processing interrupted: " + e.getMessage());
} finally {
executor.shutdown();
try {
if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
executor.shutdownNow();
}
} catch (InterruptedException e) {
executor.shutdownNow();
Thread.currentThread().interrupt();
}
}
return results;
}
/**
* Process a CSV file
*
* @param inputFilePath Path to input CSV file
* @param outputFilePath Path to output CSV file
* @throws Exception if an error occurs
*/
public void processCsvFile(String inputFilePath, String outputFilePath) throws Exception {
// Read emails from CSV
List<String> emails = readEmailsFromCsv(inputFilePath);
System.out.println("Processing " + emails.size() + " emails...");
// Verify emails
Map<String, JSONObject> results = verifyBatch(emails);
// Write results to CSV
writeToCsv(results, outputFilePath);
System.out.println("Results written to " + outputFilePath);
}
/**
* Read emails from a CSV file
*/
private List<String> readEmailsFromCsv(String filePath) throws Exception {
// Implementation depends on your CSV library
// Example using Apache Commons CSV or Java's built-in CSV parser
// This is a simplified placeholder
List<String> emails = new ArrayList<>();
// TODO: Implement CSV reading
return emails;
}
/**
* Write results to a CSV file
*/
private void writeToCsv(Map<String, JSONObject> results, String filePath) throws Exception {
// Implementation depends on your CSV library
// Example using Apache Commons CSV or Java's built-in CSV writer
// This is a simplified placeholder
// TODO: Implement CSV writing
}
public static void main(String[] args) {
String apiToken = "YOUR_API_TOKEN";
BatchEmailVerifier batchVerifier = new BatchEmailVerifier(apiToken, 5, 200);
List<String> emails = List.of(
"[email protected]",
"[email protected]",
"[email protected]"
);
Map<String, JSONObject> results = batchVerifier.verifyBatch(emails);
// Process results
for (Map.Entry<String, JSONObject> entry : results.entrySet()) {
String email = entry.getKey();
JSONObject result = entry.getValue();
System.out.println(email + ": " + result.getString("result"));
}
}
}
Conclusion
You now have all the tools you need to integrate the Fuego Email Verification API into your Java applications. This integration will help ensure that your email data is valid and deliverable, improving your email campaigns and user data quality.
For more information and advanced usage, refer to the complete API documentation.
Pricing
For information about pricing, see our pricing page where you can calculate the exact cost for your email verification needs.