Skip to content

Solana

Reads the Solana JSON-RPC API over aiohttp, the same way Algorand reads its Indexer, so both get the same retries, rate limiting and Retry-After handling. solders validates public keys. Transactions are requested with jsonParsed encoding, so the node decodes system and SPL token instructions.

Clusters

--network Endpoint
devnet (default) https://api.devnet.solana.com
testnet https://api.testnet.solana.com
mainnet https://api.mainnet.solana.com
localnet http://localhost:8899 (solana-test-validator)

To use your own endpoint, set these in .env, replacing DEVNET as needed:

SOLANA_DEVNET_RPC_SERVER=https://your-rpc.example
SOLANA_DEVNET_COMMITMENT=finalized

Commitment is confirmed (the default) or finalized. The RPC methods used here refuse processed.

Before its first request, the adapter asks the endpoint for getGenesisHash and stops with WrongNetwork if the answer belongs to a different cluster than --network. A hash that is not a public cluster's counts as localnet, because every local validator creates its own. So a devnet setting that points at mainnet fails, and so does a localnet setting that points at any public cluster. This takes one request per run.

Rate limits

The cluster docs state 40 requests per 10 seconds for a single RPC method, and warn that limits change without notice. In practice the public endpoints are stricter. In November 2026 they reported these limits per method, in their x-ratelimit-method-limit header:

Method Reported limit
getSlot 150
getAccountInfo 50
getTransaction 10
getSignaturesForAddress 10
getTokenAccountsByOwner 10
getBlock 6

A sync is mostly getTransaction, so that is the one that matters. Measured against it:

Rate Requests HTTP 429
2 per second (devnet) 30 19
1 per second (devnet) 30 2
1 every 2 seconds (devnet) 20 0
1 every 2 seconds (mainnet) 20 0

So requests default to 1 every 2 seconds. A 429 is retried after the wait the node asks for. On a dedicated endpoint, raise the rate with MCI_REQUESTS_PER_SECOND.

A sync makes one getTransaction for each signature, so a long history takes time on a public endpoint. A node that no longer holds an old transaction stops the sync with a clear error; an archival endpoint is needed for that history.

Commands

multichain-indexer --chain solana index account <address>
multichain-indexer --chain solana index token <mint>
multichain-indexer --chain solana index program <program-id>
multichain-indexer --chain solana sync <address>
multichain-indexer --chain solana metrics --days 30 --account <address>
multichain-indexer --chain solana export --format csv --output transactions.csv

Amounts are held in lamports and shown in SOL. A token amount is in the token's base units.

Transaction versions

maxSupportedTransactionVersion is sent as the integer 1. It is a ceiling, so legacy and v0 transactions still come back. All three are read:

Compute unit limit Priority fee
v1 message.transactionConfig.computeUnitLimit transactionConfig.priorityFee, the total in lamports
v0, legacy Compute Budget instruction Compute Budget price in micro-lamports per unit, times the limit (capped at 1,400,000), rounded up

priority_fee_lamports is in lamports for every version, so metrics compare correctly. A legacy or v0 transaction that sets a price but no limit is charged against a default the node works out from its instructions, so its priority fee is read back from the fee paid.

The base fee is 5000 lamports per signature, and that includes signatures verified by the Ed25519, secp256k1 and secp256r1 precompile programs, which are not signers. So:

meta.fee = 5000 * (signers + precompile signatures) + priority fee

Both counts are recorded on every transaction. This formula was checked on 15,751 mainnet and over 1,000 devnet transactions, of all three versions. The one exception it first showed was a limit above the 1,400,000 cap, which is now applied.

Status

status Meaning
pending Confirmed, not yet finalized. Fetched again on the next sync.
final Finalized and succeeded.
failed Finalized and failed. The error is in native.error.

getSignaturesForAddress has no slot bounds, so a sync applies its slot range to the rows. The checkpoint stops 150 slots behind the newest slot when the commitment is confirmed, so records still pending are fetched again.

The shared fields

  • sender is the fee payer.
  • receiver and amount come from the first transfer in the transaction. A Solana transaction can hold any number of transfers; all of them are in native.
  • amount is in lamports, or in a token's base units when native.amount_mint is set.
  • A mint or program records no creator, so creator is empty. Their authorities are in native.

The native block

Bases: NativeData

A transaction of any version.

priority_fee_lamports is in lamports for every version. A v1 transaction states the total in transactionConfig; legacy and v0 state a price per compute unit in micro-lamports, kept in compute_unit_price_micro_lamports.

The shared amount is the first transfer found: in lamports for a SOL transfer, and in the token's base units when amount_mint is set.

Bases: NativeData

One program invocation. kind is set when the node could decode it.

Bases: NativeData

Bases: NativeData

An SPL Token or Token-2022 transfer; amount is in the token's base units.

Bases: NativeData

Account state. exists is false for an address that has never held lamports.

Bases: NativeData

Bases: NativeData

An SPL mint. A mint has no creator on-chain; these authorities are what it records.

Bases: NativeData

A program. A program has no creator on-chain; the upgrade authority can change it.

Metrics

metrics adds these to the shared figures, in its native block:

Field Meaning
fees_lamports Fees paid
transaction_versions Transactions per version
compute_units Total and mean compute units consumed
priority_fees_lamports Total, mean, median, maximum, and how many paid one
program_calls The ten most called programs, inner instructions included
top_spl_tokens_by_transfers The ten most transferred mints

Example

examples/solana/ has a script and a notebook.