# FluxRPC — Complete API Reference

> FluxRPC is a high-performance RPC infrastructure for Solana and Fogo blockchains. This file contains the complete API documentation for all supported JSON-RPC methods, WebSocket subscriptions, endpoint configurations, and usage examples.

## Networks & Endpoints

FluxRPC supports two networks. Both use 100% identical Solana JSON-RPC methods.

### Solana

- HTTP: `https://eu.fluxrpc.com?key=<your-API-key>`
- Shield: `https://eu.shield.fluxrpc.com?key=<your-SHIELD-key>`
- WebSocket: `wss://ws.eu.fluxrpc.com`
- Features: Full Solana RPC 2.0, sub-100ms global latency, head-slot data

### Fogo

Fogo is a 100% SVM-compatible blockchain running the Firedancer client with 40ms block times.

- HTTP Mainnet: `https://eu.fogo.fluxrpc.com?key=<your-API-key>`
- Shield Mainnet: `https://eu.shield.fogo.fluxrpc.com?key=<your-SHIELD-key>`
- WebSocket Mainnet: `wss://ws.eu.fogo.fluxrpc.com`
- HTTP Testnet: `https://nyc.fogo.testnet.fluxrpc.com?key=<your-API-key>`
- Shield Testnet: `https://nyc.shield.fogo.testnet.fluxrpc.com?key=<your-SHIELD-key>`
- WebSocket Testnet: `wss://ws.nyc.fogo.testnet.fluxrpc.com`
- Features: 100% Solana RPC compatibility, 40ms block times, Fogo Sessions

## State Commitment Levels

Many methods accept a `commitment` parameter. In descending order of commitment:

- **finalized**: The most recent block confirmed by supermajority as having reached maximum lockout. This is the safest level. (Default)
- **confirmed**: The most recent block voted on by supermajority. Incorporates votes from gossip and replay; upholds "optimistic confirmation" guarantees.
- **processed**: The node's most recent block. Note that the block may still be skipped by the cluster.

For dependent transactions, use `confirmed`. For total safety, use `finalized`.

## RpcResponse Structure

Many methods return an `RpcResponse` JSON object with two parts:
- `context`: An `RpcResponseContext` including a `slot` field at which the operation was evaluated
- `value`: The value returned by the operation itself

## Parsed Responses

Some methods support an `encoding` parameter. When `"encoding":"jsonParsed"` is requested, account data is returned in parsed JSON format. Supported programs: SPL Token, SPL Token 2022, Stake, Vote, Config, BPF Loader, Address Lookup Tables.

---

<!-- docs:rpc-reference:start -->

## HTTP Methods

### Account



### getAccountInfo

Returns all information associated with the account of provided Pubkey.

**Parameters:**
- `pubkey` (string, required): Pubkey of account to query, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level: "finalized", "confirmed", or "processed".
  - `encoding` (string, optional): Encoding for account data: "base58", "base64", "base64+zstd", or "jsonParsed".
  - `dataSlice` (object, optional): Limit the returned account data. Only available for "base58", "base64" or "base64+zstd" encodings.
  - `minContextSlot` (number, optional): The minimum slot that the request can be evaluated at.

**Result:** `object | null` — If the account doesn't exist, result will be null. Otherwise, an object containing:
- `data` (string | [string, encoding] | object): Data associated with the account, either as encoded binary data or JSON format.
- `executable` (bool): Indicates if the account contains a program.
- `lamports` (u64): Number of lamports assigned to this account.
- `owner` (string): Base-58 encoded Pubkey of the program this account has been assigned to.
- `rentEpoch` (u64): The epoch at which this account will next owe rent.
- `space` (u64): The data size of the account.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getAccountInfo",
  "params": [
    "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
    { "commitment": "finalized", "encoding": "base58" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "apiVersion": "2.0.15", "slot": 341197053 },
    "value": {
      "data": ["", "base58"],
      "executable": false,
      "lamports": 88849814690250,
      "owner": "11111111111111111111111111111111",
      "rentEpoch": 18446744073709551615,
      "space": 0
    }
  },
  "id": 1
}
```

### getBalance

Returns the lamport balance of the account of provided Pubkey.

**Parameters:**
- `pubkey` (string, required): Pubkey of account to query, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot that the request can be evaluated at.

**Result:** `u64` — RpcResponse JSON object with value field set to the balance.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBalance",
  "params": [
    "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
    { "commitment": "finalized" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1 },
    "value": 0
  },
  "id": 1
}
```

### getLargestAccounts

Returns the 20 largest accounts, by lamport balance.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `filter` (string, optional): Filter results by account type: "circulating" or "nonCirculating".

**Result:** `array` — An array of objects containing address (base-58 string) and lamports (u64).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLargestAccounts",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 54 },
    "value": [
      { "lamports": 999974, "address": "99P8ZgtJYe1buSK8JXkvpLh8xPsCFuLYhz9hQFNw93WJ" }
    ]
  },
  "id": 1
}
```

### getMultipleAccounts

Returns the account information for a list of Pubkeys.

**Parameters:**
- `pubkeys` (array, required): An array of Pubkeys to query, as base-58 encoded strings (up to 100).
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `encoding` (string, optional): Encoding for account data.
  - `dataSlice` (object, optional): Limit the returned account data.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `array` — An array of account objects or null (for accounts that don't exist).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getMultipleAccounts",
  "params": [
    ["vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg", "4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA"],
    { "commitment": "finalized", "encoding": "base58" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1 },
    "value": [
      { "data": ["", "base58"], "executable": false, "lamports": 1000000000, "owner": "11111111111111111111111111111111", "rentEpoch": 2, "space": 0 },
      { "data": ["", "base58"], "executable": false, "lamports": 5000000000, "owner": "11111111111111111111111111111111", "rentEpoch": 2, "space": 0 }
    ]
  },
  "id": 1
}
```

### getProgramAccounts

Returns all accounts owned by the provided program Pubkey.

**Parameters:**
- `pubkey` (string, required): Pubkey of program, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `encoding` (string, optional): Encoding for account data.
  - `dataSlice` (object, optional): Limit the returned account data.
  - `filters` (array, optional): Filter results using memcmp and/or dataSize.
  - `withContext` (bool, optional): Wrap the result in an RpcResponse JSON object.
  - `minContextSlot` (number, optional): The minimum slot.
  - `changedSinceSlot` (number, optional): Only return accounts that were modified after the specified slot.
  - `cursorFilter` (object, optional): Allows paginating gPA requests by specifying a cursor (public key) and a limit (uint).
    - `limit` (number, required): Maximum number of accounts to return.
    - `cursor` (string, optional): Public key to start pagination from (omit for first page).

