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

# Como Usar getAccountInfo

> Aprenda casos de uso do getAccountInfo, exemplos de código, parâmetros de solicitação, estrutura de resposta e dicas.

O método RPC [`getAccountInfo`](https://www.helius.dev/docs/api-reference/rpc/http/getaccountinfo) é uma ferramenta fundamental para consultar o blockchain Solana. Permite que você recupere todas as informações armazenadas associadas a uma chave pública de conta específica. Isso inclui o saldo de lamports da conta, o programa que a possui, se é executável e seus dados armazenados.

## Casos de Uso Comuns

* **Verificando Saldo SOL:** Determine o saldo SOL nativo de qualquer conta.
* **Verificando Existência da Conta:** Verifique se uma conta com uma determinada chave pública foi inicializada (ou seja, possui lamports ou dados).
* **Inspecionando Contas de Programas:** Recupere os dados armazenados em uma conta pertencente a um programa, o que é crucial para entender o estado de um programa.
* **Identificando o Proprietário da Conta:** Descubra qual programa é o proprietário de uma conta. Isso ajuda a determinar como os dados da conta devem ser interpretados ou se é uma conta pertencente ao sistema.
* **Verificando se uma Conta é Executável:** Identifique se uma conta contém um programa implantado.

## Parâmetros

1. `publicKey` (string, obrigatório): A chave pública codificada em base-58 da conta a ser consultada.

2. `config` (objeto, opcional): Um objeto de configuração com os seguintes campos:
   * `commitment` (string, opcional): Especifica o [nível de compromisso](https://www.helius.dev/blog/solana-commitment-levels) a ser usado para a consulta. O padrão é `finalized`.
     * `finalized`: O nó consultará o bloco mais recente confirmado pela supermaioria do cluster como tendo atingido o bloqueio máximo.
     * `confirmed`: O nó consultará o bloco mais recente que foi votado por uma supermaioria do cluster.
     * `processed`: O nó consultará seu bloco mais recente. Note que o bloco pode não estar completo.
   * `encoding` (string, opcional): A codificação para dados da conta. O padrão é `base64`.
     * `base58` (lento)
     * `base64`
     * `base64+zstd` (se os dados estiverem comprimidos)
     * `jsonParsed`: Se os dados da conta forem um estado de programa conhecido (por exemplo, contas de token, contas de staking), o nó tentará analisá-lo em uma estrutura JSON. Para contas de programas genéricos, geralmente retorna para binário (base64).
   * `dataSlice` (objeto, opcional): Limita os dados da conta retornados a um segmento específico. Disponível apenas para as codificações `base58`, `base64` ou `base64+zstd`.
     * `offset` (número): O número de bytes do início dos dados da conta para começar o segmento.
     * `length` (número): O número de bytes a serem retornados.
   * `minContextSlot` (número, opcional): O slot mínimo em que a solicitação pode ser avaliada.

## Resposta

Se a conta for encontrada, o campo `result` conterá um objeto com duas propriedades principais:

* `context` (objeto): Contém metadados sobre a solicitação.
  * `slot` (número): O slot em que a informação foi recuperada.
  * `apiVersion` (string, opcional): A versão da API RPC.

* `value` (objeto | null): Se a conta não existir, isso será `null`. Caso contrário, é um objeto que contém:
  * `lamports` (número): O número de lamports (1 SOL = 1.000.000.000 lamports) possuídos pela conta.
  * `owner` (string): A chave pública codificada em base-58 do programa que possui esta conta.
  * `data` (array | objeto | string): Os dados armazenados na conta. O formato depende do parâmetro `encoding` usado na solicitação.
    * Para `base64` (padrão), `base58`, `base64+zstd`: Isso geralmente é um array `[encoded_string, encoding_format]`, por exemplo, `["string_data", "base64"]`.
    * Para `jsonParsed`: Isso pode ser um objeto JSON se os dados forem analisáveis pelo nó RPC (por exemplo, para contas de Token SPL). Caso contrário, pode retornar a `["", "base64"]` ou similar se os dados não forem reconhecidos como um layout padrão.
  * `executable` (booleano): `true` se a conta contiver um programa, `false` caso contrário.
  * `rentEpoch` (número): A próxima época em que esta conta deve aluguel.
  * `space` (número, opcional): O comprimento dos dados em bytes. (Nota: Os documentos oficiais do Solana listam `space`, enquanto alguns provedores de RPC podem incluí-lo. Representa o espaço total alocado para os dados da conta). Para mais detalhes sobre [dados de conta e desserialização](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana), consulte nosso guia detalhado.

Se a conta não for encontrada, o campo `value` no resultado será `null`.

## Exemplo: Obtendo Informações da Conta

Vamos obter informações para o ID do Programa Serum V3 (`9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin`) na mainnet.

**Nota:** Substitua `YOUR_API_KEY` pela sua chave de API Helius nos exemplos abaixo.

<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": "getAccountInfo",
    "params": [
      "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
      {
        "encoding": "jsonParsed"
      }
    ]
  }'
  ```

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

  async function getAccountDetails() {
    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 accountInfo = await connection.getAccountInfo(accountPubKey);

      if (accountInfo === null) {
        console.log('Account not found.');
        return;
      }

      console.log('Account Info:');
      console.log(`   Lamports: ${accountInfo.lamports}`);
      console.log(`   Owner: ${accountInfo.owner.toBase58()}`);
      console.log(`   Executable: ${accountInfo.executable}`);
      console.log(`   Rent Epoch: ${accountInfo.rentEpoch}`);
      // Data is a Buffer, you might need to deserialize it based on the account type
      // console.log(`   Data: ${accountInfo.data.toString()}`); 
    } catch (error) {
      console.error('Error fetching account info:', error);
    }
  }

  getAccountDetails();
  ```

  ```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("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg");
  const accountInfo = await rpc.getAccountInfo(publicKey).send();

  console.log("Account Info:", accountInfo);
  ```

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

      println!("{:#?}", account);

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

## Dicas para Desenvolvedores

* **Desempenho:** Para aplicativos que exigem verificações frequentes de várias contas, considere usar `getMultipleAccounts` para agrupar solicitações e reduzir idas e voltas.
* **Desserialização de Dados:** O campo `data` geralmente requer desserialização com base nas estruturas de dados do programa proprietário. Ferramentas e bibliotecas específicas para o programa (por exemplo, biblioteca de Token SPL para contas de token) geralmente são necessárias. Nosso post no blog sobre [desserialização de dados de conta](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana) fornece técnicas e exemplos úteis.
* **Limites de Taxa:** Esteja atento aos limites de taxa do nó RPC, especialmente ao consultar um grande número de contas ou fazer solicitações frequentes.
* **Gestão de Custos:** `getAccountInfo` é geralmente uma consulta de baixo custo, mas a sondagem frequente pode se acumular. Otimize seus padrões de consulta.
* **Use `jsonParsed` com Sabedoria:** Embora `jsonParsed` possa ser conveniente, pode não suportar todos os tipos de conta, e sua saída pode mudar se um programa atualizar suas estruturas de dados. Para aplicativos críticos, analisar dados binários com um layout conhecido oferece mais estabilidade.
* **Considere `dataSlice`:** Se você só precisar de uma pequena parte dos dados de uma conta, use `dataSlice` para reduzir a quantidade de dados transferidos e potencialmente diminuir os custos de consulta.

## Métodos Relacionados

<CardGroup cols={2}>
  <Card title="getMultipleAccounts" href="/docs/pt-BR/api-reference/rpc/http/getmultipleaccounts">
    Obtenha várias contas em uma única solicitação para melhor desempenho
  </Card>

  <Card title="getBalance" href="/docs/pt-BR/api-reference/rpc/http/getbalance">
    Obtenha apenas o saldo SOL sem detalhes completos da conta
  </Card>
</CardGroup>