Bootnode
Go to Dashboard

SDKs & Libraries

Official client libraries for every major language. Each SDK provides type-safe access to all Bootnode APIs with built-in retry logic, authentication, and error handling.

TypeScript / JavaScript

v2.0.0

Works with Node.js 18+, Bun, Deno, and all modern browsers (via bundler). Full TypeScript types included.

Install

npm install @bootnode/sdk
# or
yarn add @bootnode/sdk
# or
pnpm add @bootnode/sdk

Usage

import { Bootnode } from "@bootnode/sdk";

const client = new Bootnode({
  apiKey: process.env.BOOTNODE_API_KEY!,
});

// JSON-RPC
const blockNumber = await client.rpc("ethereum", "mainnet", {
  jsonrpc: "2.0",
  id: 1,
  method: "eth_blockNumber",
  params: [],
});
console.log("Block:", parseInt(blockNumber.result, 16));

// Token API
const balances = await client.tokens.getBalances("ethereum", "0xd8dA...6045");
console.log("Tokens:", balances.tokens);

// NFT API
const nft = await client.nfts.getMetadata(
  "ethereum",
  "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D",
  "1234"
);
console.log("NFT:", nft.name);

// Wallets
const wallet = await client.wallets.create({
  owner: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  chain: "base",
});
console.log("Smart wallet:", wallet.address);

// Webhooks
const webhook = await client.webhooks.create({
  url: "https://myapp.com/api/webhooks",
  chain: "ethereum",
  eventType: "address_activity",
  config: { addresses: ["0xd8dA...6045"] },
});
console.log("Webhook ID:", webhook.id);

// Gas prices
const gas = await client.gas.getPrices("ethereum");
console.log("Base fee:", gas.base_fee_gwei, "gwei");

// WebSocket subscriptions
const ws = client.ws("ethereum", "mainnet");
ws.subscribe("newHeads", (block) => {
  console.log("New block:", parseInt(block.number, 16));
});

// Bundler
const userOpHash = await client.bundler.sendUserOperation("base", "mainnet", {
  sender: wallet.address,
  nonce: "0x0",
  callData: "0x...",
  // ... other UserOp fields
});
console.log("UserOp hash:", userOpHash);

Python

v2.0.0

Python 3.10+. Async-first with sync wrappers. Full type hints with Pydantic models.

Install

pip install bootnode
# or
uv add bootnode

Usage

import asyncio
from bootnode import Bootnode

client = Bootnode(api_key="bn_live_...")

async def main():
    # JSON-RPC
    result = await client.rpc("ethereum", "mainnet", {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "eth_blockNumber",
        "params": [],
    })
    block = int(result["result"], 16)
    print(f"Block: {block}")

    # Token balances
    balances = await client.tokens.get_balances(
        "ethereum",
        "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
    )
    for token in balances["tokens"]:
        print(f"  {token['symbol']}: {token['formatted_balance']}")

    # NFT metadata
    nft = await client.nfts.get_metadata(
        "ethereum",
        "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D",
        "1234"
    )
    print(f"NFT: {nft['name']}")

    # Create smart wallet
    wallet = await client.wallets.create(
        owner="0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
        chain="base"
    )
    print(f"Wallet: {wallet['address']}")

    # Gas prices
    gas = await client.gas.get_prices("ethereum")
    print(f"Base fee: {gas['base_fee_gwei']} gwei")

asyncio.run(main())

# Sync usage (for scripts):
from bootnode import BootnodeSync

sync_client = BootnodeSync(api_key="bn_live_...")
gas = sync_client.gas.get_prices("ethereum")
print(f"Base fee: {gas['base_fee_gwei']} gwei")

Go

v1.0.0

Go 1.21+. Context-aware, idiomatic Go with strong types.

Install

go get github.com/bootnode-dev/bootnode-go

Usage

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"strconv"

	"github.com/bootnode-dev/bootnode-go"
)

func main() {
	client := bootnode.NewClient(os.Getenv("BOOTNODE_API_KEY"))
	ctx := context.Background()

	// JSON-RPC
	result, err := client.RPC(ctx, "ethereum", "mainnet", map[string]any{
		"jsonrpc": "2.0",
		"id":      1,
		"method":  "eth_blockNumber",
		"params":  []any{},
	})
	if err != nil {
		log.Fatal(err)
	}
	blockHex := result["result"].(string)
	block, _ := strconv.ParseInt(blockHex[2:], 16, 64)
	fmt.Printf("Block: %d\n", block)

	// Token balances
	balances, err := client.Tokens.GetBalances(ctx, "ethereum",
		"0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
	if err != nil {
		log.Fatal(err)
	}
	for _, token := range balances.Tokens {
		fmt.Printf("  %s: %s\n", token.Symbol, token.FormattedBalance)
	}

	// Create smart wallet
	wallet, err := client.Wallets.Create(ctx, bootnode.CreateWalletParams{
		Owner: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
		Chain: "base",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Wallet: %s\n", wallet.Address)

	// Gas prices
	gas, err := client.Gas.GetPrices(ctx, "ethereum")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Base fee: %s gwei\n", gas.BaseFeeGwei)
}

Rust

v0.9.0

Rust 1.75+. Async with Tokio. Serde-based serialization. Zero-copy where possible.

Install

# Cargo.toml
[dependencies]
bootnode = "0.9"
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Usage

use bootnode::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), bootnode::Error> {
    let client = Client::new(
        std::env::var("BOOTNODE_API_KEY")
            .expect("BOOTNODE_API_KEY must be set")
    );

    // JSON-RPC
    let result = client
        .rpc("ethereum", "mainnet", json!({
            "jsonrpc": "2.0",
            "id": 1,
            "method": "eth_blockNumber",
            "params": []
        }))
        .await?;

    let block_hex = result["result"].as_str().unwrap();
    let block = u64::from_str_radix(&block_hex[2..], 16).unwrap();
    println!("Block: {block}");

    // Token balances
    let balances = client
        .tokens()
        .get_balances("ethereum", "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
        .await?;

    for token in &balances.tokens {
        println!("  {}: {}", token.symbol, token.formatted_balance);
    }

    // Create smart wallet
    let wallet = client
        .wallets()
        .create("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "base")
        .await?;
    println!("Wallet: {}", wallet.address);

    // Gas prices
    let gas = client.gas().get_prices("ethereum").await?;
    println!("Base fee: {} gwei", gas.base_fee_gwei);

    Ok(())
}

Feature Matrix

FeatureTypeScriptPythonGoRust
JSON-RPCYesYesYesYes
Token APIYesYesYesYes
NFT APIYesYesYesYes
WalletsYesYesYesYes
WebhooksYesYesYesYes
Gas ManagerYesYesYesYes
BundlerYesYesYesYes
WebSocketYesYesYesYes
Auto-retryYesYesYesYes
StreamingYesYesYesYes

Next Steps

Quickstart

Get your first call running

API Reference

Full endpoint documentation

Examples

Common use cases

Changelog

Latest SDK updates