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 are pushed to you as the validator processes them, with no JSON-RPC polling.

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 -- earliest
  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"]`