> ## 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 getMultipleAccounts > Conoce los casos de uso de getMultipleAccounts, ejemplos de código, parámetros de solicitud, estructura de respuesta y consejos. El método RPC [`getMultipleAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getmultipleaccounts) es una forma muy eficiente de obtener simultáneamente información de una lista de cuentas de Solana. En lugar de realizar solicitudes `getAccountInfo` individuales para cada cuenta, `getMultipleAccounts` te permite agrupar estas solicitudes, lo que reduce la sobrecarga de red y mejora la capacidad de respuesta de tu aplicación. ## Casos de uso comunes * **Carga de datos de cuentas por lotes:** Cuando tu aplicación necesita mostrar o procesar datos de varias cuentas conocidas (por ejemplo, las cuentas de tokens de un usuario o una lista de configuraciones de programas en cadena). * **Rastreadores de portafolios:** Obtén los saldos y estados de numerosas cuentas de tokens propiedad de un usuario. * **Interfaces de marketplaces:** Muestra los detalles de varios NFT o artículos publicados mediante la obtención de los datos de sus cuentas en una sola operación. * **Mejora del rendimiento de una dApp:** Reduce considerablemente la cantidad de llamadas RPC, lo que permite tiempos de carga más rápidos y una mejor experiencia de usuario, especialmente cuando se trabaja con muchas cuentas. ## Parámetros de la solicitud 1. **`pubkeys`** (`array` de `string`, obligatorio): * Un arreglo de cadenas de claves públicas codificadas en base 58 para las cuentas que quieres consultar. * Máximo de 100 claves públicas por solicitud. * Ejemplo: `["So11111111111111111111111111111111111111112", "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"]` 2. **`options`** (`object`, opcional): Un objeto de configuración que contiene uno o más de los siguientes campos: * **`commitment`** (`string`): Especifica el [nivel de compromiso](https://www.helius.dev/blog/solana-commitment-levels) para la consulta (por ejemplo, `"finalized"`, `"confirmed"`, `"processed"`). * **`encoding`** (`string`): La codificación de los datos de la cuenta. Las opciones incluyen: * `"base64"` (predeterminada): Codificación base64 estándar. * `"base58"`: Es más lenta, pero puede ser útil en algunos contextos. * `"base64+zstd"`: Datos comprimidos con zstd y codificados en base64. * `"jsonParsed"`: Si la cuenta pertenece a un programa para el cual el nodo RPC tiene un analizador (por ejemplo, SPL Token Program o Stake Program), el campo `data` será un objeto JSON. Esto resulta muy útil para los datos estructurados. * **`dataSlice`** (`object`): Te permite obtener solo una parte específica de los datos de la cuenta. Esto resulta útil para cuentas grandes cuando solo necesitas una pequeña parte de la información. * `offset` (`usize`): El desplazamiento en bytes desde el inicio de los datos de la cuenta. * `length` (`usize`): La cantidad de bytes que se devolverán a partir del desplazamiento. * *Nota: `dataSlice` solo está disponible para las codificaciones `base58`, `base64` o `base64+zstd`.* * **`minContextSlot`** (`u64`): El slot mínimo en el que se puede evaluar la solicitud. ## Estructura de la respuesta El objeto de respuesta JSON-RPC tendrá un campo `result` que contiene: * **`context`** (`object`): * `slot` (`u64`): El slot en el que se recuperó la información. * `apiVersion` (`string`, opcional): La versión de la API del nodo. * **`value`** (`array`): * Un arreglo en el que cada elemento corresponde a la clave pública que se encuentra en el mismo índice del arreglo `pubkeys` de la solicitud. * Cada elemento será uno de los siguientes: * `null`: Si la cuenta de la clave pública especificada no existe o se produjo un error para esa cuenta específica. * Un **objeto de cuenta** con los siguientes campos: * `lamports` (`u64`): La cantidad de lamports que posee la cuenta. * `owner` (`string`): La clave pública codificada en base 58 del programa propietario de la cuenta. * `data` (`array` o `object`): Los datos de la cuenta. Si `encoding` es `jsonParsed` y existe un analizador, será un objeto JSON. De lo contrario, normalmente es un arreglo `["encoded_string", "encoding_format"]` (por ejemplo, `["SGVsbG8=", "base64"]`). * `executable` (`boolean`): Indica si la cuenta contiene un programa, es decir, si es ejecutable. * `rentEpoch` (`u64`): La siguiente época en la que esta cuenta deberá pagar alquiler. * `space` (`u64`): La longitud de los datos de la cuenta en bytes. ## Ejemplos ### 1. Obtén información básica de dos cuentas Este ejemplo obtiene datos de dos cuentas: SOL Llama (un NFT) y 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. Obtén datos analizados de cuentas de tokens Este ejemplo obtiene datos de dos cuentas de SPL Token y solicita la codificación `jsonParsed` para obtener datos estructurados. ```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(); ``` ## Consejos para desarrolladores * **Máximo de 100 cuentas:** Puedes solicitar un máximo de 100 cuentas por llamada. * **Atomicidad:** La solicitud no es atómica en el sentido de que, si la búsqueda de una cuenta falla, las demás aún podrían completarse correctamente. Comprueba si cada elemento del arreglo `value` es `null`. * **Comodidad de `jsonParsed`:** Se recomienda ampliamente usar la codificación `jsonParsed` cuando trabajes con tipos de cuentas comunes, como las cuentas de SPL Token, ya que evita que tengas que deserializarlas manualmente. * **`dataSlice` para cuentas grandes:** Para cuentas muy grandes (por ejemplo, algunas cuentas de estado de programas), usa `dataSlice` para obtener solo los bytes necesarios y evitar la transferencia excesiva de datos. * **Manejo de errores:** Prepárate para manejar entradas `null` en el arreglo `value` de la respuesta. Estas indican que no se encontró una cuenta o que no se pudo obtener. Al aprovechar `getMultipleAccounts`, puedes crear aplicaciones de Solana con mayor rendimiento y escalabilidad. ## Métodos relacionados Obtén información detallada de una sola cuenta Obtén todas las cuentas que pertenecen a un programa específico