RPC Methods

FalconQ RPC supports all standard Solana JSON-RPC methods with sub-100ms latency. Every method below includes curl, Web3.js, and response examples.

Endpoint

POST https://api.falconq.xyz/v1/rpc
Authorization: Bearer fq_rpc_live_YOUR_KEY
Content-Type: application/json

Method Categories

Account Methods Transaction Methods Block Methods Token Methods Network & Cluster Methods Staking & Inflation Methods

Account Methods

getAccountInfo

Returns all information associated with the account of the provided Pubkey.

Parameters: account address (string), configuration object with commitment, encoding (base58, base64, base64+zstd, jsonParsed), and optional dataSlice.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
      { "commitment": "finalized", "encoding": "base64" }
    ]
  }'

// Web3.js
import { Connection, PublicKey } from '@solana/web3.js'

const connection = new Connection('https://api.falconq.xyz/v1/rpc', {
  httpHeaders: { Authorization: 'Bearer fq_rpc_live_YOUR_KEY' },
  commitment: 'confirmed',
})

const accountInfo = await connection.getAccountInfo(
  new PublicKey('vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg')
)
console.log(accountInfo)

Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": { "apiVersion": "2.0.15", "slot": 341197053 },
    "value": {
      "data": ["F7f4N2DYrW...", "base64"],
      "executable": false,
      "lamports": 88849814690250,
      "owner": "11111111111111111111111111111111",
      "rentEpoch": 18446744073709551615,
      "space": 0
    }
  },
  "id": 1
}

getBalance

Returns the lamport balance of the account of the provided Pubkey.

Parameters: account address (string), optional configuration with commitment and minContextSlot.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBalance",
    "params": [
      "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
      { "commitment": "finalized" }
    ]
  }'

// Web3.js
const balance = await connection.getBalance(
  new PublicKey('83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri')
)
console.log('Balance (lamports):', balance)
console.log('Balance (SOL):', balance / 1e9)

Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": { "apiVersion": "2.2.16", "slot": 357068878 },
    "value": 16362443
  },
  "id": 1
}

getMultipleAccounts

Returns account information for multiple Pubkeys in a single request. More efficient than calling getAccountInfo individually.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getMultipleAccounts",
    "params": [
      [
        "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
        "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri"
      ],
      { "encoding": "base64", "commitment": "confirmed" }
    ]
  }'

// Web3.js
const accounts = await connection.getMultipleAccountsInfo([
  new PublicKey('vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg'),
  new PublicKey('83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri'),
])
accounts.forEach((acc, i) => console.log(i, acc?.lamports))

getProgramAccounts

Returns all accounts owned by the provided program address. Supports filters for efficient querying. This is a resource-intensive call — always narrow it with filters.

Filters: memcmp (byte comparison at offset), dataSize (exact data length match).

# curl — Get all Token Program accounts for a specific mint
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getProgramAccounts",
    "params": [
      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      {
        "encoding": "jsonParsed",
        "filters": [
          {
            "memcmp": {
              "offset": 0,
              "bytes": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
            }
          }
        ]
      }
    ]
  }'

// Web3.js — Get all token accounts for USDC mint
const USDC_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
const TOKEN_PROGRAM = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')

const accounts = await connection.getProgramAccounts(TOKEN_PROGRAM, {
  filters: [
    { memcmp: { offset: 0, bytes: USDC_MINT.toBase58() } }
  ],
})
console.log('Found', accounts.length, 'USDC token accounts')

Transaction Methods

getTransaction

Returns transaction details for a confirmed transaction signature.

Parameters: transaction signature (string), configuration with commitment, encoding (json, jsonParsed, base58, base64), and maxSupportedTransactionVersion (set to 0 for versioned transactions).

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTransaction",
    "params": [
      "5Pj5fCupXLUePYn18JkY8SrRaWFiUctuDTRwvUy2ML9yvkENLb1QMYbcBGcBXRrSVDjp7RjUwk9a3rLC6gpvtYpZ",
      {
        "commitment": "confirmed",
        "maxSupportedTransactionVersion": 0,
        "encoding": "json"
      }
    ]
  }'

