Documentation index

Transaction Subscriptions

Stream individual transactions as they are processed by the validator, complete with signatures, instructions, execution metadata, logs, and balance changes. Updates arrive with sub-millisecond latency from processing -- far faster than polling JSON-RPC or using WebSocket subscriptions.

Transaction subscriptions are essential for HFT bots monitoring DEX pools, MEV searchers looking for arbitrage opportunities, copy-trading systems, and any application that needs to react to on-chain activity in real time. You can filter by accounts involved, exclude vote transactions, and match only successful or failed executions.

Filter Parameters

Parameter	Type	Required	Description
`vote`	`bool`	No	If `true`, include vote transactions. If `false`, exclude them. Omit to include all.
`failed`	`bool`	No	If `true`, include failed transactions. If `false`, exclude them. Omit to include all.
`signature`	`string`	No	Monitor a specific transaction signature
`account_include`	`string[]`	No	Transaction must include at least one of these accounts
`account_exclude`	`string[]`	No	Transaction must not include any of these accounts
`account_required`	`string[]`	No	Transaction must include all of these accounts

Provide at least one filter parameter. An empty filter will match all non-vote transactions by default.

Update Payload

Field	Type	Description
`transaction`	`SubscribeUpdateTransactionInfo`	Full transaction data including signatures, message, and meta
`transaction.signature`	`bytes`	The transaction signature
`transaction.is_vote`	`bool`	Whether this is a vote transaction
`transaction.transaction`	`Transaction`	The transaction message and signatures
`transaction.meta`	`TransactionStatusMeta`	Execution metadata: fee, balances, logs, compute units
`slot`	`uint64`	Slot in which the transaction was processed
`block_time`	`int64`	Estimated Unix timestamp of the block

Code Examples

Stream Raydium DEX Transactions (Node.js)

JavaScript

stream.write({
  accounts: {},
  slots: {},
  transactions: {
    raydiumSwaps: {
      vote: false,
      failed: false,
      account_include: [
        '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8'  // Raydium AMM
      ],
      account_exclude: [],
      account_required: []
    }
  },
  transactionsStatus: {},
  blocks: {},
  blocksMeta: {},
  commitment: 0,  // Processed -- fastest
  entry: {},
  accountsDataSlice: [],
  ping: null
});

stream.on('data', (update) => {
  if (update.transaction) {
    const tx = update.transaction.transaction;
    const meta = tx.meta;
    console.log('Signature:', Buffer.from(tx.signature).toString('base58'));
    console.log('Slot:', update.transaction.slot);
    console.log('Fee:', meta.fee, 'lamports');
    console.log('Compute units:', meta.compute_units_consumed);
    console.log('Success:', meta.err === null);
    console.log('Log messages:', meta.log_messages);
  }
});

Stream Jupiter Aggregator Transactions (Rust)

Rust

use yellowstone_grpc_client::GeyserGrpcClient;
use yellowstone_grpc_proto::prelude::*;
use std::collections::HashMap;
use futures::StreamExt;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut client = GeyserGrpcClient::build_from_uri("http://88.216.36.108:10001")
        .connect()
        .await?;

    let mut transactions = HashMap::new();
    transactions.insert("jupiterSwaps".to_string(), SubscribeRequestFilterTransactions {
        vote: Some(false),
        failed: Some(false),
        signature: None,
        account_include: vec!["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4".to_string()],
        account_exclude: vec![],
        account_required: vec![],
    });

    let request = SubscribeRequest {
        accounts: HashMap::new(),
        slots: HashMap::new(),
        transactions,
        transactions_status: HashMap::new(),
        blocks: HashMap::new(),
        blocks_meta: HashMap::new(),
        commitment: Some(CommitmentLevel::Processed as i32),
        entry: HashMap::new(),
        accounts_data_slice: vec![],
        ping: None,
        from_slot: None,
    };

    let (_, mut stream) = client.subscribe_with_request(Some(request)).await?;

    while let Some(msg) = stream.next().await {
        match msg?.update_oneof {
            Some(UpdateOneof::Transaction(tx_update)) => {
                if let Some(tx_info) = tx_update.transaction {
                    println!("Tx signature: {:?}", tx_info.signature);
                    println!("Slot: {}", tx_update.slot);
                    if let Some(meta) = &tx_info.meta {
                        println!("Fee: {} lamports", meta.fee);
                    }
                }
            }
            _ => {}
        }
    }

    Ok(())
}

Common Use Cases

Use Case	Filter Configuration
Monitor Raydium swaps	`account_include: ["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"]`, `vote: false`
Track Jupiter aggregator	`account_include: ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"]`
Monitor wallet activity	`account_include: ["yourWalletPubkey"]`, `vote: false`
Track failed transactions	`failed: true`, `account_include: ["programId"]`
Copy trading	`account_required: ["targetTraderWallet", "dexProgramId"]`
Exclude specific MEV bots	`account_include: ["poolPubkey"]`, `account_exclude: ["knownBotPubkey"]`