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

# Wie man getBalance verwendet

> Lernen Sie Anwendungsfälle, Codebeispiele, Anfrageparameter, Antwortstruktur und Tipps für getBalance.

Die [`getBalance`](https://www.helius.dev/docs/api-reference/rpc/http/getbalance) RPC-Methode ist eine einfache Möglichkeit, das native SOL-Guthaben eines Kontos auf der Solana-Blockchain zu ermitteln. Es gibt das Guthaben in Lamports zurück (1 SOL = 1.000.000.000 Lamports).

Diese Methode ist leichter als `getAccountInfo`, wenn Sie *nur* das SOL-Guthaben und keine anderen Kontodetails benötigen.

## Hauptanwendungsfall

* **Schnelles Überprüfen von SOL-Beständen eines Kontos:** Der Hauptzweck ist, festzustellen, wie viel SOL ein Konto (Wallet, Programm usw.) hält.

## Parameter

1. `publicKey` (string, erforderlich): Der base-58 codierte öffentliche Schlüssel des anzufragenden Kontos.

2. `config` (Objekt, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   * `commitment` (string, optional): Gibt die [Commitment-Stufe](https://www.helius.dev/blog/solana-commitment-levels) an, die für die Abfrage verwendet werden soll. Standardmäßig `finalized`.
     * `finalized`: Der Knoten wird den neuesten Block abfragen, der von der Supermehrheit des Clusters als mit maximalem Lockout bestätigt erreicht wurde.
     * `confirmed`: Der Knoten wird den neuesten Block abfragen, der von einer Supermehrheit des Clusters abgestimmt wurde.
     * `processed`: Der Knoten wird seinen neuesten Block abfragen. Beachten Sie, dass der Block möglicherweise nicht vollständig ist.
   * `minContextSlot` (Nummer, optional): Der minimalste Slot, in dem die Anfrage ausgewertet werden kann.

## Antwort

Das `result`-Feld der JSON-RPC-Antwort wird ein Objekt enthalten:

* `context` (Objekt):
  * `slot` (Nummer): Der Slot, zu dem das Guthaben abgerufen wurde.
  * `apiVersion` (string, optional): Die RPC API Version (möglicherweise nicht von allen Knoten vorhanden).
* `value` (Nummer): Das Guthaben des Kontos in Lamports (Vorzeichenloser 64-Bit Integer).

Wenn das Konto nicht in der Blockchain existiert, gibt `getBalance` normalerweise einen Wert von `0` Lamports zurück.

## Beispiel: Abfragen des Kontoguthabens

Lassen Sie uns das SOL-Guthaben der Serum Program V3 ID (`9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin`) im Mainnet überprüfen. Dieses Programmkonto selbst hält SOL zur Rentenbefreiung.

**Hinweis:** Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Helius API-Schlüssel in den folgenden Beispielen.

<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": "getBalance",
    "params": [
      "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin"
    ]
  }'
  ```

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

  async function checkBalance() {
    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 lamports = await connection.getBalance(accountPubKey);
      const sol = lamports / LAMPORTS_PER_SOL;

      console.log(`Account PubKey: ${accountPubKey.toBase58()}`);
      console.log(`Balance (Lamports): ${lamports}`);
      console.log(`Balance (SOL): ${sol}`);

    } catch (error) {
      console.error('Error fetching balance:', error);
    }
  }

  checkBalance();
  ```

  ```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("83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri");
  const balance = await rpc.getBalance(publicKey).send();

  console.log("Account Balance:", balance);
  ```

  ```rust Rust theme={"system"}
  use anyhow::Result;
  use solana_client::nonblocking::rpc_client::RpcClient;
  use solana_sdk::{
      commitment_config::CommitmentConfig, native_token::LAMPORTS_PER_SOL, pubkey::Pubkey,
  };
  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("83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri")?;
      let balance = client.get_balance(&pubkey).await?;

      println!("{:#?} SOL", balance / LAMPORTS_PER_SOL);

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

## Entwicklertipps

* **Einfachheit für SOL-Guthaben:** Wenn Sie nur das SOL-Guthaben eines Kontos und keine anderen On-Chain-Daten (wie Besitzer, Daten oder ausführbarer Status) benötigen, ist `getBalance` effizienter als `getAccountInfo`, da weniger Daten abgerufen werden.
* **Nicht existierende Konten:** Wenn ein Konto nicht in der Blockchain existiert (nie initialisiert wurde oder kein SOL hatte), gibt `getBalance` `0` zurück. Dies kann ein schneller Weg sein, um die Existenz eines Kontos zu überprüfen, wenn Sie sich nur um dessen SOL-Guthaben kümmern.
* **Lamports vs. SOL:** Denken Sie daran, dass das Guthaben in Lamports angegeben wird. Sie müssen durch `LAMPORTS_PER_SOL` (1.000.000.000) teilen, um es in SOL umzurechnen.
* **Commitment-Stufen:** Die Wahl von `commitment` kann beeinflussen, wie schnell Sie das Guthaben erhalten und wie bestätigt dieses Guthaben ist. Für die meisten UI-Anzeigezwecke bietet `confirmed` eine gute Balance. Für kritische Finanztransaktionen bietet `finalized` die höchste Sicherheit. Siehe [Solana Commitment Levels](https://www.helius.dev/blog/solana-commitment-levels) für detaillierte Informationen.
* **Batching mit `getMultipleAccounts`:** Während `getBalance` für ein einzelnes Konto ist, kann die Verwendung von `getMultipleAccounts` und das anschließende Extrahieren des Lamport-Guthabens aus den Informationen jedes Kontos leistungsfähiger sein als viele einzelne `getBalance`-Aufrufe.

## Verwandte Methoden

<CardGroup cols={2}>
  <Card title="getAccountInfo" href="/docs/de/api-reference/rpc/http/getaccountinfo">
    Vollständige Kontodetails abrufen, einschließlich Daten, Besitzer und ausführbarem Status
  </Card>

  <Card title="getMultipleAccounts" href="/docs/de/api-reference/rpc/http/getmultipleaccounts">
    Mehrere Konten in einer einzigen Anfrage als Batch abrufen
  </Card>
</CardGroup>