**Result:** `array` — Array of JSON objects with pubkey (base-58 string) and account (object).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getProgramAccounts",
  "params": [
    "FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X",
    { "commitment": "finalized", "encoding": "jsonParsed",
    "changedSinceSlot": 406846134,
    "filters": [{ "dataSize": 324 }] }
  ]
}'
```

### getMinimumBalanceForRentExemption

Returns minimum balance required to make account rent exempt.

**Parameters:**
- `dataLength` (usize, required): The account's data length.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `u64` — Minimum lamports required in the account to remain rent free.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getMinimumBalanceForRentExemption",
  "params": [50, { "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1238880,
  "id": 1
}
```

### Block



### getBlock

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

**Parameters:**
- `slot` (u64, required): Slot number.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level ("finalized" or "confirmed").
  - `encoding` (string, optional): Encoding for each returned transaction: "json", "jsonParsed", "base58", "base64".
  - `transactionDetails` (string, optional): Level of transaction detail: "full", "accounts", "signatures", or "none".
  - `maxSupportedTransactionVersion` (number, optional): Highest transaction version to return. Set to 1 to include v1 transactions.
  - `rewards` (bool, optional): Whether to populate the rewards array.

**Result:** `object | null` — If specified block is not confirmed, result will be null.
- `blockHeight` (u64 | null): The number of blocks beneath this block.
- `blockTime` (i64 | null): Estimated production time, as Unix timestamp.
- `blockhash` (string): The blockhash of this block, as base-58 encoded string.
- `parentSlot` (u64): The slot index of this block's parent.
- `previousBlockhash` (string): The blockhash of this block's parent.
- `transactions` (array): Array of transaction objects.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlock",
  "params": [
    430,
    { "commitment": "finalized", "encoding": "json", "maxSupportedTransactionVersion": 1, "transactionDetails": "full", "rewards": false }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "blockHeight": 428,
    "blockTime": null,
    "blockhash": "3Eq21vXNB5s86c62bVuUfTeaMif1N2kUqRPBmGRJhyTA",
    "parentSlot": 429,
    "previousBlockhash": "mfcyqEXB3DnHXki6KjjmZck6YjmZLvpAByy2fj4nh6B",
    "transactions": []
  },
  "id": 1
}
```

### getBlockHeight

Returns the current block height of the node.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `u64` — Current block height.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlockHeight",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1233,
  "id": 1
}
```

### getBlocks

Returns a list of confirmed blocks between two slots.

**Parameters:**
- `startSlot` (u64, required): Start slot.
- `endSlot` (u64, optional): End slot (must be no more than 500,000 blocks higher).
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `array` — Array of u64 integers listing confirmed blocks.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlocks",
  "params": [5, 10, { "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [5, 6, 7, 8, 9, 10],
  "id": 1
}
```

### getBlocksWithLimit

Returns a list of confirmed blocks starting at the given slot.

**Parameters:**
- `startSlot` (u64, required): Start slot.
- `limit` (u64, required): Limit, as u64 (must be no more than 500,000).
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `array` — Array of u64 integers listing confirmed blocks.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlocksWithLimit",
  "params": [5, 3, { "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [5, 6, 7],
  "id": 1
}
```

### getBlockTime

Returns the estimated production time of a block.

**Parameters:**
- `slot` (u64, required): Block slot number.

**Result:** `i64 | null` — Estimated production time, as Unix timestamp (seconds since the Unix epoch).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlockTime",
  "params": [5]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1574721591,
  "id": 1
}
```

### getFirstAvailableBlock

Returns the slot of the lowest confirmed block that has not been purged from the ledger.

On Solana and Fogo Testnet, we don't yet have historical data storage. This will return the oldest cached block. On Fogo Mainnet, we do have historical data storage, and it will return normally.

**Parameters:** None.

**Result:** `u64` — Slot of the lowest confirmed block.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getFirstAvailableBlock"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 250000,
  "id": 1
}
```

### Transaction



### getTransaction

Returns transaction details for a confirmed transaction.

**Parameters:**
- `signature` (string, required): Transaction signature, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `encoding` (string, optional): Encoding for the returned transaction.
  - `maxSupportedTransactionVersion` (number, optional): Highest transaction version to return. Set to 1 to include v1 transactions.

**Result:** `object | null` — If transaction not found, result is null. Otherwise, an object containing slot, transaction, blockTime, and meta.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransaction",
  "params": [
    "2nBhEBYYvfaAe16UMNqRHre4YNSskvuYgx3M6E4JP1oDYvZEJHvoPzyUidNgNX5r9sTyN1J9UxtbCXy2rqYcuyuv",
    { "commitment": "finalized", "encoding": "jsonParsed", "maxSupportedTransactionVersion": 1 }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "slot": 430,
    "transaction": { "message": { "accountKeys": [], "instructions": [] }, "signatures": [] },
    "meta": { "err": null, "fee": 5000, "preBalances": [], "postBalances": [] },
    "blockTime": 1574721591
  },
  "id": 1
}
```

### getTransactionCount

Returns the current Transaction count from the ledger.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `u64` — The current transaction count from the ledger.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionCount",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 268,
  "id": 1
}
```

### getSignaturesForAddress

Returns signatures for confirmed transactions that include the given address in their accountKeys list. Returns signatures backwards in time from the provided signature or most recent confirmed block.

