DEV Community: Olenza

Who actually holds Litecoin? A rich list and holder distribution in 30 lines of Python

Olenza — Mon, 12 Oct 2026 08:26:08 +0000

"Who holds the coins" sounds like a simple question. Answering it yourself is not. You need the whole UTXO set (every unspent output on the chain), grouped by address, refreshed as blocks arrive. For Litecoin that is about 54 million outputs. For Bitcoin it is more.

I run full nodes and a UTXO index for several chains, so I put those numbers behind a plain JSON API. This post uses it to answer the question for Litecoin. Everything below is real output from today.

One call

curl -H "X-API-Key: $OLENZA_KEY" https://explorer.olenza.io/api/v1/ltc/stats

The answer has several parts. Two of them matter here:

distribution: how many addresses fall into each balance band, and how many coins those bands hold.
richlist: the largest addresses, with each one's share of all coins.

Every part says which block it was computed at (as_of.height), so you know how fresh it is. Amounts are strings in the smallest unit (litoshi, 10⁻⁸ LTC). They are strings so that big totals don't lose precision in JavaScript.

The script

import json, os, urllib.request

KEY = os.environ["OLENZA_KEY"]

def get(path):
    req = urllib.request.Request("https://explorer.olenza.io/api/v1/" + path,
                                 headers={"X-API-Key": KEY, "User-Agent": "holders-example/1.0"})
    return json.load(urllib.request.urlopen(req))

stats = get("ltc/stats")
dist = stats["distribution"]["data"]
dec = 10 ** dist["decimals"]
total = int(dist["total_value"])

print(f"{dist['nonzero_addresses']:,} addresses hold coins")
for b in dist["bands"]:
    share = int(b["value"]) / total
    print(f"{b['label']:>14}  {b['addresses']:>10,} addresses  {share:6.1%} of coins")

top = stats["richlist"]["data"]["top"]
top10 = sum(t["share"] for t in top[:10])
print(f"\ntop 10 addresses: {top10:.1%} of all coins")
for t in top[:3]:
    print(f"#{t['rank']} {t['address']}  {int(t['value']) / dec:,.0f} LTC")

What it prints

9,116,927 addresses hold coins
       < 0.001   4,293,546 addresses    0.0% of coins
  0.001 – 0.01   1,274,631 addresses    0.0% of coins
    0.01 – 0.1   1,274,578 addresses    0.1% of coins
       0.1 – 1   1,295,021 addresses    0.6% of coins
        1 – 10     721,005 addresses    2.9% of coins
      10 – 100     216,437 addresses    8.1% of coins
      100 – 1k      36,795 addresses   12.2% of coins
      1k – 10k       4,266 addresses   14.4% of coins
    10k – 100k         535 addresses   18.3% of coins
        ≥ 100k         113 addresses   43.4% of coins

top 10 addresses: 14.0% of all coins
#1 MQd1fJwqBJvwLuyhr17PhEFx1swiqDbPQS  2,412,949 LTC
#2 ltc1qr07zu594qf63xm7l7x6pu3a2v39m2z6hh5pp4t  2,205,009 LTC
#3 ltc1qe8akpjkr822kvexkgqcc5msew0uwj8xv0ygp5l  1,102,168 LTC

113 addresses hold 43% of all Litecoin. Almost half of all addresses hold less than 0.001 LTC each.

Reading it honestly

An address is not a person. The biggest addresses are almost always exchanges, holding coins for many customers. One person can also spread coins over hundreds of addresses. So this is a picture of how coins sit on the chain, not of who is rich.

Two Litecoin details are handled for you:

MWEB. Coins moved into MimbleWimble Extension Blocks sit in one output that no one owns, and the holders behind it are private by design. That output is reported on its own under special, not ranked as the "largest holder".
Old pay-to-pubkey outputs are counted under the normal address of the same key, so one owner is not split in two.

Calling Bitcoin, Litecoin and Decred JSON-RPC without running a node

Olenza — Tue, 06 Oct 2026 17:20:43 +0000

I run full nodes for nine chains on one server in a datacenter. For a while I used them only for my own projects. Running a node is the boring part of most crypto side projects, and it is also the part that breaks: disk fills up, a release changes a flag, sync falls behind for a day. So I put a gateway in front of mine and opened it up. It's called Olenza Node.

This post shows what calling it looks like for Bitcoin, Litecoin and Decred, with real requests and responses, and what it can't do.

The shape of a call

Every chain has one endpoint:

POST https://node.olenza.io/v1/rpc/{chain}

{chain} is one of btc, eth, ltc, doge, bch, xec, zec, dcr, xmr. The body is a normal JSON-RPC request for that chain's node. The key goes in a header. The gateway does not translate anything: Bitcoin speaks Bitcoin Core RPC, Decred speaks dcrd, Monero speaks monerod.

export OLENZA_KEY=olz_xxx   # your key from account.olenza.io

curl https://node.olenza.io/v1/rpc/btc \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"getblockcount","params":[]}'

{"result":970203,"error":null,"id":1}

Authorization: Bearer olz_xxx works too. If your client can't set headers, the key can go in the path (/v1/rpc/btc/olz_xxx). The header is better, because your own proxy or shell history may keep the URL.

Bitcoin: fee estimate and mempool

curl https://node.olenza.io/v1/rpc/btc \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"estimatesmartfee","params":[6]}'

{"result":{"feerate":0.00001000,"blocks":6},"error":null,"id":1}

curl https://node.olenza.io/v1/rpc/btc \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"getmempoolinfo","params":[]}'

{"result":{"loaded":true,"size":2515,"bytes":697554,"usage":4230912,
 "total_fee":0.02143948,"maxmempool":300000000,"mempoolminfee":0.00001000,
 "minrelaytxfee":0.00001000,"incrementalrelayfee":0.00001000,
 "unbroadcastcount":0,"fullrbf":false},"error":null,"id":1}

