> ## 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.

# Cara Menggunakan getAccountInfo

> Pelajari kasus penggunaan getAccountInfo, contoh kode, parameter permintaan, struktur respons, dan tips.

Metode RPC [`getAccountInfo`](https://www.helius.dev/docs/api-reference/rpc/http/getaccountinfo) adalah alat penting untuk membuat kueri terhadap blockchain Solana. Metode ini memungkinkan Anda mengambil semua informasi tersimpan yang terkait dengan kunci publik akun tertentu. Informasi ini mencakup saldo lamport akun, program yang memilikinya, status apakah akun dapat dieksekusi, dan data yang disimpannya.

## Kasus Penggunaan Umum

* **Memeriksa Saldo SOL:** Tentukan saldo SOL native dari akun mana pun.
* **Memverifikasi Keberadaan Akun:** Periksa apakah akun dengan kunci publik tertentu telah diinisialisasi (yaitu memiliki lamport atau data).
* **Memeriksa Akun Program:** Ambil data yang disimpan dalam akun milik suatu program. Hal ini penting untuk memahami status program.
* **Mengidentifikasi Pemilik Akun:** Cari tahu program mana yang memiliki suatu akun. Ini membantu menentukan cara menafsirkan data akun atau mengetahui apakah akun tersebut dimiliki oleh sistem.
* **Memeriksa Apakah Akun Dapat Dieksekusi:** Identifikasi apakah akun berisi program yang telah di-deploy.

## Parameter

1. `publicKey` (string, wajib): Kunci publik akun yang akan dikueri, yang dikodekan dengan base-58.

2. `config` (object, opsional): Objek konfigurasi dengan kolom berikut:
   * `commitment` (string, opsional): Menentukan [tingkat komitmen](https://www.helius.dev/blog/solana-commitment-levels) yang akan digunakan untuk kueri. Nilai default-nya adalah `finalized`.
     * `finalized`: Node akan membuat kueri terhadap blok terbaru yang dikonfirmasi oleh mayoritas super dari klaster sebagai blok yang telah mencapai penguncian maksimum.
     * `confirmed`: Node akan membuat kueri terhadap blok terbaru yang telah dipilih oleh mayoritas super dari klaster.
     * `processed`: Node akan membuat kueri terhadap blok terbarunya. Perhatikan bahwa blok tersebut mungkin belum lengkap.
   * `encoding` (string, opsional): Pengodean untuk data akun. Nilai default-nya adalah `base64`.
     * `base58` (lambat)
     * `base64`
     * `base64+zstd` (jika data dikompresi)
     * `jsonParsed`: Jika data akun merupakan status program yang dikenal (misalnya akun token atau akun stake), node akan mencoba menguraikannya menjadi struktur JSON. Untuk akun program generik, formatnya biasanya kembali ke biner (base64).
   * `dataSlice` (object, opsional): Membatasi data akun yang dikembalikan ke potongan tertentu. Hanya tersedia untuk pengodean `base58`, `base64`, atau `base64+zstd`.
     * `offset` (number): Jumlah byte dari awal data akun untuk memulai potongan.
     * `length` (number): Jumlah byte yang akan dikembalikan.
   * `minContextSlot` (number, opsional): Slot minimum tempat permintaan dapat dievaluasi.

## Respons

Jika akun ditemukan, kolom `result` akan berisi objek dengan dua properti utama:

* `context` (object): Berisi metadata tentang permintaan.
  * `slot` (number): Slot tempat informasi diambil.
  * `apiVersion` (string, opsional): Versi API RPC.

* `value` (object | null): Jika akun tidak ada, nilainya akan menjadi `null`. Jika ada, nilainya berupa objek yang berisi:
  * `lamports` (number): Jumlah lamport (1 SOL = 1.000.000.000 lamport) yang dimiliki akun.
  * `owner` (string): Kunci publik program yang memiliki akun ini, yang dikodekan dengan base-58.
  * `data` (array | object | string): Data yang disimpan dalam akun. Formatnya bergantung pada parameter `encoding` yang digunakan dalam permintaan.
    * Untuk `base64` (default), `base58`, `base64+zstd`: Biasanya berupa array `[encoded_string, encoding_format]`, misalnya `["string_data", "base64"]`.
    * Untuk `jsonParsed`: Nilainya dapat berupa objek JSON jika data dapat diuraikan oleh node RPC (misalnya untuk akun SPL Token). Jika tidak, nilainya mungkin kembali ke `["", "base64"]` atau format serupa jika data tidak dikenali sebagai tata letak standar.
  * `executable` (boolean): `true` jika akun berisi program, atau `false` jika tidak.
  * `rentEpoch` (number): Epoch berikutnya saat akun ini harus membayar sewa.
  * `space` (number, opsional): Panjang data dalam byte. (Catatan: Dokumentasi resmi Solana mencantumkan `space`, sedangkan beberapa penyedia RPC mungkin menyertakannya. Nilai ini menunjukkan total ruang yang dialokasikan untuk data akun). Untuk detail selengkapnya tentang [data akun dan deserialisasi](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana), lihat panduan terperinci kami.

Jika akun tidak ditemukan, kolom `value` dalam hasil akan bernilai `null`.

## Contoh: Mengambil Informasi Akun

Mari ambil informasi untuk ID Serum Program V3 (`9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin`) di mainnet.

**Catatan:** Ganti `YOUR_API_KEY` dengan kunci API Helius Anda yang sebenarnya dalam contoh di bawah ini.

<CodeGroup>
  ```bash curl theme={"system"}
  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": "getAccountInfo",
    "params": [
      "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
      {
        "encoding": "jsonParsed"
      }
    ]
  }'
  ```

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

  async function getAccountDetails() {
    const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Replace YOUR_API_KEY
    const connection = new Connection(rpcUrl, 'confirmed');
    const accountPubKey = new PublicKey('9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin');

    try {
      const accountInfo = await connection.getAccountInfo(accountPubKey);

      if (accountInfo === null) {
        console.log('Account not found.');
        return;
      }

      console.log('Account Info:');
      console.log(`   Lamports: ${accountInfo.lamports}`);
      console.log(`   Owner: ${accountInfo.owner.toBase58()}`);
      console.log(`   Executable: ${accountInfo.executable}`);
      console.log(`   Rent Epoch: ${accountInfo.rentEpoch}`);
      // Data is a Buffer, you might need to deserialize it based on the account type
      // console.log(`   Data: ${accountInfo.data.toString()}`); 
    } catch (error) {
      console.error('Error fetching account info:', error);
    }
  }

  getAccountDetails();
  ```

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

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

  const publicKey = address("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg");
  const accountInfo = await rpc.getAccountInfo(publicKey).send();

  console.log("Account Info:", accountInfo);
  ```

  ```rust Rust theme={"system"}
  use solana_client::nonblocking::rpc_client::RpcClient;
  use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey};
  use anyhow::Result;
  use std::str::FromStr;

  #[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 pubkey = Pubkey::from_str("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg")?;
      let account = client.get_account(&pubkey).await?;

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

      Ok(())
  }
  ```
</CodeGroup>

## Tips untuk Developer

* **Performa:** Untuk aplikasi yang perlu sering memeriksa beberapa akun, pertimbangkan penggunaan `getMultipleAccounts` untuk mengelompokkan permintaan dan mengurangi perjalanan bolak-balik.
* **Deserialisasi Data:** Kolom `data` sering kali perlu dideserialisasi berdasarkan struktur data program pemilik. Alat dan pustaka khusus program (misalnya pustaka SPL Token untuk akun token) biasanya diperlukan. Artikel blog kami tentang [deserialisasi data akun](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana) menyediakan teknik dan contoh yang bermanfaat.
* **Batas Laju:** Perhatikan batas laju node RPC, terutama saat membuat kueri terhadap banyak akun atau mengirim permintaan secara rutin.
* **Pengelolaan Biaya:** `getAccountInfo` umumnya merupakan kueri berbiaya rendah, tetapi polling yang sering dapat meningkatkan biaya. Optimalkan pola kueri Anda.
* **Gunakan `jsonParsed` dengan Bijak:** Meskipun `jsonParsed` praktis digunakan, opsi ini mungkin tidak mendukung semua jenis akun, dan output-nya dapat berubah jika program memperbarui struktur datanya. Untuk aplikasi penting, penguraian data biner dengan tata letak yang diketahui menawarkan stabilitas lebih baik.
* **Pertimbangkan `dataSlice`:** Jika Anda hanya memerlukan sebagian kecil data akun, gunakan `dataSlice` untuk mengurangi jumlah data yang ditransfer dan berpotensi menurunkan biaya kueri.

## Metode Terkait

<CardGroup cols={2}>
  <Card title="getMultipleAccounts" href="/docs/id/api-reference/rpc/http/getmultipleaccounts">
    Ambil beberapa akun secara berkelompok dalam satu permintaan untuk meningkatkan performa
  </Card>

  <Card title="getBalance" href="/docs/id/api-reference/rpc/http/getbalance">
    Dapatkan hanya saldo SOL tanpa detail akun lengkap
  </Card>
</CardGroup>