Skip to content

internet-court/internet-court-skill / vendored/quicknode/quicknode-skill

quicknode-skill

Verified

Quicknode blockchain infrastructure for 80+ chains: Core RPC API, Streams, Webhooks, Blazar WSS, Solana gRPC, HyperCore gRPC, SQL Explorer, Metaplex DAS API, Blockbook, Ordinals & Runes API, Swap API, x402, MPP, Agent Subscriptions, CLI, and MCP. Use for any Quicknode product, blockchain data access, or wallet-paid agent access.

references/mcp-reference.md

View on GitHub
# Quicknode MCP Reference

The Quicknode MCP server exposes Quicknode Admin API capabilities to AI assistants and coding tools via the Model Context Protocol (MCP). Quicknode is available as a native connector in Claude, ChatGPT, and Codex, and it can also be configured in generic MCP clients that support Streamable HTTP.


**Docs:** https://www.quicknode.com/docs/build-with-ai/quicknode-mcp

## Overview

| Property | Value |
|----------|-------|
| **Protocol** | Model Context Protocol (MCP) |
| **Transport** | HTTP (Streamable HTTP) |
| **Auth** | OAuth 2.1 for interactive setup; bearer API key for CI/non-interactive setup |
| **Directory** | Native Claude connector; native OpenAI app/plugin surface for ChatGPT and Codex |
| **Capabilities** | Endpoint management, usage monitoring, rate limits, security rules, billing |

## Client Setup

### Claude (Web, Desktop, and Claude Code)

Quicknode is listed in Claude's built-in Anthropic connector directory.

**Claude Web / Desktop:**
1. Open Claude settings → **Customize** → **Connectors**
2. Find **Quicknode** in the directory listing
3. Click **Connect**
4. Log in to Quicknode in the browser window, select **Admin** or **Viewer**, and approve access

**Claude Code (CLI):**

```bash
claude mcp add --transport http quicknode https://mcp.quicknode.com/mcp
```

By default, Claude Code installs in local scope for the current project. Use `--scope project` to share via project MCP config, or `--scope user` to make it available across your projects:

```bash
claude mcp add --transport http --scope user quicknode https://mcp.quicknode.com/mcp
```

### OpenAI (ChatGPT / Codex)

Install Quicknode directly from the ChatGPT Apps catalog or via `/plugin` in Codex when available. The interactive flow opens a Quicknode OAuth browser window where the user selects **Admin** or **Viewer** before approving access.

### Cursor / VS Code / Windsurf / Zed / Generic MCP Clients

For any MCP-compatible client that supports HTTP transport, configure:

```text
https://mcp.quicknode.com/mcp
```

If a client does not support native OAuth or HTTP transport, use `mcp-remote` as a bridge:

```json
{
  "mcpServers": {
    "quicknode": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp"]
    }
  }
}
```

## Authentication and Roles

Interactive setup uses OAuth 2.1. The user logs in to Quicknode, chooses the account to connect, then selects an API key role:

| Role | Access |
|------|--------|
| **Viewer** | Read-only access to endpoints, metrics, logs, usage, billing, and chains |
| **Admin** | Viewer access plus create/delete endpoints, security changes, and rate-limit updates |

Use **Viewer** for inspection-only workflows. Use **Admin** only when the assistant needs to make Quicknode account changes.

## Non-Interactive / CI Setup

For CI, remote machines, or clients where browser OAuth is unavailable, pass a Quicknode API key as a bearer token. The key's Quicknode role controls MCP permissions.

### Claude Code

```bash
claude mcp add quicknode --transport http https://mcp.quicknode.com/mcp --header "Authorization: Bearer YOUR_API_KEY"
```

### Codex

```bash
codex mcp add quicknode \
  --url https://mcp.quicknode.com/mcp \
  --bearer-token-env-var QUICKNODE_API_KEY
```

### Generic HTTP MCP Config

```json
{
  "mcpServers": {
    "quicknode": {
      "url": "https://mcp.quicknode.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

## Tool Surface

The Quicknode MCP server exposes tools covering the Admin API surface:

### Endpoint Management

| Tool | Description |
|------|-------------|
| `list-endpoints` | List all RPC endpoints in your account |
| `get-endpoint` | Retrieve details for a specific endpoint |
| `create-endpoint` | Create a new RPC endpoint |
| `delete-endpoint` | Delete an endpoint |
| `update-endpoint-rate-limits` | Configure global request rate limits for an endpoint |

### Per-Method Rate Limits

| Tool | Description |
|------|-------------|
| `list-endpoint-method-rate-limits` | List per-method rate limits for an endpoint |
| `create-endpoint-method-rate-limit` | Set a rate limit for a specific RPC method |
| `update-endpoint-method-rate-limit` | Update an existing method-level rate limit |
| `delete-endpoint-method-rate-limit` | Remove a method rate limit |

### Security

| Tool | Description |
|------|-------------|
| `list-endpoint-security` | List all security rules for an endpoint |
| `create-security-rule` | Add a security rule (allowlist, JWT auth, etc.) |
| `update-endpoint-security-options` | Update endpoint-level security settings |
| `delete-security-rule` | Remove a security rule |

### Usage & Monitoring

| Tool | Description |
|------|-------------|
| `get-endpoint-metrics` | Retrieve performance metrics for an endpoint |
| `list-endpoint-logs` | List request logs for an endpoint |
| `get-endpoint-log-details` | Get details for a specific log entry |
| `get-rpc-usage` | View RPC usage statistics across your account |

### Account & Billing

| Tool | Description |
|------|-------------|
| `list-chains` | List all supported blockchain networks |
| `get-billing` | Retrieve billing information |

## MCP Resources

Quicknode MCP also exposes endpoint details as MCP resources in clients that support resource browsing. Reference `@quicknode` in the client UI to attach endpoint context such as `quicknode://endpoints/<endpoint-id>` without first calling a tool.

## Example Prompts

- "List all my Quicknode endpoints"
- "Create a new Ethereum mainnet endpoint"
- "What's my RPC usage for this month?"
- "Add an IP allowlist rule to my endpoint"
- "Show me the per-method rate limits on my endpoint"
- "Connect my Quicknode workspace to Claude via MCP"

## When to Use MCP vs. CLI vs. SDK vs. Admin API

| Interface | Best For |
|-----------|----------|
| **MCP** | Conversational management inside Claude, Cursor, or other AI tools |
| **CLI (`qn`)** | Shell scripts, CI/CD pipelines, direct terminal workflows |
| **SDK** | Application or agent code that coordinates Quicknode product APIs |
| **Admin API** | Programmatic infrastructure-as-code from application code |

## Documentation

- **MCP Docs**: https://www.quicknode.com/docs/build-with-ai/quicknode-mcp
- **Build with AI Overview**: https://www.quicknode.com/docs/build-with-ai
- **SDK Docs**: https://www.quicknode.com/docs/quicknode-sdk
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall