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

# So erhalten Sie Solana SPL Tokens: Vollständiger API-Leitfaden

> "Abrufen und Abfragen von Solana SPL-Token-Daten mit Helius: Salden, Token-Konten, Angebot, Inhaber und die fungible Token-Erweiterung, mit Codebeispielen."

## Überblick

Dieser Leitfaden behandelt das Lesen von fungiblen Tokens auf Solana: Kontensalden, Token-Konten nach Besitzer oder Mint, Gesamtausgabe, größte Inhaber und die DAS fungible Token-Erweiterung. Helius bietet sowohl standardmäßige Solana RPC-Token-Methoden als auch DAS-Methoden, die Metadaten und USD-Preise hinzufügen.

Für NFTs, komprimierte NFTs, Editionen und Nachweise siehe den [Assets-Leitfaden](/docs/de/das/get-nfts). Diese Seite konzentriert sich auf fungible (SPL und Token-2022) Tokens.

## Wann Sie dies verwenden sollten

Verwenden Sie die Methoden auf dieser Seite, wenn Sie:

* Den Saldo eines einzelnen Token-Kontos lesen
* Jedes Token-Konto auflisten, das eine Wallet hält
* Alle Konten finden, die eine bestimmte Prägung halten
* Das Gesamtangebot eines Tokens oder seine größten Inhaber überprüfen
* Token-Metadaten und USD-Preis zusammen mit Salden abrufen

## Token-Kontostand

Abrufen des Saldos für ein bestimmtes Token-Konto mit standardmäßigem RPC:

```typescript theme={"system"}
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: 'getTokenAccountBalance',
    params: [
      '3emsAVdmGKERbHjmGfQ6oZ1e35dkf5iYcS6U4CPKFVaa'
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/rpc/http/gettokenaccountbalance">
  getTokenAccountBalance
</Card>

## Token-Konten nach Besitzer

Alle Token-Konten auflisten, die einer Wallet gehören:

```typescript theme={"system"}
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: 'getTokenAccountsByOwner',
    params: [
      '86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY',
      {
        programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
      },
      {
        encoding: 'jsonParsed'
      }
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

## Token-Konten nach Prägung

Alle Konten auflisten, die ein bestimmtes Token halten:

```typescript theme={"system"}
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: 'getTokenAccountsByOwner',
    params: [
      'CEXq1uy9y15PL2Wb4vDQwQfcJakBGjaAjeuR2nKLj8dk',
      {
        mint: "8wXtPeU6557ETkp9WHFY1n1EcU6NxDvbAggHGsMYiHsB"
      },
      {
        encoding: 'jsonParsed'
      }
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

Um jedes Konto zu finden, das eine Prägung über alle Besitzer hinweg hält (nicht nur ein Besitzer), verwenden Sie die DAS `getTokenAccounts` Methode unten beschrieben.

## Token-Angebot

Das gesamte Angebot eines Tokens überprüfen:

```typescript theme={"system"}
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: 'getTokenSupply',
    params: [
      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/rpc/http/gettokensupply">
  getTokenSupply
</Card>

## Größte Token-Inhaber

Identifizieren der größten Konten, die ein Token halten:

```typescript theme={"system"}
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: 'getTokenLargestAccounts',
    params: [
      'he1iusmfkpAdwvxLNGV8Y1iSbj4rUy6yMhEA3fotn9A'
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/rpc/http/gettokenlargestaccounts">
  getTokenLargestAccounts
</Card>

Gibt bis zu den 20 größten Konten für die Prägung zurück:

```json theme={"system"}
{
  "context": { "slot": 0 },
  "value": [
    { "address": "...", "amount": "1000000000000", "decimals": 9, "uiAmount": 1000.0, "uiAmountString": "1000" }
  ]
}
```

## Token-Konten mit der DAS API

Die DAS `getTokenAccounts` Methode gibt Token-Konten nach Prägung oder Besitzer zurück, einschließlich Salden, in einem einzigen paginierten Aufruf. Im Gegensatz zu `getTokenAccountsByOwner` können Sie allein nach `mint` abfragen, um jedes Konto aufzulisten, das ein Token über alle Besitzer hinweg hält.

```typescript theme={"system"}
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getTokenAccounts = async (params) => {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "my-request-id",
      method: "getTokenAccounts",
      params: params,
    }),
  });

  const { result } = await response.json();
  return result;
};

