--- title: Quicknode MCP description: Query live blockchain data and manage Quicknode infrastructure through natural language, using the official MCP server with any compatible AI assistant. tags: [] --- ## Overview > For the complete documentation index, see [llms.txt](/docs/llms.txt) The **Quicknode MCP server** connects your Quicknode account to MCP-compatible AI assistants like ChatGPT, Codex, Claude Code, Claude Desktop, Cursor, VS Code, and more. Once connected, you can read live blockchain data, create and manage endpoints, monitor usage, configure security settings, and review billing data through natural language instead of navigating the dashboard or writing API scripts. The server is hosted remotely at `https://mcp.quicknode.com/mcp` and authenticates via OAuth. Its tools reach Quicknode over two paths. The account tools call Quicknode's [Admin API](/docs/admin-api). The `call-rpc` tool reads the blockchain directly through [Tooling Access](#blockchain-rpc-calls), an account-level setting that covers every network Quicknode supports. The assistant interprets your request, selects the appropriate tool, and executes it after confirmation. TL;DR - Read live blockchain data with the `call-rpc` tool. No endpoint provisioning required. An Admin enables Tooling Access once for the account. See [Blockchain RPC Calls](#blockchain-rpc-calls) - Quicknode is an [official connector](https://claude.com/connectors/quicknode) in the **Anthropic MCP directory** — add it [directly](https://claude.ai/directory/connectors/356a8580-5936-40a0-9a06-5ab54bdaa344) or find it under **Customize** > **Connectors** in Claude - Quicknode is also available natively in **ChatGPT** and **Codex** — install directly from the [ChatGPT Apps catalog](https://chatgpt.com/apps/quicknode/asdk_app_69ca79775c848191a5f1e538e77aedbb) or via `/plugin` in Codex - All other clients (Cursor, VS Code, Windsurf, Zed) connect by pointing to `https://mcp.quicknode.com/mcp` and authorizing via OAuth - For CI/CD and non-interactive environments, skip OAuth and pass an API key directly — see [Using an API Key](#using-an-api-key) - Manage endpoints, monitor usage, configure security rules, and review billing through natural language, no dashboard or API scripts required ## Requirements - A [Quicknode account](https://www.quicknode.com/signup) - An MCP-compatible AI assistant (ChatGPT, Codex, Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Zed, or similar) ## Configuration Add the Quicknode MCP server to your assistant using the instructions for your client below. **Claude** #### Claude Web Quicknode is an [official connector](https://claude.com/connectors/quicknode) in the Anthropic MCP directory. To connect it in Claude: 1. Visit the [Quicknode connector page](https://claude.ai/directory/connectors/356a8580-5936-40a0-9a06-5ab54bdaa344), or open [Claude](https://claude.ai/) in your browser and navigate to **Customize** > **Connectors** to find Quicknode in the directory 2. Click **Connect** 3. A browser window will open — log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access #### Claude Desktop To add the Quicknode MCP server to the Claude Desktop app: 1. Navigate to **Customize** > **Connectors** 2. Find **Quicknode** in the directory and click **Connect** 3. A browser window will open — log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access #### Claude Code To add the Quicknode MCP server to Claude Code, run the following command in your terminal: 1. Add the server: ```bash claude mcp add --transport http quicknode https://mcp.quicknode.com/mcp ``` 2. Start Claude Code and type `/mcp` to authorize the server in the browser window that opens Installation Scopes By default, the command above installs the server in **local** scope (current project only). Claude Code supports three scopes: - **Local** (default) — Available only to you in the current project - **Project** (`--scope project`) — Shared with your team via a `.mcp.json` file in the project root - **User** (`--scope user`) — Available to you across all projects To install globally for your user, add the `--scope user` flag: ```bash claude mcp add --transport http --scope user quicknode https://mcp.quicknode.com/mcp ``` **OpenAI** #### ChatGPT To connect the Quicknode MCP server to ChatGPT: 1. Visit the [Quicknode app on ChatGPT](https://chatgpt.com/apps/quicknode/asdk_app_69ca79775c848191a5f1e538e77aedbb), or open [ChatGPT](https://chatgpt.com), go to **Apps** in the sidebar, and search for **Quicknode** 2. Click **Connect** on the Quicknode app page 3. A browser window opens at `mcp.quicknode.com` where you log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access 4. Quicknode is now available in your ChatGPT conversations. Mention **@Quicknode** in any chat to use it #### Codex To add Quicknode to Codex (OpenAI): 1. Open Codex and type `/plugin` in the input 2. Browse the available plugins and select **Quicknode** 3. Press Enter to view details, then select **Install plugin** 4. If you have not already connected via ChatGPT, a browser window opens for OAuth authorization where you log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access 5. After installation, Quicknode tools are available in your Codex sessions tip If you have already connected Quicknode in ChatGPT, the authorization step is skipped and the plugin is ready to use immediately. **Cursor** To add the Quicknode MCP server to Cursor: 1. Go to **Settings** > **Tools & MCPs**, and click **New MCP Server** 2. (Optionally) Open (or create) `.cursor/mcp.json` in your project root or home directory 3. Add the following configuration: ```json { "mcpServers": { "quicknode": { "url": "https://mcp.quicknode.com/mcp" } } } ``` 4. Once you save the file, Cursor will detect the new server configuration. 5. Click **Connect** next to the Quicknode MCP server in the Cursor interface 6. A browser window will open where you can log in with your Quicknode account and approve access **VS Code** To add the Quicknode MCP server to VS Code (GitHub Copilot): 1. Open the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`) 2. Search for **"MCP: Add Server"** 3. Select **"HTTP"** as the server type 4. Enter the URL: `https://mcp.quicknode.com/mcp` 5. Choose whether to save to **User Settings** (global) or **Workspace Settings** (project-only) Alternatively, add this to your `.vscode/mcp.json`: ```json { "mcp": { "servers": { "quicknode": { "type": "http", "url": "https://mcp.quicknode.com/mcp" } } } } ``` **Windsurf** To add the Quicknode MCP server to Windsurf: 1. Open **Windsurf Settings** > **Cascade** > **MCP** > **Add Server** > **Add custom server** 2. This opens `~/.codeium/windsurf/mcp_config.json`. Add: ```json { "mcpServers": { "quicknode": { "serverUrl": "https://mcp.quicknode.com/mcp" } } } ``` 3. Click the refresh button in the MCP section of settings to activate **Zed** To add the Quicknode MCP server to Zed: 1. Open **Settings** (`Cmd+,` / `Ctrl+,`) 2. Add the following to your `settings.json`: ```json { "context_servers": { "quicknode": { "transport": "http", "url": "https://mcp.quicknode.com/mcp" } } } ``` 3. Restart Zed to activate the server **Other Clients** For any other MCP-compatible client, use the following connection details: - **URL:** `https://mcp.quicknode.com/mcp` - **Transport:** Streamable HTTP - **Authentication:** OAuth 2.1 (handled automatically on first connect) If your client doesn't support OAuth or HTTP transport natively, you can use `mcp-remote` as a bridge: ```json { "mcpServers": { "quicknode": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp"] } } } ``` ## Authentication and Roles When you connect for the first time, a browser window opens where you log in with your Quicknode account. If you belong to multiple Quicknode accounts, you'll choose which one to connect. You will then select an **API key role** that determines what the MCP server can do on your behalf: - **Viewer** — Read-only access. Your assistant can read live blockchain data with `call-rpc`, list endpoints, and view metrics, logs, usage, and billing data, but cannot create, modify, or delete any resources. - **Admin** — Everything the Viewer role can do, plus write access. Your assistant can create and delete endpoints, modify security rules, update rate limits, enable or disable Tooling Access, and manage all account resources. This process creates an API key under the hood, scoped to the role you selected. You do not need to create or manage the key yourself. Choosing the Right Role Choose the **Viewer** role if you only need to inspect your infrastructure. Use **Admin** only when you need the assistant to make changes. If you need to switch roles later, remove the server from your client, re-add it, and go through the authorization flow again to re-authenticate with a different role. ## Using an API Key If you're running in a non-interactive environment where a browser-based login isn't possible (e.g., CI/CD pipelines, remote VMs, or automation agents), you can skip the OAuth flow by passing your API key as a bearer token. The MCP server recognizes the `Authorization` header and treats the request as already authenticated. Generate an API key from the [Quicknode Dashboard](https://dashboard.quicknode.com/api-keys) under **Account (_avatar icon_) > API Keys**. The role you assign to the key (Admin or Viewer) determines the MCP server's permissions, the same as choosing a role during the OAuth flow. **Claude** #### Claude Code Pass your API key as a bearer token using the `--header` flag: ```bash claude mcp add quicknode --transport http https://mcp.quicknode.com/mcp --header "Authorization: Bearer YOUR_API_KEY" ``` #### Claude Desktop Add the `--header` flag to the `mcp-remote` arguments in your `claude_desktop_config.json`: ```json { "mcpServers": { "quicknode": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp", "--header", "Authorization: Bearer YOUR_API_KEY"] } } } ``` **OpenAI** #### Codex Pass your API key as a bearer token using the `--bearer-token-env-var` flag, which tells Codex to read the key from an environment variable at runtime: ```bash codex mcp add quicknode \ --url https://mcp.quicknode.com/mcp \ --bearer-token-env-var YOUR_API_KEY ``` Run `codex mcp list` to confirm the server is registered. **Cursor** Add the following to your `.cursor/mcp.json`: ```json { "mcpServers": { "quicknode": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp", "--header", "Authorization: Bearer YOUR_API_KEY"] } } } ``` **VS Code** Add the `headers` field to your `.vscode/mcp.json`: ```json { "mcp": { "servers": { "quicknode": { "type": "http", "url": "https://mcp.quicknode.com/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } } ``` **Windsurf** Add the `headers` field to your `~/.codeium/windsurf/mcp_config.json`: ```json { "mcpServers": { "quicknode": { "serverUrl": "https://mcp.quicknode.com/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ``` **Zed** Add the `headers` field to your `settings.json`: ```json { "context_servers": { "quicknode": { "transport": "http", "url": "https://mcp.quicknode.com/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ``` **Other Clients** For any client that supports custom headers, set: ```text Authorization: Bearer YOUR_API_KEY ``` If your client uses `mcp-remote`, add the `--header` flag: ```json { "mcpServers": { "quicknode": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp", "--header", "Authorization: Bearer YOUR_API_KEY"] } } } ``` ## Blockchain RPC Calls The `call-rpc` tool reads live blockchain data. It sends a read-only JSON-RPC request through your account's **Tooling Access** setting, which covers every network Quicknode supports. You do not need to create an endpoint. An Admin turns it on once with `enable-tooling-access`, or checks the current state with the [Admin API](/docs/admin-api/tooling-access/v0-tooling-access). The same setting powers `qn rpc call` in the [CLI](/docs/cli) and the `rpc` client in the [SDK](/docs/sdk), so enabling it covers all three. One tool reaches every chain family. `eth_getBalance` on `base-mainnet`, `getSlot` on `solana-mainnet`, and `getblockcount` on `btc` all go through `call-rpc`, routed by network slug. Calls are read-only. Write methods return an error instead of broadcasting: ```text RPC method eth_sendRawTransaction is not allowed. Only registered read-only methods may be called. ``` To send transactions, create a dedicated endpoint with `create-endpoint` and call it from your own code. Disabling Is Account-Wide `disable-tooling-access` turns the setting off for the whole account. It cuts off RPC access for every Quicknode developer tool, including the CLI and the SDK, not just the assistant you are working in. ## Available Tools The MCP server exposes the following tools. Tools marked as **read-only** are available to both **Admin** and **Viewer** roles. All other tools require the **Admin** role. ### Blockchain RPC Read live blockchain data, and control the account setting that enables it. See [Blockchain RPC Calls](#blockchain-rpc-calls). | Tool | Description | Access | | --- | --- | --- | | call-rpc | Call a read-only JSON-RPC method on any supported network | read-only | | enable-tooling-access | Turn on Tooling Access for your account so Quicknode developer tools can make RPC calls | admin | | disable-tooling-access | Turn off Tooling Access for the whole account | admin | ### Endpoint Management Create, read, update, and delete Quicknode endpoints across any supported chain and network. | Tool | Description | Access | | --- | --- | --- | | list-endpoints | List all endpoints on your account | read-only | | get-endpoint | Get details for a specific endpoint | read-only | | create-endpoint | Create a new endpoint on a specified chain and network | admin | | delete-endpoint | Delete an endpoint | admin | | get-endpoint-metrics | Retrieve performance metrics for an endpoint | read-only | | list-endpoint-logs | Fetch recent logs for an endpoint | read-only | | get-endpoint-log-details | Get detailed information for a specific log entry | read-only | ### Rate Limits Configure method-level and endpoint-level rate limits. | Tool | Description | Access | | --- | --- | --- | | update-endpoint-rate-limits | Set overall rate limits (RPS, RPM, RPD) for an endpoint | admin | | list-endpoint-method-rate-limits | List method-specific rate limits | read-only | | create-endpoint-method-rate-limit | Add a rate limit for a specific RPC method | admin | | update-endpoint-method-rate-limit | Update an existing method rate limit | admin | | delete-endpoint-method-rate-limit | Remove a method rate limit | admin | ### Security Manage authentication and access control settings for endpoints. The `create-security-rule` and `delete-security-rule` tools support multiple rule types: IP allowlists, JWT validation, referrer restrictions, domain masks, and authentication tokens. | Tool | Description | Access | | --- | --- | --- | | list-endpoint-security | View current security settings and rules | read-only | | update-endpoint-security-options | Enable or disable security features (CORS, HSTS, IP filtering, etc.) | admin | | create-security-rule | Add a security rule (IP, JWT, referrer, domain mask, or token) | admin | | delete-security-rule | Remove a security rule | admin | ### Usage and Billing Monitor RPC usage and review billing information. | Tool | Description | Access | | --- | --- | --- | | get-rpc-usage | Get RPC usage with optional breakdown by endpoint, method, or chain | read-only | | get-billing | View billing invoices or payment history | read-only | ### Chains Query available chains and networks. | Tool | Description | Access | | --- | --- | --- | | list-chains | List all supported chains and their available networks | read-only | ## MCP Resources In addition to tools, the Quicknode MCP server exposes your endpoints as **MCP resources**. Resources let your AI assistant reference endpoint details directly in context without needing to call a tool first. In clients that support MCP resources, you can type `@quicknode` to browse and attach your endpoints to the conversation (e.g., `quicknode://endpoints/`). This is useful when you want the assistant to have your endpoint configuration readily available while working on a task, such as writing code that targets a specific chain or debugging a request. ## Example Prompts You do not need to reference tool names directly. The AI assistant maps natural language to the appropriate tool. Some examples: **Live blockchain data:** - "What is the current block number on Base?" - "Get the balance of 5s3vajJvaAbabQvxFdiMfg14y23b2jvK6K2Mw4PYcYK on Solana mainnet" - "Read the latest block on Ethereum and on Arbitrum, then compare the timestamps" **Endpoint management:** - "Create a new Base mainnet endpoint" - "Show me all my endpoints and their current status" **Monitoring and debugging:** - "Check the logs for my Arbitrum endpoint from the last hour" - "Show me the performance metrics for my Ethereum endpoint over the past week" **Security:** - "Add JWT authentication to my Ethereum mainnet endpoint" - "Review security settings across all endpoints" **Usage and billing:** - "Show me my RPC usage broken down by chain for this month" - "Which endpoint is using the most credits this month?" **Rate limiting:** - "Set a rate limit of 100 requests per second on my Polygon endpoint" - "Add a method-specific rate limit for eth_call" tip - **Start simple** — Try asking "What endpoints do I have?" or "Show me my usage for this month" to get familiar with the available tools. - **Be specific** — When you have multiple endpoints, mention the chain or name to help the assistant find the right one quickly. ## How It Works The MCP server is hosted remotely at `https://mcp.quicknode.com/mcp` and uses OAuth 2.1 for authentication. When your AI assistant receives a request, it calls the appropriate MCP tool. Account tools go to the Admin API, and `call-rpc` goes to Tooling Access. The assistant then formats the response and presents it in natural language. - **Account tools** send authenticated requests to the Quicknode [Admin API](/docs/admin-api). This covers endpoints, rate limits, security rules, logs, metrics, usage, and billing. - **`call-rpc`** sends the JSON-RPC request to your account's Tooling Access URL. The server mints a short-lived credential for the call, so there is no endpoint or long-lived credential in your configuration. Write operations (creating endpoints, modifying security settings, deleting resources, changing the Tooling Access setting) require the **Admin** role and your explicit confirmation before the assistant executes them. If you connected with the **Viewer** role, the assistant can only perform read-only operations. tip Quicknode MCP reads live blockchain data and manages your account-level infrastructure. To help AI coding agents plan, build, and improve Web3 apps, with accurate knowledge of Quicknode's APIs and products when writing code, see the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin), which bundles this MCP server with the `build-web3` skill in a single install. For AI-optimized documentation discovery, see [LLM-Optimized Docs](/docs/build-with-ai/llms-txt). ## Resources [ Quicknode Connector on Claude Add Quicknode directly from the Anthropic MCP directory →](https://claude.com/connectors/quicknode)[ Setup Guide Read blockchain data and manage infrastructure with AI and MCP →](https://www.quicknode.com/guides/ai/quicknode-mcp)[ Quicknode on ChatGPT Install the Quicknode app directly from the ChatGPT Apps catalog →](https://chatgpt.com/apps/quicknode/asdk_app_69ca79775c848191a5f1e538e77aedbb)[ Admin API Docs Quicknode Admin API reference →](/docs/admin-api)[ EVM MCP Server Guide for using the EVM MCP server →](https://www.quicknode.com/guides/ai/evm-mcp-server)[ Solana MCP Server Guide for using the Solana MCP server →](https://www.quicknode.com/guides/ai/solana-mcp-server)