JavaScript / TypeScript

Unlike the EVM world with its ethers and viem, Bitcoin has no single dominant high-level JavaScript SDK — most apps talk to the Bitcoin Core JSON-RPC API directly over a plain HTTP client. The two common choices are axios and node-fetch (or the global fetch built into modern Node), and either is enough to read chain data or broadcast a transaction. Note that building and signing transactions is a separate concern handled client-side by a library such as bitcoinjs-lib; the RPC endpoint only relays the finished hex. The recommendation is to wrap https://bitcoin.therpc.io/YOUR_API_KEY (the key from your TheRPC dashboard) in one small rpc() helper and reuse it for every call.

Every request uses Bitcoin Core's legacy JSON-RPC 1.0 envelope: { jsonrpc: "1.0", id: "therpc", method, params }. The params value is always a positional array — arguments go in a fixed order and are never passed as named keys, so getting the order right matters on each method. Your TheRPC API key lives in the URL path (https://bitcoin.therpc.io/YOUR_API_KEY), which keeps the request body identical to a call against any Bitcoin node.

Using axios

Install axios with npm install axios, then build a single rpc() helper that posts the 1.0 envelope to the BTC endpoint and returns data.result. The key detail: a failed Bitcoin RPC still comes back as an HTTP 200 — the failure lives in the response body's error field, not in the HTTP status — so the helper checks data.error and throws on it rather than relying on axios to reject. With that in place, reading the chain tip (getblockcount) or decoding a verbose transaction (getrawtransaction with the second arg true) is a one-liner.

1import axios from 'axios';
2 
3const ENDPOINT = 'https://bitcoin.therpc.io/YOUR_API_KEY';
4 
5async function rpc(method, params = []) {
6  const { data } = await axios.post(ENDPOINT, {
7    jsonrpc: '1.0',
8    id: 'therpc',
9    method,
10    params,
11  });
12  if (data.error) throw new Error(data.error.message);
13  return data.result;
14}
15 
16// Read current chain height
17const height = await rpc('getblockcount');
18 
19// Fetch and decode a transaction
20const tx = await rpc('getrawtransaction', [
21  '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
22  true,
23]);
24console.log(tx.confirmations, tx.vout.length);

Using node-fetch

If you'd rather not add a dependency, node-fetch — or the global fetch shipped with modern Node and every browser — calls the same endpoint with no extra SDK. The helper is identical in spirit: serialize the 1.0 envelope, POST it as JSON, and pull result/error off the parsed body. Here it estimates a fee rate with estimatesmartfee (BTC/kvB, which you convert to sat/vByte with * 1e5) and then broadcasts a fully signed, hex-encoded transaction via sendrawtransaction, which returns the txid the network accepted into its mempool.

1import fetch from 'node-fetch';
2 
3const ENDPOINT = 'https://bitcoin.therpc.io/YOUR_API_KEY';
4 
5async function rpc(method, params = []) {
6  const res = await fetch(ENDPOINT, {
7    method: 'POST',
8    headers: { 'Content-Type': 'application/json' },
9    body: JSON.stringify({ jsonrpc: '1.0', id: 'therpc', method, params }),
10  });
11  const { result, error } = await res.json();
12  if (error) throw new Error(error.message);
13  return result;
14}
15 
16// Estimate a fee rate for confirmation within 6 blocks
17const fee = await rpc('estimatesmartfee', [6]);
18const satPerVByte = fee.feerate ? Math.round(fee.feerate * 1e5) : null;
19 
20// Broadcast a fully signed raw transaction
21const txid = await rpc('sendrawtransaction', ['0200000001abcd...00000000']);
22console.log('Broadcast txid:', txid);

TypeScript Support

In TypeScript, give the envelope a generic shape — RpcResponse<T> with result: T | null and a nullable error — and make rpc<T>() return Promise<T> so each call site names the result type it expects (rpc<number>('getblockcount')). Watch the units when you type results: most Bitcoin methods report amounts as floating-point BTC (e.g. a value of 0.5), while a few — notably getblockstats — report them as integer satoshis (1 BTC = 100,000,000 sat). Typing a satoshi field as a BTC float, or vice versa, silently corrupts any math you do on it, so model each method's units deliberately.

1interface RpcResponse<T> {
2  result: T | null;
3  error: { code: number; message: string } | null;
4  id: string;
5}
6 
7const ENDPOINT = 'https://bitcoin.therpc.io/YOUR_API_KEY';
8 
9async function rpc<T>(method: string, params: unknown[] = []): Promise<T> {
10  const res = await fetch(ENDPOINT, {
11    method: 'POST',
12    headers: { 'Content-Type': 'application/json' },
13    body: JSON.stringify({ jsonrpc: '1.0', id: 'therpc', method, params }),
14  });
15  const body = (await res.json()) as RpcResponse<T>;
16  if (body.error) throw new Error(body.error.message);
17  return body.result as T;
18}
19 
20const height = await rpc<number>('getblockcount');

• axios — promise-based HTTP client used in the first example to POST the JSON-RPC envelope.
• node-fetch — fetch for older Node runtimes; modern Node and browsers expose fetch globally.
• bitcoinjs-lib — build and sign Bitcoin transactions client-side, then broadcast the resulting hex with sendrawtransaction.