Tomba email finder SDKs & Libraries: Python, Node.js, PHP (2026)

SDKs overview

Tomba email finder offers a range of Software Development Kits (SDKs) and client libraries designed to facilitate integration with its email finding and verification API. These SDKs abstract the underlying RESTful API calls, simplifying tasks such as constructing requests, handling authentication, and parsing responses. By using an SDK, developers can reduce the boilerplate code required to interact with the Tomba API, allowing for more rapid development and integration of email-related functionalities into their applications.

The SDKs provided cover several popular programming languages, ensuring broad compatibility across different development environments. Each SDK is tailored to the conventions of its respective language, offering a native development experience. The primary goal of these libraries is to enable developers to programmatically access Tomba's core services, including finding email addresses by domain or name, verifying email addresses for deliverability, and performing comprehensive domain searches to retrieve professional contact information. For full details on the underlying API, consult the official Tomba API reference documentation.

Official SDKs by language

Tomba maintains official SDKs for several programming languages, providing tested and supported client libraries for developers. These SDKs are typically available through standard package managers for each language, simplifying the installation and dependency management process. The table below lists the officially supported SDKs, their package names, and typical installation commands.

Installation

Installing Tomba's official SDKs typically involves using the standard package manager for your chosen programming language. This ensures that all necessary dependencies are resolved and the library is correctly integrated into your project. Below are detailed installation instructions for the primary supported languages: Python, Node.js, and PHP.

Python

To install the Python SDK, use pip, the package installer for Python. Ensure you have Python 3.6 or higher installed. You can verify your Python version by running python --version or python3 --version in your terminal. For more information on Python package management, refer to the official Python packaging guide.

pip install tomba

After installation, you can import the tomba client into your Python scripts.

Node.js

For Node.js projects, the Tomba SDK is available via npm, the Node.js package manager. Ensure you have Node.js and npm installed. You can check their versions with node -v and npm -v.

npm install @tomba.io/api

Once installed, you can require the @tomba.io/api module in your JavaScript or TypeScript files.

PHP

The PHP SDK is managed using Composer, the dependency manager for PHP. Ensure Composer is installed globally on your system. If not, follow the instructions on the Composer official documentation.

composer require tomba-io/tomba-php

After running this command, Composer will add the Tomba PHP SDK to your project's vendor/ directory and update your composer.json and composer.lock files.

Quickstart example

This section provides a quickstart example demonstrating how to use the Tomba SDKs to find an email address for a given domain. These examples assume you have already installed the respective SDK and have your API Key and API Secret readily available from your Tomba account dashboard.

Python Quickstart

This Python example initializes the Tomba client and uses the domain_search method to find email addresses associated with a specified domain.

from tomba.client import Client

def main():
    # Replace with your actual API Key and API Secret
    api_key = "YOUR_TOMBA_API_KEY"
    api_secret = "YOUR_TOMBA_API_SECRET"

    client = Client(api_key=api_key, api_secret=api_secret)

    try:
        # Perform a domain search
        response = client.domain_search.domain_search(
            domain="tomba.io",
            limit=10,
            offset=0
        )
        print("Domain Search Results:")
        print(response.to_json())

        # Example: Find email by name and domain
        # response = client.email_finder.email_finder(
        #     domain="example.com",
        #     first_name="John",
        #     last_name="Doe"
        # )
        # print("Email Finder Result:")
        # print(response.to_json())

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

if __name__ == "__main__":
    main()

Node.js Quickstart

This Node.js example demonstrates how to set up the Tomba client and execute a domain search to retrieve email addresses.

const { Client } = require('@tomba.io/api');

async function main() {
    // Replace with your actual API Key and API Secret
    const apiKey = "YOUR_TOMBA_API_KEY";
    const apiSecret = "YOUR_TOMBA_API_SECRET";

    const client = new Client(apiKey, apiSecret);

    try {
        // Perform a domain search
        const response = await client.domainSearch.domainSearch({
            domain: "tomba.io",
            limit: 10,
            offset: 0
        });
        console.log("Domain Search Results:");
        console.log(JSON.stringify(response, null, 2));

        // Example: Find email by name and domain
        // const emailFinderResponse = await client.emailFinder.emailFinder({
        //     domain: "example.com",
        //     firstName: "John",
        //     lastName: "Doe"
        // });
        // console.log("Email Finder Result:");
        // console.log(JSON.stringify(emailFinderResponse, null, 2));

    } catch (error) {
        console.error(`An error occurred: ${error.message}`);
    }
}

main();

PHP Quickstart

This PHP example shows how to initialize the Tomba client using Composer's autoloader and perform a domain search.

<?php

require_once __DIR__ . '/vendor/autoload.php';

use Tomba\Client;
use Tomba\Model\DomainSearchParameters;

// Replace with your actual API Key and API Secret
$apiKey = "YOUR_TOMBA_API_KEY";
$apiSecret = "YOUR_TOMBA_API_SECRET";

$client = new Client($apiKey, $apiSecret);

try {
    // Perform a domain search
    $params = new DomainSearchParameters();
    $params->setDomain("tomba.io");
    $params->setLimit(10);
    $params->setOffset(0);

    $response = $client->domainSearch->domainSearch($params);

    echo "Domain Search Results:\n";
    echo json_encode($response->jsonSerialize(), JSON_PRETTY_PRINT) . "\n";

    // Example: Find email by name and domain
    // use Tomba\Model\EmailFinderParameters;
    // $finderParams = new EmailFinderParameters();
    // $finderParams->setDomain("example.com");
    // $finderParams->setFirstName("John");
    // $finderParams->setLastName("Doe");
    // $emailFinderResponse = $client->emailFinder->emailFinder($finderParams);
    // echo "Email Finder Result:\n";
    // echo json_encode($emailFinderResponse->jsonSerialize(), JSON_PRETTY_PRINT) . "\n";

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

?>

Community libraries

In addition to the official SDKs, the broader developer community may contribute unofficial client libraries or wrappers for Tomba email finder's API. While these community-driven projects can offer flexibility or support for less common languages/frameworks, they typically do not receive the same level of support or maintenance as official SDKs. Developers are advised to assess the maturity, documentation, and active development status of any third-party library before integrating it into production systems.

As of late 2026, the official SDKs cover a wide range of popular languages, reducing the immediate need for extensive community-contributed alternatives for core functionalities. Developers seeking to interact with the Tomba API in a language not officially supported are encouraged to consult the Tomba API reference and consider implementing a custom client based on REST principles. This approach allows direct control over API interactions and ensures compatibility with the latest API versions, as outlined by the W3C's architectural principles for RESTful APIs.