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

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

Metode RPC [`getTokenAccountBalance`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenaccountbalance) mengembalikan saldo token dari akun Token SPL tertentu. Metode ini penting bagi aplikasi yang perlu menampilkan atau memverifikasi jumlah token tertentu yang disimpan dalam akun token.

## Kasus Penggunaan Umum

* **Menampilkan Saldo Token Pengguna:** Menunjukkan kepada pengguna jumlah token tertentu yang mereka miliki dalam dompet mereka (akun token terkait).
* **Memverifikasi Ketersediaan Token:** Memeriksa apakah akun token memiliki saldo yang cukup sebelum mencoba transfer atau operasi lainnya.
* **Melacak Portofolio:** Menggabungkan saldo token pengguna dari berbagai akun token.
* **Interaksi Kontrak Pintar:** Kontrak pintar mungkin meminta saldo token sebagai bagian dari logikanya (meskipun program on-chain biasanya mengakses data ini langsung dari informasi akun).

## Parameter Permintaan

1. **Kunci Publik Akun Token** (string, wajib): Kunci publik akun Token SPL yang ingin Anda minta, dengan enkode base-58.
2. **Objek Konfigurasi** (object, opsional): Objek opsional yang dapat berisi bidang berikut:
   * **`commitment`** (string, opsional): Menentukan [tingkat commitment](https://www.helius.dev/blog/solana-commitment-levels) untuk permintaan. Jika dihilangkan, commitment default dari node RPC akan digunakan (biasanya `finalized`).

## Struktur Respons

Bidang `result` dalam respons JSON-RPC berisi objek dengan bidang `context` dan `value`. Objek `value` menyimpan informasi saldo:

* **`amount`** (string): Saldo mentah akun token dalam bentuk string. Nilai ini adalah bilangan bulat yang mewakili unit terkecil token (misalnya, jika token memiliki 6 angka desimal, jumlah "1000000" berarti 1 token).
* **`decimals`** (u8): Jumlah angka desimal yang ditentukan untuk jenis token ini (oleh mint-nya).
* **`uiAmount`** (number | null): Saldo yang diformat sebagai bilangan floating-point dengan memperhitungkan `decimals`. Dalam konteks tertentu, bidang ini mungkin bernilai `null` atau sudah tidak digunakan lagi dan digantikan oleh `uiAmountString`.
* **`uiAmountString`** (string): Saldo yang diformat sebagai string dengan memperhitungkan `decimals`. Format ini sering lebih disarankan untuk ditampilkan guna menghindari potensi ketidakakuratan floating-point.

**Contoh Respons:**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 183457201
    },
    "value": {
      "amount": "500000000",
      "decimals": 9,
      "uiAmount": 0.5,
      "uiAmountString": "0.5"
    }
  },
  "id": 1
}
```

## Contoh Kode

<CodeGroup>
  ```bash cURL theme={"system"}
  # Basic Request (replace <TOKEN_ACCOUNT_PUBKEY>):
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getTokenAccountBalance",
      "params": [
        "<TOKEN_ACCOUNT_PUBKEY>"
      ]
    }' \
    <YOUR_RPC_URL>

  # Request with commitment (replace <TOKEN_ACCOUNT_PUBKEY>):
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getTokenAccountBalance",
      "params": [
        "<TOKEN_ACCOUNT_PUBKEY>",
        {
          "commitment": "confirmed"
        }
      ]
    }' \
    <YOUR_RPC_URL>
  ```

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

  async function checkTokenBalance(tokenAccountPublicKey) {
    // Replace with your RPC endpoint
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    
    try {
      const tokenAccountPubKey = new PublicKey(tokenAccountPublicKey);
      const balance = await connection.getTokenAccountBalance(tokenAccountPubKey);

      if (!balance.value) {
          console.log(`Could not find token account: ${tokenAccountPublicKey}`);
          return;
      }

      console.log(`Token Account: ${tokenAccountPublicKey}`);
      console.log(`Raw Amount: ${balance.value.amount}`);
      console.log(`Decimals: ${balance.value.decimals}`);
      console.log(`UI Amount (string): ${balance.value.uiAmountString}`);
      // console.log(JSON.stringify(balance, null, 2)); // For full response details

    } catch (error) {
      console.error(`Error fetching token account balance for ${tokenAccountPublicKey}:`, error);
    }
  }

  // Replace with an actual SPL Token Account Public Key
  const exampleTokenAccount = 'HHisAGTT6ADDd52jY1g65Akn3N2f4jSdQS2rTiyDEw5c'; // Example: An account holding some USDC on mainnet
  checkTokenBalance(exampleTokenAccount);

  // Example for a token account that might not exist or have 0 balance
  // const nonExistentAccount = '11111111111111111111111111111111'; 
  // checkTokenBalance(nonExistentAccount);
  ```
</CodeGroup>

## Tips untuk Developer

* **Akun Token vs. Akun Mint vs. Akun Pemilik:** Pastikan Anda memberikan kunci publik *Akun Token SPL*, bukan *alamat mint* token atau *alamat dompet pemilik*. Anda biasanya dapat memperoleh akun token milik seorang pemilik menggunakan `getTokenAccountsByOwner`.
* **Desimal:** Selalu gunakan bidang `decimals` untuk menafsirkan `amount` dengan benar. `uiAmountString` umumnya lebih aman untuk ditampilkan daripada `uiAmount` agar terhindar dari masalah presisi floating-point.
* **Akun yang Tidak Ada:** Jika kunci publik yang diberikan tidak sesuai dengan akun token yang ada, perilakunya mungkin sedikit berbeda menurut penyedia RPC atau pustaka. Namun, `value` dalam respons sering kali akan bernilai `null`, atau akan muncul error. Contoh JavaScript menyertakan pemeriksaan dasar untuk `balance.value`.
* **Tingkat Commitment:** Penggunaan tingkat commitment yang berbeda dapat memengaruhi seberapa cepat Anda melihat perubahan saldo, terutama untuk transaksi yang sangat baru. `finalized` adalah opsi paling aman, tetapi memiliki latensi tertinggi.

Panduan ini akan membantu Anda mengambil dan menafsirkan saldo token SPL secara akurat menggunakan metode `getTokenAccountBalance`.

## Metode Terkait

<CardGroup cols={2}>
  <Card title="getTokenAccountsByOwner" href="/docs/id/api-reference/rpc/http/gettokenaccountsbyowner">
    Dapatkan semua akun token milik seorang pemilik
  </Card>

  <Card title="getTokenSupply" href="/docs/id/api-reference/rpc/http/gettokensupply">
    Dapatkan total suplai dari mint token
  </Card>
</CardGroup>