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

> Erfahren Sie mehr über die Anwendungsfälle, Codebeispiele, Anforderungsparameter, Antwortstruktur und Tipps zu getAccountInfo.

Die [`getAccountInfo`](https://www.helius.dev/docs/api-reference/rpc/http/getaccountinfo) RPC-Methode ist ein grundlegendes Werkzeug zum Abfragen der Solana-Blockchain. Sie ermöglicht das Abrufen aller gespeicherten Informationen, die mit einem bestimmten Konto-Public-Key verbunden sind. Dazu gehören der Lamport-Saldo des Kontos, das Programm, dem es gehört, ob es ausführbar ist, und seine gespeicherten Daten.

## Häufige Anwendungsfälle

* **Prüfung des SOL-Guthabens:** Bestimmen Sie das native SOL-Guthaben eines Kontos.
* **Überprüfung der Konto-Existenz:** Prüfen Sie, ob ein Konto mit einem gegebenen Public Key initialisiert wurde (d. h. ob Lamports oder Daten vorhanden sind).
* **Untersuchung von Programmkonten:** Rufen Sie die in einem Konto gespeicherten Daten ab, das einem Programm gehört, was entscheidend für das Verständnis des Programmzustands ist.
* **Identifizierung des Kontoinhabers:** Finden Sie heraus, welches Programm der Inhaber eines Kontos ist. Dies hilft zu bestimmen, wie die Kontodaten interpretiert werden sollten oder ob es sich um ein systemeigenes Konto handelt.
* **Prüfung, ob ein Konto ausführbar ist:** Erkennen Sie, ob ein Konto ein bereitgestelltes Programm enthält.

## Parameter

1. `publicKey` (string, erforderlich): Der base-58-kodierte Public Key des abzufragenden Kontos.

2. `config` (Objekt, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   * `commitment` (string, optional): Gibt das zu verwendende [Commitment Level](https://www.helius.dev/blog/solana-commitment-levels) für die Abfrage an. Standardmäßig ist `finalized`.
     * `finalized`: Der Knoten wird den zuletzt bestätigten Block abfragen, der von der Supermehrheit des Clusters als maximale Sperrung erreicht wurde.
     * `confirmed`: Der Knoten wird den zuletzt vom Supermehrheit des Clusters abgestimmten Block abfragen.
     * `processed`: Der Knoten wird seinen zuletzt erstellten Block abfragen. Beachten Sie, dass der Block möglicherweise nicht vollständig ist.
   * `encoding` (string, optional): Die Codierung für Kontodaten. Standardmäßig ist `base64`.
     * `base58` (langsam)
     * `base64`
     * `base64+zstd` (wenn Daten komprimiert sind)
     * `jsonParsed`: Wenn die Kontodaten ein bekannter Programmzustand sind (z. B. Token-Konten, Stake-Konten), wird der Knoten versuchen, sie in eine JSON-Struktur zu parsen. Für generische Programmkonten fällt dies normalerweise auf binär (base64) zurück.
   * `dataSlice` (Objekt, optional): Begrenzt die zurückgegebenen Kontodaten auf einen bestimmten Abschnitt. Nur verfügbar für `base58`, `base64` oder `base64+zstd` Codierungen.
     * `offset` (Zahl): Die Anzahl der Bytes vom Start der Kontodaten, um den Abschnitt zu beginnen.
     * `length` (Zahl): Die Anzahl der zurückzugebenden Bytes.
   * `minContextSlot` (Zahl, optional): Der minimale Slot, bei dem die Anforderung bewertet werden kann.

## Antwort

Wenn das Konto gefunden wird, enthält das `result`-Feld ein Objekt mit zwei Haupt-Eigenschaften:

* `context` (Objekt): Enthält Metadaten über die Anfrage.
  * `slot` (Zahl): Der Slot, bei dem die Information abgerufen wurde.
  * `apiVersion` (string, optional): Die RPC-API-Version.

* `value` (Objekt | null): Wenn das Konto nicht existiert, wird dies `null` sein. Andernfalls ist es ein Objekt, das Folgendes enthält:
  * `lamports` (Zahl): Die Anzahl der Lamports (1 SOL = 1.000.000.000 Lamports), die dem Konto gehören.
  * `owner` (string): Der base-58-kodierte Public Key des Programms, dem dieses Konto gehört.
  * `data` (Array | Objekt | string): Die im Konto gespeicherten Daten. Das Format hängt von dem im Anfrage verwendeten `encoding`-Parameter ab.
    * Für `base64` (Standard), `base58`, `base64+zstd`: Dies ist typischerweise ein Array `[encoded_string, encoding_format]`, z. B. `["string_data", "base64"]`.
    * Für `jsonParsed`: Dies kann ein JSON-Objekt sein, wenn die Daten vom RPC-Knoten parsiert werden können (z. B. für SPL-Token-Konten). Andernfalls kann es auf `["", "base64"]` oder ähnlich zurückfallen, wenn die Daten nicht als Standardlayout erkannt werden.
  * `executable` (boolean): `true`, wenn das Konto ein Programm enthält, `false` andernfalls.
  * `rentEpoch` (Zahl): Das nächste Epoch, zu dem dieses Konto Miete schuldet.
  * `space` (Zahl, optional): Die Länge der Daten in Bytes. (Hinweis: Die offiziellen Solana-Dokumente listen `space`, während einige RPC-Anbieter es einbeziehen könnten. Es stellt den gesamten für die Kontodaten zugewiesenen Speicherplatz dar). Für weitere Details zu [Kontodaten und Deserialisierung](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana), siehe unseren detaillierten Leitfaden.

Wenn das Konto nicht gefunden wird, ist das `value`-Feld im Ergebnis `null`.

## Beispiel: Abrufen von Kontoinformationen

Holen wir Informationen für die Serum Program V3 ID (`9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin`) im Mainnet ab.

**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": "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>

## Entwicklertipps

* **Leistung:** Für Anwendungen, die häufige Überprüfungen mehrerer Konten erfordern, sollten Sie `getMultipleAccounts` verwenden, um Anfragen zu bündeln und Rundreisen zu reduzieren.
* **Daten-Deserialisierung:** Das `data`-Feld erfordert oft eine Deserialisierung basierend auf den Datenstrukturen des Eigentümerprogramms. Werkzeuge und Bibliotheken, die spezifisch für das Programm sind (z. B. SPL-Token-Bibliothek für Token-Konten), werden in der Regel benötigt. Unser Blogpost zur [Deserialisierung von Kontodaten](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana) bietet hilfreiche Techniken und Beispiele.
* **Ratenlimits:** Beachten Sie die Ratenlimits des RPC-Knotens, insbesondere wenn eine große Anzahl von Konten abgefragt wird oder häufige Anfragen gestellt werden.
* **Kostenmanagement:** `getAccountInfo` ist im Allgemeinen eine kostengünstige Abfrage, aber häufiges Abrufen kann sich summieren. Optimieren Sie Ihre Abfragemuster.
* **Verwenden Sie `jsonParsed` mit Bedacht:** Während `jsonParsed` praktisch sein kann, unterstützt es möglicherweise nicht alle Kontotypen, und sein Output kann sich ändern, wenn ein Programm seine Datenstrukturen aktualisiert. Für kritische Anwendungen bietet das Parsen von Binärdaten mit einem bekannten Layout mehr Stabilität.
* **Erwägen Sie `dataSlice`:** Wenn Sie nur einen kleinen Teil der Kontodaten benötigen, verwenden Sie `dataSlice`, um die übertragenen Daten zu reduzieren und möglicherweise die Abfragekosten zu senken.

## Verwandte Methoden

<CardGroup cols={2}>
  <Card title="getMultipleAccounts" href="/docs/de/api-reference/rpc/http/getmultipleaccounts">
    Abrufen mehrerer Konten in einer einzigen Anfrage für bessere Leistung
  </Card>

  <Card title="getBalance" href="/docs/de/api-reference/rpc/http/getbalance">
    Nur das SOL-Guthaben ohne vollständige Kontodetails abrufen
  </Card>
</CardGroup>