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

# How to Use getProgramAccounts

> Erfahren Sie mehr über Anwendungsfälle, Codebeispiele, Anfrageparameter, Antwortstruktur und Tipps zur Nutzung von getProgramAccounts.

Die [`getProgramAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getprogramaccounts) RPC-Methode ist ein leistungsstarkes Werkzeug zum Abfragen der Solana-Blockchain. Sie ermöglicht es Ihnen, alle Konten abzurufen, die von einem bestimmten On-Chain-Programm verwaltet werden. Dies ist für eine Vielzahl von Anwendungen unerlässlich, von der Suche nach allen Token-Konten, die mit einem Benutzer für eine bestimmte Token-Prägung verbunden sind, bis hin zur Entdeckung aller benutzerspezifischen Datenkonten für eine dezentrale Anwendung.

Aufgrund der potenziell großen Anzahl von Konten, die ein Programm besitzen könnte, bietet `getProgramAccounts` robuste Filtermöglichkeiten, um Ihnen zu helfen, Ihre Suche einzugrenzen und nur die Daten effizient zu erfassen, die Sie benötigen.

Für Anwendungen, die sehr große Mengen an Programmkonten abfragen müssen, sollten Sie [`getProgramAccountsV2`](/docs/de/api-reference/rpc/http/getprogramaccountsv2) verwenden, das eine Cursor-basierte Paginierung mit konfigurierbaren Seitengrößen von bis zu 10.000 Konten pro Anfrage bietet.

## Häufige Anwendungsfälle

* **Finden aller Token-Konten für eine Prägung:** Entdecken Sie alle Inhaber eines bestimmten SPL-Tokens.
* **Abrufen benutzerspezifischer Daten:** Holen Sie alle Konten ab, die von einem Programm für einen bestimmten Benutzer erstellt wurden (z. B. die Positionen eines Benutzers in einem DeFi-Protokoll, ihren Spielstatus in einem Play-to-Earn-Spiel).
* **Auflisten aller Instanzen eines benutzerdefinierten Kontotyps:** Wenn Ihr Programm eine bestimmte Kontostruktur definiert, kann `getProgramAccounts` alle Instanzen dieser Struktur finden.
* **Überwachung des Programmstatus:** Beobachten aller Konten, die mit einem Programm verbunden sind, um seinen Gesamtstatus oder Aktivität zu verfolgen.
* **Erstellen von Explorer- und Analysetools:** Aggregieren von Daten über Programme und ihre zugehörigen Konten.

## Anfrageparameter

1. **`programId`** (`string`, erforderlich):
   * Der base-58 codierte öffentliche Schlüssel des Programms, dessen Konten Sie abrufen möchten.
   * Beispiel: `"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"` (für das SPL Token Programm).

2. **`options`** (`object`, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   * **`commitment`** (`string`): Spezifiziert das [Commitment-Level](https://www.helius.dev/blog/solana-commitment-levels) (z. B. `"finalized"`, `"confirmed"`).
   * **`encoding`** (`string`): Kodierung für das `data`-Feld innerhalb jedes zurückgegebenen Kontos. Standardmäßig `"base64"`.
     * `"base58"`: Langsamere Alternative für Binärdaten.
     * `"base64"`: Standard-Base64-Kodierung für Binärdaten.
     * `"base64+zstd"`: Base64-codierte, zstd-komprimierte Binärdaten.
     * `"jsonParsed"`: Wenn der RPC-Knoten einen Parser für den Kontotyp des Programms hat (z. B. SPL Token, Stake), wird das `data`-Feld ein strukturiertes JSON-Objekt sein. Dies wird dringend für Lesbarkeit und Benutzerfreundlichkeit empfohlen.
   * **`filters`** (`array`): Ein Array von Filterobjekten, das auf die Konten angewendet werden soll. Dies ist entscheidend für Leistung und Relevanz. Sie können bis zu 4 Filter verwenden. Häufige Filter umfassen:
     * **`dataSize`** (`object`):
       * `dataSize` (`u64`): Filtert Konten nach ihrer Datenlänge in Bytes. Beispiel: `{ "dataSize": 165 }` (für SPL Token Konten).
     * **`memcmp`** (`object`): Speichervergleich. Vergleicht einen Abschnitt der Kontodaten mit den bereitgestellten Bytes.
       * `offset` (`usize`): Der Byte-Offset in die Kontodaten, an dem der Vergleich beginnen soll.
       * `bytes` (`string`): Ein base-58 codierter String der Bytes, die übereinstimmen sollen. Der Byte-String darf kleiner als 129 Bytes sein.
       * Beispiel: Um Token-Konten für eine bestimmte Prägung zu finden, würden Sie `memcmp` mit `offset: 0` verwenden (wo die Prägeadresse in einem Token-Konto gespeichert ist) und `bytes` auf den öffentlichen Schlüssel der Prägung setzen.
   * **`dataSlice`** (`object`): Gibt nur einen bestimmten Abschnitt der Daten jedes Kontos zurück. Nützlich für große Konten, wenn Sie nur Teilinformationen benötigen.
     * `offset` (`usize`): Der Byte-Offset, ab dem der Schnitt beginnen soll.
     * `length` (`usize`): Die Anzahl der zurückzugebenden Bytes.
     * *Hinweis: `dataSlice` ist hauptsächlich für Binärkodierungen, nicht `jsonParsed`.*
   * **`withContext`** (`boolean`): Wenn `true`, wird die Antwort ein `RpcResponse`-Objekt enthalten, das eine `context` (mit `slot`) und die `value` (das Kontenarray) enthält. Wenn `false` oder weggelassen, wird normalerweise nur das Kontenarray zurückgegeben. Das Verhalten kann je nach RPC-Anbieter leicht variieren.
   * **`minContextSlot`** (`u64`): Der Mindestspeicherbereich, den die Anfrage erreichen kann.

## Antwortstruktur

Die Antwort ist ein Array von Objekten, bei denen jedes Objekt ein gefundenes Konto darstellt und Folgendes umfasst:

* **`pubkey`** (`string`): Der base-58 codierte öffentliche Schlüssel des Kontos.
* **`account`** (`object`):
  * `lamports` (`u64`): Saldo des Kontos in Lamport.
  * `owner` (`string`): Base-58 codierter öffentlicher Schlüssel des Programms, dem dieses Konto gehört (dies wird der `programId` sein, nach dem Sie gesucht haben).
  * `data` (`string`, `array` oder `object`): Die Kontodaten, formatiert gemäß dem `encoding`-Parameter.
    * Für `jsonParsed`: Ein JSON-Objekt, das den deserialisierten Kontostatus darstellt.
    * Für `base64`: Ein Array `["encoded_string", "base64"]`.
  * `executable` (`boolean`): Ob das Konto ausführbar ist (d. h. ein Programm selbst).
  * `rentEpoch` (`u64`): Das Epoche, bei der dieses Konto das nächste Mal Miete zahlen muss.
  * `space` (`u64`, optional): Die Datenlänge des Kontos in Bytes. Manchmal auch `data.length` genannt, wenn Daten ein Puffer sind oder Teil der analysierten Struktur.

Wenn `withContext: true` verwendet wird, wird dieses Array unter dem `value`-Feld eines `RpcResponse`-Objekts verschachtelt.

## Beispiele

### 1. Finden aller Token-Konten für eine spezifische Prägung (USDC)

Dieses Beispiel findet alle SPL-Token-Konten, die USDC halten. Es verwendet `dataSize`, um nach Token-Konten (165 Bytes) zu filtern, und `memcmp`, um die USDC-Prägeadresse bei Offset 0 abzugleichen.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  # USDC Mint: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
  # Token Program ID: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getProgramAccounts",
      "params": [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
        {
          "encoding": "jsonParsed",
          "filters": [
            { "dataSize": 165 },
            {
              "memcmp": {
                "offset": 0, 
                "bytes": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
              }
            }
          ]
        }
      ]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection, PublicKey } = require('@solana/web3.js');
  const { TOKEN_PROGRAM_ID } = require('@solana/spl-token');

  const USDC_MINT_ADDRESS = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

  async function findUsdcTokenAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

    try {
      const accounts = await connection.getProgramAccounts(TOKEN_PROGRAM_ID, {
        encoding: 'jsonParsed',
        filters: [
          {
            dataSize: 165, // Standard token account size
          },
          {
            memcmp: {
              offset: 0, // Offset for the mint address in a token account
              bytes: USDC_MINT_ADDRESS, // Base-58 encoded mint address
            },
          },
        ],
      });

      console.log(`Found ${accounts.length} USDC token accounts.`);
      accounts.forEach((accountInfo, index) => {
        console.log(`--- Account ${index + 1} ---`);
        console.log(`  Pubkey: ${accountInfo.pubkey.toBase58()}`);
        // Accessing parsed data
        const parsedData = accountInfo.account.data.parsed.info;
        console.log(`  Owner: ${parsedData.owner}`);
        console.log(`  Amount: ${parsedData.tokenAmount.uiAmountString}`);
      });
    } catch (error) {
      console.error('Error fetching USDC token accounts:', error);
    }
  }

  findUsdcTokenAccounts();
  ```
</CodeGroup>

### 2. Finden aller Token-Konten, die von einer bestimmten Wallet verwaltet werden

Dieses Beispiel findet alle SPL-Token-Konten, die von einer bestimmten Wallet-Adresse verwaltet werden. Es verwendet `dataSize` (165 Bytes) und `memcmp` bei Offset 32 (wo der Besitzer-Pubkey in einem Token-Konto gespeichert ist).

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  # Example Wallet Address: Helioo21241PANoNdeG55722hgUnp2VawDgsz2g
  # Token Program ID: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getProgramAccounts",
      "params": [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
        {
          "encoding": "jsonParsed",
          "filters": [
            { "dataSize": 165 },
            {
              "memcmp": {
                "offset": 32, 
                "bytes": "Helioo21241PANoNdeG55722hgUnp2VawDgsz2g"
              }
            }
          ]
        }
      ]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection, PublicKey } = require('@solana/web3.js');
  const { TOKEN_PROGRAM_ID } = require('@solana/spl-token');

  const TARGET_WALLET_ADDRESS = 'Helioo21241PANoNdeG55722hgUnp2VawDgsz2g';

  async function findWalletTokenAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

    try {
      const accounts = await connection.getProgramAccounts(TOKEN_PROGRAM_ID, {
        encoding: 'jsonParsed',
        filters: [
          {
            dataSize: 165, // Standard token account size
          },
          {
            memcmp: {
              offset: 32, // Offset for the owner address in a token account
              bytes: TARGET_WALLET_ADDRESS, // Base-58 encoded wallet address
            },
          },
        ],
      });

      console.log(`Found ${accounts.length} token accounts for wallet ${TARGET_WALLET_ADDRESS}.`);
      accounts.forEach((accountInfo, index) => {
        console.log(`--- Account ${index + 1} (${accountInfo.pubkey.toBase58()}) ---`);
        const parsedData = accountInfo.account.data.parsed.info;
        console.log(`  Mint: ${parsedData.mint}`);
        console.log(`  Amount: ${parsedData.tokenAmount.uiAmountString}`);
      });
    } catch (error) {
      console.error('Error fetching token accounts for wallet:', error);
    }
  }

  findWalletTokenAccounts();
  ```
</CodeGroup>

## Erweiterte Filterung

Optimieren Sie Ihre Abfragen mit Filtern, um die Antwortgröße zu verringern und die Leistung zu verbessern:

```typescript theme={"system"}
// Example filtering by memcmp (memory comparison)
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: "getProgramAccounts",
      params: [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Solana Token Program
        {
          encoding: "jsonParsed",
          filters: [
            {
              dataSize: 165, // Size of token account data
            },
            {
              memcmp: {
                offset: 32, // Location of owner address in the token account
                bytes: "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
              },
            },
          ],
        },
      ],
    }),
  }
);
const data = await response.json();
console.log("Filtered program accounts data:", data);
```

<Card title="API Reference" horizontal icon="code" href="/docs/de/api-reference/rpc/http/getprogramaccounts">
  getProgramAccounts
</Card>

### Filterarten

* `memcmp`: Filterkonten, die einem bestimmten Muster bei einem bestimmten Offset entsprechen
* `dataSize`: Filterkonten nach ihrer genauen Datengröße
* Mehrere Filter: Alle Bedingungen müssen erfüllt sein (logisches UND)

## Entwicklertipps

* **Leistung:** `getProgramAccounts` kann ressourcenintensiv auf RPC-Knoten sein, insbesondere ohne Filter oder für Programme mit vielen Konten. Verwenden Sie immer Filter (`dataSize`, `memcmp`) und `dataSlice`, wo möglich, um den Abfrageumfang und die Antwortgröße zu reduzieren.
* **Große Ergebnismengen:** Bei Abfragen, die viele Ergebnisse zurückgeben, könnte die Antwort abgeschnitten oder ein Timeout auftreten. Verwenden Sie Filter, um den Umfang zu reduzieren, oder ziehen Sie [`getProgramAccountsV2`](/docs/de/api-reference/rpc/http/getprogramaccountsv2) für Unterstützung bei der Paginierung in Betracht.
* **Ratenbeschränkungen:** Beachten Sie die Ratenbeschränkungen des RPC-Anbieters, da häufige oder schwere `getProgramAccounts`-Anrufe diese Grenzen erreichen können.
* **Wissen über Datenlayout:** Effektive Nutzung von `memcmp` erfordert das Verständnis des Byte-Layouts der Kontodaten, die Sie abfragen.
* **Verfügbarkeit von `jsonParsed`:** Die `jsonParsed`-Kodierung hängt davon ab, ob der RPC-Knoten einen Parser für die spezifischen Kontotypen des Programms hat. Sie wird häufig für gängige Programme wie SPL Token unterstützt.

`getProgramAccounts` ist eine unverzichtbare Methode für Entwickler, die Sätze von Konten abfragen und mit ihnen interagieren müssen, die von einem Programm verwaltet werden. Die Beherrschung seiner Filteroptionen ist entscheidend für den Aufbau effizienter und robuster Solana-Anwendungen.

## Paginierung für große Datensätze

Für Anwendungen, die mit Programmen arbeiten, die eine große Anzahl von Konten besitzen (10.000+), verwenden Sie [`getProgramAccountsV2`](/docs/de/api-reference/rpc/http/getprogramaccountsv2), das Folgendes bietet:

* **Cursor-basierte Paginierung**: Setzen Sie `limit` (1-10.000) und verwenden Sie `paginationKey`, um durch Ergebnisse zu navigieren
* **Inkrementelle Aktualisierungen**: Verwenden Sie `changedSinceSlot`, um nur Konten abzurufen, die seit einem bestimmten Slot geändert wurden
* **Bessere Leistung**: Verhindert Timeouts und reduziert den Speicherverbrauch
* **Paginierungverhalten**: Das Ende der Paginierung wird nur angezeigt, wenn keine Konten zurückgegeben werden. Weniger Konten als das Limit können aufgrund von Filtern 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: "getProgramAccountsV2",
    params: [
      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      {
        encoding: "base64",
        filters: [{ dataSize: 165 }],
        limit: 5000
      }
    ]
  })
});

const data = await response.json();
console.log(`Found ${data.result.accounts.length} 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 accounts available");
}
```

## Verwandte Methoden

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