RPCX Live Tables

The nine RPCX live tables: the latest Solana transactions, instructions, logs, balance changes, and blocks, and the current state of accounts and token holdings, read in bulk.

A method reads nine live tables. RPCX reads their rows from NoLimitNodes' own nodes when the method runs. Seven chain tables hold the latest Solana data, up to the newest blocks. Two state tables hold the current state of accounts. Older history is not available.

TableOne row isRead by
live_signaturesA transaction: signature, status, memoaddress, sig, or a range
live_transactionsA transaction, with fee, signer, accounts, programs, and logsaddress, sig, or a range
live_instructionsAn instruction, inner instructions includedaddress, program, sig, or a range
live_logsA program log lineaddress, sig, or a range
live_sol_balance_changesAn account whose SOL balance changed in a transactionaddress, sig, or a range
live_token_balance_changesA token account whose balance changed in a transactionaddress, sig, or a range
live_blocksA blockA range only
live_accountsAn account as it is nowaddress
live_token_accountsA token account a wallet holds nowowner

You read a live table like any other table. Every step works the same: filter, derive, group, join with other live tables, sort, and take.

Keys and ranges

Every read of a live table needs a filter that tells RPCX what to read. Put it in the filter right after from. Other conditions can join it with &&. A key or range under || or !, or in a later step, does not count, and Validate refuses the method with live_key_missing.

The filter is one of these:

  • A key. address == <param> finds the transactions that touch the address. address is any address: a wallet, a program, a pool, a mint, or a token account. sig == <param> finds one transaction. On live_instructions, program == <param> finds the instructions of that program. On live_accounts the key is address, and on live_token_accounts it is owner. A key can also be in a list param or a literal list: (address | in wallets).
  • A bounded range, on a chain table: a lower and an upper bound on ts or slot, such as ts >= from && ts < to or slot >= start && slot < stop. A range without a key reads every block in it, so it may cover at most 3,000 slots. A longer range is refused when the method runs. live_blocks has no key, so it is always read by a range.

With a key, add a ts range as well. The range then only narrows what RPCX reads, so it is not held to the 3,000 slots, and it keeps the run fast and cheap.

RPCX methodtext
method recentTxs(wallet: pubkey, from: time, to: time) {  from live_transactions  filter address == wallet && ts >= from && ts < to  select {ts, sig, success, fee, programs}  sort {-ts}}

live_accounts and live_token_accounts take a key only. They have no ts column and no ranges.

Read many addresses at once

Reads are bulk. Pass a list of addresses as one param and filter with in:

RPCX methodtext
method txsFor(wallets: pubkey[] "Accounts", from: time, to: time) {  from live_transactions  filter (address | in wallets) && ts >= from && ts < to  sort {-ts}}

A call passes the list as a JSON array:

{"wallets": ["ARu4n5mFdZogZAravu7CcizaojWnS6oqka37gdLT5SZn", "EKmzDJWkajsqLMkY5WLWts9iUgqHCQny6hhd77fcQGN"], "from": "2026-11-15T12:00:00Z", "to": "2026-11-15T13:00:00Z"}
  • RPCX reads every address in the list in the same run. Do not call a method once per wallet.
  • A list param holds up to 1,000 values.
  • A transaction that touches two of your addresses is read once. In tables read by address, it shows once for each of them, and the address column says which one.
  • There is no cap on the number of transactions a run reads. A run still has 30 seconds and returns at most 10,000 rows on a JSON-RPC call. See Limits per query.

The data

  • The chain tables hold the latest Solana data, up to the newest blocks. Older history is not available, so a range that starts earlier returns only the rows RPCX still has.
  • Only finalized blocks are read.
  • Failed transactions are included. Their success column is false.
  • live_accounts and live_token_accounts hold the state at the time the method runs. The slot column says which slot the state was read at.

Cost

A run is billed for the bytes RPCX reads for it: 1 CU per MiB, at least 1 CU per run, with no charge per request. What you read decides the cost, not how many rows you return.

  • Always add a ts range to a read by address. Without one, RPCX reads every transaction of the address that it has.
  • Very busy accounts, such as programs, the USDC mint, or the System Program, have a lot of transactions. Reading one of them reads a lot of data, even in a short range.
  • live_signatures is the cheapest way to find transactions. Read live_transactions only when you need the details.

See Compute units.

Columns

The same columns, with search, are on All tables. For an example method on each table, see Examples by table.

live_signatures

One row per transaction: signature and status, without the details. The fastest table for finding transactions. Read by address (transactions that touch the address, newest first), sig, or a range.

ColumnTypeDescription
addressStringThe address the row was found by (the value of your address filter). Empty when read by sig, program or a time/slot range.
sigStringTransaction signature (base58).
slotUInt64Slot of the transaction.
tsDateTime64(3, 'UTC')Block time of the transaction (UTC).
successBooltrue when the transaction succeeded, false when it failed.
errStringThe error as JSON text when the transaction failed, else empty.
memoStringThe memo of the transaction, if any, else empty.
confirmation_statusStringAlways finalized: only finalized blocks are stored.
tx_indexUInt64Position of the transaction in its block (0 = first).

live_transactions

One row per transaction. Read by address (transactions that touch the address), sig (one transaction), or a range.