**Parameters:**
- `address` (string, required): Account address as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `limit` (number, optional): Maximum transaction signatures to return (1-1000, default: 1000).
  - `before` (string, optional): Start searching backwards from this signature.
  - `until` (string, optional): Search until this transaction signature.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `array` — Array of transaction signature information objects with signature, slot, err, memo, and blockTime.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    "Vote111111111111111111111111111111111111111",
    { "commitment": "finalized", "limit": 1 }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [
    {
      "blockTime": 1654173549,
      "confirmationStatus": "finalized",
      "err": null,
      "memo": null,
      "signature": "5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv",
      "slot": 114
    }
  ],
  "id": 1
}
```

### getTransactionsForAddress

Transaction history query with advanced filtering, bidirectional sorting, and efficient pagination. This method provides significantly more power than the standard getSignaturesForAddress, with features including:

• Retrieve full transaction data in a single call without additional getTransaction requests
• Time-based filtering with Unix timestamps and slot ranges
• Status filtering for succeeded/failed transactions
• Chronological or reverse-chronological sorting
• Simple pagination with slot:position tokens.

**Parameters:**
- `address` (string, required): Base-58 encoded public key of the account to query transaction history for.
- `config` (object, optional): Configuration object with advanced filtering options.
  - `transactionDetails` (string, optional): Level of detail to return: "signatures" for basic info (up to 1000), or "full" for complete transaction data (up to 100). Default: "signatures".
  - `sortOrder` (string, optional): Sort order: "desc" for newest first (default), or "asc" for chronological order (oldest first).
  - `limit` (number, optional): Maximum transactions to return. Up to 1000 for "signatures" mode, up to 100 for "full" mode.
  - `paginationToken` (string, optional): Pagination token from previous response in format "slot:position".
  - `commitment` (string, optional): Commitment level: "finalized" or "confirmed". Note: "processed" is not supported.
  - `encoding` (string, optional): Encoding format for transaction data (only applies when transactionDetails is "full"). Options: "json", "jsonParsed", "base64", "base58". Default: "json".
  - `maxSupportedTransactionVersion` (number, optional): Highest transaction version to return. Set to 1 to include v1 transactions. If omitted, only legacy transactions are returned.
  - `minContextSlot` (number, optional): The minimum slot that the request can be evaluated at.
  - `filters` (object, optional): Advanced filtering options for narrowing results.
    - `slot` (object, optional): Filter by slot number using comparison operators: gte, gt, lte, lt. Example: { "slot": { "gte": 1000, "lte": 2000 } }
    - `blockTime` (object, optional): Filter by Unix timestamp using comparison operators: gte, gt, lte, lt, eq. Example: { "blockTime": { "gte": 1640995200, "lte": 1641081600 } }
    - `signature` (object, optional): Filter by transaction signature using comparison operators: gte, gt, lte, lt. Example: { "signature": { "lt": "SIGNATURE_STRING" } }
    - `status` (string, optional): Filter by transaction status: "succeeded" (only successful), "failed" (only failed), or "any" (both). Default: "any".
    - `tokenAccounts` (string, optional): Include related token account transactions: "none" (default, only direct references), "balanceChanged" (recommended, includes balance-changing token operations), or "all" (all token account activity).

**Result:** `object` — Object containing data array and optional paginationToken for next page.
- `data` (array): Array of transaction data. Structure depends on transactionDetails parameter.
- `paginationToken` (string | null): Token for fetching the next page in format 'slot:position', or null if no more results. Pass this value as the paginationToken parameter in the next request to continue pagination.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionsForAddress",
  "params": [
    "7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi",
    {
      "transactionDetails": "full",
      "sortOrder": "asc",
      "limit": 10,
      "commitment": "finalized",
      "filters": {
        "blockTime": {
          "gte": 1735689600,
          "lte": 1738368000
        },
        "status": "succeeded",
        "tokenAccounts": "balanceChanged"
      },
      "encoding": "jsonParsed",
      "maxSupportedTransactionVersion": 1
    }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "data": [
      {
        "slot": 123456789,
        "transactionIndex": 5,
        "blockTime": 1735692000,
        "transaction": {
          "signatures": ["5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv"],
          "message": {
            "accountKeys": ["7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi"],
            "recentBlockhash": "EkSnNWid2cvwEVnVx9aBqawnmiCNiDgp3gUdkDPTKN1N",
            "instructions": []
          }
        },
        "meta": {
          "err": null,
          "fee": 5000,
          "preBalances": [1000000000],
          "postBalances": [999995000],
          "innerInstructions": [],
          "logMessages": [],
          "preTokenBalances": [],
          "postTokenBalances": [],
          "rewards": []
        }
      }
    ],
    "paginationToken": "123456790:0"
  },
  "id": 1
}
```

### getSignatureStatuses

Returns the statuses of a list of signatures. Each signature must be a txid, the first signature of a transaction.

**Parameters:**
- `signatures` (array, required): An array of transaction signatures to confirm, as base-58 encoded strings (up to 256).
- `config` (object, optional): Configuration object.
  - `searchTransactionHistory` (bool, optional): If true, a Solana node will search its ledger cache for any signatures not found in the recent status cache.

**Result:** `array` — Array of objects (or null) with slot, confirmations (u64 | null), err (object | null), and confirmationStatus.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignatureStatuses",
  "params": [
    ["5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW"],
    { "searchTransactionHistory": true }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 82 },
    "value": [
      {
        "slot": 72,
        "confirmations": 10,
        "err": null,
        "status": { "Ok": null },
        "confirmationStatus": "finalized"
      }
    ]
  },
  "id": 1
}
```

### getRecentPrioritizationFees

Returns a list of prioritization fees from recent blocks. Currently, a node's prioritization-fee cache stores data from up to 150 blocks.

**Parameters:**
- `addresses` (array, optional): An array of Account addresses (up to 128), as base-58 encoded strings.

**Result:** `array` — Array of objects with slot (u64) and prioritizationFee (u64).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getRecentPrioritizationFees",
  "params": [["CxELquR1gPP8wHe33gZ4QxqGB3sZ9RSwsJ2KshVewkFY"]]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [
    { "slot": 348125, "prioritizationFee": 0 },
    { "slot": 348126, "prioritizationFee": 1000 }
  ],
  "id": 1
}
```

### sendTransaction

Submits a signed transaction to the cluster for processing.

**Parameters:**
- `transaction` (string, required): Fully-signed transaction, as encoded string.
- `config` (object, optional): Configuration object.
  - `encoding` (string, optional): Encoding used for the transaction data ("base58" or "base64", default: "base58").
  - `skipPreflight` (bool, optional): If true, skip the preflight transaction checks.
  - `preflightCommitment` (string, optional): Commitment level for preflight.
  - `maxRetries` (usize, optional): Maximum number of times for the RPC node to retry sending the transaction.
  - `minContextSlot` (number, optional): Set the minimum slot at which to perform preflight checks.

