RPC endpoints and API reference for 36 chains.

Introduction

BoltRPC is a production-grade RPC node service giving developers instant access to 36 blockchain networks through a single, unified API. Whether you're building DeFi protocols, NFT platforms, wallets, or indexers - BoltRPC handles the infrastructure so you don't have to.

Quick Start

Get your first response in under 60 seconds.

curl -s -X POST \
  "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x14a5f3b"
}

Authentication

Your API key is embedded directly in the endpoint URL. No extra headers required.

https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/{network}
wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/{network}

BOLTRPC_URL=https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum

Supported Networks

All networks below are available via both HTTPS and WebSocket unless noted. Each network name links to its page with the RPC URL, chain ID and connection examples, for example the Ethereum RPC endpoint, Base RPC and BNB Chain (BSC) RPC.

gRPC: native HTTP/2 on endpoints.boltrpc.io:443 plus gRPC-Web at /grpc/<slug>, see Native gRPC.

Hyperliquid support coming soon.

Connecting

https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/{network}

wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/{network}

# Set your target network
BOLTRPC_URL="https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/base"

curl -s -X POST "$BOLTRPC_URL" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Sepolia: dApp development & smart contract testing
https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum-sepolia

# Hoodi: validator infrastructure & staking
https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum-hoodi

: stream closed: Key revoked
retry: 60000

curl "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum-beacon/eth/v1/node/syncing"

curl "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum-beacon/eth/v1/beacon/states/finalized/finality_checkpoints"

curl -X POST "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"starknet_blockNumber","params":[],"id":1}'

{"jsonrpc":"2.0","id":1,"method":"starknet_subscribe","params":["newHeads"]}

# Matrix Chain: HTTPS (node health)
curl -s -X POST "https://enjin-matrix-chain.matrixed.link" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"system_health","params":[],"id":1}'

# Relay Chain: HTTPS (finalized head)
curl -s -X POST "https://enjin-relay-chain.matrixed.link" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"chain_getFinalizedHead","params":[],"id":1}'

# Matrix Chain: WebSocket (subscribe to new heads)
wscat -c wss://enjin-matrix-chain.matrixed.link

Code Examples

const BOLTRPC_URL = "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum";

async function getBlockNumber() {
  const res = await fetch(BOLTRPC_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 1 }),
  });
  const data = await res.json();
  console.log("Latest block:", parseInt(data.result, 16));
}

getBlockNumber();

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider(
  "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum"
);

const blockNumber = await provider.getBlockNumber();
console.log("Latest block:", blockNumber);

import requests

url = "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum"

payload = {
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
}

response = requests.post(url, json=payload)
data = response.json()
print("Latest block:", int(data["result"], 16))

from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum"
))

print("Connected:", w3.is_connected())
print("Latest block:", w3.eth.block_number)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum"
    body := `{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}`

    resp, _ := http.Post(url, "application/json", bytes.NewBufferString(body))
    defer resp.Body.Close()

    var result map[string]interface{}

    b, _ := io.ReadAll(resp.Body)
    json.Unmarshal(b, &result)
    fmt.Println("Result:", result["result"])
}

API Reference

Request limits & behaviours

The bounds the gateway enforces, and what it does for you underneath. Everything here is per request and independent of your plan.

Errors you can fix in the dashboard

When the gateway refuses a key for a reason you can fix yourself, the plain-text body says what happened and where to fix it. The status codes never change, so branch on the status, not on the text.

Every other refusal (a wrong or disabled key, IP or origin allowlists, chain scope, per-key rate limits, daily caps, team member caps) keeps its existing body. The 429 rate-limit headers (Retry-After, X-RateLimit-*) are the same in every case.

WebSocket Subscriptions

WebSocket connections enable real-time event streaming without polling. Available on all paid plans.

wscat -c "wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/ethereum"

{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "eth_subscribe",
  "params": [
    "logs",
    {
      "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
    }
  ]
}

{"jsonrpc":"2.0","id":3,"method":"eth_subscribe","params":["newPendingTransactions"]}

{"jsonrpc":"2.0","id":4,"method":"eth_unsubscribe","params":["YOUR_SUBSCRIPTION_ID"]}

Each subscription is tied to the active connection and closes automatically when the socket disconnects.

Failover, duplicates and gaps

When a node fails, the gateway moves your socket to another node of the same chain. The socket stays open and your subscription ids stay the same. Blocks you missed during the switch are replayed in order. Missed logs are replayed too, in block order, but a replayed log can arrive after a newer live log, so do not assume log block numbers only go up. On EVM chains the replay covers up to 128 blocks for newHeads and up to 5,000 blocks for logs. Solana logsSubscribe replays up to 1,500 slots and Starknet subscribeEvents up to 100 blocks. A Solana replay also delivers at most 200 transactions. When a gap on a very busy address holds more than that, the gateway either keeps the newest 200 and does not send the older ones (the default), or, on chains where close code 4013 is enabled, sends none of them and closes the socket with the whole gap in the reason. Fetch the missing transactions with getSignaturesForAddress and getTransaction if you need every one.

