SDKs overview

Ethplorer provides developers with programmatic access to its extensive dataset of Ethereum blockchain information through a Public API. To streamline integration, Ethplorer offers official Software Development Kits (SDKs) and supports community-contributed libraries. These tools abstract the underlying HTTP requests and JSON parsing, allowing developers to interact with the API using familiar language constructs. The primary goal of these SDKs is to simplify fetching data related to Ethereum transactions, token details, address balances, and event logs, among other data points available via the Ethplorer Public API reference.

The SDKs are designed to facilitate common operations such as retrieving transaction details by hash, getting token information by contract address, or fetching the balance and transaction history of a specific Ethereum address. By utilizing these libraries, developers can reduce the boilerplate code required for API communication and instead focus on building their application's core logic. The availability of SDKs across different programming languages caters to a broad developer base, ensuring that a wide range of applications can leverage Ethplorer's data.

While the official SDKs offer direct wrappers for the Ethplorer API, it's also possible to interact with the API directly using standard HTTP clients. However, SDKs often provide benefits such as error handling, request builders, and data model mappings, which can accelerate development and improve code maintainability. For those interested in exploring different approaches to API interaction, the Fetch API documentation provides further details on making HTTP requests in web environments.

Official SDKs by language

Ethplorer currently maintains official SDKs for two widely used programming languages: Python and JavaScript. These SDKs are developed and supported by the Ethplorer team to ensure compatibility and provide the most up-to-date functionality with the Ethplorer Public API.

The official SDKs are hosted on popular package managers, making installation and dependency management straightforward. They encapsulate the necessary authentication mechanisms and API endpoint structures, allowing developers to focus on data retrieval and processing rather than raw HTTP requests. Each SDK is designed to reflect the structure and capabilities of the Ethplorer API, providing methods that map directly to the API's available endpoints.

Below is a table summarizing the official SDKs:

Language Package Name Install Command Maturity
Python ethplorer-py pip install ethplorer-py Stable
JavaScript (Node.js/Browser) ethplorer-js npm install ethplorer-js Stable

These SDKs are regularly updated to reflect any changes or additions to the Ethplorer documentation, ensuring that developers always have access to the latest features and improvements. Using an official SDK is generally recommended for optimal performance and access to support from the Ethplorer development team.

Installation

Installing Ethplorer's official SDKs involves using the respective package managers for Python and JavaScript environments. The process is designed to be straightforward, allowing developers to quickly integrate the libraries into their projects.

Python SDK (ethplorer-py)

The Python SDK can be installed using pip, the standard package installer for Python. Ensure you have Python and pip installed on your system. Python 3.6 or newer is generally recommended for modern development. More information about Python package management can be found in the pip user guide.

To install:

pip install ethplorer-py

After installation, you can import the library into your Python scripts:

from ethplorer_api import Ethplorer

JavaScript SDK (ethplorer-js)

The JavaScript SDK is available via npm, the package manager for Node.js. This makes it suitable for both Node.js backend applications and frontend browser-based projects (with appropriate bundling tools).

To install in a Node.js project:

npm install ethplorer-js

To use in your JavaScript code:

const Ethplorer = require('ethplorer-js'); // For CommonJS in Node.js
// OR
import Ethplorer from 'ethplorer-js'; // For ES Modules

For browser environments, you might include it via a script tag if a UMD build is available, or use a module bundler like Webpack or Rollup to include it in your frontend bundle. Always refer to the specific SDK's README for detailed browser integration instructions.

Quickstart example

This quickstart guide provides basic examples for fetching information using both the Python and JavaScript Ethplorer SDKs. Before running these examples, ensure you have installed the respective SDK as described in the Installation section and have your Ethplorer API key ready. You can obtain an API key by signing up on the Ethplorer homepage.

Python Quickstart

This example demonstrates how to retrieve the details of an Ethereum transaction using its hash.

from ethplorer_api import Ethplorer
import os

# It's recommended to store your API key as an environment variable
API_KEY = os.environ.get("ETHPLORER_API_KEY")