Bitcoin has 45 methods open: blocks, transactions, mempool, fee estimation, PSBT tools, sendrawtransaction, testmempoolaccept. Wallet, peer and node-control methods are closed.

Litecoin: same dialect, MWEB visible in getblockchaininfo

curl https://node.olenza.io/v1/rpc/ltc \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"getblockchaininfo","params":[]}'

Trimmed response:

{"result":{"chain":"main","blocks":3190632,"headers":3190632,
 "initialblockdownload":false,"pruned":false,
 "softforks":{
   "taproot":{"type":"bip8","active":true,"height":2257920},
   "mweb":{"type":"bip8","active":true,"height":2265984}}},
 "error":null,"id":1}

curl https://node.olenza.io/v1/rpc/ltc \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"estimatesmartfee","params":[6]}'

{"result":{"feerate":0.00000999,"blocks":6},"error":null,"id":1}

Litecoin has 42 methods open.

Decred: the staking calls

Decred is where a hosted node saves the most work, because dcrd has calls that Bitcoin-style nodes don't: tickets, votes, treasury. 47 methods are open.

Ticket price right now:

curl https://node.olenza.io/v1/rpc/dcr \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"getstakedifficulty","params":[]}'

{"jsonrpc":"1.0","result":{"current":275.77403247,"next":275.77403247},"error":null,"id":1}

Treasury balance (in atoms, 1 DCR = 100,000,000 atoms):

curl https://node.olenza.io/v1/rpc/dcr \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '{"jsonrpc":"1.0","id":1,"method":"gettreasurybalance","params":[]}'

{"jsonrpc":"1.0","result":{"hash":"345339d9…534fc120","height":1121329,"balance":88191381920627},"error":null,"id":1}

That is about 881,914 DCR. getcoinsupply, getticketpoolvalue, livetickets, ticketsforaddress, getvoteinfo and gettreasuryspendvotes are there too. dcrd has no address history index, so for an address you get existsaddress and ticketsforaddress, not a transaction list.

Batches

Send an array and you get an array back. Each call in the batch counts as one unit, so this costs 2:

curl https://node.olenza.io/v1/rpc/btc \
  -H "X-API-Key: $OLENZA_KEY" \
  --data '[{"jsonrpc":"1.0","id":1,"method":"getblockcount","params":[]},
           {"jsonrpc":"1.0","id":2,"method":"getbestblockhash","params":[]}]'

[{"result":970203,"error":null,"id":1},
 {"result":"00000000000000000001411305f8c4987a46839f5e5c7109adcd5847f6f3820a","error":null,"id":2}]

The free plan allows batches of up to 5 calls (Starter 20, Pro 50). A bigger batch is refused with BATCH_TOO_LARGE. Monero is the exception: monerod doesn't take batches at all, so for xmr you send one call per request. The gateway refuses an array there with INVALID_REQUEST and doesn't charge for it.

What you see when you're refused

A closed method:

{"error":{"code":-32601,"data":{"reason":"METHOD_NOT_ALLOWED"},
 "message":"method \"getwalletinfo\" is not available"},"id":null,"jsonrpc":"2.0"}

No key:

{"error":{"code":-32001,"data":{"reason":"MISSING_API_KEY"},
 "message":"an API key is required"},"id":null,"jsonrpc":"2.0"}

error.data.reason is a stable code, so you can switch on it. The full list is in the docs.

Every response also carries your limits, so you never have to guess:

x-ratelimit-limit: 10
x-ratelimit-remaining: 8
x-ratelimit-reset: 1
x-quota-daily-limit: 10000
x-quota-daily-remaining: 9926
x-quota-monthly-limit: 300000
x-quota-monthly-remaining: 299924
x-request-id: c2ab92cbe93db0e4

Limits and price

Free: 10,000 calls a day, 300,000 a month, 5 requests a second (burst 10), all nine chains. Every call is one unit, whatever the method.
Starter: $25 a month. Pro: $79 a month. Paying 6 or 12 months up front takes 25% or 50% off.
When you hit a limit you get HTTP 429 with Retry-After. Errors on our side (node down, node syncing, gateway busy) are not charged.
Some heavy calls have a per-request cap, for example eth_getLogs covers at most 10,000 blocks per call. Over the cap you get RANGE_TOO_LARGE and page through instead. The docs list each one.
Payment is in crypto: BTC, LTC or USDT through BTCPay, or LTC, ETH, USDT or USDC sent directly.

What it is not

I'd rather say this up front:

It's one person's project, run from one server. I watch it, it has alerting, and the status page is public, but there is no team on call and no SLA.
No wallet RPC, no peer or node-control methods, no scantxoutset.
Bitcoin-style nodes have no address index. For "all transactions of an address" you need an indexer. Olenza Explorer has a REST API for that (separate free plan: 5,000 calls a day), but that's another post.
Monero only exposes /json_rpc methods. The binary endpoints a light wallet syncs from are not open.
Ethereum runs on an Erigon archive node, so eth_call and trace_* work at any height, but trace_* on old blocks is slow.

Why bother

If you're building a small tool, a bot, a payment check or a dashboard, and you need a few thousand calls a day to a real node for an odd chain like Decred or eCash, there are not many places that sell that. I wanted one.

To try it, make a free key at https://account.olenza.io (email sign-up) and paste one of the curl lines above.

Docs: https://olenza.io/docs (also as OpenAPI and as llms.txt)
Methods per chain: https://node.olenza.io
Pricing: https://olenza.io/pricing
Status: https://olenza.io/status

If something answers wrong, or a method you need is closed for no good reason, tell me in the comments. I read all of them.