Deduplicate logs and events. A new logs subscription, or a Starknet subscribeEvents subscription, may deliver events from the block in which it was created or from a few blocks before it. Deduplicate by block hash and log index, as you already do for reorgs (removed: true). Starknet events carry no index: use the transaction hash together with the event's address, keys and data.

A gap too long to replay. If a gap is longer than the replay limit, or its replay keeps failing, the missed range may not be sent and the stream continues with new blocks. On newHeads this shows as a jump in block numbers, or the stream stalls briefly first. Fetch the missing range yourself with eth_getBlockByNumber or eth_getLogs.

Native gRPC (Sui Beta, Tron)

Two networks expose their native gRPC APIs on the same endpoint as everything else: Sui's sui.rpc.v2 and Tron's protocol.Wallet / protocol.WalletSolidity. Use the official generated clients unchanged.

Billing: a unary gRPC call costs the same request units as the matching JSON-RPC or HTTP method. A Sui BatchGetTransactions / BatchGetObjects call bills once, whatever the item count. Sui server streams (Subscribe*, List*) bill by delivered data: 1 RU per 24 KB, rounded up once when the stream closes; opening a stream is free; five concurrent streams per key. Tron's gRPC is unary-only. Every weight is in the calculator under the Sui and Tron gRPC groups.

Chain IDs

Use these when configuring wallets (MetaMask, Rabby) or EVM SDKs (ethers.js, viem, web3.py).

Key Restrictions

Every API key can be scoped to exactly one job, self-serve on every plan. Changes are enforced at the edge within about 30 seconds.

Key rotation. Rolling a key issues a new secret immediately while the old one keeps working for a grace period you pick: revoke now, 1 hour, 24 hours or 7 days. Deploys never break mid-rotation.

Usage, Alerts & Export

The dashboard's Usage & Logs view breaks traffic down by method, network, key and status, with human-readable labels for every JSON-RPC error code. History is retained for 18 months.

Export. Request logs export as CSV or NDJSON (up to 92 days and 1M rows per file); usage summaries export as CSV or JSON.

Alerts. Email alerts fire at 80%, 90% and 100% of your included request units, plus one custom threshold you pick. If you enable on-demand usage, separate alerts fire at 80, 90 and 100% of what your spending limit covers.

Teams

Invite teammates by email or link. Per member you decide:

An organization-wide default policy applies to invites without their own. When a member leaves, their keys are disabled automatically.

Management API

Everything the dashboard does with keys is also available programmatically over a documented REST API: create, scope, restrict, rotate and revoke keys from your own tooling. The OpenAPI specification ships with your account; contact us for access details and examples.

Plans & Request Units

Monthly plans are flat and fixed; on-demand usage (with or without a plan) is $25 per 15M request units, capped by a spending limit you set. Plans accept card or crypto; on-demand usage without a plan is card only and has the same methods as Builder (how it works). Archive depth and trace/debug support are per chain (see Supported Networks), not per plan; "unbounded debug methods" are debug_accountRange, debug_storageRangeAt and debug_dumpBlock. See full pricing →

On-demand usage: how it works

Pay only for what you use, with no plan and no monthly fee. Add a card in the dashboard (Billing) and your key keeps working, whether you are on the free trial, your trial has ended, or you never had a plan.

• Price. $25 per 15M request units, charged per started block. Request units are the same as on every plan (see Method Weighting). Unused units from your free trial are used first.
• Spending limit. You set a monthly limit in steps of $25, and it pays for whole blocks: $50 covers 2 blocks (30M request units). On-demand usage is served until those are used, then stops. New accounts start at $50. Change it any time under Billing.
• Alerts. We email you at 80, 90 and 100% of what your limit covers, once per threshold each billing period.
• Your first invoice. Until your first invoice with a charge is paid, the limit can be at most $100 (60M request units). This lifts automatically once that invoice is paid. Need more sooner? Contact support and we can raise it.
• Rate limit. On-demand usage on its own is limited to 100 requests per second (burst 200). Monthly plans have no rate limit.
• Methods. The same methods as the Builder plan.
• When the limit is reached. Requests get HTTP 429 with the body "Too Many Requests: your on-demand spending limit is reached. Raise it in the dashboard to continue on the same key". Raise the limit and the same key works again within seconds; nothing in your integration changes.
• Billing. Usage is invoiced to your card once a month. Invoices and payment methods are in the dashboard under Billing, Manage billing.
• Moving to a plan. Choose a plan any time: you get a monthly allowance and no rate limit, on the same key and the same card.
• Stopping. Turn on-demand usage off under Billing to stop new charges right away (your key stops serving), or cancel the subscription: it stays on until the end of the period, and usage up to then is invoiced as usual.

Support