**Result:** `string` — First transaction signature embedded in the transaction, as base-58 encoded string.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "sendTransaction",
  "params": [
    "4hXTCkRzt9WyecNzV1XPgCDfGAZzQKNxLXgynz5QDuWWPSAZBZSHptvWRL3BjCvzUXRdKvHL2b7yGrRQcWyaqsaBCncVG7BFggS8w9snUts67BSh3EqKpXLUm5UMHfD7ZBe9GhARjbNQMLJ1QD3Spr6oMTBU6EhdB4RD8CP2xUxr2u3d6fos36PD98XS6oX8TQjLpsMwncs5DAMiD4nNnR8NBfyghGCWvCVifVwvA8B8TJxE1aiyiv2L429BCWfyzAme5sZW8rDb14NeCQHhZbtNqfXhcp2tAnaAT"
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": "2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR7Bv5j3e7JDAYR6",
  "id": 1
}
```

### simulateTransaction

Simulate sending a transaction.

**Parameters:**
- `transaction` (string, required): Transaction, as an encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `encoding` (string, optional): Encoding used for the transaction data.
  - `sigVerify` (bool, optional): If true, the transaction signatures will be verified.
  - `replaceRecentBlockhash` (bool, optional): If true, the transaction recent blockhash will be replaced.
  - `accounts` (object, optional): Accounts configuration object.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `object` — RpcResponse with err (object | null), logs (array | null), accounts (array | null), unitsConsumed (u64), and returnData.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "simulateTransaction",
  "params": [
    "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMia1tLmq7zz4DinMNN0pJ1JtLdqIJPUw3YrGCzYAMHBsgN27lcgB6H2WQvFgyZuJYHa46puOQo9yQ8CVQbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp20C7Wj6n1P3AVBCUaEIhVGNMf+WhIY3D+5PiWrCDvovAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADz4BSAAAAAAM1M",
    { "commitment": "finalized" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 218 },
    "value": {
      "err": null,
      "accounts": null,
      "logs": ["Program 11111111111111111111111111111111 invoke [1]", "Program 11111111111111111111111111111111 success"],
      "unitsConsumed": 0
    }
  },
  "id": 1
}
```

### getFeeForMessage

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

**Parameters:**
- `message` (string, required): Base-64 encoded message.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `u64 | null` — Fee corresponding to the message at the specified blockhash.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getFeeForMessage",
  "params": [
    "AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA",
    { "commitment": "finalized" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 5068 },
    "value": 5000
  },
  "id": 1
}
```

### getPriorityFeeEstimate

Estimates the priority fee (in microlamports) required for a transaction. This method can also estimate the optimal Jito fee. Requires either a serialized transaction, or an array of Solana account public keys.

**Parameters:**
- `request` (object, required): Requires either a serialized transaction, or an array of Solana account public keys.
  - `transaction` (string, optional): The transaction to calculate priority fees for. Can be base58 or base64 encoded. If a transaction is supplied, the transactionEncoding option must be set accordingly.
  - `accountKeys` (array, optional): If specified in lieu of a transaction, this array of public keys is used to calculate priority fees.
  - `options` (object, optional): Configuration object.
    - `transactionEncoding` (string, optional): Format of the provided transaction, either 'Base58' or 'Base64'.
    - `priorityLevel` (string, optional): The priority level for the transaction, from slowest to fastest: Min, Low, Medium, High, VeryHigh, UnsafeMax.
    - `includeAllPriorityFeeLevels` (boolean, optional): If true, returns estimates for all priority fee levels instead of just one level.
    - `includeJito` (boolean, optional): If set to true, this will additionally estimate the best jito fee.
    - `lookbackSlots` (number, optional): Number of recent slots used to estimate priority fees. Must be between 1 and 150.
    - `includeVote` (boolean, optional): When true, includes Vote transactions in the priority fee calculation.
    - `recommended` (boolean, optional): When true, returns a single recommended fee instead of requiring a priority level.
    - `evaluateEmptySlotAsZero` (boolean, optional): When set, slots with no transactions are treated as zero-fee slots.

**Result:** `object` — A result object containing the estimated priority fee and/or estimates for each priority fee level.
- `priorityFeeEstimate` (float): The estimated priority fee in microlamports.
- `priorityFeeLevels` (object): An object containing fee estimates (microlamports) at different priority fee levels.
- `jitoTipEstimate` (object): An object containing jito fee estimates (microlamports) at different priority fee levels.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getPriorityFeeEstimate",
  "params": [
    {
      "transaction": "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEEjNmKiZGiOtSZ+g0//wH5kEQo3+UzictY+KlLV8hjXcs44M/Xnr+1SlZsqS6cFMQc46yj9PIsxqkycxJmXT+veJjIvefX4nhY9rY+B5qreeqTHu4mG6Xtxr5udn4MN8PnBt324e51j94YQl285GzN2rYa/E2DuQ0n/r35KNihi/zamQ6EeyeeVDvPVgUO2W3Lgt9hT+CfyqHvIa11egFPCgEDAwIBAAkDZAAAAAAAAAA=",
      "options": {
        "transactionEncoding": "Base64",
        "includeAllPriorityFeeLevels": true,
        "includeJito": true
      }
    }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "priorityFeeEstimate": 100000,
    "priorityFeeLevels": {
      "min": 1,
      "low": 510,
      "medium": 8040,
      "high": 100000,
      "veryHigh": 1000000,
      "unsafeMax": 7151020
    },
    "jitoTipEstimate": {
      "low": 1000,
      "medium": 5115,
      "high": 12023804
    }
  }
}
```

### Token



### getTokenAccountBalance

Returns the token balance of an SPL Token account.

**Parameters:**
- `pubkey` (string, required): Pubkey of Token account to query, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `object` — RpcResponse with value containing amount (string), decimals (u8), and uiAmountString (string).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenAccountBalance",
  "params": ["5Dui9R5UUFJuXm911BmijxZcsm5hmx5gBBdvTwzo9zfE", { "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1114 },
    "value": {
      "amount": "9864",
      "decimals": 2,
      "uiAmount": 98.64,
      "uiAmountString": "98.64"
    }
  },
  "id": 1
}
```

### getTokenAccountsByOwner

Returns all SPL Token accounts by token owner.

**Parameters:**
- `pubkey` (string, required): Pubkey of account owner to query, as base-58 encoded string.
- `filter` (object, required): Either { mint: "" } or { programId: "" }.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `encoding` (string, optional): Encoding for account data.
  - `dataSlice` (object, optional): Limit the returned account data.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `array` — Array of JSON objects with pubkey and account information.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenAccountsByOwner",
  "params": [
    "4Qkev8aNZcqFNSRhQzwyLMFSsi94jHqE8WNVTJzTP99F",
    { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
    { "commitment": "finalized", "encoding": "jsonParsed" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1114 },
    "value": [
      {
        "pubkey": "28YTZEwqtMHWrhWcvv34se7pjS7wctgqzCPB3gReCFKp",
        "account": {
          "data": { "parsed": { "info": { "isNative": false, "mint": "3wyAj7Rt1TWVPZVteFCPi2bMFn8recJ9eNhWZaBsKFYR" } } },
          "executable": false,
          "lamports": 1726080,
          "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
        }
      }
    ]
  },
  "id": 1
}
```

