> ## 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 getMultipleAccounts > Aprenda casos de uso do getMultipleAccounts, exemplos de código, parâmetros de solicitação, estrutura de resposta e dicas. O método RPC [`getMultipleAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getmultipleaccounts) é uma maneira altamente eficiente de buscar informações para uma lista de contas Solana simultaneamente. Em vez de fazer solicitações `getAccountInfo` individuais para cada conta, `getMultipleAccounts` permite que você agrupe essas solicitações, reduzindo a sobrecarga de rede e melhorando a capacidade de resposta da sua aplicação. ## Casos Comuns de Uso * **Carregamento em Lote de Dados de Conta:** Quando seu aplicativo precisa exibir ou processar dados de várias contas conhecidas (por exemplo, contas de token de um usuário, uma lista de configurações de programa on-chain). * **Rastreadores de Portfólio:** Buscando saldos e estados de várias contas de token pertencentes a um usuário. * **Interfaces de Marketplace:** Exibindo detalhes de vários NFTs ou itens listados buscando seus dados de conta de uma só vez. * **Melhoria de Desempenho de dApps:** Reduzindo significativamente o número de chamadas RPC, levando a tempos de carregamento mais rápidos e uma melhor experiência do usuário, especialmente ao lidar com muitas contas. ## Parâmetros de Solicitação 1. **`pubkeys`** (`array` de `string`, obrigatório): * Um array de strings de chave pública codificadas em base-58 para as contas que você deseja consultar. * No máximo 100 chaves públicas por solicitação. * Exemplo: `["So11111111111111111111111111111111111111112", "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"]` 2. **`options`** (`object`, opcional): Um objeto de configuração contendo um ou mais dos seguintes campos: * **`commitment`** (`string`): Especifica o [nível de compromisso](https://www.helius.dev/blog/solana-commitment-levels) para a consulta (por exemplo, `"finalized"`, `"confirmed"`, `"processed"`). * **`encoding`** (`string`): A codificação para os dados da conta. As opções incluem: * `"base64"` (padrão): Codificação padrão base64. * `"base58"`: Mais lenta, mas pode ser útil em alguns contextos. * `"base64+zstd"`: Dados comprimidos zstd codificados em base64. * `"jsonParsed"`: Se a conta for propriedade de um programa para o qual o nó RPC possui um parser (por exemplo, Programa SPL Token, Programa Stake), o campo `data` será um objeto JSON. Isso é muito útil para dados estruturados. * **`dataSlice`** (`object`): Permite buscar apenas uma parte específica dos dados da conta. Isso é útil para contas grandes onde você só precisa de uma pequena parte das informações. * `offset` (`usize`): O deslocamento em bytes a partir do início dos dados da conta. * `length` (`usize`): O número de bytes a retornar a partir do deslocamento. * *Nota: `dataSlice` está disponível apenas para codificações `base58`, `base64` ou `base64+zstd`.* * **`minContextSlot`** (`u64`): O slot mínimo em que a solicitação pode ser avaliada. ## Estrutura de Resposta O objeto de resposta JSON-RPC terá um campo `result` contendo: * **`context`** (`object`): * `slot` (`u64`): O slot no qual a informação foi obtida. * `apiVersion` (`string`, opcional): A versão da API do nó. * **`value`** (`array`): * Um array onde cada elemento corresponde à chave pública no mesmo índice no array `pubkeys` da solicitação. * Cada elemento será: * `null`: Se a conta na chave pública especificada não existir ou ocorrer um erro específico para aquela conta. * Um **Objeto de Conta** com os seguintes campos: * `lamports` (`u64`): O número de lamports de propriedade da conta. * `owner` (`string`): A chave pública codificada em base-58 do programa que possui a conta. * `data` (`array` ou `object`): Os dados da conta. Se `encoding` for `jsonParsed` e existir um parser, isso será um objeto JSON. Caso contrário, é tipicamente um array `["encoded_string", "encoding_format"]` (por exemplo, `["SGVsbG8=", "base64"]`). * `executable` (`boolean`): Indica se a conta contém um programa (é executável). * `rentEpoch` (`u64`): O próximo epoch no qual esta conta deverá alugar. * `space` (`u64`): O comprimento dos dados da conta em bytes. ## Exemplos ### 1. Buscar Informações Básicas para Duas Contas Este exemplo busca dados para duas contas: o SOL Llama (um NFT) e o Serum Dex Program v3. ```bash cURL theme={"system"} # Replace with your Helius API key # SOL Llama Mint: Abug4qgG1x23AEdjS2h9CEJ1m6ha2Z22LdK2kL2pys3F # Serum Dex Program v3: 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \ '{ "jsonrpc": "2.0", "id": 1, "method": "getMultipleAccounts", "params": [ [ "Abug4qgG1x23AEdjS2h9CEJ1m6ha2Z22LdK2kL2pys3F", "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin" ] ] }' ``` ```javascript JavaScript (using @solana/web3.js) theme={"system"} // Replace with your Helius API key const { Connection, PublicKey } = require('@solana/web3.js'); async function fetchMultipleAccountInfo() { const connection = new Connection('https://mainnet.helius-rpc.com/?api-key='); const accountPubkeys = [ new PublicKey('Abug4qgG1x23AEdjS2h9CEJ1m6ha2Z22LdK2kL2pys3F'), // SOL Llama new PublicKey('9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin') // Serum Dex Program v3 ]; try { const accountsInfo = await connection.getMultipleAccountsInfo(accountPubkeys); accountsInfo.forEach((account, index) => { console.log(`--- Account ${index + 1} (${accountPubkeys[index].toBase58()}) ---`); if (account) { console.log(` Owner: ${account.owner.toBase58()}`); console.log(` Lamports: ${account.lamports}`); console.log(` Executable: ${account.executable}`); console.log(` Data length: ${account.data.length}`); // For brevity, not logging full data buffer } else { console.log(" Account not found or error fetching."); } }); } catch (error) { console.error('Error fetching multiple accounts:', error); } } fetchMultipleAccountInfo(); ``` ### 2. Buscar Dados de Conta de Token Analisados Este exemplo busca dados para duas contas SPL Token e solicita a codificação `jsonParsed` para obter dados estruturados. ```bash cURL theme={"system"} # Replace with your Helius API key # Example USDC Token Account 1: GqoZ2MCrdTtygoX1F2b8X7F2tDXxNxyvMvykR9RzQW8p # Example USDT Token Account 2: HYnLMbkaPMh9W2aPNy2yP4LzLSWWw9zSCYEZdX2g2E7m curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \ '{ "jsonrpc": "2.0", "id": 1, "method": "getMultipleAccounts", "params": [ [ "GqoZ2MCrdTtygoX1F2b8X7F2tDXxNxyvMvykR9RzQW8p", "HYnLMbkaPMh9W2aPNy2yP4LzLSWWw9zSCYEZdX2g2E7m" ], { "encoding": "jsonParsed" } ] }' ``` ```javascript JavaScript (using @solana/web3.js) theme={"system"} // Replace with your Helius API key const { Connection, PublicKey } = require('@solana/web3.js'); async function fetchParsedTokenAccounts() { const connection = new Connection('https://mainnet.helius-rpc.com/?api-key='); const tokenAccountPubkeys = [ new PublicKey('GqoZ2MCrdTtygoX1F2b8X7F2tDXxNxyvMvykR9RzQW8p'), // Example USDC account new PublicKey('HYnLMbkaPMh9W2aPNy2yP4LzLSWWw9zSCYEZdX2g2E7m') // Example USDT account ]; try { const accountsInfo = await connection.getMultipleAccountsInfo(tokenAccountPubkeys, 'confirmed'); // Can also pass commitment here // Note: @solana/web3.js's getMultipleAccountsInfo automatically requests jsonParsed if the node supports it for token accounts. // For explicit control with raw RPC, you use the options object as in the cURL example. accountsInfo.forEach((account, index) => { console.log(`--- Token Account ${index + 1} (${tokenAccountPubkeys[index].toBase58()}) ---`); if (account && account.data && typeof account.data !== 'string') { // Check if data is parsed // The actual structure of account.data depends on the program (e.g., SPL Token) // For SPL Token accounts, you'd typically find parsed data in account.data.parsed.info const parsedInfo = (account.data as any).parsed?.info; if (parsedInfo) { console.log(` Mint: ${parsedInfo.mint}`); console.log(` Owner: ${parsedInfo.owner}`); console.log(` Amount: ${parsedInfo.tokenAmount.uiAmountString} (decimals: ${parsedInfo.tokenAmount.decimals})`); } else { console.log(" Account data is not in the expected parsed format or is not a token account."); // console.log("Raw data:", account.data.toString('base64')); // if buffer } } else if (account) { console.log(" Account found, but data is not parsed or is a string (binary data)."); // console.log(" Raw data:", account.data.toString()); // if string } else { console.log(" Account not found or error fetching."); } }); } catch (error) { console.error('Error fetching parsed token accounts:', error); } } fetchParsedTokenAccounts(); ``` ## Dicas para Desenvolvedores * **Máximo de 100 Contas:** Você pode solicitar no máximo 100 contas por chamada. * **Atomicidade:** A solicitação não é atômica no sentido de que, se a busca de uma conta falhar, outras ainda podem ter sucesso. Verifique cada elemento no array `value` quanto a `null`. * **Conveniência `jsonParsed`:** Usar a codificação `jsonParsed` é altamente recomendável ao lidar com tipos comuns de contas, como contas SPL Token, pois isso evita a desserialização manual. * **`dataSlice` para Contas Grandes:** Para contas muito grandes (por exemplo, algumas contas de estado de programa), use `dataSlice` para buscar apenas os bytes necessários e evitar transferência excessiva de dados. * **Tratamento de Erros:** Esteja preparado para lidar com as entradas `null` na resposta na array `value`, indicando que uma conta não foi encontrada ou não pôde ser buscada. Ao aproveitar `getMultipleAccounts`, você pode criar aplicações Solana mais performantes e escaláveis. ## Métodos Relacionados Buscar informações detalhadas para uma única conta Obter todas as contas de propriedade de um programa específico