
The Bitcoin builder’s dilemma
When Satoshi Nakamoto released Bitcoin in 2009, the network was built for peer-to-peer value transfer, not application querying. Unlike account-based chains, Bitcoin tracks ownership entirely through Unspent Transaction Outputs (UTXOs) and transaction IDs. Because of this, a vanilla node stores neither native account balances nor address-level indexes.
If you try pulling basic app data straight from a raw Bitcoin node, you hit a wall. You end up stuck with brutal workarounds:
scantxoutsetcalls: Every time you run it, the node has to parse the entire active UTXO set from scratch- History parsing: Rebuilding an address’s transaction history means chewing through raw blocks all the way back to the genesis block
For production wallets, payment processors and block explorers, these native RPC limitations introduce high latency and compute overhead. Building scalable Bitcoin applications requires an indexing layer that pre-parses chain data into instant address-level queries.
What is Blockbook and how it solves the Bitcoin indexing bottleneck
Developed by Trezor as an open-source indexer, Blockbook bypasses raw node limitations by parsing the chain once and mapping transactions directly to addresses. Instead of forcing your node to parse block files or run scantxoutset on every request, Blockbook maintains a dedicated address index that serves balances, UTXOs, and histories via low-latency endpoints.
Here is how the same tasks compare on a Bitcoin node with and without Blockbook:
| Task | Bitcoin Core JSON-RPC on a Global Node | Blockbook |
|---|---|---|
| Get the balance of an address | scantxoutset, which reads the entire UTXO set | GET /api/v2/address/{address} |
| List the UTXOs of an address | scantxoutset | GET /api/v2/utxo/{address} |
| List the transactions of an address | Not available | GET /api/v2/address/{address}?details=txids |
| Get the balance and transactions of a wallet account | Not available | GET /api/v2/xpub/{xpub} |
| Get notified when an address sends or receives | Not available | WebSocket subscribeAddresses |
For the Bitcoin Core methods available on Chainstack, see Bitcoin methods.
How does it work?
Instead of lagging behind, Blockbook stays locked into live mempool activity. Unconfirmed transactions and newly mined blocks pop up instantly for querying, which means your app can ditch heavy polling loops and switch to a clean, event-driven setup.
Using WebSocket streams like subscribeAddresses and subscribeNewBlock, applications receive real-time push notifications the moment an address interacts with the network or a block is mined.
Use cases: wallet, payment or explorer
Because Blockbook pre-indexes the chain by address and streams live mempool updates, it handles the core data requirements for three distinct classes of Bitcoin applications:
Wallets
Query aggregated balances, spendable UTXOs, and full account activity across multi-address HD wallets using a single extended public key (xpub, ypub, zpub) or Taproot output descriptor.
curl "https://blockbook-bitcoin-mainnet.core.chainstack.com/YOUR_AUTH_TOKEN/api/v2/xpub/zpub6rFR7y4Q2AijBEqTUquhVz398htDFrtymD9xYYfG1m4wAcvPhXNfE3EfH1r1ADqtfSdVCToUG868RvUUkgDKf31mGDtKsAYz2oz2AGutZYs?details=basic"
Payment services
Detect incoming deposits the moment they enter the mempool (and optionally on first block confirmation) via WebSocket subscriptions instead of relying on constant RPC polling loops.
{
"id": "1",
"method": "subscribeAddresses",
"params": {
"addresses": ["bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu"],
"newBlockTxs": true
}
}
Block explorers
Serve fast, paginated lookups for address transaction histories, block payloads and dynamic fee estimates directly from the index without running raw chain scans.
curl "https://blockbook-bitcoin-mainnet.core.chainstack.com/YOUR_AUTH_TOKEN/api/v2/address/bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu?page=1&pageSize=10"
The address and the zpub in these examples come from the public BIP-84 test vectors. Anyone can send to them, so their balance is usually 0.
Supporting these workloads at scale comes down to choosing the right infrastructure architecture.
How Blockbook stands out
Unlike third-party indexers that force you to manage out-of-band databases, Blockbook runs directly alongside your Chainstack Global Node as a co-located add-on.
It natively processes the full spectrum of Bitcoin script formats, ranging from legacy addresses to Taproot output descriptors, while pairing predictable Request Unit economics with fixed, RPS-tiered monthly plans.
Setting up Blockbook on Chainstack
Spinning up Blockbook doesn’t require maintaining a separate database cluster. Available as a paid add-on starting from the Growth plan, you can activate address indexing straight from the Chainstack console on any active Bitcoin Mainnet Global Node (note that Blockbook is Mainnet-only and isn’t supported on Bitcoin testnets). This instantly provides dedicated HTTPS REST and WSS WebSocket endpoints secured by your node’s native token.
You can scale throughput easily by choosing between three monthly tiers (Starter at 10 RPS for $49 a month, Pro at 50 RPS for $149 or Business at 200 RPS for $449) directly from the dashboard as your app grows. Because the indexer runs alongside your node on Chainstack, you don’t have to provision separate servers, maintain a massive database or debug sync issues.
How to install Blockbook on a Bitcoin node
Blockbook needs a Bitcoin Mainnet Global Node on the Growth plan or higher. Installing it takes four steps:
- Deploy a Bitcoin Mainnet Global Node in the Chainstack console if you don’t have one yet.
- Open the node and select the Add-ons tab.
- Click Enable on the Blockbook add-on, select a tier in the Install Add-on dialog and click Install.
- Open Access and credentials and copy the two Blockbook endpoints: HTTPS for REST and WSS for WebSocket. Both use your node’s auth token.
To check the setup, request the balance of an address from the REST endpoint. This call returns the balance and transaction counts of the public BIP-84 test address:
curl "https://blockbook-bitcoin-mainnet.core.chainstack.com/YOUR_AUTH_TOKEN/api/v2/address/bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu?details=basic"
To switch tiers or remove the add-on later, see Manage node add-ons.
On Chainstack nodes. Blockbook has its own HTTPS and WSS endpoints that use your node’s auth token, and each request or WebSocket notification costs 1 RU. See the Blockbook docs.
Conclusion: Empowering the next era of Bitcoin utility
Building wallets, payment processors, or explorers on Bitcoin shouldn’t mean spending engineering cycles maintaining custom chain parsers. Raw RPC workarounds don’t scale, and self-hosting an indexer adds another piece of stateful infrastructure your team has to keep online.
Running Blockbook directly alongside a Chainstack Global Node gives you immediate access to address balances, UTXOs, and real-time mempool events over standard REST and WebSocket endpoints. You get the indexed data your application needs out of the box, leaving your team to focus on the product itself.
FAQ
Blockbook is an open-source blockchain indexer built by Trezor. It reads every block once, records each transaction under the addresses it touches and keeps that index up to date with new blocks and mempool transactions. One request then returns the balance, UTXOs or transaction history of an address or wallet.
Bitcoin stores transactions by transaction ID and keeps the current set of UTXOs, but it has no index by address. To get a balance, the node’s scantxoutset method reads the entire UTXO set on every call, and building an address history means reading every block since 2009.
An extended public key (xpub) is the public key of one wallet account. A wallet derives all the addresses of an account from it and uses a new address for each payment, so the funds of one account spread across many addresses. Blockbook finds the used addresses of an xpub and returns their combined balance and transactions in one request.
Connect to the Blockbook WebSocket endpoint and send a subscribeAddresses request with the addresses you want to watch. Blockbook pushes a notification when one of them appears in a mempool transaction. Set newBlockTxs to true to also receive its transactions when a block confirms them.
Blockbook is a paid add-on for Bitcoin Mainnet Global Nodes, available from the Growth plan. It isn’t available on the Bitcoin testnets. It has three monthly tiers with a limit of 10, 50 or 200 requests per second.
Each REST request, WebSocket request and WebSocket subscription notification costs 1 request unit (RU), on top of the tier’s monthly price. On a node with the Unlimited Node add-on, Blockbook requests don’t consume RUs, and the tier’s RPS limit still applies.
Related reading
- Blockbook (Chainstack docs)
- Bitcoin methods (Chainstack docs)
- Bitcoin tooling (Chainstack docs)
- Global Nodes
