getAccountInfo

Explore the full capabilities of getAccountInfo—including its key use cases, example code snippets, request parameters, response format, and expert tips for effective integration.

The getAccountInfo RPC method is a core utility for querying detailed information about any account on the Solana blockchain. By supplying a public key, this method returns comprehensive data about the associated account—such as its balance, ownership, executable status, and raw or parsed storage data.

🔍 Common Use Cases

  • Check SOL Balance Retrieve the lamport balance (1 SOL = 1,000,000,000 lamports) for any public key.

  • Verify Account Initialization Determine if an account exists and has been initialized with lamports or data.

  • Inspect Program State Read data stored in program-owned accounts—vital for decoding on-chain program states.

  • Identify Account Ownership Determine which program owns the account to understand how its data should be interpreted.

  • Check Executability Discover whether an account contains a deployed program (i.e., if it’s executable).

🛠 Parameters

  • publicKey (string, required): Base-58 encoded public key of the account to query.

  • config (object, optional): Optional configuration fields:

    • commitment (string): Sets the desired commitment level:

      • finalized (default) – Highest confirmation level.

      • confirmed – Voted on by supermajority.

      • processed – Most recent block, possibly unconfirmed.

    • encoding (string): Specifies the data encoding:

      • base64 (default)

      • base58 (slower)

      • base64+zstd (for compressed data)

      • jsonParsed (for known account types like tokens or stakes)

    • dataSlice (object): Return a partial slice of the data (valid only for binary encodings):

      • offset: Starting byte offset.

      • length: Number of bytes to return.

    • minContextSlot (number): Minimum slot that must be reached before evaluating the request.

📦 Response Structure

If the account exists, the result object includes:

  • context (object):

    • slot: The slot at which the data was retrieved.

    • apiVersion: (Optional) The version of the RPC API used.

  • value (object | null): If null, the account was not found. Otherwise:

    • lamports (number): Total SOL balance in lamports.

    • owner (string): Public key of the program that owns the account.

    • data (array | object | string): Account data content:

      • For base64, base58, or base64+zstd: [encoded_string, encoding]

      • For jsonParsed: Parsed JSON if applicable, otherwise defaults to base64 structure.

    • executable (boolean): true if the account contains a program.

    • rentEpoch (number): The next epoch at which rent will be collected.

    • space (number, optional): Total allocated byte size of the account’s data.

If the account is not found, the value will be null.

💡 Example: Querying Account Info

Let’s retrieve information for the Serum V3 program ID on mainnet:

Public Key: 4UJuvGZ7Ge8H3je63Nsb9ZRNVBAd3CG2ajibnRaVSbw5

Sample Request (CoinVera RPC):

const fetch = require('node-fetch');

async function getAccountInfo(rpcUrl) {
  try {
    const response = await fetch(rpcUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'getAccountInfo',
        "params": [
            "4UJuvGZ7Ge8H3je63Nsb9ZRNVBAd3CG2ajibnRaVSbw5",
            {
              "encoding": "jsonParsed"
            }
          ]
      }),
    });

    const data = await response.json();
    
    // Print the exact full response
    console.log('Full RPC Response:');
    console.log(JSON.stringify(data, null, 2));
    
    return data;
  } catch (error) {
    console.error('Error getting health:', error.message);
    return null;
  }
}

// Example usage
const RPC_URL = 'https://rpc.coinvera.io/?x-api-key=your-coinvera-x-api-key';

getAccountInfo(RPC_URL);

Example Response

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "context": {
      "slot": 355178140,
      "apiVersion": "2.2.7"
    },
    "value": {
      "lamports": 196248541,
      "data": [
        "",
        "base64"
      ],
      "owner": "11111111111111111111111111111111",
      "executable": false,
      "rentEpoch": 18446744073709552000,
      "space": 0
    }
  }
}

💡 Developer Tips (Using getAccountInfo with CoinVera)

  • Optimize with getMultipleAccounts For applications that require checking multiple accounts simultaneously, use the getMultipleAccounts method to batch requests. This significantly reduces network overhead and improves performance.

  • Deserialize Account Data Properly The data field returned by getAccountInfo is often in raw or encoded form. To interpret this correctly, you’ll need deserialization logic tailored to the owning program (e.g., use the SPL Token library for token accounts). Refer to CoinVera’s blog for practical techniques on deserializing Solana account data.

  • Watch for RPC Rate Limits CoinVera RPC endpoints may enforce rate limits. Avoid excessive polling or redundant queries to maintain reliability and avoid throttling when accessing many accounts.

  • Manage Costs Efficiently Although getAccountInfo is a lightweight RPC call, high-frequency polling can accumulate bandwidth and compute costs. Optimize polling frequency and request patterns to stay efficient.

  • Use jsonParsed with Caution The jsonParsed encoding is helpful for known account types like tokens and stakes, but it may not support all custom programs. Its structure can also evolve if a program changes. For mission-critical use cases, decode binary data directly using a fixed layout for maximum consistency.

  • Leverage dataSlice for Precision If your use case only requires part of the account’s data, use the dataSlice option to fetch only the needed bytes. This reduces payload size and accelerates queries—especially valuable when working at scale.

PreviousRPCNextgetBalance

Last updated