# RPCX MCP Server

> Connect a coding agent to the RPCX MCP server so it can read the live tables, the rules, and the method language, and validate methods before you run them.

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

The RPCX MCP server gives your coding agent what it needs to write a correct method: the nine live tables and their columns, the rules for reading them in bulk, the method language with example methods, and a validator. It uses the Model Context Protocol, so it works with Claude Code and other MCP clients.

The MCP server never runs a method and never bills you. Methods run only from the dashboard or as `rpcx_` calls with your API key.

The server is at `https://rpcx.mainnet.solana.nolimitnodes.com/mcp`.

## Get a key

Open the **RPCX** page in the [dashboard](https://dash.nolimitnodes.com/app). In **Use with an AI agent**, select **Generate key**. Copy the key when it appears. It starts with `rpcx_mcp_` and is shown once.

The MCP key is not your API key. It only lets an agent read the tables and validate methods. Each workspace has one active key. **Regenerate** creates a new key and revokes the old one. **Revoke** stops the key. An agent with a revoked key gets HTTP `401`, within about a minute.

Treat the key like a password. Do not commit it to a repository.

## Connect Claude Code

The RPCX page shows this command with your key filled in:

```bash
claude mcp add --transport http rpcx https://rpcx.mainnet.solana.nolimitnodes.com/mcp \
  --header "Authorization: Bearer rpcx_mcp_YOUR_KEY"
```

## Connect other clients

The server uses the Streamable HTTP transport with JSON responses. Send the key as a bearer token:

```json
{
  "mcpServers": {
    "rpcx": {
      "type": "http",
      "url": "https://rpcx.mainnet.solana.nolimitnodes.com/mcp",
      "headers": {
        "Authorization": "Bearer rpcx_mcp_YOUR_KEY"
      }
    }
  }
}
```

The server accepts MCP protocol versions `2025-06-18`, `2025-03-26`, and `2024-11-05`.

## Tools

| Tool | Arguments | What it returns |
|---|---|---|
| `list_tables` | `filter` (name substring), `limit` (default 100) | The nine live tables, the key or range filter each one needs, the data each holds, and notes |
| `describe_table` | `name` | Columns, types, and descriptions, the key columns, the scan limit for range reads, and the rules that apply to that table |
| `get_rules` | none | The rules (keys, ranges, bulk reads, joins), the per-query limits, billing, and the method language: the header format, param types including list params, transforms, functions, operators, and example methods for each kind of read |
| `validate_method` | `source` (the method text), optional `args` (test values) | The same checks as the dashboard **Validate** button, with each problem's line and column in the method text |
| `list_my_methods` | none | Your saved methods, the name to call each one by, and its method text |

When the server starts a session, it also sends the correctness rules as instructions, so the agent sees them before it writes anything. The server only teaches the method language. Raw SQL is refused.

The server answers JSON, not a stream, and keeps no session. A check with test values is limited to 30 per key per minute; past that, `validate_method` still runs the static checks and adds a `dry_run_rate_limited` warning.

## Validate before you paste

Ask the agent to validate every method. `validate_method` runs the same checks as the dashboard. It also checks the method on empty tables, which catches problems such as a column that does not exist. The check reads no data from Solana and is not billed. It does not return a cost estimate.

When a method is valid, the result includes `call_as` (`rpcx_`) and a `copy_paste` block. The block tells you what to do in the dashboard, lists the test values the agent used, and holds the method text. The agent is told to end its answer with that block unchanged.

To use it, open the **RPCX** page, select **New Method**, and paste the method text into the **Code** tab. The name and params fill in. Enter the test values in **Params**, select **Save**, then **Run**.

## What to ask for

- Say which addresses the method reads and whether you want to pass many at once. The agent makes a list param such as `wallets: pubkey[]`.
- Say the time range you care about, or ask for current balances and holdings. A method that reads by address should always take a time range: ask for `from` and `to` params.
- Say if an address is very busy, such as a program or a popular mint. The agent can then read a narrower range or a cheaper table, such as `live_signatures`.
- Say which values you want to pass when you call the method, for example a token mint or a time window. The agent makes those params.
- Check the result of a new method before you rely on it.

  ### [Writing methods](/docs/api-reference/rpcx/writing-methods)

The method language and the rules the validator checks.

  ### [Dashboard](/docs/api-reference/rpcx/dashboard)

Paste, validate, save, run, and export.
