# RPCX Errors, Limits, and Billing

> RPCX error codes, per-query limits, the monthly plan allowance, buying CU, the compute unit budget per minute, and what each call is billed.

Canonical: https://nolimitnodes.com/docs/api-reference/rpcx/errors-limits

## Error codes

| Code | Kind | Meaning | What to do |
|---|---|---|---|
| `-32601` | `method_not_found` | No saved method with that name in your workspace, or a method that does not start with `rpcx_` | Check the name in the RPCX page. Call it as `rpcx_`. |
| `-32602` | `invalid_params` | A param is missing, has the wrong type, or is out of range | Pass every required param in a named object. |
| `-32002` | `limit_exceeded` | The call hit a per-query limit, such as the 30-second run time, the 10,000-row result, or a range without a key over 3,000 slots | Narrow the `ts` range, add a key, pass fewer addresses, or add filters. |
| `-32003` | `budget_exceeded` | The CU budget for this minute is used up, or 4 runs are already in flight | Retry in the next minute, or after a running call ends. |
| `-32004` | `disabled` | RPCX is not available for this workspace | Contact support. |
| `-32005` | `upstream` | Reading the data failed after retries, or the account service could not be reached | Retry in a moment. |
| `-32006` | `invalid_query` | The method fails validation, for example `live_key_missing` when a live table read has no key and no bounded range | Validate it in the dashboard and fix the errors. |
| `-32007` | `allowance_exhausted` | Your plan's allowance for this month is used up and you have no bought CU left, or the workspace has no paid plan | Buy CU in the RPCX page, or wait for the reset on the 1st of next month. See [When both run out](#when-both-run-out). |
| `-32010` | `unauthorized` | An MCP key that is missing, unknown, or revoked | Generate a new key in the RPCX page. |
| `-32603` | `internal` | Server error | Retry, then contact support with the request ID. |

Every response carries an `x-rpcx-request-id` header. The dashboard shows the same id next to each result. Include it when you contact support.

## Limits per query

| Limit | Value |
|---|---|
| Run time | 30 seconds |
| Transactions read | No cap |
| A range read without a key | 3,000 slots |
| Values in a list param | 1,000 |
| Rows returned by a JSON-RPC call | 10,000 |
| Rows shown by **Run** in the dashboard | 1,000 |
| Rows in an export | 5,000,000 |
| Calls in a batch | 100 |
| Runs in flight per workspace | 4. A fifth call waits up to 2 seconds for a free slot, then fails with `-32003`. |

## Known limits

- **Live data only.** The chain tables hold the latest Solana data, up to the newest blocks. Older history is not available. A range that starts earlier returns only the rows RPCX still has.
- **Account tables are current state.** `live_accounts` and `live_token_accounts` show the state when the method runs. They keep no history.
- **A key or a range.** Every read of a live table needs, in the filter right after `from`, a key (`address`, `sig`, `program` on `live_instructions`, `owner` on `live_token_accounts`) or, on a chain table, a bounded `ts` or `slot` range. `live_blocks` takes a range only. Without one, **Validate** refuses the method with `live_key_missing`, and a call returns `-32006`, `invalid_query`.
- **3,000 slots per range read.** A range without a key reads every block in it, so it may cover at most 3,000 slots. A longer one fails with `-32002` when the method runs. With a key, a range only narrows the read.
- **30 seconds per run.** There is no cap on the number of transactions a run reads, so a run over many busy addresses can hit the time limit. Add a `ts` range or pass fewer addresses per call.

See [Live tables](/docs/api-reference/rpcx/tables) for the columns.

## Compute units

Each run is metered in compute units (CU). The cost is the data the run read, measured after it runs. It is not an estimate. There is no charge per request.

### How CU is calculated

```text
CU = ceil(bytes_read / 1,048,576), at least 1
```

| Work | CU |
|---|---|
| 1 MiB read | 1 |
| A run that reads less than 1 MiB | 1 |

`bytes_read` is the size of the Solana data RPCX reads for the run. There is no charge per request, per address, per transaction, or per row returned. The total is rounded up to a whole number. A run costs at least 1 CU. The price is **$1 per 1,000 CU**.

Example: a run reads 81,540,920 bytes.

```text
81,540,920 / 1,048,576 = 77.76, rounded up to 78 CU = $0.078
```

The cost depends on how much data the method reads, not on how many rows it returns. Full transactions cost more than signatures. A narrow `ts` range and fewer addresses keep it low.