ColumnTypeDescription
addressStringThe address the row was found by (the value of your address filter). Empty when read by sig, program or a time/slot range.
sigStringTransaction signature (base58).
slotUInt64Slot of the transaction.
tsDateTime64(3, 'UTC')Block time of the transaction (UTC).
successBooltrue when the transaction succeeded, false when it failed.
errStringThe error as JSON text when the transaction failed, else empty.
feeUInt64Fee paid, in lamports.
compute_unitsUInt64Compute units consumed.
signerStringThe fee payer (first account key).
accountsArray(String)Every account key of the transaction, loaded addresses included.
programsArray(String)Distinct program ids invoked, inner instructions included.
versionStringlegacy, 0 or 1.
log_messagesArray(String)Program log lines.
tx_indexUInt64Position of the transaction in its block (0 = first).

live_instructions

One row per instruction, inner instructions included. Read by address (every instruction of the transactions that touch the address), program (instructions of that program), sig, or a range. stack_height == 1 keeps only top-level instructions.

ColumnTypeDescription
addressStringThe address the row was found by (the value of your address filter). Empty when read by sig, program or a time/slot range.
sigStringTransaction signature (base58).
slotUInt64Slot of the transaction.
tsDateTime64(3, 'UTC')Block time of the transaction (UTC).
tx_indexUInt64Position of the transaction in its block (0 = first).
outer_indexUInt64Index of the top-level instruction (for an inner instruction: of the instruction that invoked it).
inner_indexUInt64Index among the inner instructions of outer_index; null for a top-level instruction.
stack_heightUInt64Invocation depth: 1 for a top-level instruction, 2 and more for inner ones.
programStringProgram id of the instruction.
accountsArray(String)Account keys passed to the instruction, in order.
dataStringInstruction data (base58).
successBooltrue when the transaction succeeded, false when it failed.

live_logs

One row per program log line. Read by address (lines of the transactions that touch the address), sig, or a range.

ColumnTypeDescription
addressStringThe address the row was found by (the value of your address filter). Empty when read by sig, program or a time/slot range.
sigStringTransaction signature (base58).
slotUInt64Slot of the transaction.
tsDateTime64(3, 'UTC')Block time of the transaction (UTC).
tx_indexUInt64Position of the transaction in its block (0 = first).
line_indexUInt64Position of the line in the transaction's log (0 = first).
lineStringThe log line.

live_sol_balance_changes

One row per account whose SOL balance changed in a transaction. Read by address, sig, or a range. Add account == <param> to keep only that account.

ColumnTypeDescription
addressStringThe address the row was found by (the value of your address filter). Empty when read by sig, program or a time/slot range.
sigStringTransaction signature (base58).
slotUInt64Slot of the transaction.
tsDateTime64(3, 'UTC')Block time of the transaction (UTC).
successBooltrue when the transaction succeeded, false when it failed.
accountStringThe account whose SOL balance changed.
preUInt64Balance before the transaction, in lamports.
postUInt64Balance after the transaction, in lamports.
changeInt64post - pre, in lamports. The fee is included for the fee payer.

live_token_balance_changes

One row per token account whose balance changed in a transaction. Read by address, sig, or a range. Add owner == <param> or mint == <param> to narrow.

ColumnTypeDescription
addressStringThe address the row was found by (the value of your address filter). Empty when read by sig, program or a time/slot range.
sigStringTransaction signature (base58).
slotUInt64Slot of the transaction.
tsDateTime64(3, 'UTC')Block time of the transaction (UTC).
successBooltrue when the transaction succeeded, false when it failed.
token_accountStringThe token account whose balance changed.
ownerStringOwner of the token account.
mintStringToken mint.
decimalsUInt8Decimals of the mint.
pre_amountUInt64Balance before, in base units (0 when the account was created).
post_amountUInt64Balance after, in base units (0 when the account was closed).
changeInt128post_amount - pre_amount, in base units.

live_blocks

One row per block. Read by a ts or slot range only. It has no key.

ColumnTypeDescription
slotUInt64Slot of the block.
tsDateTime64(3, 'UTC')Block time (UTC).
blockhashStringBlock hash (base58).
parent_slotUInt64Slot of the parent block.
block_heightUInt64Block height.
tx_countUInt64Number of transactions in the block.

live_accounts

The current state of each account. Read by address. One row per address that exists. Not a history.

ColumnTypeDescription
addressStringThe account address (the value of your address filter).
lamportsUInt64SOL balance in lamports (1 SOL = 1,000,000,000 lamports).
ownerStringProgram that owns the account.
executableBooltrue for a program account.
rent_epochUInt64Rent epoch of the account.
data_lenUInt64Size of the account data in bytes.
dataStringAccount data, base64. Empty for accounts without data.
slotUInt64Slot the state was read at.

live_token_accounts

The token accounts each wallet holds now, for SPL Token and Token-2022. Read by owner. One row per token account. Not a history.

ColumnTypeDescription
ownerStringThe wallet that owns the token accounts (the value of your owner filter).
token_accountStringAddress of the token account.
mintStringToken mint.
amountUInt64Balance in base units.
decimalsUInt8Decimals of the mint.
ui_amountFloat64Balance in whole tokens (amount / 10^decimals).
programStringToken program: Token or Token-2022 program id.
slotUInt64Slot the state was read at.

Find a column

Ask your agent, or call the tools yourself:

list_tablesdescribe_table   name: "live_token_balance_changes"

list_tables returns the nine tables, the key or range each one needs, and notes. describe_table returns the columns and types, and the rules that apply to that table.

In the dashboard, the Code tab completes table and column names as you type. Type from to see the list of tables.