// Web3.js
import { Connection, type GetVersionedTransactionConfig } from '@solana/web3.js'

const signature = '5Pj5fCupXLUePYn18JkY8SrRaWFiUctuDTRwvUy2ML9y...'

const config: GetVersionedTransactionConfig = {
  commitment: 'confirmed',
  maxSupportedTransactionVersion: 0,
}

const tx = await connection.getTransaction(signature, config)
console.log('Fee:', tx?.meta?.fee)
console.log('Logs:', tx?.meta?.logMessages)

Response

{
  "jsonrpc": "2.0",
  "result": {
    "blockTime": 1746479684,
    "slot": 378917547,
    "meta": {
      "err": null,
      "fee": 5000,
      "preBalances": [1000000000, 0, 1],
      "postBalances": [989995000, 10000000, 1],
      "logMessages": [
        "Program 11111111111111111111111111111111 invoke [1]",
        "Program 11111111111111111111111111111111 success"
      ]
    },
    "transaction": {
      "message": { "accountKeys": ["..."], "instructions": ["..."] },
      "signatures": ["5Pj5fCup..."]
    }
  },
  "id": 1
}

sendTransaction

Submits a signed transaction to the cluster for processing. The returned signature is the transaction identifier.

Parameters: signed transaction (base64 encoded string), optional configuration with skipPreflight, preflightCommitment, maxRetries.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "BASE64_ENCODED_TRANSACTION",
      { "skipPreflight": false, "preflightCommitment": "confirmed" }
    ]
  }'

// Web3.js
import { VersionedTransaction } from '@solana/web3.js'

const base64Tx = 'AbuRLtc5C9bZtAUT4F4Y2H5SRRUK1HwOFZOK3V4qm...'
const tx = VersionedTransaction.deserialize(Buffer.from(base64Tx, 'base64'))

const signature = await connection.sendTransaction(tx, {
  skipPreflight: false,
  preflightCommitment: 'confirmed',
})
console.log('Transaction signature:', signature)

Response

{
  "jsonrpc": "2.0",
  "result": "2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb",
  "id": 1
}

getSignaturesForAddress

Returns confirmed signatures for transactions involving an address, backwards in time. Useful for building transaction history.

Parameters: account address (string), optional configuration with limit (default 1000, max 1000), before, until.

# curl — Get last 10 transactions for an address
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSignaturesForAddress",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
      { "limit": 10, "commitment": "confirmed" }
    ]
  }'

// Web3.js
const signatures = await connection.getSignaturesForAddress(
  new PublicKey('vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg'),
  { limit: 10 }
)
signatures.forEach(sig => {
  console.log(sig.signature, sig.blockTime, sig.err ? 'FAILED' : 'OK')
})

Response

{
  "jsonrpc": "2.0",
  "result": [
    {
      "signature": "5Pj5fCupXLUePYn18JkY8SrRaWFiUctuDTRwvUy2ML9y...",
      "slot": 378917547,
      "blockTime": 1746479684,
      "err": null,
      "memo": null,
      "confirmationStatus": "confirmed"
    }
  ],
  "id": 1
}

getSignatureStatuses

Returns the statuses of a list of transaction signatures. Use this to confirm whether a transaction was processed.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSignatureStatuses",
    "params": [
      ["5Pj5fCupXLUePYn18JkY8SrRaWFiUctuDTRwvUy2ML9y..."],
      { "searchTransactionHistory": true }
    ]
  }'

// Web3.js
const statuses = await connection.getSignatureStatuses([
  '5Pj5fCupXLUePYn18JkY8SrRaWFiUctuDTRwvUy2ML9y...'
], { searchTransactionHistory: true })

statuses.value.forEach((status, i) => {
  console.log(status?.confirmationStatus, status?.err ? 'FAILED' : 'OK')
})

