getMultipleAccounts — Solana JSON-RPC

getMultipleAccounts fetches the current on-chain state of several accounts at once, identified by their base-58 public keys. It is the batched counterpart of getAccountInfo: instead of one request per account, you pass up to 100 public keys and receive one AccountInfo entry per key, in the same order you requested them.

Use it whenever you would otherwise loop over getAccountInfo — for example to read a set of token accounts, several PDAs, or a basket of mints — to cut latency and stay well within your rate limit. All accounts are read at the same slot, so the returned values are mutually consistent.

The value array is positional and the same length as the pubkeys you sent. Any account that does not exist comes back as a null entry at that position (the surrounding array and context are still populated). The shape of each account's data field depends on the encoding you request, exactly as for getAccountInfo.

Positional params array: [pubkeys, config?].

The second entry is null because no account exists at that public key. The value array is always the same length and order as the pubkeys you sent.

Errors use the standard JSON-RPC envelope (error.code, error.message, error.data).

Example rate-limit response — HTTP 429 with a plain body, not a JSON-RPC envelope:

{
  "error": "rate_limited",
  "message": "Rate limit reached: your free plan allows 20 requests/s for sol_read_rpc. Retry in 1s (see the Retry-After header) or upgrade for a higher limit at https://triport.io/app/pricing",
  "current_tier": "free",
  "category": "sol_read_rpc",
  "limit_rps": 20,
  "burst_capacity": 40,
  "retry_after_sec": 1,
  "upgrade_url": "https://triport.io/app/pricing",
  "docs_url": "https://triport.io/errors/http-429-rate-limit"
}

See the shared errors reference for the full envelope and retry guidance.

JavaScript (fetch)

const res = await fetch("https://triport.io/sol", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "getMultipleAccounts",
    params: [
      [
        "So11111111111111111111111111111111111111112",
        "4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA",
      ],
      { encoding: "jsonParsed", commitment: "finalized" },
    ],
  }),
});


const { result } = await res.json();
result.value.forEach((account, i) => {
  if (account === null) console.log(`account ${i} does not exist`);
  else console.log(account.lamports, account.owner);
});

• 100-key limit: at most 100 public keys per call. Split larger sets across multiple requests and stay within your tier's RPS.
• Positional results: value is parallel to pubkeys — index i of the response always corresponds to index i of the request, with null for any missing account. Don't assume non-null entries; check each.
• Consistent snapshot: every account is read at the single context.slot, so the batch is internally consistent — an advantage over issuing separate getAccountInfo calls.
• Encoding & size: base58 only works for account data smaller than 129 bytes; use base64 or base64+zstd for larger accounts. dataSlice (binary encodings only) fetches just a window of each account's bytes and is ignored by jsonParsed.
• Commitment: use confirmed or processed to see changes sooner when you can tolerate possible rollbacks; finalized is the safest choice for settled state.
• Related methods: getAccountInfo (single account), getBalance (lamports only), and getProgramAccounts (all accounts owned by a program — note its much stricter sol_read_rpc_heavy rate limits of 2 / 5 / 20 / 80 rps).