getTokenAccountsByDelegate — Solana JSON-RPC

getTokenAccountsByDelegate returns every SPL Token account whose delegate authority has been set to the public key you provide. When a token-account owner calls approve, they grant a delegate the right to transfer up to a fixed amount on their behalf; this method enumerates all accounts that have named a particular delegate.

You must narrow the query with exactly one filter — either a specific mint (only accounts of that token) or a programId (all accounts owned by that token program, typically the SPL Token or Token-2022 program). The result is a positional value array of { pubkey, account } pairs read at a single slot, so the set is internally consistent.

Use jsonParsed encoding to get a decoded token-account object (mint, owner, delegate, token amount) instead of raw bytes — this is usually what you want for displaying delegated balances. This is the delegate-keyed counterpart of getTokenAccountsByOwner, which keys by the account owner instead.

Positional params array: [delegate, filter, config?].

Response fields

The result is a TokenAccountsResponse: an RpcContext plus a value array of { pubkey, account } pairs.

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: "getTokenAccountsByDelegate",
    params: [
      "4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA",
      { programId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      { encoding: "jsonParsed", commitment: "finalized" },
    ],
  }),
});


const { result } = await res.json();
result.value.forEach(({ pubkey, account }) => {
  const info = account.data.parsed.info;
  console.log(pubkey, info.mint, info.delegatedAmount.uiAmountString);
});

• Exactly one filter: the filter object must carry either mint or programId, not both and not neither. Use mint to scope to a single token; use programId (the SPL Token or Token-2022 program) to enumerate every delegated account across all mints.
• Delegate vs. owner: this method matches the token account's delegate authority, not its owner. To list accounts by their owner instead, use getTokenAccountsByOwner.
• Use jsonParsed: for token accounts, jsonParsed decodes the layout into mint, owner, delegate, delegatedAmount, and tokenAmount, which is far easier to work with than raw bytes. Binary encodings (base64, base64+zstd) return the account as a [data, encoding] tuple; base58 only works for data under 129 bytes.
• Consistent snapshot: all accounts are read at the single context.slot, so the returned set is internally consistent.
• 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: getTokenAccountsByOwner (by owner), getTokenLargestAccounts, and getAccountInfo (a single account by its address).