EVA SDKs & Libraries: Python, PHP, Node.js, .NET, Go (2026)

SDKs overview

EVA provides Software Development Kits (SDKs) to facilitate the integration of its email validation services into various applications and platforms. These SDKs abstract the underlying HTTP API requests and responses, allowing developers to interact with the EVA service using familiar language constructs rather than direct API calls. This approach aims to reduce development time and potential errors in API consumption, making it easier to implement features like real-time email verification, bulk list cleaning, and deliverability checks within existing codebases. The official SDKs are designed to align with the EVA API reference documentation, offering consistent functionality across supported languages.

The SDKs typically handle common development tasks, including:

• Authentication: Managing API key submission for secure access to EVA services.
• Request Formatting: Constructing API requests with appropriate parameters (e.g., email address, options).
• Response Parsing: Interpreting API responses, converting JSON data into native language objects for easier handling.
• Error Handling: Providing structured error messages and exceptions for API-specific issues.

By using an SDK, developers can focus on application logic rather than the intricacies of RESTful API communication. For example, validating an email address becomes a direct method call within the SDK, returning an object that can be queried for validation status, rather than requiring manual HTTP client configuration and JSON parsing. This is a standard practice for many API providers, including payment processors like Stripe's developer documentation, which also offers client libraries to simplify integration.

Official SDKs by language

EVA offers official SDKs for a range of popular programming languages, ensuring broad compatibility for developers. These SDKs are maintained by EVA and are kept up-to-date with the latest API features and best practices. Developers are encouraged to use the official SDKs for stability, support, and access to the most current functionalities. Each SDK is designed to reflect the native conventions of its respective language, providing an intuitive development experience.

The EVA SDKs documentation provides detailed setup instructions and usage examples for each language. These SDKs typically mirror the structure of the API endpoints, offering methods for actions such as single email validation, batch validation, and checking credit balance. Developers can find further specifics on method signatures and response structures within the dedicated documentation for each SDK.

Installation

Installing an EVA SDK generally involves using the package manager specific to the programming language or environment being used. The process is designed to be straightforward, allowing developers to quickly integrate the SDK into their projects.

Python

The Python SDK can be installed using pip, the standard package installer for Python. This command fetches the latest version of the eva-python package from the Python Package Index (PyPI).

pip install eva-python

PHP

For PHP projects, Composer is the recommended tool for dependency management. The eva/eva-php package can be added to your project with Composer.

composer require eva/eva-php

After installation, Composer's autoloader will make the SDK classes available in your PHP application.

Node.js

Node.js developers can install the eva-nodejs package using npm (Node Package Manager) or Yarn.

npm install eva-nodejs
# or
yarn add eva-nodejs

This command adds the package to your project's node_modules directory and updates your package.json file.

.NET

For .NET applications, the SDK is available via NuGet. You can install it using the .NET CLI or the NuGet Package Manager in Visual Studio.

dotnet add package Eva.NET

This adds a reference to the Eva.NET package in your project file.

Go

Go developers use the go get command to fetch and install the Go SDK. This command downloads the package and its dependencies into your Go workspace.

go get github.com/eva-id/go-sdk

Ensure your GOPATH is correctly configured for the package to be accessible.

Ruby

Ruby projects typically manage dependencies with RubyGems. The eva-ruby gem can be installed using the gem install command.

gem install eva-ruby

For Bundler-managed projects, add gem 'eva-ruby' to your Gemfile and run bundle install.

Java

Java developers can incorporate the EVA Java SDK using build tools like Maven or Gradle. The necessary dependency declarations must be added to your project's build configuration file (pom.xml for Maven, build.gradle for Gradle).

Maven example (pom.xml):

<dependencies>
    <dependency>
        <groupId>id.eva</groupId>
        <artifactId>eva-java</artifactId>
        <version>1.0.0</version> <!-- Use the latest version -->
    </dependency>
</dependencies>

Gradle example (build.gradle):

dependencies {
    implementation 'id.eva:eva-java:1.0.0' // Use the latest version
}

Consult the official EVA documentation for the most up-to-date version numbers and specific instructions for each SDK.

Quickstart example

The following quickstart examples demonstrate how to perform a basic email validation using the EVA SDKs in Python, PHP, and Node.js. These snippets illustrate the typical workflow: initializing the client with your API key and calling a validation method.

Python Quickstart