### getTokenAccountsByDelegate

Returns all SPL Token accounts by approved delegate.

**Parameters:**
- `pubkey` (string, required): Pubkey of account delegate to query, as base-58 encoded string.
- `filter` (object, required): Either { mint: "" } or { programId: "" }.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `encoding` (string, optional): Encoding for account data.
  - `dataSlice` (object, optional): Limit the returned account data.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `array` — Array of JSON objects with pubkey and account information.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenAccountsByDelegate",
  "params": [
    "4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T",
    { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
    { "commitment": "finalized", "encoding": "jsonParsed" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1114 },
    "value": []
  },
  "id": 1
}
```

### getTokenLargestAccounts

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

**Parameters:**
- `pubkey` (string, required): Pubkey of the token Mint to query, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `array` — Array of objects with address, amount, decimals, and uiAmountString.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenLargestAccounts",
  "params": ["3wyAj7Rt1TWVPZVteFCPi2bMFn8recJ9eNhWZaBsKFYR", { "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1114 },
    "value": [
      { "address": "FYjHNoFtSQ5uijKrZFyYAxvEkiiCGDzfcgG6BoEFAbJL", "amount": "771090", "decimals": 2, "uiAmountString": "7710.90" }
    ]
  },
  "id": 1
}
```

### getTokenSupply

Returns the total supply of an SPL Token type.

**Parameters:**
- `pubkey` (string, required): Pubkey of the token Mint to query, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `object` — RpcResponse with value containing amount, decimals, and uiAmountString.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenSupply",
  "params": ["3wyAj7Rt1TWVPZVteFCPi2bMFn8recJ9eNhWZaBsKFYR", { "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1114 },
    "value": {
      "amount": "100000",
      "decimals": 2,
      "uiAmount": 1000,
      "uiAmountString": "1000"
    }
  },
  "id": 1
}
```

### getTokenAccountsCount

Returns the number of token accounts that have been created for this mint.

**Parameters:**
- `pubkey` (string, required): Pubkey of the mint to query, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `excludeZero` (boolean, optional): If set to true, will exclude zero-balance token accounts from the count. Setting it to false will include zero-balance accounts. Default is false.

**Result:** `u64` — The number of token accounts that have been created for this mint.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenAccountsCount",
  "params": [
       "FLUXBmPhT3Fd1EDVFdg46YREqHBeNypn1h4EbnTzWERX",
       {
         "excludeZero": true
       }
       ]
}'
```

**Example Response:**
```json
{"jsonrpc":"2.0","id":1,"result":16579}
```

### Epoch



### getEpochInfo

Returns information about the current epoch.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `object` — An object containing epoch, slotIndex, slotsInEpoch, absoluteSlot, blockHeight, and transactionCount.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getEpochInfo",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "absoluteSlot": 166598,
    "blockHeight": 166500,
    "epoch": 27,
    "slotIndex": 2790,
    "slotsInEpoch": 8192,
    "transactionCount": 22661093
  },
  "id": 1
}
```

### getEpochSchedule

Returns the epoch schedule information from this cluster's genesis config.

**Parameters:** None.

**Result:** `object` — An object with slotsPerEpoch, leaderScheduleSlotOffset, warmup, firstNormalEpoch, and firstNormalSlot.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getEpochSchedule"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "firstNormalEpoch": 8,
    "firstNormalSlot": 8160,
    "leaderScheduleSlotOffset": 8192,
    "slotsPerEpoch": 8192,
    "warmup": true
  },
  "id": 1
}
```

### Slot



### getSlot

Returns the slot that has reached the given or default commitment level.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `u64` — Current slot.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSlot",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1234,
  "id": 1
}
```

### getSlotLeader

Returns the current slot leader.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `string` — Node identity Pubkey as base-58 encoded string.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSlotLeader",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": "ENvAW7JScgYq6o4zKZwewtkzzJgDzb1wAAj18WBIheGg",
  "id": 1
}
```

### getSlotLeaders

Returns the slot leaders for a given slot range.

**Parameters:**
- `startSlot` (u64, required): Start slot.
- `limit` (u64, required): Limit, as u64 (between 1 and 5,000).

**Result:** `array` — Array of node identity public keys as base-58 encoded strings.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSlotLeaders",
  "params": [100, 10]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [
    "ChorusmmC7i2AQjCWK1h7G3MFUZGKQ5YTPC1ibK4T1fdg",
    "ChorusmmC7i2AQjCWK1h7G3MFUZGKQ5YTPC1ibK4T1fdg",
    "Fud6e2BSAJCjFxwTPGjQdxBNYA4TdS2KPXGKB3zRBx7S"
  ],
  "id": 1
}
```

### getMaxRetransmitSlot

Get the max slot seen from retransmit stage.

**Parameters:** None.

**Result:** `u64` — Slot number.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getMaxRetransmitSlot"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1234,
  "id": 1
}
```

### getMaxShredInsertSlot

Get the max slot seen from after shred insert.

**Parameters:** None.

**Result:** `u64` — Slot number.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getMaxShredInsertSlot"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1234,
  "id": 1
}
```

### minimumLedgerSlot

Returns the lowest slot that the node has information about in its ledger.

**Parameters:** None.

**Result:** `u64` — Minimum ledger slot number.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "minimumLedgerSlot"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": 1234,
  "id": 1
}
```

### Cluster & Node



### getClusterNodes

Returns information about all the nodes participating in the cluster.

**Parameters:** None.

**Result:** `array` — Array of objects with pubkey, gossip, tpu, rpc, version, featureSet, and shredVersion.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getClusterNodes"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [
    {
      "gossip": "10.239.6.48:8001",
      "pubkey": "9QzsJf7LPLj8GkXbYT3LFDKqsj2hHG7TA3xinJHu8epQ",
      "rpc": "10.239.6.48:8899",
      "tpu": "10.239.6.48:8856",
      "version": "1.0.0 c375ce1f"
    }
  ],
  "id": 1
}
```

### getHealth

Returns the current health of the node. A healthy node is one that is within HEALTH_CHECK_SLOT_DISTANCE slots of the latest cluster confirmed slot.

**Parameters:** None.

**Result:** `string` — If the node is healthy: "ok". If the node is unhealthy, a JSON RPC error response is returned.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getHealth"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": "ok",
  "id": 1
}
```

