Bitcoin Data: Index Transactions, Addresses, and UTXO Flows

Index Bitcoin transactions, inputs, outputs, addresses, and fees in one pipeline, delivered to your own database. Real-time and complete historical data, no Bitcoin Core node to run.

Bitcoin describes itself as an innovative payment network and a new kind of money, a peer-to-peer system with no central authority, where managing transactions and issuing bitcoins is carried out collectively by the network. It is the original proof-of-work chain and still the deepest pool of onchain value. You can read how the project frames it at bitcoin.org.

Bitcoin data does not look like account-based chain data. There are no balances, no contracts, and no event logs: every transaction spends earlier outputs and creates new ones, and every balance is a sum over unspent outputs. Indexing Co delivers each block as Bitcoin Core verbose JSON, with every input already resolved to the address and value it spends, so you can reshape inputs, outputs, and fees into the rows you want and land them in your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.

Source Bitcoin blocks

Ingest txs, vin, vout

Decode prevouts to addresses

Transform your JavaScript

Deliver your database

Why Bitcoin data is hard

UTXOs, Not Accounts A Bitcoin transaction has no "from" field. Each input only points at a previous transaction id and output index. Knowing who paid and how much means looking up every spent output, which on a raw node means a second lookup per input or a full UTXO index of your own.

Fees Are Implicit There is no fee field in the protocol. The fee is whatever the inputs were worth minus what the outputs pay out, so it can only be computed once every input value is known. Get one prevout wrong and every fee and balance downstream is wrong too.

Many Script Types Outputs come in legacy pubkey-hash, script-hash, SegWit v0, and Taproot forms, plus OP_RETURN data outputs with no address at all. Turning scripts into addresses consistently, and knowing which outputs to skip, is easy to get subtly wrong.

Thousands of Transactions per Block A single full block can carry several thousand transactions and many more inputs and outputs. Backfilling the whole chain from a node over RPC is slow, and keeping an address-level dataset current and reorg-safe is a standing job.

What Indexing Co delivers for Bitcoin

The DIY Path

Run a node and rebuild the UTXO view yourself.

Operate a Bitcoin Core node with a transaction index, or rent an RPC.
Resolve every input against the output it spends to recover addresses and values.
Derive fees, handle every script type, and skip non-address outputs.
Build backfill, reorg handling, and real-time delivery from scratch.

Indexing Co

One pipeline sources, resolves, and delivers Bitcoin to your store.

Every input arrives with its prevout: spending address, value, and script type.
Outputs with decoded addresses, plus a per-transaction fee.
Shaped by your transform, landed in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no RPC babysitting.

What you can index

Bitcoin data type	What it gives you
Inputs with prevout	Spending address, value, and script type for every input
Outputs	Receiving address, value, output index, and script type
Transaction fees	Fee per transaction, plus size, vsize, and weight
Coinbase transactions	Block rewards and the miner payout addresses
Block headers	Height, time, difficulty, and transaction count

A transform, not a subgraph

You write the transform in JavaScript, not AssemblyScript, and change it without re-indexing from block zero. Indexing Co runs your function over each block server-side. This one emits a row per output, with the sending addresses, input value, and fee alongside.

// Indexing Co transform: one row per Bitcoin output, with input context
function transform(block) {
  const rows = [];

  for (const tx of block.tx || []) {
    const coinbase = Boolean(tx.vin?.[0]?.coinbase);
    // Bitcoin inputs carry prevout: the address and value being spent
    const fromAddresses = [...new Set(
      (tx.vin || []).map((input) => input.prevout?.scriptPubKey?.address).filter(Boolean)
    )];
    const inputValue = (tx.vin || []).reduce((sum, input) => sum + (input.prevout?.value || 0), 0);

    for (const out of tx.vout || []) {
      const address = out.scriptPubKey?.address;
      if (!address) continue; // OP_RETURN and other non-address outputs
      rows.push({
        chain: block._network,
        block: block.height,
        block_time: block.time,
        txid: tx.txid,
        coinbase,
        from_addresses: fromAddresses,
        input_value_btc: inputValue,
        to_address: address,
        script_type: out.scriptPubKey.type,
        output_index: out.n,
        value_btc: out.value,
        fee_btc: tx.fee ?? null,
      });
    }
  }
  return rows;
}

Bitcoin with Indexing Co

Run it yourself if

You want full control of node infrastructure and have the team to run Bitcoin Core with a transaction index, resolve every prevout, and build backfill and reorg handling in-house.

Use Indexing Co if

You want Bitcoin inputs, outputs, addresses, and fees delivered to your own database, on the same schema as your other chains, with real-time plus complete history and no infrastructure to run.

Get a Demo Open the Console

FAQ

Do I need to run a Bitcoin node?

No. Indexing Co sources Bitcoin blocks for you, including full historical data, so you never operate Bitcoin Core or maintain a transaction index.

Can I see which address sent a Bitcoin transaction?

Yes. Every input in the block arrives with its prevout, which carries the address, value, and script type of the output being spent. You do not need a second lookup to know who paid.

How are Bitcoin fees calculated?

Each transaction carries a fee field, which is the total input value minus the total output value. Coinbase transactions have no fee, since they create new coins.

What happens to OP_RETURN outputs?

They have no address. The example transform above skips them, but the output script is in the block, so you can index OP_RETURN data in its own table if you need it.

Can I index Bitcoin alongside my EVM and Solana chains?

Yes. Bitcoin lands in your own database on the same schema as your other chains. Mesh runs BTC, ETH, and SOL transfers through Indexing Co into one unified interface on exactly this pattern.

Get Started

Index Bitcoin in minutes. Set up your first address, transfer, or fee pipeline without running a node.