Skip to content
0%

How to choose a reliable Bitcoin RPC endpoint

Alchemy team headshot

Written by Alchemy

Published on November 20, 202613 min read

How to choose a reliable Bitcoin RPC endpoint title card

Every deposit your app credits, every withdrawal it broadcasts and every balance it shows passes through a Bitcoin RPC endpoint first. When that endpoint falls behind the chain or drops a request, your users see a missing deposit or a stuck payout.

A Bitcoin RPC endpoint is a URL that takes JSON-RPC requests, such as "what's the latest block?" or "broadcast this transaction," and passes them to a Bitcoin node. A reliable one returns data that matches the chain, stays up under load, supports the methods your app calls, and tells you why a request failed.

A reliable endpoint agrees with the chain, every time.

At a glance

  • Judge providers on ten criteria. Correct data and uptime come first.
  • Test before you commit: run the script below against the endpoint and a second source for an hour.
  • Compare providers on chain coverage, indexed data, streaming and SOC 2, using each provider's own pages.
  • Alchemy puts Bitcoin, Litecoin, Dogecoin and Bitcoin Cash on the same API key and dashboard as 100+ other chains, and the free plan includes Bitcoin JSON-RPC.

The Bitcoin RPC reliability checklist

Ten criteria cover the ways a Bitcoin endpoint fails in production, and you can test each one yourself. Correct data and uptime come first. A fast endpoint that serves a stale block still credits deposits late.

#
Criterion
What good looks like
How to test it
Matters most for

1

Correct chain data

Same blocks and hashes as the network, even after a reorg (the chain swapping out its newest blocks)

Compare getblockhash with a second source, 6 blocks below the tip

Custody, payments, reconciliation

2

Availability

Keeps answering when a node behind it fails

Over an hour, count failures, timeouts and blocks behind. Read the status page history

Exchanges

3

Method and node support

Every method you call, on unpruned nodes with a full transaction index (txindex)

Call each method. Fetch an old transaction by its ID alone

Custody, reconciliation, analytics

4

Rate limits

Handles your peak without HTTP 429 (too many requests) errors

Send peak traffic and count 429s separately

Exchanges, analytics

5

Latency from your region

Fast enough from your own servers

Time successful calls only. Count timeouts as failures

Trading

6

Broadcast reliability

Your transactions reach other nodes' mempools (their queues of unconfirmed transactions)

Run testmempoolaccept on mainnet, then a small send on testnet4

Payments

7

Debuggability

Clear errors, request logs, Bitcoin on the status page

Send a bad request and read the error

Every team

8

Security

A SOC 2 Type II report

Ask for the report and check the trust page

Regulated teams

9

Support

A real person who answers fast

Send a technical question before you buy. Ask about a signed SLA

Every team

10

Exit cost

Standard methods, with equivalents for any indexed calls

List your non-standard calls and check the new provider

Every team

How do Bitcoin RPC providers compare?

The table compares providers on chain coverage, indexed data, streaming and compliance, using each provider's own pages. It doesn't rank performance. "Not stated" means we couldn't confirm the item on the provider's pages.

Provider
UTXO chains
Bitcoin node and data
Streaming
Free tier with Bitcoin
Dedicated Bitcoin option
SOC 2
Status page lists Bitcoin

Alchemy

BTC, BCH, LTC, DOGE

Unpruned full nodes with txindex; indexed UTXO API

WebSocket

Yes (JSON-RPC)

Yes

Type II

Yes

Blockdaemon

BTC, BCH, LTC, DOGE

UTXO data via custom RPC methods and REST

Event streaming

Not stated

Yes

Type II

Yes

Blockstream

BTC, Liquid

Indexed Esplora REST and Electrum; Bitcoin Core JSON-RPC not stated

Not stated

Yes

Yes

Not stated

Yes

Chainstack

BTC; LTC and DOGE on dedicated nodes

Unpruned with txindex

Not stated

Yes

Yes

Type II

Yes

GetBlock

BTC, BCH, LTC, DOGE

Full node; indexed Blockbook API

WebSocket via Blockbook (paid plans)

Yes

Yes

Type II

Not stated

NOWNodes

BTC, BCH, LTC, DOGE