### getIdentity

Returns the identity pubkey for the current node.

**Parameters:** None.

**Result:** `object` — An object with identity (the identity pubkey of the current node, as base-58 encoded string).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getIdentity"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "identity": "2r1F4iWqVcb8M1DbAjQuFpebkQHY9hcVU4WuW2DJBppN"
  },
  "id": 1
}
```

### getVersion

Returns the current Solana version running on the node.

**Parameters:** None.

**Result:** `object` — An object with solana-core (software version) and feature-set (unique identifier of the feature set).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getVersion"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": { "solana-core": "1.15.0", "feature-set": 2891131721 },
  "id": 1
}
```

### getHighestSnapshotSlot

Returns the highest slot information that the node has snapshots for.

**Parameters:** None.

**Result:** `object` — An object with full (highest full snapshot slot) and incremental (highest incremental snapshot slot or null).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getHighestSnapshotSlot"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": { "full": 100, "incremental": 110 },
  "id": 1
}
```

### getGenesisHash

Returns the genesis hash.

**Parameters:** None.

**Result:** `string` — A hash as a base-58 encoded string.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getGenesisHash"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": "GH7ome3EiwEr7tu9JuTh2dpYWBJK3z69Xm1ZE3MEE6JC",
  "id": 1
}
```

### getRecentPerformanceSamples

Returns a list of recent performance samples, in reverse slot order. Performance samples are taken every 60 seconds.

**Parameters:**
- `limit` (usize, optional): Number of samples to return (maximum 720).

**Result:** `array` — Array of objects with slot, numTransactions, numSlots, and samplePeriodSecs.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getRecentPerformanceSamples",
  "params": [4]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [
    { "numSlots": 126, "numTransactions": 992, "numNonVoteTransactions": 10, "samplePeriodSecs": 60, "slot": 348125 },
    { "numSlots": 126, "numTransactions": 984, "numNonVoteTransactions": 8, "samplePeriodSecs": 60, "slot": 347999 }
  ],
  "id": 1
}
```

### Inflation



### getInflationGovernor

Returns the current inflation governor.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `object` — An object with initial, terminal, taper, foundation, and foundationTerm.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getInflationGovernor",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "foundation": 0.05,
    "foundationTerm": 7,
    "initial": 0.15,
    "taper": 0.15,
    "terminal": 0.015
  },
  "id": 1
}
```

### getInflationRate

Returns the specific inflation values for the current epoch.

**Parameters:** None.

**Result:** `object` — An object with total, validator, foundation, and epoch.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getInflationRate"
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "epoch": 100,
    "foundation": 0.001,
    "total": 0.149,
    "validator": 0.148
  },
  "id": 1
}
```

### getInflationReward

Returns the inflation / staking reward for a list of addresses for an epoch.

**Parameters:**
- `addresses` (array, required): An array of addresses to query, as base-58 encoded strings.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `epoch` (u64, optional): An epoch for which the reward occurs.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `array` — Array of objects (or null) with epoch, effectiveSlot, amount, postBalance, and commission.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getInflationReward",
  "params": [
    ["6dmNQ5jwLeLk5REvio1JcMshcbvkYMwy26sJ8pbkvStu", "BGsqMegLpV6n6Ve146sSX2dTjUMj3M92HnU8BbNRMhF2"],
    { "commitment": "finalized", "epoch": 2 }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": [
    { "amount": 2500, "effectiveSlot": 224, "epoch": 2, "postBalance": 499999442500 },
    null
  ],
  "id": 1
}
```

### Stake & Vote



### getStakeMinimumDelegation

Returns the stake minimum delegation, in lamports.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.

**Result:** `u64` — The stake minimum delegation, in lamports.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getStakeMinimumDelegation",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 501 },
    "value": 1000000000
  },
  "id": 1
}
```

### getVoteAccounts

Returns the account info and associated stake for all the voting accounts in the current bank.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `votePubkey` (string, optional): Only return results for this validator vote address.
  - `keepUnstakedDelinquents` (bool, optional): Do not filter out delinquent validators with no stake.
  - `delinquentSlotDistance` (u64, optional): Specify the number of slots behind the tip that a validator must fall to be considered delinquent.

**Result:** `object` — An object with current (array of current vote accounts) and delinquent (array of delinquent vote accounts).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getVoteAccounts",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "current": [
      {
        "commission": 0,
        "epochVoteAccount": true,
        "epochCredits": [[1, 64, 0], [2, 192, 64]],
        "nodePubkey": "B97CCUW3AEZFGy6uUg6zUdnNYvnVq5VG8PUtb2HayTDD",
        "lastVote": 147,
        "activatedStake": 42,
        "votePubkey": "3ZT31jkAGhUaw8jsy4bTknwBKodePJQ4Hmb8kXhSk1Jk"
      }
    ],
    "delinquent": []
  },
  "id": 1
}
```

### Miscellaneous



### getSupply

Returns information about the current supply.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `excludeNonCirculatingAccountsList` (bool, optional): Exclude non circulating accounts list from response.

**Result:** `object` — An object with total, circulating, nonCirculating, and nonCirculatingAccounts.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSupply",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 1114 },
    "value": {
      "circulating": 16000,
      "nonCirculating": 1000000,
      "nonCirculatingAccounts": ["FEy8pTbP5fEoqMV1GdTz83byuA8EKByqYat1PKDgVAq5"],
      "total": 1016000
    }
  },
  "id": 1
}
```

### getLatestBlockhash

Returns the latest blockhash.

**Parameters:**
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `object` — RpcResponse with value containing blockhash (string) and lastValidBlockHeight (u64).

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLatestBlockhash",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 2792 },
    "value": {
      "blockhash": "EkSnNWid2cvwEVnVx9aBqawnmiCNiDgp3gUdkDPTKN1N",
      "lastValidBlockHeight": 3090
    }
  },
  "id": 1
}
```

### isBlockhashValid

Returns whether a blockhash is still valid or not.

**Parameters:**
- `blockhash` (string, required): The blockhash of the block to evaluate, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `minContextSlot` (number, optional): The minimum slot.

