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

# Verwendung von getTokenAccountBalance

> Lernen Sie Anwendungsfälle, Codebeispiele, Anforderungsparameter, Antwortstruktur und Tipps für getTokenAccountBalance kennen.

Die [`getTokenAccountBalance`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenaccountbalance) RPC-Methode gibt den Token-Saldo eines bestimmten SPL Token-Kontos zurück. Dies ist unerlässlich für Anwendungen, die die Menge eines bestimmten Tokens anzeigen oder verifizieren müssen, die von einem Token-Konto gehalten wird.

## Häufige Anwendungsfälle

* **Anzeigen von Nutzertokenständen:** Anzeigen, wie viel von einem bestimmten Token der Benutzer in seiner Wallet (zugehörige Token-Konten) besitzt.
* **Überprüfung der Token-Verfügbarkeit:** Überprüfen, ob ein Token-Konto ausreichend Guthaben hat, bevor ein Transfer oder eine andere Aktion versucht wird.
* **Portfolio-Tracking:** Aggregieren von Token-Bilanzen für einen Benutzer über verschiedene Token-Konten hinweg.
* **Interaktionen mit Smart Contracts:** Smart Contracts können Token-Bilanzen als Teil ihrer Logik abfragen (obwohl On-Chain-Programme diese Daten normalerweise direkt aus den Kontoinformationen abrufen).

## Anforderungsparameter

1. **Öffentlicher Schlüssel des Token-Kontos** (string, erforderlich): Der Base-58-kodierte öffentliche Schlüssel des SPL Token-Kontos, das Sie abfragen möchten.
2. **Konfigurationsobjekt** (object, optional): Ein optionales Objekt, das das folgende Feld enthalten kann:
   * **`commitment`** (string, optional): Gibt die [Commitment-Stufe](https://www.helius.dev/blog/solana-commitment-levels) für die Abfrage an. Wenn weggelassen, wird das Standard-Commitment des RPC-Knotens verwendet (normalerweise `finalized`).

## Antwortstruktur

Das Feld `result` in der JSON-RPC-Antwort enthält ein Objekt mit einem `context`- und einem `value`-Feld. Das `value`-Objekt enthält die Balance-Informationen:

* **`amount`** (string): Der Rohsaldo des Token-Kontos als Zeichenkette. Dies ist eine Ganzzahl, die die kleinste Einheit des Tokens repräsentiert (z. B., wenn ein Token 6 Dezimalstellen hat, bedeutet ein Betrag von "1000000" 1 Token).
* **`decimals`** (u8): Die Anzahl der Dezimalstellen, die für diesen Tokentyp (durch sein Mint) definiert sind.
* **`uiAmount`** (number | null): Der Saldo, formatiert als Gleitkommazahl, unter Berücksichtigung von `decimals`. Dieses Feld könnte `null` oder in einigen Kontexten zugunsten von `uiAmountString` veraltet sein.
* **`uiAmountString`** (string): Der Saldo formatiert als Zeichenkette, unter Berücksichtigung von `decimals`. Dies wird oft zur Anzeige bevorzugt, um potenzielle Gleitkomma-Ungenauigkeiten zu vermeiden.

**Beispielantwort:**

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

## Code-Beispiele

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

## Entwicklertipps

* **Token-Konto vs. Mint-Konto vs. Inhaberkonto:** Stellen Sie sicher, dass Sie den öffentlichen Schlüssel des *SPL Token-Kontos* angeben, nicht die *Mint-Adresse* des Tokens oder die *Wallet-Adresse des Inhabers*. Sie erhalten normalerweise Token-Konten für einen Inhaber mit `getTokenAccountsByOwner`.
* **Dezimalstellen:** Verwenden Sie immer das `decimals`-Feld, um das `amount` korrekt zu interpretieren. Das `uiAmountString` ist im Allgemeinen sicherer zur Anzeige als `uiAmount`, um Gleitkomma-Präzisionsprobleme zu vermeiden.
* **Nicht existierende Konten:** Wenn der angegebene öffentliche Schlüssel keinem bestehenden Token-Konto entspricht, kann das Verhalten je nach RPC-Anbieter oder Bibliothek leicht variieren, aber oft wird das `value` in der Antwort `null` sein oder ein Fehler wird ausgelöst. Das JavaScript-Beispiel enthält eine grundlegende Überprüfung für `balance.value`.
* **Commitment-Level:** Die Verwendung verschiedener Commitment-Level kann beeinflussen, wie schnell Sie Guthabenänderungen sehen, insbesondere für sehr aktuelle Transaktionen. `finalized` ist am sichersten, hat aber die längste Latenz.

Dieser Leitfaden sollte Ihnen helfen, SPL-Token-Bilanzen genau abzurufen und zu interpretieren, indem Sie die Methode `getTokenAccountBalance` verwenden.

## Verwandte Methoden

<CardGroup cols={2}>
  <Card title="getTokenAccountsByOwner" href="/docs/de/api-reference/rpc/http/gettokenaccountsbyowner">
    Alle Token-Konten für einen Eigentümer abrufen
  </Card>

  <Card title="getTokenSupply" href="/docs/de/api-reference/rpc/http/gettokensupply">
    Den Gesamtsupply eines Token-Mints abrufen
  </Card>
</CardGroup>