// Example: Get all accounts holding a specific token
getTokenAccounts({
  mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  page: 1,
  limit: 100
});
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/das/gettokenaccounts">
  getTokenAccounts
</Card>

Paginiert; jeder Eintrag enthält das Konto, die Prägung, den Besitzer und den Saldo:

```json theme={"system"}
{
  "total": 100,
  "limit": 100,
  "page": 1,
  "token_accounts": [
    { "address": "...", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "owner": "...", "amount": 12345678 }
  ]
}
```

## Token-Metadaten und Preis mit der DAS API

Für Token-Metadaten und USD-Preise rufen Sie die DAS `getAsset` Methode mit `showFungible` aktiviert auf. Preise für verifizierte Token werden unter `token_info.price_info` zurückgegeben.

<Note>
  Preisdaten von `getAsset` werden bis zu 600 Sekunden zwischengespeichert, sodass sie bis zu 10 Minuten alt sein können.
</Note>

```typescript theme={"system"}
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: 'getAsset',
    params: {
      id: 'DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263', // Bonk
      options: {
        showFungible: true
      }
    }
  })
});
const { result } = await response.json();
console.log(result.token_info.price_info);
```

<Card title="API-Referenz" horizontal icon="code" href="/docs/de/api-reference/das/getasset">
  getAsset
</Card>

Die Antwort gibt das Angebot, die Dezimalstellen und den Preis unter `token_info` zurück:

```json theme={"system"}
{
  "token_info": {
    "symbol": "Bonk",
    "supply": 8881594973561640000,
    "decimals": 5,
    "token_program": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
    "price_info": {
      "price_per_token": 0.0000192271,
      "currency": "USDC"
    }
  }
}
```

### Marktkapitalisierung berechnen

Den Preis mit dem dezimalanpassenden Angebot multiplizieren:

```typescript theme={"system"}
const { price_per_token } = result.token_info.price_info;
const { supply, decimals } = result.token_info;
const marketCap = (supply / Math.pow(10, decimals)) * price_per_token;
```

Um jedes fungible Token in einer Wallet (mit Salden und Preisen) in einem Aufruf aufzulisten, verwenden Sie `getAssetsByOwner` oder `searchAssets` mit `tokenType: "fungible"`. Siehe die [fungible Token-Erweiterung](/docs/de/das/fungible-token-extension), um zu erfahren, wie `tokenType`, Salden, Token-2022-Erweiterungen und Preisdaten in der Antwort erscheinen.

## Beste Praktiken

* Verwenden Sie die Paginierung für Methoden, die große Ergebnismengen zurückgeben. Siehe den [Paginierungsleitfaden](/docs/de/das/pagination).
* Bevorzugen Sie DAS-Methoden (`getAsset`, `getAssetsByOwner`, `getTokenAccounts`), wenn Sie Metadaten oder USD-Preise benötigen; verwenden Sie standardmäßige RPC-Methoden für rohe On-Chain-Salden und Angebot.
* Gehen Sie Fehler mit try/catch-Blöcken und Wiederholungen griffig an.
* Zwischenspeichern Sie Antworten, wenn dies angebracht ist, um API-Aufrufe zu reduzieren.

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Fungible Token-Erweiterung" icon="coins" href="/docs/de/das/fungible-token-extension">
    Wie DAS fungible Tokens, Token-2022-Erweiterungen und Preise zurückgibt.
  </Card>

  <Card title="Assets (NFTs) abrufen" icon="image" href="/docs/de/das/get-nfts">
    Abrufen von NFTs, komprimierten NFTs, Editionen und Nachweisen.
  </Card>

  <Card title="DAS API-Referenz" icon="code" href="/docs/de/api-reference/das">
    Vollständige Schemas für jede DAS-Methode.
  </Card>
</CardGroup>