- Always add a `ts` range to a method that reads by address.
- Very busy accounts, such as programs, the USDC mint, or the System Program, have a lot of transactions. A method that reads one of them reads a lot of data.

A method call returns its CU in `result.cu`. The dashboard shows the CU of each **Run**, and the RPCX page lists the CU of every recent call.

### No estimate before a run

RPCX does not show a cost estimate before a run. **Validate** checks the method only. To learn what a method costs, run it once with a short time range or a few addresses and read the CU.

### What is charged

| Case | CU |
|---|---|
| Validate, or a check from the MCP server | 0 |
| A successful run | The work it did |
| A run that fails partway, for example on the 30-second limit | The data it read before it failed |
| A call whose caller disconnects | The run finishes and is billed for the data it read |
| A call refused before any work (budget used up, allowance and bought CU used up, unknown method, invalid method) | 0 |
| An export of a result you already ran, 1,000 rows or fewer | 0. Nothing runs again. |
| An export of a bigger result | The work of the new run |
| An export you cancel | The work done until you cancelled |

## Plan allowance and bought CU

RPCX is a premium add-on. For a limited time it is available on every paid plan at no extra cost. Each plan includes a monthly RPCX allowance. The Free plan has none: running methods needs a paid plan.

| Plan | Per month | CU | MiB read |
|---|---|---|---|
| Enterprise | $100 | 100,000 | 100,000 |
| Max | $60 | 60,000 | 60,000 |
| Ultra | $40 | 40,000 | 40,000 |
| Pro | $20 | 20,000 | 20,000 |
| Free | None | 0 | None |

Every run costs at least 1 CU, so a run that reads less than 1 MiB still uses 1 CU of the allowance. The price does not change: **$1 per 1,000 CU**, with CU counted as in [How CU is calculated](#how-cu-is-calculated).

### The monthly reset

The allowance is a fixed amount for each calendar month. It resets on the 1st of every month at 00:00 UTC. Unused allowance does not carry over. For example, on Pro you use $2 of your $20 in October. November starts at $20 again, not $38.

### Allowance first, then bought CU

Every run is paid in this order:

1. From your plan's allowance for the month, until it is used up.
2. Then from the CU you bought, until they are used up.

Usage never charges your wallet. RPCX is prepaid: the only money it takes is a purchase you make yourself, and there is no bill at the end of the month.

### Buying CU

Buy CU in the **Compute units** panel of the RPCX page:

- A pack of **1,000 CU for $1**, **5,000 CU for $5**, or **25,000 CU for $25**.
- Or a custom amount: a whole number of CU, a multiple of 100, from 1,000 to 1,000,000 CU per purchase. The price is the same, $1 per 1,000 CU.

A purchase is paid from your credits: the balance in your shared NoLimitNodes wallet, the same wallet other pay-as-you-go products use. Select **Add credits** in the RPCX page to add credits by card or crypto, then buy CU. Every purchase asks you to confirm first.

Bought CU never expire. They stay with the workspace until runs use them, and they cannot be turned back into credits. Owners and admins of the workspace can buy CU.

### When both run out

When the allowance for the month is used up and you have no bought CU left, new runs are refused with code `-32007`, kind `allowance_exhausted`:

> Your plan's RPCX allowance for this month is used up and you have no CU left. Buy CU on the RPCX page to keep going, or wait for the allowance reset on 2026-12-01 UTC.

The date is the 1st of the next month. A refused call costs 0 CU. On the RPC endpoint the error comes back with HTTP status `200`, like every JSON-RPC error. **Run** in the dashboard gets HTTP status `402` and shows **Allowance used up** with a **Buy CU** link. Runs start again as soon as you buy CU, or on the 1st when the allowance resets.

A run that is already going when the line is crossed finishes and returns its result. The part of it that neither the allowance nor your bought CU can pay for is not charged.

## Budget per minute

Each plan has a CU budget per minute. RPCX adds up the CU of every call in a minute. When the total reaches the budget, new calls fail with `-32003` until the next minute starts.

| Plan | CU per minute |
|---|---|
| Pro | 8,000 |
| Ultra | 20,000 |
| Max | 40,000 |
| Enterprise | 80,000 |

The budget per minute limits how fast you spend. It is separate from the monthly allowance.

RPCX records the CU of every call by the minute. The RPCX page shows the CU available (plan CU left this month plus bought CU) and the CU of the current month, and updates every 10 seconds. See [Dashboard](/docs/api-reference/rpcx/dashboard#compute-units).