if not API_KEY:
    print("Error: ETHPLORER_API_KEY environment variable not set.")
    exit()

ethplorer = Ethplorer(api_key=API_KEY)

transaction_hash = "0xbe309a473ddc631a0e882937747e93f7736f88d90460c571767175510668b577" # Example transaction hash

try:
    tx_info = ethplorer.get_tx_info(transaction_hash)
    print(f"Transaction Hash: {tx_info['hash']}")
    print(f"Block Number: {tx_info['blockNumber']}")
    print(f"From: {tx_info['from']}")
    print(f"To: {tx_info['to']}")
    print(f"Value (ETH): {tx_info['value'] / 10**18}") # Convert Wei to ETH
    print(f"Timestamp: {tx_info['timestamp']}")
except Exception as e:
    print(f"An error occurred: {e}")

To run this Python example, save it as a .py file, set the ETHPLORER_API_KEY environment variable with your actual API key, and execute it from your terminal.

JavaScript Quickstart (Node.js)

This example shows how to fetch account information for a specific Ethereum address using the JavaScript SDK in a Node.js environment.

const Ethplorer = require('ethplorer-js');

// It's recommended to store your API key as an environment variable
const API_KEY = process.env.ETHPLORER_API_KEY;

if (!API_KEY) {
    console.error("Error: ETHPLORER_API_KEY environment variable not set.");
    process.exit(1);
}

const ethplorer = new Ethplorer(API_KEY);

const address = "0x742d35Cc6634C05329C31a86bF00006Bc44cC44A"; // Example Ethereum address

async function getAddressInfo() {
    try {
        const addressInfo = await ethplorer.getAddressInfo(address);
        console.log(`Address: ${addressInfo.address}`);
        console.log(`ETH Balance: ${addressInfo.ETH.balance}`);
        if (addressInfo.tokens) {
            console.log("Tokens:");
            addressInfo.tokens.forEach(token => {
                console.log(`  - ${token.tokenInfo.symbol}: ${token.balance / (10 ** token.tokenInfo.decimals)}`);
            });
        }
    } catch (error) {
        console.error(`An error occurred: ${error.message}`);
    }
}

getAddressInfo();

Save this JavaScript code as a .js file, set the ETHPLORER_API_KEY environment variable, and run it using node your_script_name.js.

These quickstarts provide a foundation for integrating Ethplorer data into your applications. For more detailed API calls and available parameters, consult the Ethplorer Public API documentation.

Community libraries

While Ethplorer provides official SDKs, the broader developer community often contributes libraries that extend functionality, offer alternative implementations, or support languages not officially covered. These community-driven projects can be valuable resources, providing flexibility and catering to specific project needs.

Community libraries are typically found on platforms like GitHub, npm, or PyPI, and their quality and maintenance vary. When considering a community-contributed library, it is advisable to check its documentation, the freshness of its last update, the number of contributors, and any reported issues. These factors can indicate the library's reliability and ongoing support.

As of late 2026, a search for ethplorer on package repositories like PyPI (for Python) and npm (for JavaScript) will yield both the official packages and various community efforts. These may include:

  • Alternative API clients: Wrappers that might offer different syntaxes or integrate with specific frameworks.
  • Data parsers: Libraries focused solely on processing the raw JSON output from the Ethplorer API into more user-friendly data structures.
  • Specialized tools: Projects that use Ethplorer data to perform specific tasks, such as generating reports or monitoring certain addresses.

It is important to note that community libraries are not officially supported by Ethplorer. Users should exercise due diligence when integrating them into production environments. Always review the source code and licensing terms of any third-party library before use. Developers can also explore the broader ecosystem of blockchain development tools, which often includes libraries for interacting with Ethereum nodes directly, such as web3.js or ethers.js, even if they don't specifically wrap Ethplorer's API.

For the most authoritative and up-to-date information regarding Ethplorer's official offerings, always refer to the Ethplorer official documentation. If you develop a community library, consider contributing it to the open-source community to benefit other developers.