Full node; indexed Blockbook API

WebSocket on paid plans

Yes (trial)

Yes

Not stated

Not stated

QuickNode

BTC, BCH; LTC and DOGE as paid add-ons

Pruning disabled; Blockbook add-on

Streams (block data only)

Yes (trial)

Yes (Enterprise)

Type II

Yes

Sources: each provider's own docs, pricing, security and status pages, checked November 19, 2026. Start with Alchemy, Blockdaemon, Blockstream, Chainstack, GetBlock, NOWNodes and QuickNode.

If you need balances and address history, start with the node and data column, because Bitcoin Core keeps no address index. If you need real-time updates, check streaming. In a regulated industry, start with SOC 2.

How do you test a Bitcoin RPC endpoint before you commit?

Run the script below against the endpoint and a second source for an hour, then compare. Think of the second source like a second clock in a server room: one clock can't tell you it's wrong, but two clocks that disagree tell you to look.

Your second source can be your own Bitcoin Core node or another provider. Over an hour (about six new blocks), the script counts failures by type, times successful calls, tracks how far the endpoint trails, and checks that both sources agree on the block hash six blocks below the tip. At about one request per second it isn't a load test, so test peak throughput separately.

javascript
Copied
// test-endpoint.mjs: check a Bitcoin RPC endpoint against a second source. Node 18+, no dependencies. // PRIMARY_URL=https://bitcoin-mainnet.g.alchemy.com/v2/YOUR_KEY REFERENCE_URL=http://user:[email protected]:8332 node test-endpoint.mjs const env = process.env; const DURATION_S = Number(env.DURATION_S ?? 3600); // an hour sees ~6 new blocks const INTERVAL_MS = Number(env.INTERVAL_MS ?? 2000); const TIMEOUT_MS = Number(env.TIMEOUT_MS ?? 5000); // slower than this counts as a timeout const DEPTH = 6; // compare hashes 6 blocks below the tip, past normal reorgs // A 200 response only counts if the result has the right shape. const VALID = { getblockcount: Number.isInteger, getblockhash: (h) => /^[0-9a-f]{64}$/.test(h) }; if (!env.PRIMARY_URL || !env.REFERENCE_URL) throw new Error("Set PRIMARY_URL and REFERENCE_URL."); // fetch() rejects user:pass in URLs, so move credentials into a header. function target(raw) { const url = new URL(raw); const headers = { "content-type": "application/json" }; if (url.username) { const creds = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`; headers.authorization = "Basic " + Buffer.from(creds).toString("base64"); url.username = url.password = ""; } return { url: url.toString(), headers }; } async function rpc({ url, headers }, method, params = []) { const started = performance.now(); try { const res = await fetch(url, { method: "POST", headers, signal: AbortSignal.timeout(TIMEOUT_MS), body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }) }); const text = await res.text(); const ms = performance.now() - started; let body; try { body = JSON.parse(text); } catch { return { kind: res.ok ? "bad_response" : `http_${res.status}` }; } if (body?.error) return { kind: `rpc_${body.error.code}` }; // Bitcoin Core before v28 sends these as HTTP 500 if (!res.ok) return { kind: `http_${res.status}` }; if (!VALID[method](body?.result)) return { kind: "bad_response" }; return { ok: true, result: body.result, ms }; } catch (err) { return { kind: err.name === "TimeoutError" || err.name === "AbortError" ? "timeout" : "network" }; } } const P = target(env.PRIMARY_URL), R = target(env.REFERENCE_URL); const latencies = [], errors = {}, referenceErrors = {}, checked = new Set(), mismatches = new Set(); let calls = 0, maxBehind = 0, behindSince = null, longestBehindMs = 0; const tally = (bag, r) => r.ok || (bag[r.kind] = (bag[r.kind] ?? 0) + 1); // Call both endpoints at once. Returns [primary, reference] results, or null if either failed. async function both(method, params) { const [p, r] = await Promise.all([rpc(P, method, params), rpc(R, method, params)]); calls++; tally(errors, p); tally(referenceErrors, r); if (p.ok) latencies.push(p.ms); return p.ok && r.ok ? [p.result, r.result] : null; } console.log(`Testing for ${DURATION_S}s...`); for (const end = Date.now() + DURATION_S * 1000; Date.now() < end; await new Promise((r) => setTimeout(r, INTERVAL_MS))) { const heights = await both("getblockcount"); // does the primary keep up? if (!heights) continue; const behind = heights[1] - heights[0]; maxBehind = Math.max(maxBehind, behind); behindSince = behind > 0 ? behindSince ?? Date.now() : null; if (behindSince) longestBehindMs = Math.max(longestBehindMs, Date.now() - behindSince); const height = Math.min(...heights) - DEPTH; const hashes = await both("getblockhash", [height]); // do both agree on a settled block? if (!hashes) continue; checked.add(height); if (hashes[0] !== hashes[1]) mismatches.add(height); } const sorted = latencies.sort((a, b) => a - b); const pct = (q) => (sorted.length ? Math.round(sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))]) : null); const failed = Object.values(errors).reduce((a, b) => a + b, 0); console.log({ primaryCalls: calls, failures: errors, failureRate: `${((100 * failed) / Math.max(calls, 1)).toFixed(2)}%`, latencyMsOnSuccess: { p50: pct(0.5), p95: pct(0.95), p99: pct(0.99) }, maxBlocksBehindReference: maxBehind, longestSecondsBehind: Math.round(longestBehindMs / 1000), blockHeightsChecked: checked.size, hashMismatchesAtHeights: [...mismatches], referenceFailures: referenceErrors, // if this is high, pick a better second source });

