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

# Anleitung zur Verwendung von getTokenAccountsByOwner

> Lernen Sie Anwendungsfälle, Codebeispiele, Anfrageparameter, Antwortstruktur und Tipps zur Nutzung von getTokenAccountsByOwner.

Die [`getTokenAccountsByOwner`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenaccountsbyowner) RPC-Methode wird verwendet, um alle SPL [Tokenkonten](https://www.helius.dev/blog/how-to-get-token-holders-on-solana) zu erhalten, die von einem bestimmten öffentlichen Schlüssel besessen werden. Dies ist eine grundlegende Methode für Wallets und Anwendungen, die das Token-Portfolio eines Benutzers anzeigen oder mit ihren verschiedenen Tokenkonten interagieren müssen.

Sie müssen die Abfrage entweder nach einem bestimmten Token `mint` oder einem `programId` (z. B. dem SPL Token-Programm oder Token-2022-Programm) filtern.

Für Wallets mit umfangreichen Token-Portfolios ziehen Sie in Betracht, [`getTokenAccountsByOwnerV2`](/docs/de/api-reference/rpc/http/gettokenaccountsbyownerv2) zu verwenden, das Cursor-basierte Pagination mit konfigurierbaren Seitengrößen von bis zu 10.000 Konten pro Anfrage bietet.

## Häufige Anwendungsfälle

* **Benutzerportfolio anzeigen:** Abrufen aller Tokenkonten (und damit Salden) für eine bestimmte Wallet-Adresse eines Benutzers, um sein vollständiges Token-Portfolio zu zeigen.
* **Anwendungslogik:** Identifizieren eines bestimmten Tokenkontos eines Benutzers für ein bestimmtes Mint, bevor ein Transfer oder eine andere Interaktion eingeleitet wird.
* **Verifizierung:** Überprüfen, welche Tokenkonten ein Besitzer für einen bestimmten Token-Typ besitzt.
* **Indexierung von Token-Inhabern:** Obwohl weniger effizient für die globale Indexierung als andere Methoden, kann es verwendet werden, um Konten für einen bekannten Satz von Besitzern zu finden.

## Anfrageparameter

1. **`ownerPubkey`** (string, erforderlich): Der Base-58-kodierte öffentliche Schlüssel des Kontobesitzers, dessen Tokenkonten Sie abrufen möchten.

2. **`filter`** (Objekt, erforderlich): Ein JSON-Objekt, das **muss** entweder `mint` oder `programId` spezifizieren:
   * **`mint`** (string): Der Base-58-kodierte öffentliche Schlüssel eines bestimmten Token-Mints. Wenn angegeben, werden nur Tokenkonten für dieses Mint zurückgegeben, die von `ownerPubkey` besitzen werden.
   * **`programId`** (string): Der Base-58-kodierte öffentliche Schlüssel des Token-Programms, das die Konten verwaltet. Gängige Werte sind:
     * SPL Token-Programm: `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`
     * Token-2022-Programm: `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`

3. **`options`** (Objekt, optional): Ein optionales Konfigurationsobjekt, das Folgendes enthalten kann:
   * **`commitment`** (string, optional): Gibt das [Commitment-Level](https://www.helius.dev/blog/solana-commitment-levels) an.
   * **`encoding`** (string, optional): Die Codierung für Kontodaten. `"jsonParsed"` wird sehr empfohlen. Weitere Optionen: `"base64"`, `"base64+zstd"`. Standardmäßig `"base64"`.
   * **`dataSlice`** (Objekt, optional): Um einen bestimmten Ausschnitt der Kontodaten abzurufen (`offset`: usize, `length`: usize). Nur für `base58`, `base64` oder `base64+zstd` Codierungen.
   * **`minContextSlot`** (u64, optional): Das Mindest-Slot für die Abfrage.

## Antwortstruktur

Das `result.value` Feld in der JSON-RPC-Antwort ist ein Array von Objekten. Jedes Objekt entspricht einem SPL Tokenkonto, das von `ownerPubkey` besessen wird und mit `filter` übereinstimmt.

Jedes Objekt im `value` Array enthält:

* **`pubkey`** (string): Der Base-58-kodierte öffentliche Schlüssel des Tokenkontos selbst.
* **`account`** (Objekt): Detaillierte Informationen über das Tokenkonto:
  * **`lamports`** (u64): Lamport-Saldo für Freistellung von der Miete.
  * **`owner`** (string): Das besitzende Programm (z. B. der Token-Programm-öffentliche Schlüssel).
  * **`data`**: Kontodaten. Wenn die `"jsonParsed"`-Codierung verwendet wird, enthält dies:
    * **`program`** (string): z. B. `"spl-token"`.
    * **`parsed`**: Ein Objekt mit strukturierten Informationen:
      * **`info`**: Details wie:
        * **`mint`** (string): Die Mint-Adresse des Tokens.
        * **`owner`** (string): Der Besitzer des Tokenkontos (dies sollte mit `ownerPubkey` aus der Anfrage übereinstimmen).
        * **`tokenAmount`** (Objekt): Der Saldo der Tokens (`amount`, `decimals`, `uiAmount`, `uiAmountString`).
        * **`state`** (string): Zustand des Tokenkontos (z. B. `"initialized"`).
        * **`isNative`** (boolean): Ob das Konto gewickelte SOL hält.
        * **`delegate`** (string, optional): Die Delegiertenadresse, falls eine gesetzt ist.
        * **`delegatedAmount`** (Objekt, optional): Der delegierte Betrag, wenn ein Delegat gesetzt ist.
      * **`type`** (string): z. B. `"account"`.
  * **`executable`** (boolean): Ob das Konto ausführbar ist.
  * **`rentEpoch`** (u64): Nächste Epoche, in der die Miete fällig ist.
  * **`space`** (u64, wenn nicht `jsonParsed`): Länge der rohen Kontodaten in Bytes.

**Beispielantwort (mit `jsonParsed`-Codierung, gefiltert nach `programId`):**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 183459000
    },
    "value": [
      {
        "pubkey": "AssociatedTokenAccountPubkey1...",
        "account": {
          "data": {
            "program": "spl-token",
            "parsed": {
              "info": {
                "isNative": false,
                "mint": "SomeTokenMintPubkey...",
                "owner": "OwnerPubkeyProvidedInRequest...",
                "state": "initialized",
                "tokenAmount": {
                  "amount": "1000000000", // 1 token if decimals is 9
                  "decimals": 9,
                  "uiAmount": 1.0,
                  "uiAmountString": "1.0"
                }
              },
              "type": "account"
            },
            "space": 165
          },
          "executable": false,
          "lamports": 2039280,
          "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
          "rentEpoch": 380
        }
      },
      {
        "pubkey": "AnotherAssociatedTokenAccountPubkey...",
        "account": {
          // ... similar structure for another token owned by the same owner
        }
      }
    ]
  },
  "id": 1
}
```

## Code-Beispiele

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <OWNER_PUBKEY> and <TOKEN_MINT_PUBKEY> or <TOKEN_PROGRAM_ID>

  # Example filtering by programId (SPL Token Program)
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getTokenAccountsByOwner",
      "params": [
        "<OWNER_PUBKEY>",
        { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
        { "encoding": "jsonParsed" }
      ]
    }' \
    <YOUR_RPC_URL>

  # Example filtering by a specific mint
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getTokenAccountsByOwner",
      "params": [
        "<OWNER_PUBKEY>",
        { "mint": "<SPECIFIC_TOKEN_MINT_PUBKEY>" },
        { "encoding": "jsonParsed", "commitment": "confirmed" }
      ]
    }' \
    <YOUR_RPC_URL>
  ```

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

  async function findOwnerTokenAccounts(ownerAddress, filter, encoding = 'jsonParsed') {
    // Replace with your RPC endpoint
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    const ownerPubKey = new PublicKey(ownerAddress);

    try {
      let actualFilter;
      if (filter.mint) {
        actualFilter = { mint: new PublicKey(filter.mint) };
      } else if (filter.programId) {
        actualFilter = { programId: new PublicKey(filter.programId) };
      } else {
        console.error("Filter must contain either 'mint' or 'programId'");
        return;
      }

      const accounts = await connection.getTokenAccountsByOwner(
        ownerPubKey,
        actualFilter,
        { encoding }
      );

      console.log(`Found ${accounts.value.length} token accounts for owner ${ownerAddress}:`);
      accounts.value.forEach(accInfo => {
        console.log(`  Token Account: ${accInfo.pubkey.toBase58()}`);
        if (encoding === 'jsonParsed' && accInfo.account.data.parsed) {
          console.log(`    Mint: ${accInfo.account.data.parsed.info.mint}`);
          console.log(`    Balance: ${accInfo.account.data.parsed.info.tokenAmount.uiAmountString}`);
        }
        // console.log(JSON.stringify(accInfo, null, 2)); // For full details
      });

    } catch (error) {
      console.error(`Error fetching token accounts for owner ${ownerAddress}:`, error);
    }
  }

  // Replace with an actual owner's public key
  const exampleOwner = 'HXtBm8XZbxaTt41uqaKhwUAa6Z1aPyvJdsZVENiWsetg'; // Example wallet address

  // Example 1: Find all SPL Token Program accounts owned by `exampleOwner`
  findOwnerTokenAccounts(exampleOwner, { programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA' });

  // Example 2: Find USDC token accounts owned by `exampleOwner`
  // const usdcMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
  // findOwnerTokenAccounts(exampleOwner, { mint: usdcMint });

  // Example 3: Find Token-2022 Program accounts owned by `exampleOwner`
  // findOwnerTokenAccounts(exampleOwner, { programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb' });
  ```
</CodeGroup>

## Entwickler-Tipps

* **Filteranforderung:** Sie *müssen* entweder einen `mint` oder einen `programId` im Filter angeben. Es ist nicht möglich, alle Tokenkonten für einen Besitzer über alle Tokentypen hinweg ohne einen dieser primären Filter abzufragen.
* **Assoziierte Tokenkonten:** Diese Methode gibt alle Tokenkonten zurück, die vom öffentlichen Schlüssel besessen werden, einschließlich standardmäßiger Assoziierter Tokenkonten (ATAs) und aller anderen SPL-Tokenkonten, die sie möglicherweise besitzen (z. B. von älteren Wallet-Implementierungen oder benutzerdefinierten Setups).
* **Codierung:** Die Verwendung von `"jsonParsed"` für die `encoding`-Option wird sehr empfohlen. Es dekodiert die binären Kontodaten in eine besser nutzbare JSON-Struktur.
* **Performance:** Wenn ein Besitzer eine sehr große Anzahl von Tokenkonten hat (insbesondere wenn nur nach `programId` gefiltert wird), kann die Antwort groß sein. Verwenden Sie in solchen Fällen [`getTokenAccountsByOwnerV2`](/docs/de/api-reference/rpc/http/gettokenaccountsbyownerv2), das eingebaute Unterstützung für die Paginierung bietet.
* **Token-2022 (Token-Erweiterungen):** Wenn Sie mit Tokens arbeiten, die mit dem Token-2022-Programm erstellt wurden (das Erweiterungen wie Transfergebühren, Zinsen usw. unterstützt), stellen Sie sicher, dass Sie den richtigen `programId` verwenden: `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`.

Dieses Handbuch bietet ein umfassendes Verständnis der `getTokenAccountsByOwner` RPC-Methode, die es Ihnen ermöglicht, Tokenkonto-Informationen effizient für jede Solana-Adresse abzurufen.

## Paginierung für große Token-Portfolios

Für Wallets mit umfangreichen Tokenbeständen verwenden Sie [`getTokenAccountsByOwnerV2`](/docs/de/api-reference/rpc/http/gettokenaccountsbyownerv2), das folgende Vorteile bietet:

* **Cursor-basierte Paginierung**: Setzen Sie `limit` (1-10.000) und verwenden Sie `paginationKey`, um durch die Ergebnisse zu navigieren
* **Inkrementelle Updates**: Verwenden Sie `changedSinceSlot`, um nur die Tokenkonten abzurufen, die seit einem bestimmten Slot geändert wurden
* **Bessere Performance**: Verhindert Zeitüberschreitungen und ermöglicht das Echtzeit-Tracking von Portfolios
* **Paginierungsverhalten**: Das Ende der Paginierung wird nur angezeigt, wenn keine Tokenkonten zurückgegeben werden. Aufgrund von Filterung können weniger Konten als das Limit zurückgegeben werden - setzen Sie die Paginierung fort, bis `paginationKey` null ist.

```typescript theme={"system"}
// Example: Paginated query for all token accounts
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "1",
    method: "getTokenAccountsByOwnerV2",
    params: [
      "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
      { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      {
        encoding: "jsonParsed",
        limit: 1000
      }
    ]
  })
});

const data = await response.json();
console.log(`Found ${data.result.value.length} token accounts`);
if (data.result.paginationKey) {
  console.log("More results available, use paginationKey for next page");
  // Continue pagination even if fewer than limit accounts were returned
} else {
  console.log("End of pagination - no more token accounts available");
}
```

## Verwandte Methoden

<CardGroup cols={2}>
  <Card title="getTokenAccountsByOwnerV2" href="/docs/de/api-reference/rpc/http/gettokenaccountsbyownerv2">
    Paginierte Version mit Cursor-basierter Navigation für große Portfolios
  </Card>

  <Card title="getTokenAccountBalance" href="/docs/de/api-reference/rpc/http/gettokenaccountbalance">
    Den Saldo eines bestimmten Tokenkontos abrufen
  </Card>
</CardGroup>