This Python example initializes the EVA client and validates a single email address. The response object contains detailed information about the validation result.

import os
from eva_python import EvaClient

# Replace with your actual EVA API Key or set as environment variable
api_key = os.environ.get('EVA_API_KEY', 'YOUR_EVA_API_KEY')

client = EvaClient(api_key=api_key)

try:
    email_to_validate = "[email protected]"
    validation_result = client.validate_email(email_to_validate)

    print(f"Email: {email_to_validate}")
    print(f"Status: {validation_result.status}")
    print(f"Deliverable: {validation_result.deliverable}")
    print(f"Reason: {validation_result.reason}")
    print(f"Score: {validation_result.score}")

    if validation_result.deliverable:
        print("Email is deliverable.")
    else:
        print("Email is not deliverable.")

except Exception as e:
    print(f"An error occurred: {e}")

PHP Quickstart

The PHP example demonstrates instantiating the EvaClient and calling the validate method to check an email address. Error handling is included to catch potential API issues.

<?php
require 'vendor/autoload.php';

use Eva\EvaClient;
use Eva\Exception\EvaException;

// Replace with your actual EVA API Key or set as environment variable
$apiKey = getenv('EVA_API_KEY') ?: 'YOUR_EVA_API_KEY';

$client = new EvaClient($apiKey);

try {
    $emailToValidate = "[email protected]";
    $validationResult = $client->validate($emailToValidate);

    echo "Email: " . $emailToValidate . "\n";
    echo "Status: " . $validationResult->getStatus() . "\n";
    echo "Deliverable: " . ($validationResult->isDeliverable() ? 'Yes' : 'No') . "\n";
    echo "Reason: " . $validationResult->getReason() . "\n";
    echo "Score: " . $validationResult->getScore() . "\n";

    if ($validationResult->isDeliverable()) {
        echo "Email is deliverable.\n";
    } else {
        echo "Email is not deliverable.\n";
    }

} catch (EvaException $e) {
    echo "An error occurred: " . $e->getMessage() . "\n";
} catch (Exception $e) {
    echo "An unexpected error occurred: " . $e->getMessage() . "\n";
}

Node.js Quickstart

This Node.js example uses async/await to handle the asynchronous API call to validate an email. The result object provides various properties about the email's validity.

const EvaClient = require('eva-nodejs');

// Replace with your actual EVA API Key or set as environment variable
const apiKey = process.env.EVA_API_KEY || 'YOUR_EVA_API_KEY';

const client = new EvaClient(apiKey);

async function validateEmail() {
    try {
        const emailToValidate = "[email protected]";
        const validationResult = await client.validate(emailToValidate);

        console.log(`Email: ${emailToValidate}`);
        console.log(`Status: ${validationResult.status}`);
        console.log(`Deliverable: ${validationResult.deliverable}`);
        console.log(`Reason: ${validationResult.reason}`);
        console.log(`Score: ${validationResult.score}`);

        if (validationResult.deliverable) {
            console.log("Email is deliverable.");
        } else {
            console.log("Email is not deliverable.");
        }
    } catch (error) {
        console.error(`An error occurred: ${error.message}`);
    }
}

validateEmail();

These quickstart examples use a placeholder API key. For production environments, it is recommended to load the API key from environment variables or a secure configuration system rather than hardcoding it directly in the source code. Detailed explanations of the status codes, reasons, and other fields returned by the validation process can be found in the EVA API reference guide.

Community libraries

In addition to the officially supported SDKs, the EVA API can be accessed directly using any HTTP client library in virtually any programming language. While official SDKs are preferred for comprehensive support and feature parity, community-contributed libraries or custom integrations can also be developed. These might offer specialized functionality or cater to specific project requirements not directly addressed by the official offerings.

Developers creating their own wrappers or tools might refer to general API consumption guidelines, such as those provided by the IETF's HTTP/1.1 RFC 7231 for HTTP semantics, to ensure correct interaction with the EVA RESTful API. When considering community libraries, it is advisable to assess their maintenance status, community support, and alignment with the latest EVA API version.

As of late 2026, the primary focus for EVA integration remains on its official SDKs due to their direct maintenance and guaranteed compatibility with the service. However, the underlying REST API is fully documented for those who require a more customized integration approach or prefer to use a language not covered by an official SDK. This flexibility is characteristic of many modern API platforms, offering choice to developers while maintaining a clear path for official support.