Run it with your own endpoint URLs:

bash
Copied
PRIMARY_URL=https://bitcoin-mainnet.g.alchemy.com/v2/YOUR_KEY \ REFERENCE_URL=https://your-second-source.example \ DURATION_S=3600 node test-endpoint.mjs

If your second source is your own Bitcoin Core node, put its RPC username and password in the URL, such as http://user:[email protected]:8332. The script moves them into an authorization header.

Here's how to read the output:

Field
Healthy
If not

failureRate

Close to 0%

http_429: you're at your plan's rate limit. rpc_: the node returned an error. bad_response: no usable answer, such as a gateway error page or an empty result

maxBlocksBehindReference

0 or 1

Each block behind is about 10 minutes of missing transactions

longestSecondsBehind

A few seconds

Minutes behind means stale data, even at one block

blockHeightsChecked

More than 2

Run the test longer

hashMismatchesAtHeights

Empty

One source is almost certainly on the wrong chain

referenceFailures

Low

Your second source is the problem. Pick another and rerun

Run the test at your busiest time of day, from the region where your servers run. The same rules we follow for our public RPC benchmarks apply: send every provider the same requests at the same time, and report failures next to latency.

When is Alchemy the right Bitcoin RPC provider?

Alchemy is a good fit if you want Bitcoin, Litecoin, Dogecoin and Bitcoin Cash on the same RPC platform you already use for Ethereum, Solana and 100+ other chains: one API key, one dashboard, one bill.

