Litecoin RPC: Core JSON-RPC + Blockbook for Addresses and UTXOs

If you've only ever built on Ethereum, connecting to Litecoin is a small culture shock. There's no eth_getBalance, no accounts, no gas, no smart contracts. Litecoin is a UTXO chain — closer to Bitcoin than to any EVM network — and its API reflects that. The good news: once you understand the two-API model, querying Litecoin is straightforward. Here's the map.

Litecoin in one paragraph

Litecoin is one of the oldest cryptocurrencies (live since 2011), built for fast, low-fee payments. It shares Bitcoin's UTXO model but targets a ~2.5-minute block time (four times faster than Bitcoin) and uses the Scrypt proof-of-work algorithm. Supply caps at 84 million LTC, halving every 840,000 blocks. It has activated SegWit and MWEB (MimbleWimble Extension Blocks) for optional confidential transactions. For a developer, the thing that matters most is the data model: coins are unspent outputs, not account balances.

Two APIs, because Litecoin Core has no address index

Here's the key architectural fact that trips up newcomers: Litecoin Core, like Bitcoin Core, has no built-in address index. It can tell you everything about a transaction if you already know its ID, but it cannot answer "what is this address's balance?" or "list this wallet's history." That's not a bug — full nodes don't index by address by default because it's expensive.

So you use two complementary APIs:

SwiftNodes runs Blockbook (Trezor's indexer) alongside the node, so both are available under one key.

The UTXO model in 60 seconds

Litecoin has no account balances. Coins exist as unspent transaction outputs (UTXOs) — discrete chunks locked to an address. A "balance" is just the sum of an address's UTXOs. To spend, a transaction consumes whole UTXOs as inputs and creates new outputs (the payment, plus a change output back to yourself). This is why you almost always fetch the UTXO list before building a transaction — and why balance queries live in the Blockbook index, not in Litecoin Core.

Core JSON-RPC: blocks and broadcasting

Standard Litecoin Core methods, POSTed to /rpc/ltc:

# Current block height
curl -s -X POST https://rpc.swiftnodes.io/rpc/ltc?key=YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"getblockcount","params":[],"id":1}'
# -> {"result":3140156,"error":null,"id":1}

The methods you'll actually use: getblockchaininfo, getblock / getblockhash, getrawtransaction (set verbose true for decoded), sendrawtransaction (broadcast a signed tx), estimatesmartfee (fee rate for a target confirmation window), and gettxout (is a specific output still unspent?).

Blockbook: address, UTXO & xpub queries

This is the part Litecoin Core can't give you. All routes are GET under /blockbook/ltc/api/v2/:

# Address balance & history
curl -s "https://rpc.swiftnodes.io/blockbook/ltc/api/v2/address/Ltc1Address…?key=YOUR_API_KEY"
# -> {"address":"…","balance":"1152339","totalReceived":"…","txs":121, …}

# Spendable UTXOs for that address (what you need to build a tx)
curl -s "https://rpc.swiftnodes.io/blockbook/ltc/api/v2/utxo/Ltc1Address…?key=YOUR_API_KEY"
# -> [{"txid":"…","vout":0,"value":"546","confirmations":9}, …]

# Whole-wallet view from an extended public key
curl -s "https://rpc.swiftnodes.io/blockbook/ltc/api/v2/xpub/zpub…?details=txs&key=YOUR_API_KEY"

Balances are in litoshi (1 LTC = 100,000,000 litoshi), just as Bitcoin uses satoshis. The /xpub/ route is especially useful for wallets and exchanges: hand it an extended public key and Blockbook returns the balance and history across all derived addresses — no need to track each address yourself.

Building and broadcasting a transaction

There's no server-side wallet — you build and sign client-side (keys never leave your environment), then broadcast:

1. Get UTXOs for the sending address — Blockbook /utxo/{addr}.
2. Estimate the fee — Core estimatesmartfee or Blockbook /estimatefee/6. Litecoin fees are litoshi per virtual byte (sat/vB equivalent), multiplied by the transaction's vsize.
3. Build & sign locally with a library like bitcoinjs-lib (it supports Litecoin's network params), selecting inputs and adding a change output.
4. Broadcast — Core sendrawtransaction or Blockbook /sendtx/{hex}.
5. Track — poll Blockbook /tx/{txid} and watch confirmations climb.

A note on MWEB: the node runs a current Litecoin Core with MWEB active. Standard JSON-RPC and Blockbook address queries work as normal; MWEB confidential outputs follow Litecoin's own visibility rules, so don't expect to enumerate them like ordinary UTXOs.

How it differs from an EVM chain

If you've integrated Bitcoin before, Litecoin will feel almost identical — same UTXO model, same Core-plus-Blockbook split, same address/xpub patterns. The differences are cosmetic: faster blocks, Scrypt instead of SHA-256, litoshi instead of satoshi, and MWEB. Our Bitcoin RPC & Blockbook guide covers the shared UTXO API in more depth, and if you want to run the node yourself, see How to Run a Litecoin Node.

The short version

Litecoin is a UTXO chain, so it uses Litecoin Core JSON-RPC (blocks, raw transactions, broadcasting, fees) plus a Blockbook REST API for the address, UTXO, and xpub queries Core can't answer. Balances are the sum of unspent outputs (in litoshi), you fetch UTXOs before building a transaction, fees are litoshi/vB, and finality is probabilistic (~6 confirmations). Treat it like Bitcoin with faster blocks and MWEB, and reach for Blockbook the moment you need anything address-level.

One key gets you both the Litecoin Core JSON-RPC and the Blockbook address/UTXO/xpub API, flat-rate, alongside dozens of other chains. Our Litecoin RPC endpoint exposes both. Grab a free key and connect:

https://rpc.swiftnodes.io/rpc/ltc?key=YOUR_API_KEY                    # Core JSON-RPC
https://rpc.swiftnodes.io/blockbook/ltc/api/v2/…?key=YOUR_API_KEY     # Blockbook REST