simulateTransaction

Simulates sending a transaction without submitting it. Returns logs, account changes, and compute units consumed.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "simulateTransaction",
    "params": [
      "BASE64_ENCODED_TRANSACTION",
      {
        "encoding": "base64",
        "commitment": "confirmed",
        "sigVerify": false,
        "replaceRecentBlockhash": true
      }
    ]
  }'

// Web3.js
const result = await connection.simulateTransaction(tx, {
  sigVerify: false,
  replaceRecentBlockhash: true,
})
console.log('Logs:', result.value.logs)
console.log('Error:', result.value.err)
console.log('CU consumed:', result.value.unitsConsumed)

Block Methods

getBlock

Returns identity and transaction information about a confirmed block in the ledger.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlock",
    "params": [
      378917547,
      {
        "encoding": "json",
        "transactionDetails": "full",
        "rewards": false,
        "maxSupportedTransactionVersion": 0
      }
    ]
  }'

// Web3.js
const block = await connection.getBlock(378917547, {
  maxSupportedTransactionVersion: 0,
})
console.log('Block time:', block?.blockTime)
console.log('Transactions:', block?.transactions.length)

getLatestBlockhash

Returns the latest blockhash. Required for building transactions.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLatestBlockhash",
    "params": [{ "commitment": "confirmed" }]
  }'

// Web3.js
const { blockhash, lastValidBlockHeight } =
  await connection.getLatestBlockhash('confirmed')
console.log('Blockhash:', blockhash)
console.log('Last valid height:', lastValidBlockHeight)

Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 378917547 },
    "value": {
      "blockhash": "EkSnNWid2cvwEVnVx9aBqawnmiCNiDgp3gUdkDPTKN1N",
      "lastValidBlockHeight": 3090
    }
  },
  "id": 1
}

getSlot

Returns the current slot the node is processing.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSlot"}'

// Web3.js
const slot = await connection.getSlot()
console.log('Current slot:', slot)

getBlockTime

Returns the estimated production time of a block as a Unix timestamp (seconds).

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getBlockTime","params":[378917547]}'

// Web3.js
const blockTime = await connection.getBlockTime(378917547)
console.log('Block time:', new Date(blockTime * 1000).toISOString())

Token Methods

getTokenAccountBalance

Returns the token balance of an SPL Token account.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountBalance",
    "params": ["7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU"]
  }'

// Web3.js
const balance = await connection.getTokenAccountBalance(
  new PublicKey('7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU')
)
console.log('Amount:', balance.value.uiAmountString)
console.log('Decimals:', balance.value.decimals)

Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 378917547 },
    "value": {
      "amount": "1000000000",
      "decimals": 6,
      "uiAmount": 1000.0,
      "uiAmountString": "1000"
    }
  },
  "id": 1
}

getTokenAccountsByOwner

Returns all SPL Token accounts by approved owner. Use this to list all tokens in a wallet.

# curl — Get all token accounts for a wallet
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountsByOwner",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
      { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      { "encoding": "jsonParsed" }
    ]
  }'

// Web3.js — List all tokens in a wallet
const TOKEN_PROGRAM = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')

const tokenAccounts = await connection.getTokenAccountsByOwner(
  new PublicKey('vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg'),
  { programId: TOKEN_PROGRAM },
)

tokenAccounts.value.forEach(({ pubkey, account }) => {
  const info = account.data.parsed.info
  console.log(
    'Mint:', info.mint,
    '| Balance:', info.tokenAmount.uiAmountString,
    '| ATA:', pubkey.toBase58()
  )
})

getTokenSupply

Returns the total supply of an SPL Token type.

# curl — Get USDC total supply
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenSupply",
    "params": ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"]
  }'

// Web3.js
const supply = await connection.getTokenSupply(
  new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
)
console.log('Total supply:', supply.value.uiAmountString)

getTokenLargestAccounts

