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

# Cómo usar getBalance

> Conoce los casos de uso de getBalance, ejemplos de código, parámetros de solicitud, estructura de respuesta y consejos.

El método RPC [`getBalance`](https://www.helius.dev/docs/api-reference/rpc/http/getbalance) es una forma sencilla de consultar el saldo nativo en SOL de cualquier cuenta en la blockchain de Solana. Devuelve el saldo en lamports (1 SOL = 1,000,000,000 lamports).

Este método es más ligero que `getAccountInfo` si *solo* necesitas el saldo en SOL y ningún otro detalle de la cuenta.

## Caso de uso principal

* **Consultar rápidamente las tenencias en SOL de una cuenta:** El uso principal es determinar cuánto SOL tiene una cuenta (billetera, programa, etc.).

## Parámetros

1. `publicKey` (cadena, obligatorio): La clave pública codificada en base 58 de la cuenta que deseas consultar.

2. `config` (objeto, opcional): Un objeto de configuración con los siguientes campos:
   * `commitment` (cadena, opcional): Especifica el [nivel de compromiso](https://www.helius.dev/blog/solana-commitment-levels) que se usará para la consulta. El valor predeterminado es `finalized`.
     * `finalized`: El nodo consultará el bloque más reciente que la supermayoría del clúster haya confirmado como bloque que alcanzó el bloqueo máximo.
     * `confirmed`: El nodo consultará el bloque más reciente por el que haya votado una supermayoría del clúster.
     * `processed`: El nodo consultará su bloque más reciente. Ten en cuenta que el bloque podría no estar completo.
   * `minContextSlot` (número, opcional): El slot mínimo en el que se puede evaluar la solicitud.

## Respuesta

El campo `result` de la respuesta JSON-RPC será un objeto que contiene:

* `context` (objeto):
  * `slot` (número): El slot en el que se obtuvo el saldo.
  * `apiVersion` (cadena, opcional): La versión de la API RPC (puede que no esté disponible en todos los nodos).
* `value` (número): El saldo de la cuenta en lamports (entero sin signo de 64 bits).

Si la cuenta no existe en la blockchain, `getBalance` normalmente devolverá un valor de `0` lamports.

## Ejemplo: Obtener el saldo de una cuenta

Consultemos el saldo en SOL del ID del programa Serum V3 (`9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin`) en la red principal. Esta cuenta de programa contiene SOL para la exención de alquiler.

**Nota:** Reemplaza `YOUR_API_KEY` por tu clave de API de Helius en los siguientes ejemplos.

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

## Consejos para desarrolladores

* **Simplicidad para consultar el saldo en SOL:** Si solo necesitas el saldo en SOL de una cuenta y ningún otro dato de la blockchain (como el propietario, los datos o el estado de ejecución), `getBalance` es más eficiente que `getAccountInfo` porque obtiene menos datos.
* **Cuentas inexistentes:** Si una cuenta no existe en la blockchain (nunca se inicializó ni tuvo SOL), `getBalance` devolverá `0`. Esta puede ser una forma rápida de comprobar si una cuenta existe cuando solo te interesa su saldo en SOL.
* **Lamports frente a SOL:** Recuerda que el saldo se devuelve en lamports. Debes dividirlo entre `LAMPORTS_PER_SOL` (1,000,000,000) para convertirlo a SOL.
* **Niveles de compromiso:** La elección de `commitment` puede afectar la rapidez con la que obtienes el saldo y el grado de confirmación de ese saldo. Para la mayoría de las interfaces de usuario, `confirmed` ofrece un buen equilibrio. Para transacciones financieras críticas, `finalized` ofrece la máxima garantía. Consulta [Niveles de compromiso de Solana](https://www.helius.dev/blog/solana-commitment-levels) para obtener información detallada.
* **Procesamiento por lotes con `getMultipleAccounts`:** Aunque `getBalance` sirve para una sola cuenta, si necesitas los saldos de muchas cuentas, usar `getMultipleAccounts` y después extraer el saldo en lamports de la información de cada cuenta puede ofrecer un mejor rendimiento que hacer muchas llamadas individuales a `getBalance`.

## Métodos relacionados

<CardGroup cols={2}>
  <Card title="getAccountInfo" href="/docs/es/api-reference/rpc/http/getaccountinfo">
    Obtén todos los detalles de la cuenta, incluidos los datos, el propietario y el estado de ejecución
  </Card>

  <Card title="getMultipleAccounts" href="/docs/es/api-reference/rpc/http/getmultipleaccounts">
    Obtén varias cuentas por lotes en una sola solicitud
  </Card>
</CardGroup>