**Result:** `bool` — true if the blockhash is still valid.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 45,
  "method": "isBlockhashValid",
  "params": [
    "J7rBdM6AecPDEZp8aPq5iPSNKVkU5Q76F3oAV4eW5wsW",
    { "commitment": "finalized" }
  ]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 2483 },
    "value": false
  },
  "id": 45
}
```

### getLeaderSchedule

Returns the leader schedule for an epoch.

**Parameters:**
- `slot` (u64, optional): Fetch the leader schedule for the epoch that corresponds to the provided slot. If unspecified, the leader schedule for the current epoch is fetched.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level.
  - `identity` (string, optional): Only return results for this validator identity.

**Result:** `object | null` — A dictionary of validator identities and their corresponding leader slot indices.

**Example Request:**
```bash
curl "https://eu.fluxrpc.com?key=<your-API-key>" -s -X POST -H "Content-Type: application/json" -d '
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLeaderSchedule",
  "params": [{ "commitment": "finalized" }]
}'
```

**Example Response:**
```json
{
  "jsonrpc": "2.0",
  "result": {
    "4Qkev8aNZcqFNSRhQzwyLMFSsi94jHqE8WNVTJzTP99F": [0, 1, 2, 3, 4]
  },
  "id": 1
}
```

<!-- docs:rpc-reference:end -->

<!-- docs:ws-reference:start -->

## WebSocket Subscriptions

WebSocket subscriptions follow a subscribe/unsubscribe pattern. Subscribing returns a subscription id, which identifies incoming notifications and cancels the subscription when passed to the matching unsubscribe method.

### Connection

- Solana: `wss://ws.eu.fluxrpc.com`
- Fogo (Mainnet): `wss://ws.eu.fogo.fluxrpc.com`
- Fogo (Testnet): `wss://ws.nyc.fogo.testnet.fluxrpc.com`

### Subscribe Flow

1. **Subscribe:** send a JSON-RPC request with the subscribe method.
2. **Subscribe response:** receive a subscription id.
3. **Notifications:** receive real-time notifications carrying that subscription id.
4. **Unsubscribe:** send the matching unsubscribe method with the subscription id.

### Methods

#### accountSubscribe

Subscribe to an account to receive notifications when the lamports or data for a given account public key changes.

**Parameters:**
- `pubkey` (string, required): Account Pubkey, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level: "processed", "confirmed", or "finalized".
  - `encoding` (string, optional): Encoding for account data: "base58", "base64", "base64+zstd", "binary", or "jsonParsed". Default: "binary".
  - `dataSlice` (object, optional): Limit the returned account data. Only available for "base58", "base64", "base64+zstd" or "binary" encodings.

#### accountUnsubscribe

Unsubscribe from account change notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### logsSubscribe

Subscribe to transaction logging.

**Parameters:**
- `filter` (string | object, required): Filter criteria: "all", "allWithVotes", or { mentions: [""] }.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level: "processed", "confirmed", or "finalized".

#### logsUnsubscribe

Unsubscribe from transaction logging.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### programSubscribe

Subscribe to a program to receive notifications when the lamports or data for an account owned by the given program changes.

**Parameters:**
- `pubkey` (string, required): Program ID Pubkey, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level: "processed", "confirmed", or "finalized".
  - `encoding` (string, optional): Encoding for account data: "base58", "base64", "base64+zstd", "binary", or "jsonParsed". Default: "binary".
  - `dataSlice` (object, optional): Limit the returned account data. Only available for "base58", "base64", "base64+zstd" or "binary" encodings.
  - `filters` (array, optional): Filter results using up to 4 memcmp and/or dataSize filters.
  - `withContext` (bool, optional): Accepted for compatibility; notifications already include context.

#### programUnsubscribe

Unsubscribe from program-owned account change notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### signatureSubscribe

Subscribe to receive a notification when the transaction with the given signature reaches the specified commitment level.

**Parameters:**
- `signature` (string, required): Transaction signature, as base-58 encoded string.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level: "processed", "confirmed", or "finalized".
  - `enableReceivedNotification` (bool, optional): Whether to also send a receivedSignature notification as soon as the node receives the transaction, before it reaches the requested commitment.

#### signatureUnsubscribe

Unsubscribe from signature confirmation notification.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### slotSubscribe

Subscribe to receive notification anytime a slot is processed by the validator.

**Parameters:** None.

#### slotUnsubscribe

Unsubscribe from slot notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### rootSubscribe

Subscribe to receive notification anytime a new root is set by the validator.

**Parameters:** None.

#### rootUnsubscribe

Unsubscribe from root notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### blockSubscribe

Subscribe to receive notification anytime a new block is confirmed or finalized.

**Parameters:**
- `filter` (string | object, required): Filter criteria: "all" or { mentionsAccountOrProgram: "" }.
- `config` (object, optional): Configuration object.
  - `commitment` (string, optional): Commitment level ("finalized" or "confirmed").
  - `encoding` (string, optional): Encoding for each returned transaction: "json", "jsonParsed", "base58", or "base64".
  - `transactionDetails` (string, optional): Level of transaction detail: "full", "accounts", "signatures", or "none".
  - `maxSupportedTransactionVersion` (number, optional): Highest transaction version to return. Set to 1 to include v1 transactions.
  - `showRewards` (bool, optional): Whether to populate the rewards array.

#### blockUnsubscribe

Unsubscribe from block notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### slotsUpdatesSubscribe

Subscribe to receive a notification from the validator on a variety of updates on every slot.

**Parameters:** None.

#### slotsUpdatesUnsubscribe

Unsubscribe from slot-update notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

#### voteSubscribe

Subscribe to receive notification anytime a new vote is observed in gossip.

**Parameters:** None.

#### voteUnsubscribe

Unsubscribe from vote notifications.

**Parameters:**
- `subscriptionId` (number, required): ID of the subscription to cancel.

<!-- docs:ws-reference:end -->

<!-- docs:method-table:start -->

## Quick Reference: All Methods

