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)

1stream.write({
2  accounts: {},
3  slots: {},
4  transactions: {},
5  transactionsStatus: {
6    myTxStatus: {
7      vote: false,
8      failed: false,
9      account_include: [
10        '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8'  // Raydium AMM
11      ],
12      account_exclude: [],
13      account_required: []
14    }
15  },
16  blocks: {},
17  blocksMeta: {},
18  commitment: 1,
19  entry: {},
20  accountsDataSlice: [],
21  ping: null
22});
23
24stream.on('data', (update) => {
25  if (update.transactionStatus) {
26    const status = update.transactionStatus;
27    console.log('Signature:', Buffer.from(status.signature).toString('base58'));
28    console.log('Slot:', status.slot);
29    console.log('Is vote:', status.is_vote);
30    console.log('Success:', status.err === null);
31  }
32});

Track Transaction Success/Failure (Rust)

1use yellowstone_grpc_client::GeyserGrpcClient;
2use yellowstone_grpc_proto::prelude::*;
3use std::collections::HashMap;
4use futures::StreamExt;
5
6#[tokio::main]
7async fn main() -> anyhow::Result<()> {
8    let mut client = GeyserGrpcClient::build_from_uri("http://[IP_ADDRESS]:[PORT]")
9        .connect()
10        .await?;
11
12    let mut tx_status = HashMap::new();
13    tx_status.insert("statusFilter".to_string(), SubscribeRequestFilterTransactions {
14        vote: Some(false),
15        failed: None,  // Include both successful and failed
16        signature: None,
17        account_include: vec!["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8".to_string()],
18        account_exclude: vec![],
19        account_required: vec![],
20    });
21
22    let request = SubscribeRequest {
23        accounts: HashMap::new(),
24        slots: HashMap::new(),
25        transactions: HashMap::new(),
26        transactions_status: tx_status,
27        blocks: HashMap::new(),
28        blocks_meta: HashMap::new(),
29        commitment: Some(CommitmentLevel::Confirmed as i32),
30        entry: HashMap::new(),
31        accounts_data_slice: vec![],
32        ping: None,
33        from_slot: None,
34    };
35
36    let (_, mut stream) = client.subscribe_with_request(Some(request)).await?;
37
38    while let Some(msg) = stream.next().await {
39        match msg?.update_oneof {
40            Some(UpdateOneof::TransactionStatus(status)) => {
41                println!("Tx: {:?} | Slot: {} | Vote: {} | Error: {:?}",
42                    status.signature, status.slot, status.is_vote, status.err);
43            }
44            _ => {}
45        }
46    }
47
48    Ok(())
49}

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)