Go

For talking to the Bitcoin Core JSON-RPC API from Go, the simplest path is also the most portable: raw JSON-RPC over the standard library's net/http and encoding/json, with zero third-party dependencies. The btcsuite/btcd project ships an rpcclient package that gives you a typed Bitcoin client if you want method signatures and structs out of the box, but it's tuned for a local bitcoind and a plain HTTP client works just as well against a hosted provider like TheRPC. The recommendation here is a small reusable client with one Call method that you point at https://bitcoin.therpc.io/YOUR_API_KEY (the key comes from your TheRPC dashboard) and reuse across every RPC.

Bitcoin Core uses the legacy JSON-RPC 1.0 envelope: each request is {"jsonrpc":"1.0","id":"therpc","method":...,"params":[...]} where params is an ordered, positional array — argument order is significant on every method. Your TheRPC key lives in the URL path (https://bitcoin.therpc.io/YOUR_API_KEY), so the HTTP request itself stays plain. A failed RPC does not come back as an HTTP error — the call returns 200 and surfaces the failure in the response body's error field, so always check that field rather than relying on the status code.

Raw JSON-RPC with net/http

Model the 1.0 envelope with two small structs: an rpcRequest carrying the jsonrpc, id, method, and []interface{} positional params, and an rpcResponse whose Result is a json.RawMessage (so you can defer decoding into the concrete shape each method returns) plus an optional Error with the node's numeric code and message. A single Call method marshals the request, posts it to the BTC endpoint, decodes the envelope, returns a Go error when the error field is set, and otherwise unmarshals Result into whatever out value the caller passed.

1package bitcoin
2 
3import (
4	"bytes"
5	"encoding/json"
6	"fmt"
7	"net/http"
8)
9 
10type Client struct {
11	endpoint string
12	http     *http.Client
13}
14 
15func NewClient(endpoint string) *Client {
16	return &Client{endpoint: endpoint, http: &http.Client{}}
17}
18 
19type rpcRequest struct {
20	JSONRPC string        `json:"jsonrpc"`
21	ID      string        `json:"id"`
22	Method  string        `json:"method"`
23	Params  []interface{} `json:"params"`
24}
25 
26type rpcResponse struct {
27	Result json.RawMessage `json:"result"`
28	Error  *struct {
29		Code    int    `json:"code"`
30		Message string `json:"message"`
31	} `json:"error"`
32}
33 
34func (c *Client) Call(method string, params []interface{}, out interface{}) error {
35	body, _ := json.Marshal(rpcRequest{JSONRPC: "1.0", ID: "therpc", Method: method, Params: params})
36	resp, err := c.http.Post(c.endpoint, "application/json", bytes.NewReader(body))
37	if err != nil {
38		return err
39	}
40	defer resp.Body.Close()
41 
42	var r rpcResponse
43	if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
44		return err
45	}
46	if r.Error != nil {
47		return fmt.Errorf("rpc error %d: %s", r.Error.Code, r.Error.Message)
48	}
49	if out != nil {
50		return json.Unmarshal(r.Result, out)
51	}
52	return nil
53}

Reading and Broadcasting

Reading chain state is a matter of choosing the right out type per method. getblockcount returns a bare integer, so decode it straight into an int64 to get the current tip height. getblockchaininfo returns an object, so decode the fields you care about — here chain, blocks, and difficulty — into a small anonymous struct. Broadcasting works the same way: pass a fully signed, hex-encoded raw transaction as the single positional param to sendrawtransaction and decode the result into a string, which is the txid the network accepted. Since Bitcoin mines a block roughly every ten minutes under proof of work, that txid sits in the mempool until a miner includes it — you confirm later by polling, not by waiting on the broadcast call.

1package main
2 
3import (
4	"fmt"
5	"log"
6)
7 
8func main() {
9	c := NewClient("https://bitcoin.therpc.io/YOUR_API_KEY")
10 
11	// Read current chain height
12	var height int64
13	if err := c.Call("getblockcount", nil, &height); err != nil {
14		log.Fatal(err)
15	}
16	fmt.Println("Tip height:", height)
17 
18	// Decode a subset of getblockchaininfo
19	var info struct {
20		Chain  string  `json:"chain"`
21		Blocks int64   `json:"blocks"`
22		Diff   float64 `json:"difficulty"`
23	}
24	if err := c.Call("getblockchaininfo", nil, &info); err != nil {
25		log.Fatal(err)
26	}
27	fmt.Printf("%s @ %d (difficulty %.0f)\n", info.Chain, info.Blocks, info.Diff)
28 
29	// Broadcast a fully signed raw transaction
30	var txid string
31	err := c.Call("sendrawtransaction", []interface{}{"0200000001abcd...00000000"}, &txid)
32	if err != nil {
33		log.Fatal(err)
34	}
35	fmt.Println("Broadcast txid:", txid)
36}

Checking UTXOs

Because Bitcoin tracks money as unspent transaction outputs (UTXOs) rather than account balances, you inspect a single output by its txid and output index with gettxout. The trick is the spent case: when the referenced output has already been spent — or never existed in the UTXO set — the node returns JSON null, which encoding/json decodes into a nil pointer. Decode the result into a *TxOut and check for nil before reading any field; treating a nil pointer as a present output is the most common bug here. A non-nil result carries the output's value (in BTC), confirmation count, and scriptPubKey details such as the address and script type.

1type TxOut struct {
2	Confirmations int64   `json:"confirmations"`
3	Value         float64 `json:"value"`
4	ScriptPubKey  struct {
5		Type    string `json:"type"`
6		Address string `json:"address"`
7	} `json:"scriptPubKey"`
8}
9 
10func (c *Client) GetTxOut(txid string, vout int) (*TxOut, error) {
11	var out *TxOut
12	if err := c.Call("gettxout", []interface{}{txid, vout, true}, &out); err != nil {
13		return nil, err
14	}
15	// out is nil when the output is spent or unknown
16	return out, nil
17}

• net/http — the standard-library HTTP client used above; no external dependency needed to call the BTC endpoint.
• btcd rpcclient — optional typed Bitcoin JSON-RPC client if you prefer method signatures and structs over raw Call.
• btcutil — Bitcoin address and amount (satoshi ↔ BTC) helpers for working with the values these RPCs return.