| Method | Category | Description |
|--------|----------|-------------|
| getAccountInfo | Account | Returns all information associated with the account of provided Pubkey |
| getBalance | Account | Returns the lamport balance of the account of provided Pubkey |
| getLargestAccounts | Account | Returns the 20 largest accounts, by lamport balance |
| getMultipleAccounts | Account | Returns the account information for a list of Pubkeys |
| getProgramAccounts | Account | Returns all accounts owned by the provided program Pubkey |
| getMinimumBalanceForRentExemption | Account | Returns minimum balance required to make account rent exempt |
| getBlock | Block | Returns identity and transaction information about a confirmed block in the ledger |
| getBlockHeight | Block | Returns the current block height of the node |
| getBlocks | Block | Returns a list of confirmed blocks between two slots |
| getBlocksWithLimit | Block | Returns a list of confirmed blocks starting at the given slot |
| getBlockTime | Block | Returns the estimated production time of a block |
| getFirstAvailableBlock | Block | Returns the slot of the lowest confirmed block that has not been purged from the ledger |
| getTransaction | Transaction | Returns transaction details for a confirmed transaction |
| getTransactionCount | Transaction | Returns the current Transaction count from the ledger |
| getSignaturesForAddress | Transaction | Returns signatures for confirmed transactions that include the given address in their accountKeys list |
| getTransactionsForAddress | Transaction | Transaction history query with advanced filtering, bidirectional sorting, and efficient pagination |
| getSignatureStatuses | Transaction | Returns the statuses of a list of signatures |
| getRecentPrioritizationFees | Transaction | Returns a list of prioritization fees from recent blocks |
| sendTransaction | Transaction | Submits a signed transaction to the cluster for processing |
| simulateTransaction | Transaction | Simulate sending a transaction |
| getFeeForMessage | Transaction | Get the fee the network will charge for a particular message |
| getPriorityFeeEstimate | Transaction | Estimates the priority fee (in microlamports) required for a transaction |
| getTokenAccountBalance | Token | Returns the token balance of an SPL Token account |
| getTokenAccountsByOwner | Token | Returns all SPL Token accounts by token owner |
| getTokenAccountsByDelegate | Token | Returns all SPL Token accounts by approved delegate |
| getTokenLargestAccounts | Token | Returns the 20 largest accounts of a particular SPL Token type |
| getTokenSupply | Token | Returns the total supply of an SPL Token type |
| getTokenAccountsCount | Token | Returns the number of token accounts that have been created for this mint |
| getEpochInfo | Epoch | Returns information about the current epoch |
| getEpochSchedule | Epoch | Returns the epoch schedule information from this cluster's genesis config |
| getSlot | Slot | Returns the slot that has reached the given or default commitment level |
| getSlotLeader | Slot | Returns the current slot leader |
| getSlotLeaders | Slot | Returns the slot leaders for a given slot range |
| getMaxRetransmitSlot | Slot | Get the max slot seen from retransmit stage |
| getMaxShredInsertSlot | Slot | Get the max slot seen from after shred insert |
| minimumLedgerSlot | Slot | Returns the lowest slot that the node has information about in its ledger |
| getClusterNodes | Cluster & Node | Returns information about all the nodes participating in the cluster |
| getHealth | Cluster & Node | Returns the current health of the node |
| getIdentity | Cluster & Node | Returns the identity pubkey for the current node |
| getVersion | Cluster & Node | Returns the current Solana version running on the node |
| getHighestSnapshotSlot | Cluster & Node | Returns the highest slot information that the node has snapshots for |
| getGenesisHash | Cluster & Node | Returns the genesis hash |
| getRecentPerformanceSamples | Cluster & Node | Returns a list of recent performance samples, in reverse slot order |
| getInflationGovernor | Inflation | Returns the current inflation governor |
| getInflationRate | Inflation | Returns the specific inflation values for the current epoch |
| getInflationReward | Inflation | Returns the inflation / staking reward for a list of addresses for an epoch |
| getStakeMinimumDelegation | Stake & Vote | Returns the stake minimum delegation, in lamports |
| getVoteAccounts | Stake & Vote | Returns the account info and associated stake for all the voting accounts in the current bank |
| getSupply | Miscellaneous | Returns information about the current supply |
| getLatestBlockhash | Miscellaneous | Returns the latest blockhash |
| isBlockhashValid | Miscellaneous | Returns whether a blockhash is still valid or not |
| getLeaderSchedule | Miscellaneous | Returns the leader schedule for an epoch |
| accountSubscribe | WebSocket | Subscribe to an account to receive notifications when the lamports or data for a given account public key changes |
| accountUnsubscribe | WebSocket | Unsubscribe from account change notifications |
| logsSubscribe | WebSocket | Subscribe to transaction logging |
| logsUnsubscribe | WebSocket | Unsubscribe from transaction logging |
| programSubscribe | WebSocket | Subscribe to a program to receive notifications when the lamports or data for an account owned by the given program changes |
| programUnsubscribe | WebSocket | Unsubscribe from program-owned account change notifications |
| signatureSubscribe | WebSocket | Subscribe to receive a notification when the transaction with the given signature reaches the specified commitment level |
| signatureUnsubscribe | WebSocket | Unsubscribe from signature confirmation notification |
| slotSubscribe | WebSocket | Subscribe to receive notification anytime a slot is processed by the validator |
| slotUnsubscribe | WebSocket | Unsubscribe from slot notifications |
| rootSubscribe | WebSocket | Subscribe to receive notification anytime a new root is set by the validator |
| rootUnsubscribe | WebSocket | Unsubscribe from root notifications |
| blockSubscribe | WebSocket | Subscribe to receive notification anytime a new block is confirmed or finalized |
| blockUnsubscribe | WebSocket | Unsubscribe from block notifications |
| slotsUpdatesSubscribe | WebSocket | Subscribe to receive a notification from the validator on a variety of updates on every slot |
| slotsUpdatesUnsubscribe | WebSocket | Unsubscribe from slot-update notifications |
| voteSubscribe | WebSocket | Subscribe to receive notification anytime a new vote is observed in gossip |
| voteUnsubscribe | WebSocket | Unsubscribe from vote notifications |

<!-- docs:method-table:end -->

<!-- pricing:start -->

## Pricing

FluxRPC plans start free and run from $38/month (Developer) to $849/month (Pro).

- **Free** — $0 · 15 requests/sec · 10 GB bandwidth · includes Websocket Access, Lantern Access, Discord Support · not included: Yellowstone Access
- **Developer** — $38/month or $342/year (save 25%) · 100 requests/sec · 250 GB bandwidth/mo · includes Yellowstone Access, Websocket Access, Lantern Access, Paid Support · $15 for the first month with promo code NEWUSER15
- **Scale** — $349/month or $3,141/year (save 25%) · 300 requests/sec · 3 TB bandwidth/mo · includes Yellowstone Access, Websocket Access, Lantern Access, Priority Support
- **Pro** — $849/month or $7,641/year (save 25%) · 750 requests/sec · 15 TB bandwidth/mo · includes Yellowstone Access, Websocket Access, Lantern Access, Dedicated Priority Support

- Yearly billing saves up to 25% against paying monthly.
- Billing is metered on bandwidth, not request credits.

Full pricing page: https://fluxrpc.com/pricing

<!-- pricing:end -->