> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# How to Use getBlock

> Learn getBlock use cases, code examples, request parameters, response structure, and tips.

The [`getBlock`](https://www.helius.dev/docs/api-reference/rpc/http/getblock) RPC method allows you to retrieve detailed information about a confirmed block in the Solana ledger. This is essential for block explorers, transaction history analysis, and understanding the state of the chain at a specific point in time.

> [!WARNING]
>
> **Avoid Batching for Better Performance**
>
> Batching archival methods significantly increases latency. Batches over 10 requests are not allowed.

## Common Use Cases

* **Inspecting Block Contents:** View all transactions included in a specific [block](https://www.helius.dev/blog/solana-slots-blocks-and-epochs).
* **Retrieving Block Hashes:** Get the blockhash for a given slot, its parent's blockhash, and its parent slot.
* **Checking Block Height and Time:** Find out a block's height (its sequence number) and its estimated production time.
* **Analyzing Transaction Details:** With appropriate parameters, you can get full transaction data, including metadata like fees, status, pre/post balances, and inner instructions.
* **Fetching Rewards:** Optionally include reward information for the block.

## Parameters

1. `slot` (number, required): The slot number of the block to query (u64).

2. `config` (object, optional): A configuration object with the following fields:
   * `commitment` (string, optional): Specifies the [commitment level](https://www.helius.dev/blog/solana-commitment-levels) to use. `processed` is not supported for this method. Defaults to `finalized`.
   * `encoding` (string, optional): The encoding for transaction data. Defaults to `json` if `transactionDetails` is `full` or `accounts`, otherwise `base64`.
     * `json`: Returns transactions and accounts data in JSON format (deprecated in favor of `jsonParsed`).
     * `jsonParsed`: Returns transactions and accounts data as parsed JSON. This is recommended as it includes all transaction account keys (including those from Address Lookup Tables).
     * `base58` (slow)
     * `base64`
     * `base64+zstd`
   * `transactionDetails` (string, optional): Specifies the level of transaction detail to return. Defaults to `full`.
     * `full`: Returns full transaction details, including transaction metadata.
     * `accounts`: Returns a list of accounts detailed in each transaction, but not the full transaction data or metadata.
     * `signatures`: Returns only the transaction signatures.
     * `none`: Returns no transaction details.
   * `rewards` (boolean, optional): Whether to include the rewards array in the response. Defaults to `false`.
   * `maxSupportedTransactionVersion` (number, optional): The maximum transaction version to return. If the block contains a transaction with a higher version, the request fails with JSON-RPC error `-32015`. If omitted, only legacy transactions are returned, and a block with any versioned transaction causes an error. Set to `1` to include legacy, v0 (Address Lookup Tables), and v1 transactions. See [Transaction v1 support](https://www.helius.dev/docs/rpc/transaction-v1.md).

## Response

If the specified block is confirmed and found, the `result` field will be an object containing information about the block. If the block is not found or not confirmed, `result` will be `null`.

Key fields in the block object include:

* `blockhash` (string): The base-58 encoded blockhash for this block.
* `previousBlockhash` (string): The base-58 encoded blockhash of the previous block. If the parent is not available (due to ledger cleanup), this might be the system program ID.
* `parentSlot` (number): The slot number of the parent block.
* `transactions` (array): An array of transaction objects included in the block. The structure of these objects depends on the `encoding` and `transactionDetails` parameters.
  * Each transaction object typically contains `meta` (metadata like fee, status, logs, pre/post balances) and `transaction` (the actual transaction data, including message and signatures).
* `rewards` (array, optional): An array of reward objects, present if `rewards: true` was specified. Each object details the `pubkey`, `lamports`, `postBalance`, `rewardType`, and potentially `commission`.
* `blockTime` (number | null): The estimated production time of the block as a Unix timestamp (seconds since epoch), or `null` if not available.
* `blockHeight` (number | null): The height of this block (number of blocks before it in the chain originating from slot 0), or `null` if not available.

Refer to the official Solana RPC documentation for the complete and detailed structure of the transaction and meta objects within the response.

## Example: Fetching Block Information

Let's try to fetch information for an illustrative slot number on Devnet.
**Important:** Slot numbers are processed rapidly. The slot number used below (`250000000`) is a placeholder. You should replace it with a recent, confirmed slot that you know exists on your target network (e.g., Devnet or Mainnet) when you run the example. You can find recent slot numbers using a Solana block explorer.

**Note:** Replace `YOUR_API_KEY` with your actual Helius API key in the examples below.

```bash curl theme={"system"}
# Replace 250000000 with a valid, recent slot number on Devnet/Mainnet
curl https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY -X POST -H "Content-Type: application/json" -d \
'{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlock",
  "params": [
    250000000, 
    {
      "encoding": "jsonParsed",
      "transactionDetails": "full",
      "rewards": true,
      "maxSupportedTransactionVersion": 1
    }
  ]
}'
```

```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection } = require('@solana/web3.js');

async function getBlockDetails() {
  const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Replace YOUR_API_KEY
  const connection = new Connection(rpcUrl, 'confirmed');
  
  // Replace with a valid, recent slot number on your target network
  const slotToQuery = 250000000; 

  try {
    const block = await connection.getBlock(slotToQuery, {
      encoding: "jsonParsed",
      transactionDetails: "full",
      rewards: true,
      maxSupportedTransactionVersion: 1 
    });

    if (block) {
      console.log('Block Details:');
      console.log(`   Slot: ${slotToQuery}`);
      console.log(`   Blockhash: ${block.blockhash}`);
      console.log(`   Previous Blockhash: ${block.previousBlockhash}`);
      console.log(`   Parent Slot: ${block.parentSlot}`);
      console.log(`   Block Height: ${block.blockHeight !== null ? block.blockHeight : 'N/A'}`);
      console.log(`   Block Time: ${block.blockTime ? new Date(block.blockTime * 1000).toISOString() : 'N/A'}`);
      console.log(`   Transactions Count: ${block.transactions.length}`);
      // console.log('   Transactions:', JSON.stringify(block.transactions, null, 2)); // Full transaction details
      // console.log('   Rewards:', JSON.stringify(block.rewards, null, 2)); // Reward details
    } else {
      console.log(`Block at slot ${slotToQuery} not found or not confirmed.`);
    }
  } catch (error) {
    console.error(`Error fetching block ${slotToQuery}:`, error);
  }
}

getBlockDetails();
```

```typescript Kit theme={"system"}
import { createSolanaRpc } from "@solana/kit";

const rpc_url = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY";
const rpc = createSolanaRpc(rpc_url);

const slot_number = BigInt(377261141);

let block = await rpc
  .getBlock(
    slot_number,
    {
      commitment: "finalized",
      encoding: "json",
      transactionDetails: "full",
      maxSupportedTransactionVersion: 1,
      rewards: false,
    },
  )
  .send();

console.log("block:", block);
```

```rust Rust theme={"system"}
use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::commitment_config::CommitmentConfig;
use solana_transaction_status_client_types::{TransactionDetails, UiTransactionEncoding};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"),
        CommitmentConfig::confirmed(),
    );

    let slot_number = 377261141;

    let config = solana_client::rpc_config::RpcBlockConfig {
        encoding: UiTransactionEncoding::Base58.into(),
        transaction_details: TransactionDetails::Full.into(),
        rewards: None,
        commitment: CommitmentConfig::finalized().into(),
        max_supported_transaction_version: Some(0),
    };
    let block = client.get_block_with_config(slot_number, config).await?;

    println!("Block: {:#?}", block);

    Ok(())
}
```

## Developer Tips

* **Slot vs. Block Height:** Remember that `getBlock` takes a `slot` number as input, not necessarily a block height. While slots are sequential, some slots might be skipped by leaders. The `blockHeight` field in the response indicates the actual number of blocks before this one.
* **`maxSupportedTransactionVersion` is Crucial:** To inspect blocks with versioned transactions (which are standard now and use Address Lookup Tables), you **must** set `maxSupportedTransactionVersion: 1` (or a higher version if a new standard emerges). Forgetting this will result in errors for most modern blocks.
* **Choosing `transactionDetails`:**
  * `full` is needed for most detailed analysis but returns the most data.
  * `signatures` is useful if you only need to list transactions in a block.
  * `accounts` can be a middle ground if you need to see which accounts were involved without fetching all instruction data.
  * `none` is rare but could be used if you only care about block-level metadata like `blockhash` or `rewards`.
* **`jsonParsed` is Recommended for Encoding:** When requesting transaction details, `jsonParsed` provides the most developer-friendly output and correctly resolves accounts from Address Lookup Tables, which `json` (deprecated) does not.
* **Block Unavailability:** A `null` result means the block at that slot was not found. This could be because the slot was skipped, the block hasn't been confirmed to the level specified by your `commitment`, or the RPC node has pruned that historical block from its ledger (common for older slots).
* **Rewards Information:** Setting `rewards: true` is necessary to see the distribution of block rewards to the validator (and potentially stakers, depending on the reward type). This adds to the response size.
* **Understanding Block Structure:** For a deeper understanding of how blocks fit into Solana's architecture, see [Understanding Slots, Blocks, and Epochs on Solana](https://www.helius.dev/blog/solana-slots-blocks-and-epochs).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.