Quick Start

TheRPC gives you a hosted, production-grade Bitcoin Core JSON-RPC endpoint — the same RPC bitcoind speaks — without running, syncing, or securing a node yourself. Bitcoin developers use it to read the chain, look up transactions and UTXOs, estimate fees, and broadcast signed transactions through one URL and one API key. This guide takes you from zero to a working call in a few minutes: grab a key, point at https://bitcoin.therpc.io/YOUR_API_KEY, and run your first request in curl, JavaScript, or Python.

Step 1: Get an API Key

Sign up for a free account at TheRPC.io, then open your Dashboard and go to the API Keys section. Click Generate to create a key, or copy an existing one. The key is an opaque token you'll drop into the endpoint URL in place of YOUR_API_KEY — so your live endpoint becomes https://bitcoin.therpc.io/<your-key>. Keep it private; you can revoke and regenerate it from the dashboard at any time.

Step 2: Choose Your Network

TheRPC serves both Bitcoin mainnet — the real network where BTC has value — and testnet, where coins are free for development. Both speak the identical JSON-RPC interface and accept the same API key, so the only thing that changes between them is the endpoint host. Configure your environment with the Bitcoin endpoint URL and your key (shown below), and start on testnet while you build so mistakes cost nothing.

Step 2: Choose Your Network

1API_ENDPOINT="https://bitcoin.therpc.io/YOUR_API_KEY"
2API_KEY="YOUR_API_KEY"

Step 3: Make Your First Call

Below are three ways to make the same first call — curl, JavaScript (axios), and Python (requests) — so you can use whichever fits your stack; the Tools & SDKs reference at the end covers each language in more depth. The call is getblockchaininfo, a read-only query that returns the network's current state (chain, height, best block hash, sync progress). It's the ideal first request: it touches no keys or private data, just confirms your endpoint and API key work end to end.

Using Curl

1curl --request POST https://bitcoin.therpc.io/YOUR_API_KEY \
2  --header 'Content-Type: application/json' \
3  --header 'Authorization: Bearer YOUR_API_KEY' \
4  --data '{
5    "jsonrpc": "1.0",
6    "id": "therpc",
7    "method": "getblockchaininfo",
8    "params": []
9  }'

Using JavaScript

1const axios = require('axios');
2 
3const config = {
4  url: 'https://bitcoin.therpc.io/YOUR_API_KEY',
5  apiKey: 'YOUR_API_KEY',
6};
7 
8async function getBlockchainInfo() {
9  const response = await axios.post(
10    config.url,
11    {
12      jsonrpc: '1.0',
13      id: 'therpc',
14      method: 'getblockchaininfo',
15      params: [],
16    },
17    {
18      headers: {
19        'Content-Type': 'application/json',
20        Authorization: `Bearer ${config.apiKey}`,
21      },
22    },
23  );
24 
25  console.log('Chain height:', response.data.result.blocks);
26}

Using Python

1import requests
2 
3config = {
4    'url': 'https://bitcoin.therpc.io/YOUR_API_KEY',
5    'api_key': 'YOUR_API_KEY'
6}
7 
8def get_blockchain_info():
9    response = requests.post(
10        config['url'],
11        headers={
12            'Content-Type': 'application/json',
13            'Authorization': f"Bearer {config['api_key']}"
14        },
15        json={
16            'jsonrpc': '1.0',
17            'id': 'therpc',
18            'method': 'getblockchaininfo',
19            'params': []
20        }
21    )
22    return response.json()['result']

Step 4: Using RPC Client Libraries

Unlike some ecosystems, Bitcoin has no single dominant high-level SDK — most production code simply talks raw JSON-RPC over HTTP, which is exactly what the examples above do. Thin convenience clients exist per language, such as python-bitcoinrpc (which lets you put the API key in the connection URL), but they're optional: a plain HTTP client works everywhere and keeps your dependencies light. The two snippets below show both styles — a reusable rpc() helper over node-fetch, and the python-bitcoinrpc proxy. See the Tools & SDKs documentation for full, language-specific coverage.

Node.js (node-fetch)

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 
16const height = await rpc('getblockcount');
17console.log('Tip height:', height);

Python (python-bitcoinrpc)

1from bitcoinrpc.authproxy import AuthServiceProxy
2 
3# The API key goes in the URL path
4rpc = AuthServiceProxy('https://bitcoin.therpc.io/YOUR_API_KEY')
5 
6info = rpc.getblockchaininfo()
7print('Chain:', info['chain'], 'Height:', info['blocks'])

Available Methods

The full list of supported methods lives on the All Methods page. Each method has its own reference covering its purpose, parameters, response shape, error codes, real-world use cases, and copy-paste examples in curl, JavaScript, Python, and Go. Note the public surface is read and broadcast methods only — block and chain reads, mempool inspection, raw transaction lookup, fee estimation, address validation, and sendrawtransaction. Wallet methods and node-admin methods are not exposed, since they act on a single node's private wallet and configuration and have no place on a shared endpoint.

Network Selection

Mainnet and testnet each have their own endpoint host; you select the network by choosing which URL you point at, with the same API key and request format on both. The Bitcoin endpoint URL follows the pattern https://bitcoin.therpc.io/YOUR_API_KEY, with your key in the path.

Next Steps

• All Methods — browse the full Bitcoin Core JSON-RPC surface TheRPC serves.
• Tools & SDKs — language-specific setup for JavaScript/TypeScript, Python, Go, and HTTP/curl.
• Authentication — secure your API key, URL-path vs Bearer header, environment setup.
• Rate Limits — quotas, backoff, batching, and sensible tip-polling intervals.
• Basic Operations — blocks, transactions, UTXOs, fee estimation, and broadcasting in practice.