Documentation index

GetTransaction

Returns the complete transaction data for a given transaction signature, including the message, signatures, execution metadata, logs, and balance changes. This is the gRPC equivalent of the JSON-RPC getTransaction method.

Use this method to look up specific transactions by their signature, verify execution results, and retrieve detailed metadata such as compute units consumed, inner instructions, and pre/post token balances. This is essential for transaction confirmation flows, debugging, and building transaction explorers.

Type: Unary (request/response)

Parameters

Parameter	Type	Required	Description
`signature`	`string`	Yes	The transaction signature as a base-58 encoded string
`commitment`	`CommitmentLevel`	No	Commitment level: `Processed` (0), `Confirmed` (1), or `Finalized` (2). Default: `Finalized`

Response

Field	Type	Description
`transaction`	`Transaction`	The full transaction object with signatures, message, and account keys
`meta`	`TransactionStatusMeta`	Execution metadata: fee, pre/post balances, inner instructions, logs, compute units
`slot`	`uint64`	The slot the transaction was processed in
`block_time`	`int64`	Estimated Unix timestamp when the block was produced

Code Examples

Node.js

JavaScript

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const packageDef = protoLoader.loadSync('geyser.proto', {
  keepCase: true, longs: String, enums: String, defaults: true, oneofs: true
});
const proto = grpc.loadPackageDefinition(packageDef).geyser;
const client = new proto.Geyser('88.216.36.108:10001', grpc.credentials.createInsecure());

const txSignature = '5UfDuX7WXYZbLBfLXwKjMrqPfvTMczAFPbk5oNBhx9TX3GFzM2kXZHvFgnNxPDmS4NLUyN9wQELjS9skByBJiKR';

client.getTransaction({ signature: txSignature, commitment: 2 }, (err, response) => {
  if (err) { console.error('gRPC error:', err); return; }
  console.log('Slot:', response.slot);
  console.log('Block time:', new Date(response.block_time * 1000).toISOString());
  console.log('Fee:', response.meta.fee, 'lamports');
  console.log('Compute units:', response.meta.compute_units_consumed);
  console.log('Success:', response.meta.err === null);
});

Rust

use yellowstone_grpc_client::GeyserGrpcClient;
use yellowstone_grpc_proto::prelude::*;

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

    let signature = "5UfDuX7WXYZbLBfLXwKjMrqPfvTMczAFPbk5oNBhx9TX3GFzM2kXZHvFgnNxPDmS4NLUyN9wQELjS9skByBJiKR";
    let response = client
        .get_transaction(signature.to_string(), Some(CommitmentLevel::Finalized as i32))
        .await?;
    let tx = response.into_inner();

    println!("Slot: {}", tx.slot);
    if let Some(meta) = &tx.meta {
        println!("Fee: {} lamports", meta.fee);
        println!("Compute units: {}", meta.compute_units_consumed);
    }

    Ok(())
}

Example Response

JSON

{
  "transaction": {
    "signatures": ["5UfDuX7...BJIKR"],
    "message": {
      "account_keys": ["9WzDXwBb..."],
      "instructions": [{ "program_id_index": 2, "accounts": [0, 1], "data": "..." }]
    }
  },
  "meta": {
    "err": null,
    "fee": "5000",
    "pre_balances": ["1000000000", "500000000"],
    "post_balances": ["999995000", "500005000"],
    "compute_units_consumed": "150000",
    "log_messages": [
      "Program 11111111111111111111111111111111 invoke [1]",
      "Program 11111111111111111111111111111111 success"
    ]
  },
  "slot": "250000042",
  "block_time": "1704067200"
}