Documentation index

Transaction Status Subscriptions

Stream lightweight transaction status updates without the overhead of full transaction data. You receive the slot, signature, vote flag, and error status for each matching transaction -- but not the full message, instructions, or execution metadata.

This is the bandwidth-efficient alternative to full Transaction Subscriptions. Use it when you only need to know whether a transaction succeeded or failed, without needing to parse its contents. Ideal for confirmation trackers, dashboards, and systems that monitor transaction throughput.

Filter Parameters

Parameter	Type	Required	Description
`vote`	`bool`	No	If `true`, include vote transactions. If `false`, exclude them.
`failed`	`bool`	No	If `true`, include failed transactions. If `false`, exclude them.
`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

The filter parameters are identical to Transaction Subscriptions -- only the update payload differs.

Update Payload

Field	Type	Description
`slot`	`uint64`	Slot in which the transaction was processed
`signature`	`bytes`	The transaction signature
`is_vote`	`bool`	Whether this is a vote transaction
`err`	`TransactionError (nullable)`	The error if the transaction failed, or null if it succeeded

Code Examples

Monitor Transaction Confirmations (Node.js)

JavaScript

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

stream.on('data', (update) => {
  if (update.transactionStatus) {
    const status = update.transactionStatus;
    console.log('Signature:', Buffer.from(status.signature).toString('base58'));
    console.log('Slot:', status.slot);
    console.log('Is vote:', status.is_vote);
    console.log('Success:', status.err === null);
  }
});

Track Transaction Success/Failure (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 tx_status = HashMap::new();
    tx_status.insert("statusFilter".to_string(), SubscribeRequestFilterTransactions {
        vote: Some(false),
        failed: None,  // Include both successful and failed
        signature: None,
        account_include: vec!["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8".to_string()],
        account_exclude: vec![],
        account_required: vec![],
    });

    let request = SubscribeRequest {
        accounts: HashMap::new(),
        slots: HashMap::new(),
        transactions: HashMap::new(),
        transactions_status: tx_status,
        blocks: HashMap::new(),
        blocks_meta: HashMap::new(),
        commitment: Some(CommitmentLevel::Confirmed 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::TransactionStatus(status)) => {
                println!("Tx: {:?} | Slot: {} | Vote: {} | Error: {:?}",
                    status.signature, status.slot, status.is_vote, status.err);
            }
            _ => {}
        }
    }

    Ok(())
}

Common Use Cases

Use Case	Filter Configuration
Confirm your own transactions	`signature: "yourTxSignature"`
Monitor DEX success rate	`account_include: ["dexProgramId"]`, include both `failed: true` and `failed: false`
Track wallet throughput	`account_include: ["walletPubkey"]`, `vote: false`
Detect failed program calls	`account_include: ["programId"]`, `failed: true`
High-throughput status dashboard	`account_include: ["programId"]` (lightweight alternative to full tx stream)