Choose Alchemy if:

  • You already run EVM or Solana on Alchemy. Bitcoin becomes one more network on your app, with no new vendor or security review.
  • You need balances, UTXOs and address history. Our indexed UTXO API answers those over REST, including lookups by xpub (an extended public key that derives all of a wallet's addresses) and output descriptor.
  • You need real-time updates. Our Bitcoin WebSockets stream new blocks and activity on the addresses you watch. Address activity webhooks for Bitcoin and Dogecoin are in beta.
  • You're migrating from another UTXO API. Our UTXO migration guide maps QuickNode, BlockCypher and Blockdaemon calls to Alchemy.
  • Your security review requires SOC 2 Type II. We're certified, and our trust center has the details.

Supported node methods work the same as on your own Bitcoin Core node. Check the method list for the ones you call. Wallet methods like getbalance and listunspent aren't available on our endpoints, so use the indexed UTXO API for balances.

What about Litecoin, Dogecoin and Bitcoin Cash?

All three come from Bitcoin's codebase, so they share its UTXO model, most of its JSON-RPC methods and the same checklist.

Chain
Block time
What's different
Networks we support

Litecoin

About 2.5 minutes

"Two blocks behind" is a smaller gap than on Bitcoin

Mainnet, testnet

Dogecoin

About 1 minute

Blocks arrive about ten times as often as on Bitcoin

Mainnet

Bitcoin Cash

About 10 minutes

Uses estimatefee instead of estimatesmartfee

Mainnet, testnet

The UTXO chains guide explains how all four differ from account-based chains like Ethereum.

How do you get a Bitcoin RPC endpoint on Alchemy?

Create an app, enable Bitcoin, and send a request.

  1. Sign in to the Alchemy dashboard and create an app.
  2. Enable Bitcoin Mainnet.
  3. Copy the endpoint URL. It looks like https://bitcoin-mainnet.g.alchemy.com/v2/YOUR_KEY.
  4. Send a request:
bash
Copied
curl -X POST https://bitcoin-mainnet.g.alchemy.com/v2/YOUR_KEY \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"getblockcount","params":[]}'

The response is the current block height. The Bitcoin API reference lists every supported method.

The indexed UTXO API (balances, UTXOs, address and xpub history) is a paid add-on. On pay-as-you-go plans you buy it per chain from the dashboard, and Enterprise plans include it along with a signed SLA. For capacity reserved for your team alone, see Dedicated Clusters or talk to our team.

Ready to see for yourself? Create a free Bitcoin endpoint and run the test script against it. No sales call, no contract. For Enterprise plans or Dedicated Clusters, talk to our team.

Frequently asked questions

How do I choose a reliable Bitcoin RPC endpoint?

Compare providers on ten criteria: correctness, availability, method and node support, rate limits, latency from your region, broadcast reliability, debuggability, security, support and exit cost. Then test your shortlist against a second source for an hour. Count failures, timeouts, blocks behind and block-hash mismatches, and time successful calls only.

What is a Bitcoin RPC provider?

A Bitcoin RPC provider runs Bitcoin nodes for you and gives you an endpoint URL for JSON-RPC requests. The provider handles syncing, upgrades and disk growth. Many providers also offer indexed APIs for balances and address history, which Bitcoin Core doesn't provide on its own.

Should I run my own Bitcoin node or use a provider?

Run your own node for local development, or if you need full control of its configuration. Use a provider in production if you'd rather not run syncing, upgrades, monitoring and an address indexer yourself. Many teams do both, and use their own node as the second source when they test a provider.

Which Bitcoin RPC methods should my provider support?

At a minimum: getblockcount, getblockhash, getblock, getrawtransaction, sendrawtransaction, estimatesmartfee, getblockchaininfo and mempool methods such as getrawmempool. Check that getrawtransaction finds old transactions by ID alone, which requires txindex. Wallets and custody apps also need balance, UTXO and xpub lookups from an indexed API.

Does Alchemy support Bitcoin, Litecoin, Dogecoin and Bitcoin Cash?

Yes. Alchemy supports JSON-RPC on Bitcoin, Litecoin, Dogecoin and Bitcoin Cash, plus an indexed UTXO API for balances, UTXOs and address history on all four. The indexed API is a per-chain add-on on pay-as-you-go plans and is included on Enterprise. All four share one dashboard and API key with 100+ other chains.

Does Alchemy offer an archive Bitcoin node?

Yes, in the sense Bitcoin teams usually mean. Alchemy's Bitcoin endpoints run on unpruned full nodes with a full transaction index (txindex), so you can fetch any block and any confirmed transaction by its ID. For address balances and history, use the indexed UTXO API, because Bitcoin Core keeps no address index.

What happens during a chain reorg?

A reorg happens when the network replaces its newest block, or several, with a competing branch. Transactions in the replaced blocks, other than miners' rewards, go back to the mempool, and most confirm again later. One can drop out if a conflicting transaction confirmed on the new branch, so wait for enough confirmations before crediting deposits, and be ready to reverse.

Is there a free Bitcoin RPC endpoint?

Yes. Several providers include Bitcoin JSON-RPC on a free plan, including Alchemy, and free public endpoints exist for testing. Free plans have lower rate limits, and public endpoints have no uptime commitment, so use them for development. On Alchemy, the indexed UTXO API isn't available on the free plan.

Background gradient

Build blockchain magic

Alchemy combines the most powerful web3 developer products and tools with resources, community and legendary support.