# BlockVectra: multi-chain RPC & Data API [Health: Active]

**Category:** 💰 Finance & Fintech  
**Repository:** https://github.com/blockvectra/mcp  
**GitHub Stars:** 0  
**Views:** 9  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/blockvectra-multi-chain-rpc-data-api

## Description
Keyless multi-chain EVM JSON-RPC, indexed Data API, docs, CU pricing and status. API key optional.

## Tools
Capabilities this server exposes over MCP:

- **read_doc** — Read the raw Markdown content of a documentation page from /md/{lang}/{path}.md. Path must be an internal relative path (e.g. 'quickstart', 'guides/ai-agents', 'api/json-rpc', 'chains').
- **search_docs** — Find documentation by topic or task keywords when the page path is unknown. Searches page titles, navigation titles, relative paths, and page summaries, returning titles, relative paths, and summaries. Read a result with read_doc using its path and the same lang; use read_doc directly for a known path or list_docs to browse the documentation catalog. Omit lang for English; limit is 1-20 (default 5). If no results match, try broader keywords or browse list_docs. Available without an API key.
- **list_chains** — Fetch supported blockchain networks and static parameters from `GET /v1/chains`. `methods.allow` and `methods.deny` support wildcard patterns where `deny` takes precedence over `allow`. `state_window_blocks` indicates the historical state window in blocks for state queries (null when full history is available); `max_logs_block_range` limits `eth_getLogs`: the range is inclusive, so `toBlock - fromBlock + 1` must not exceed it, otherwise the call fails with `logs_range_too_large`. `public` describes the keyless endpoint: `public.url` serves only the methods in `public.methods`, and `public.history_blocks` is how far back a block reference may reach on that endpoint (it does not add methods). Pass `chain` (a slug such as `base_mainnet`) to return only that chain.
- **get_status** — Live operational status and network health from `GET /v1/status`. Confirm chain `status` is 'ok' before calling methods; see `list_chains` for static chain capabilities and method policies. For Data API, `data_status` can be 'ok', 'syncing' (queryable and billed normally, but indexing is lagging behind latest block time), or 'unavailable'.
- **get_pricing** — Live prices and plan limits from `GET /v1/plans`. Use before estimating cost or when asked about free credits, rate limits or per-method prices. Units: 1 billing unit = `pricing.cu_per_unit` CU; 1 USD buys `pricing.units_per_usd` units. `method_weights` includes JSON-RPC and Data API CU per call, `push.log` / `push.native_transfer` / `push.token_transfer` per delivered data event, `push.history` per successful history request and `push.address_day` per billable address-day; resolve a method by exact match, then the longest prefix rule ending in `*`, then the `*` row (JSON-RPC only; Data API and push operations have no default). `free.*` values are in billing units; `key_defaults` are per-key CU/s and burst CU. `promo.ends_at` is a sign-up coverage cutoff, not the end of the offer. For a single method's chain support and documentation use get_method_info instead; for projecting cycle costs use estimate_usage instead.
- **estimate_usage** — Calculate projected daily and billing cycle Compute Units (CU) and USD costs for planned call volumes across one or more methods, factoring in method weights and free credit allowances from /v1/plans. Available without an API key. Estimates the API key count for planned traffic under key_defaults. Use this tool for volume budget calculations and capacity planning. For looking up raw system pricing tables, use get_pricing instead. For checking whether a single method is supported on a specific chain, use get_method_info instead. Accepts 'lines' array of {method, calls_per_day} or single 'method' and 'calls_per_day'.
- **how_to_get_api_key** — Get instructions and endpoints for obtaining a BlockVectra API key via preferred programmatic SIWE sign-up or browser handoff, plus authentication header and URL formats for JSON-RPC and Data API.
- **get_method_info** — Inspect a single method's chain-by-chain availability, Compute Unit (CU) weight, price per million calls, and documentation link. Check JSON-RPC method policy and Data API dataset coverage separately. JSON-RPC follows methods.allow and methods.deny from /v1/chains. Data API coverage follows data_features in GET /v1/status, with data enabled in /v1/chains. Pricing comes from /v1/plans. For the full system-wide pricing schedule and rate card, use get_pricing instead. For calculating projected bills for expected call volumes across methods, use estimate_usage instead.
- **explain_error** — Lookup error code, reason, or HTTP status in the official error reference catalog. Returns meaning, billing implications (whether the call was billed), retryability, retry delay, recommended agent action, and documentation URL.
- **list_docs** — List all available documentation pages, relative paths, and titles from the static documentation index, including webhook push subscriptions, signatures, delivery and billing. Available without an API key.
- **rpc_call** — Execute a read-only JSON-RPC 2.0 method on a specified blockchain network using your BlockVectra API key, or via the keyless public endpoint if available on the chain. Chain slugs look like 'base_mainnet'; take them from list_chains. Without a key the call goes to the keyless endpoint `/v1/{chain}/public` (the chain's `public.url` in list_chains), which only serves the methods listed in that chain's `public.methods`. Write methods (such as 'eth_sendRawTransaction') are not supported in rpc_call; use 'send_raw_transaction' instead. Consult the Ethereum JSON-RPC specification (https://ethereum.org/en/developers/docs/apis/json-rpc/) and the BlockVectra method reference (https://docs.blockvectra.com/en/api/json-rpc/methods/). With a key, set the 'x-api-key' or 'Authorization: Bearer <key>' HTTP header in your MCP client configuration for full access (keys must not be passed in tool parameters or chat). Returns the raw JSON-RPC response from the server.
- **data_api_get** — Query the BlockVectra Data API for a specified chain and path using your BlockVectra API key. For endpoint schemas and parameter specifications, see the OpenAPI contract at https://docs.blockvectra.com/openapi/data.yaml. Requires the 'x-api-key' or 'Authorization: Bearer <key>' HTTP header in your MCP client configuration (keys must not be passed in tool parameters or chat). Returns the HTTP status and JSON response body.
- **get_account** — Get the API key's own balance, Compute Units (CU), rate limits, and key parameters from GET /v1/account using your BlockVectra API key. Free and unbilled. Requires the 'x-api-key' or 'Authorization: Bearer <key>' HTTP header in your MCP client configuration (never pass keys in tool parameters or chat). Returns the account's key_id, plan, balance_units, balance_cu, balance_as_of_age_ms, and key limits.
- **get_deposit_address** — Requires an API key. Get your account's dedicated on-chain deposit address and open networks to top up balance; only transfer to the listed networks and tokens.
- **send_raw_transaction** — Broadcast a signed raw transaction to a specified blockchain network via eth_sendRawTransaction. Requires the 'x-api-key' or 'Authorization: Bearer <key>' HTTP header in your MCP client configuration for full access, or uses the keyless public endpoint if permitted on the chain (keys must not be passed in tool parameters or chat). Returns the transaction hash or JSON-RPC error.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "blockvectra-multi-chain-rpc-data-api": {
    "command": "npx",
    "args": ["--yes","@blockvectra/mcp@0.1.0"]
  }
}
```

## Documentation & README

# BlockVectra MCP server

Remote [Model Context Protocol](https://modelcontextprotocol.io) server for [BlockVectra](https://blockvectra.com/en/agents/?ref=gh-mcp): multi-chain EVM JSON-RPC, indexed Data API, docs, CU pricing and status. Documentation, discovery, pricing and status need no API key. Keyless RPC depends on each chain's public method policy; indexed Data API and account tools require your own BlockVectra API key.

[中文](https://github.com/blockvectra/mcp/blob/HEAD/README.zh.md)

## Robinhood Chain mainnet and testnet tasks

Use the [chain RPC guide](https://docs.blockvectra.com/en/guides/robinhood-chain/) for mainnet public read-only RPC tasks. Use the [testnet starter](https://docs.blockvectra.com/en/guides/robinhood-testnet-starter/) and [faucet guide](https://docs.blockvectra.com/en/guides/robinhood-testnet-faucet/) for testnet tasks. Mainnet public reads do not require claiming testnet tokens first.

Connect to `https://docs.blockvectra.com/mcp` without headers for documentation and discovery. Robinhood Chain public endpoints allow supported RPC reads without a key; methods outside the public policy require an API key. Faucet claims require `x-api-key`. HTTP `202` means accepted; check the transaction receipt for on-chain inclusion (`status: "0x1"`), which is not finality.

## Local stdio bridge

Use Node.js 22 or newer to run the MIT-licensed stdio bridge:

```bash
npx --yes @blockvectra/mcp@0.1.0
```

Configure a stdio client:

```json
{
  "mcpServers": {
    "blockvectra-docs": {
      "command": "npx",
      "args": ["--yes", "@blockvectra/mcp@0.1.0"]
    }
  }
}
```

For a source checkout, run `npm ci`, then use `node` with the absolute path to `src/cli.js` instead.

The CLI always bridges to `https://docs.blockvectra.com/mcp`; it accepts no command-line arguments. Optionally supply `BLOCKVECTRA_API_KEY` through the child process environment or your client's private environment settings. It is forwarded only as `x-api-key`. Never put a key in CLI arguments, tool arguments, or chat; never supply private keys.

The bridge connects the official `StreamableHTTPClientTransport` and `StdioServerTransport` directly, without rebuilding capabilities or tools. It preserves initialize parameters/results, capabilities, instructions, protocolVersion, tool results, JSON-RPC errors, notifications and bidirectional requests at the JSON message level (not byte formatting). After a successful initialize response, it sets the HTTP transport's negotiated protocol version before forwarding that response. stdout contains MCP messages only; stderr uses fixed diagnostics without SDK error text. EOF, SIGINT and SIGTERM close both transports; transport failures close the bridge with exit code 1. HTTP/SSE behavior, parsing and reconnection remain SDK behavior.

Dependencies are pinned to official `@modelcontextprotocol/client` and `@modelcontextprotocol/server` **2.3.1**, whose published package exports and source provide these transports and require Node >=20. See the [official SDK repository/releases](https://github.com/modelcontextprotocol/typescript-sdk/releases) and [connection documentation](https://ts.sdk.modelcontextprotocol.io/v2/clients/connect). As of 2026-10-13, [Node's official release table](https://nodejs.org/en/about/previous-releases) lists Node 20 as EOL and Node 22 as LTS, so this package requires **Node >=22**.

Local verification: `npm test` runs only the serial mock HTTP/real stdio subprocess tests; `npm pack --dry-run` checks the package contents. No build is required.

## Install in one step

Server URL (Streamable HTTP, no key needed): `https://docs.blockvectra.com/mcp`

| Client | One-line install | Source |
| --- | --- | --- |
| Claude Code | `claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp` | [MCP in Claude Code](https://code.claude.com/docs/en/mcp) |
| Claude Code plugin (MCP server + `blockvectra-rpc` skill) | `/plugin marketplace add blockvectra/mcp`, then `/plugin install blockvectra-docs@blockvectra` | [Create a marketplace](https://code.claude.com/docs/en/plugin-marketplaces), [Plugin dependencies](https://code.claude.com/docs/en/plugins/dependencies) |
| Cursor | [Add to Cursor](https://cursor.com/link/mcp/install?name=blockvectra-docs&config=eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9) (web link), or open `cursor://anysphere.cursor-deeplink/mcp/install?name=blockvectra-docs&config=eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9` | [MCP install links](https://cursor.com/docs/mcp/install-links), [web link form](https://cursor.com/docs/reference/deeplinks) |
| VS Code | `code --add-mcp '{"name":"blockvectra-docs","type":"http","url":"https://docs.blockvectra.com/mcp"}'` | [Use MCP servers in VS Code](https://code.visualstudio.com/docs/agent-customization/mcp-servers) |
| VS Code (link) | `vscode:mcp/install?%7B%22name%22%3A%22blockvectra-docs%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fdocs.blockvectra.com%2Fmcp%22%7D` | [MCP developer guide](https://code.visualstudio.com/api/extension-guides/ai/mcp) |

The Cursor `config` value is the base64 of `{"url":"https://docs.blockvectra.com/mcp"}`. The VS Code link is the URL-encoded JSON server configuration.

The plugin is described by [`.claude-plugin/marketplace.json`](https://github.com/blockvectra/mcp/blob/HEAD/.claude-plugin/marketplace.json) and [`.claude-plugin/plugin.json`](https://github.com/blockvectra/mcp/blob/HEAD/.claude-plugin/plugin.json). It installs the `blockvectra` MCP server from [`.mcp.json`](https://github.com/blockvectra/mcp/blob/HEAD/.mcp.json) and, as a dependency, the `blockvectra-rpc` skill from [blockvectra/skills](https://github.com/blockvectra/skills).

- **Endpoint:** `https://docs.blockvectra.com/mcp` (Streamable HTTP, stateless)
- **Auth:** optional `x-api-key` header (a BlockVectra API key). `Authorization: Bearer <key>` is also accepted. Without a key you can use the documentation, chain, pricing and status tools, and the JSON-RPC methods that a chain's public endpoint allows.
- **Never** put API keys or private keys in tool arguments or chat; the server reads the key only from HTTP headers.

Chains, prices and limits change, so this README does not list them. Read them live:

- Supported chains: `GET https://api.blockvectra.com/v1/chains`
- Plans, prices and limits: `GET https://console-api.blockvectra.com/v1/plans`
- Service status: `GET https://api.blockvectra.com/v1/status`

More: [BlockVectra for agents](https://blockvectra.com/en/agents/?ref=gh-mcp) and [AI agents guide](https://docs.blockvectra.com/en/guides/ai-agents/?ref=gh-mcp).

## Tools

This table reflects the server currently live at `https://docs.blockvectra.com/mcp`. Call `tools/list` for the authoritative list.

| Tool | What it does | API key | Read / write |
| --- | --- | --- | --- |
| `read_doc` | Read the raw Markdown of a documentation page | not needed | read-only |
| `search_docs` | Keyword search over documentation titles, paths and summaries | not needed | read-only |
| `list_docs` | List all documentation pages | not needed | read-only |
| `list_chains` | Supported chains, static parameters and method policy (`GET /v1/chains`) | not needed | read-only |
| `get_status` | Live service and network status (`GET /v1/status`) | not needed | read-only |
| `get_pricing` | Plans, CU weights and limits (`GET /v1/plans`) | not needed | read-only |
| `estimate_usage` | Estimate CU and USD cost for methods and daily call volumes | not needed | read-only |
| `get_method_info` | Per-chain availability, CU weight and price of a JSON-RPC method | not needed | read-only |
| `explain_error` | Look up an error code or reason: billing, retryability, recommended action | not needed | read-only |
| `how_to_get_api_key` | Steps to get an API key (programmatic SIWE sign-up or browser handoff) and the auth header formats | not needed | read-only |
| `rpc_call` | Execute a read-only JSON-RPC 2.0 method on a chain | optional: without a key only the chain's keyless public endpoint is used, where available | read-only |
| `data_api_get` | Query the Data API for a chain and path | required | read-only |
| `get_account` | Balance, CU and rate limits of your API key (`GET /v1/account`) | required | read-only |
| `get_deposit_address` | Your account's on-chain deposit address and open networks | required | read-only |
| `send_raw_transaction` | Broadcast an already signed raw transaction on a chain | optional: keyless access depends on the chain's public method policy | write (`destructiveHint: true`) |

Note: `get_deposit_address` and the other keyed tools return an error that points to `how_to_get_api_key` when called without a key.

## Use in Cursor / Cline

The keyless Cursor configuration is in [`.mcp.json`](https://github.com/blockvectra/mcp/blob/HEAD/.mcp.json), referenced by the [Cursor plugin manifest](https://github.com/blockvectra/mcp/blob/HEAD/.cursor-plugin/plugin.json). For Cline's Streamable HTTP setup and optional `x-api-key` headers, follow [llms-install.md](https://github.com/blockvectra/mcp/blob/HEAD/llms-install.md). Start without headers: call `list_chains`, then `read_doc` with `{"path":"quickstart","lang":"en"}`.

## Connect a client

Each snippet below follows the client's own documentation. Add the optional key header as that documentation describes for custom headers.

| Client | Official documentation |
| --- | --- |
| Claude Code | [MCP in Claude Code](https://code.claude.com/docs/en/mcp) |
| Cursor | [Model Context Protocol in Cursor](https://cursor.com/docs/context/mcp) |
| VS Code | [Use MCP servers in VS Code](https://code.visualstudio.com/docs/copilot/customization/mcp-servers) |
| Codex | [Codex MCP](https://developers.openai.com/codex/mcp) |

### Claude Code

```bash
claude mcp add --transport http blockvectra https://docs.blockvectra.com/mcp
# For an optional key, use private environment-backed header settings;
# see the Codex env_http_headers example below. Never pass a key as a CLI argument.
```

### Cursor (`mcp.json`)

```json
{
  "mcpServers": {
    "blockvectra-docs": {
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

### VS Code (`.vscode/mcp.json`)

```json
{
  "servers": {
    "blockvectra-docs": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

### Codex (`~/.codex/config.toml`)

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
# optional: read the key from an environment variable
env_http_headers = { "x-api-key" = "BLOCKVECTRA_API_KEY" }
```

## Registry

`server.json` describes this server for the [official MCP Registry](https://registry.modelcontextprotocol.io) under the name `com.blockvectra/docs`. Publishing is a manual workflow (`.github/workflows/publish.yml`).

## License

[MIT](https://github.com/blockvectra/mcp/blob/HEAD/LICENSE)