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.
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.addressis any address: a wallet, a program, a pool, a mint, or a token account.sig == <param>finds one transaction. Onlive_instructions,program == <param>finds the instructions of that program. Onlive_accountsthe key isaddress, and onlive_token_accountsit isowner. A key can also beina list param or a literal list:(address | in wallets). - A bounded range, on a chain table: a lower and an upper bound on
tsorslot, such asts >= from && ts < toorslot >= 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_blockshas 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.
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:
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 theaddresscolumn 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
successcolumn isfalse. live_accountsandlive_token_accountshold the state at the time the method runs. Theslotcolumn 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
tsrange 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_signaturesis the cheapest way to find transactions. Readlive_transactionsonly 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.
live_transactions
One row per transaction. Read by address (transactions that touch the address), sig (one transaction), or a range.
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.
live_logs
One row per program log line. Read by address (lines of the transactions that touch the address), sig, or a range.
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.
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.
live_blocks
One row per block. Read by a ts or slot range only. It has no key.
live_accounts
The current state of each account. Read by address. One row per address that exists. Not a history.
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.
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.