> ## 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 utiliser getBalance

> Découvrez les cas d'utilisation de getBalance, des exemples de code, les paramètres de requête, la structure de réponse et des astuces.

La méthode RPC [`getBalance`](https://www.helius.dev/docs/api-reference/rpc/http/getbalance) est un moyen simple de connaître le solde SOL natif de n'importe quel compte sur la blockchain Solana. Elle retourne le solde en lamports (1 SOL = 1 000 000 000 lamports).

Cette méthode est plus légère que `getAccountInfo` si vous avez *uniquement* besoin du solde SOL et d'aucun autre détail de compte.

## Cas d'utilisation principal

* **Vérification rapide des avoirs SOL d'un compte :** L'utilisation principale est de déterminer combien de SOL un compte (portefeuille, programme, etc.) détient.

## Paramètres

1. `publicKey` (string, requis) : La clé publique encodée en base-58 du compte à interroger.

2. `config` (objet, optionnel) : Un objet de configuration avec les champs suivants :
   * `commitment` (string, optionnel) : Spécifie le [niveau d'engagement](https://www.helius.dev/blog/solana-commitment-levels) à utiliser pour la requête. La valeur par défaut est `finalized`.
     * `finalized` : Le nœud interrogera le bloc le plus récent confirmé par la supermajorité du cluster comme ayant atteint le verrouillage maximal.
     * `confirmed` : Le nœud interrogera le bloc le plus récent qui a été voté par une supermajorité du cluster.
     * `processed` : Le nœud interrogera son bloc le plus récent. Notez que le bloc peut ne pas être complet.
   * `minContextSlot` (nombre, optionnel) : Le slot minimum auquel la requête peut être évaluée.

## Réponse

Le champ `result` de la réponse JSON-RPC sera un objet contenant :

* `context` (objet) :
  * `slot` (nombre) : Le slot auquel le solde a été récupéré.
  * `apiVersion` (string, optionnel) : La version de l'API RPC (peut ne pas être présente pour tous les nœuds).
* `value` (nombre) : Le solde du compte en lamports (entier sans signe 64 bits).

Si le compte n'existe pas sur la chaîne, `getBalance` retournera généralement une valeur de `0` lamports.

## Exemple : Obtenir le solde d'un compte

Vérifions le solde SOL de l'ID du programme Serum V3 (`9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin`) sur le mainnet. Ce compte programme détient lui-même du SOL pour l'exemption de loyer.

**Remarque :** Remplacez `YOUR_API_KEY` par votre clé API Helius réelle dans les exemples ci-dessous.

<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": "getBalance",
    "params": [
      "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin"
    ]
  }'
  ```

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

  async function checkBalance() {
    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 lamports = await connection.getBalance(accountPubKey);
      const sol = lamports / LAMPORTS_PER_SOL;

      console.log(`Account PubKey: ${accountPubKey.toBase58()}`);
      console.log(`Balance (Lamports): ${lamports}`);
      console.log(`Balance (SOL): ${sol}`);

    } catch (error) {
      console.error('Error fetching balance:', error);
    }
  }

  checkBalance();
  ```

  ```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("83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri");
  const balance = await rpc.getBalance(publicKey).send();

  console.log("Account Balance:", balance);
  ```

  ```rust Rust theme={"system"}
  use anyhow::Result;
  use solana_client::nonblocking::rpc_client::RpcClient;
  use solana_sdk::{
      commitment_config::CommitmentConfig, native_token::LAMPORTS_PER_SOL, pubkey::Pubkey,
  };
  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("83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri")?;
      let balance = client.get_balance(&pubkey).await?;

      println!("{:#?} SOL", balance / LAMPORTS_PER_SOL);

      Ok(())
  }
  ```
</CodeGroup>

## Conseils pour les développeurs

* **Simplicité pour le solde SOL :** Si vous avez seulement besoin du solde SOL d'un compte et d'aucune autre donnée on-chain (comme le propriétaire, les données ou le statut exécutable), `getBalance` est plus efficace que `getAccountInfo` car elle récupère moins de données.
* **Comptes inexistants :** Si un compte n'existe pas sur la chaîne (n'a jamais été initialisé ou n'a pas de SOL), `getBalance` retournera `0`. Cela peut être un moyen rapide de vérifier l'existence d'un compte si vous vous souciez uniquement de son solde SOL.
* **Lamports vs. SOL :** Rappelez-vous que le solde est retourné en lamports. Vous devrez diviser par `LAMPORTS_PER_SOL` (1 000 000 000) pour le convertir en SOL.
* **Niveaux d'engagement :** Le choix de `commitment` peut affecter la rapidité avec laquelle vous obtenez le solde et à quel point ce solde est confirmé. Pour la plupart des affichages UI, `confirmed` offre un bon équilibre. Pour les transactions financières critiques, `finalized` fournit la plus grande assurance. Voir [Solana Commitment Levels](https://www.helius.dev/blog/solana-commitment-levels) pour des informations détaillées.
* **Batching avec `getMultipleAccounts` :** Bien que `getBalance` soit pour un compte unique, si vous avez besoin des soldes de nombreux comptes, utiliser `getMultipleAccounts` puis extraire le solde en lamports des infos de chaque compte peut être plus performant que de nombreuses appels individuels `getBalance`.

## Méthodes associées

<CardGroup cols={2}>
  <Card title="getAccountInfo" href="/docs/fr/api-reference/rpc/http/getaccountinfo">
    Obtenez les détails complets du compte, y compris les données, le propriétaire et le statut exécutable
  </Card>

  <Card title="getMultipleAccounts" href="/docs/fr/api-reference/rpc/http/getmultipleaccounts">
    Récupérez en batch plusieurs comptes en une seule requête
  </Card>
</CardGroup>