Returns the 20 largest accounts of a particular SPL Token type.

# curl — Get top USDC holders
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenLargestAccounts",
    "params": ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"]
  }'

// Web3.js
const largest = await connection.getTokenLargestAccounts(
  new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
)
largest.value.forEach((acc, i) => {
  console.log(`#${i + 1}: ${acc.address} — ${acc.uiAmountString}`)
})

Network & Cluster Methods

getHealth

Returns "ok" if the node is healthy. Use this for health checks and monitoring.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getHealth"}'

// Web3.js — No direct method, use raw RPC
const response = await fetch('https://api.falconq.xyz/v1/rpc', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer fq_rpc_live_YOUR_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    jsonrpc: '2.0', id: 1, method: 'getHealth'
  }),
})
const { result } = await response.json()
console.log('Health:', result) // "ok"

getVersion

Returns the current Solana version running on the node.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getVersion"}'

Response

{
  "jsonrpc": "2.0",
  "result": {
    "solana-core": "2.0.15",
    "feature-set": 3244388462
  },
  "id": 1
}

getEpochInfo

Returns information about the current epoch: slot index, slots in epoch, absolute slot, and transaction count.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getEpochInfo"}'

// Web3.js
const epochInfo = await connection.getEpochInfo()
console.log('Epoch:', epochInfo.epoch)
console.log('Slot index:', epochInfo.slotIndex, '/', epochInfo.slotsInEpoch)
console.log('Absolute slot:', epochInfo.absoluteSlot)

getRecentPrioritizationFees

Returns a list of prioritization fees from recent blocks. Useful for estimating priority fees for your transactions.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getRecentPrioritizationFees",
    "params": [["vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg"]]
  }'

// Web3.js
const fees = await connection.getRecentPrioritizationFees([
  new PublicKey('vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg')
])
const medianFee = fees.sort((a, b) => a.prioritizationFee - b.prioritizationFee)[
  Math.floor(fees.length / 2)
]
console.log('Median priority fee:', medianFee.prioritizationFee, 'micro-lamports')

getFeeForMessage

Returns the fee the network will charge for a particular message.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getFeeForMessage",
    "params": ["BASE64_ENCODED_MESSAGE", { "commitment": "confirmed" }]
  }'

getClusterNodes

Returns information about all the nodes participating in the cluster.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getClusterNodes"}'

getSupply

Returns information about the current supply of SOL.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSupply"}'

// Web3.js
const supply = await connection.getSupply()
console.log('Total:', supply.value.total / 1e9, 'SOL')
console.log('Circulating:', supply.value.circulating / 1e9, 'SOL')

Staking & Inflation Methods

getVoteAccounts

Returns the account info and stake of all current and delinquent vote accounts.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getVoteAccounts"}'

// Web3.js
const voteAccounts = await connection.getVoteAccounts()
console.log('Current validators:', voteAccounts.current.length)
console.log('Delinquent:', voteAccounts.delinquent.length)

getInflationRate

Returns the specific inflation values for the current epoch.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getInflationRate"}'

// Web3.js
const inflation = await connection.getInflationRate()
console.log('Total:', (inflation.total * 100).toFixed(2) + '%')
console.log('Validator:', (inflation.validator * 100).toFixed(2) + '%')
console.log('Foundation:', (inflation.foundation * 100).toFixed(2) + '%')
console.log('Epoch:', inflation.epoch)

getStakeMinimumDelegation

Returns the stake minimum delegation in lamports.

# curl
curl -X POST https://api.falconq.xyz/v1/rpc \
  -H "Authorization: Bearer fq_rpc_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getStakeMinimumDelegation"}'

// Web3.js
const minDelegation = await connection.getStakeMinimumDelegation()
console.log('Min delegation:', minDelegation.value / 1e9, 'SOL')

Full Method Reference

FalconQ supports all standard Solana JSON-RPC methods. For the complete parameter and response specifications, see the official Solana RPC documentation.