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

# Comment obtenir des jetons Solana SPL : Guide complet de l'API

> Récupérez et interrogez les données des jetons SPL de Solana avec Helius : soldes, comptes de jetons, approvisionnement, détenteurs et extension de jetons fongibles, avec des exemples de code.

## Vue d'ensemble

Ce guide couvre la lecture des jetons fongibles sur Solana : soldes des comptes, comptes de jetons par propriétaire ou émission, approvisionnement total, plus grands détenteurs, et l'extension de jetons fongibles DAS. Helius expose à la fois les méthodes de jetons RPC standard Solana et les méthodes DAS qui ajoutent des métadonnées et des prix en USD.

Pour les NFT, NFT compressés, éditions et preuves, consultez le [guide Obtenir des actifs](/docs/fr/das/get-nfts). Cette page se concentre sur les jetons fongibles (SPL et Token-2022).

## Quand utiliser ceci

Utilisez les méthodes de cette page lorsque vous :

* Lisez le solde d'un seul compte de jeton
* Listez tous les comptes de jetons qu'un portefeuille détient
* Trouvez tous les comptes qui détiennent une émission spécifique
* Vérifiez l'approvisionnement total d'un jeton ou ses plus grands détenteurs
* Récupérez les métadonnées du jeton et le prix en USD en plus des soldes

## Solde du compte de jetons

Obtenez le solde pour un compte de jeton spécifique en utilisant le RPC standard :

```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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/rpc/http/gettokenaccountbalance">
  getTokenAccountBalance
</Card>

## Comptes de jetons par propriétaire

Listez tous les comptes de jetons détenus par un portefeuille :

```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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

## Comptes de jetons par émission

Listez tous les comptes détenant un jeton spécifique :

```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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

Pour trouver chaque compte détenant une émission parmi tous les propriétaires (pas seulement un propriétaire), utilisez la méthode DAS `getTokenAccounts` décrite ci-dessous.

## Approvisionnement en jetons

Vérifiez l'approvisionnement total d'un jeton :

```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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/rpc/http/gettokensupply">
  getTokenSupply
</Card>

## Plus grands détenteurs de jetons

Identifiez les plus grands comptes détenant un jeton :

```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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/rpc/http/gettokenlargestaccounts">
  getTokenLargestAccounts
</Card>

Retourne jusqu'à 20 des plus grands comptes pour l'émission :

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

## Comptes de jetons avec l'API DAS

La méthode DAS `getTokenAccounts` retourne les comptes de jetons par émission ou propriétaire, y compris les soldes, en un seul appel paginé. Contrairement à `getTokenAccountsByOwner`, vous pouvez interroger par `mint` seul pour lister chaque compte détenant un jeton parmi tous les propriétaires.

```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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/das/gettokenaccounts">
  getTokenAccounts
</Card>

Paginé; chaque entrée inclut le compte, l'émission, le propriétaire et le solde :

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

## Métadonnées de jetons et prix avec l'API DAS

Pour les métadonnées de jetons et le prix en USD, appelez la méthode DAS `getAsset` avec `showFungible` activé. Les prix pour les jetons vérifiés sont retournés sous `token_info.price_info`.

<Note>
  Les données de prix de `getAsset` sont mises en cache pendant jusqu'à 600 secondes, elles peuvent donc être vieilles jusqu'à 10 minutes.
</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="Référence de l'API" horizontal icon="code" href="/docs/fr/api-reference/das/getasset">
  getAsset
</Card>

La réponse retourne l'approvisionnement, les décimales et le prix sous `token_info` :

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

### Calculer la capitalisation boursière

Multipliez le prix par l'approvisionnement ajusté aux décimales :

```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;
```

Pour lister chaque jeton fongible d'un portefeuille (avec soldes et prix) en un seul appel, utilisez `getAssetsByOwner` ou `searchAssets` avec `tokenType: "fungible"`. Voir l'[extension de jetons fongibles](/docs/fr/das/fungible-token-extension) pour savoir comment `tokenType`, les soldes, les extensions Token-2022 et les données de prix apparaissent dans la réponse.

## Meilleures pratiques

* Utilisez la pagination pour les méthodes qui retournent de grands ensembles de résultats. Consultez le [guide de pagination](/docs/fr/das/pagination).
* Préférez les méthodes DAS (`getAsset`, `getAssetsByOwner`, `getTokenAccounts`) lorsque vous avez besoin de métadonnées ou de prix en USD ; utilisez les méthodes RPC standard pour les soldes et approvisionnements bruts sur la chaîne.
* Gérez les erreurs de manière gracieuse avec des blocs try/catch et des tentatives répétées.
* Mettez en cache les réponses lorsque c'est approprié pour réduire les appels API.

## Prochaines étapes

<CardGroup cols={3}>
  <Card title="Extension de jetons fongibles" icon="coins" href="/docs/fr/das/fungible-token-extension">
    Comment DAS retourne les jetons fongibles, extensions Token-2022, et prix.
  </Card>

  <Card title="Obtenir des actifs (NFTs)" icon="image" href="/docs/fr/das/get-nfts">
    Récupérez des NFTs, NFTs compressés, éditions et preuves.
  </Card>

  <Card title="Référence API DAS" icon="code" href="/docs/fr/api-reference/das">
    Schémas complets pour chaque méthode DAS.
  </Card>
</CardGroup>