MCP Blockchain Server
Provides containerization support for running the PostgreSQL database, Redis cache, MCP Server, and Web DApp as a complete system
Handles environment variable configuration for the MCP Blockchain Server
Enables reading balances, contract state, and other on-chain data from the Ethereum blockchain, as well as preparing unsigned transactions for user approval and signing
Hosts the MCP Blockchain Server repository and provides dependency installation sources
Serves as the runtime environment for the MCP Blockchain Server
Manages package dependencies for the MCP Blockchain Server
Provides support for reading data and preparing transactions on the Polygon network as part of the multi-chain EVM-compatible blockchain support
Used for storing users, API keys, and transaction records in the MCP blockchain server system
Powers the Web DApp that provides the user interface for wallet connection and transaction signing
Utilized for caching frequently accessed blockchain data to improve performance
Used for implementing the MCP server and related components
Alternative package manager for installing dependencies
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Blockchain Server check my ETH balance on Ethereum mainnet"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Blockchain Server
An MCP server that lets AI assistants read blockchain data and prepare transactions — while the user keeps full custody of their keys and signs every transaction in their own wallet.
It runs as a single, self-contained process. No database, no Redis, no API keys, no separate frontend to build. Point your MCP client at it and go.
┌──────────────┐ MCP (stdio) ┌─────────────────────┐ RPC ┌────────────┐
│ AI assistant │ ──────────────► │ mcp-blockchain │ ───────► │ Blockchain │
│ (Claude …) │ ◄────────────── │ server │ ◄─────── │ (EVM) │
└──────────────┘ │ + signing web page │ └────────────┘
└─────────┬───────────┘
│ opens link, signs in wallet
▼
┌───────────┐
│ User │ (MetaMask / Rabby / …)
└───────────┘Why this design
The hard problem in AI + blockchain is letting an assistant act without ever touching private keys. This server solves it by splitting the work:
Reads (balances, contract state) happen server-side and return directly to the assistant.
Writes are only ever prepared server-side. The server hands back a URL; the user opens it, reviews the details, and signs in their own wallet. The wallet broadcasts the transaction. The server only ever learns the resulting transaction hash. Private keys never reach the server.
Related MCP server: keygenix-mcp
Quick start
Requirements: Node.js 18+. No clone, no build, no API keys.
Add the server to any MCP client that launches stdio servers. For Claude Desktop, open Settings → Developer → Edit Config and add:
{
"mcpServers": {
"blockchain": {
"command": "npx",
"args": ["-y", "mcp-blockchain-server"]
}
}
}Restart the client. You can now ask things like "What's the ETH balance of vitalik.eth?" or "Send 0.01 test ETH to 0x… on Sepolia." For a send, the assistant returns a link — open it, review, and sign in your wallet.
No configuration is required: the server ships with free public RPC endpoints and defaults to the Sepolia testnet.
Use it in other clients
The same npx command works anywhere that runs an MCP stdio server — the config
shape is identical across clients:
{ "command": "npx", "args": ["-y", "mcp-blockchain-server"] }This is the block to drop into Cursor (.cursor/mcp.json), Cline,
Windsurf, VS Code (.vscode/mcp.json), and others. To pass options, add
an "env" block (see Configuration).
Run from source (development)
git clone https://github.com/zhangzhongnan928/mcp-blockchain-server.git
cd mcp-blockchain-server
npm install # installs and builds (via the prepare script)Then point the client at the build instead of npx:
{ "command": "node", "args": ["/absolute/path/to/mcp-blockchain-server/build/index.js"] }Remote / web clients (HTTP transport)
For MCP clients that connect over HTTP instead of spawning a local process, run the server in HTTP mode. It then serves the MCP endpoint and the signing page on one port:
MCP_TRANSPORT=http PUBLIC_BASE_URL=https://your-host npx -y mcp-blockchain-serverMCP endpoint (Streamable HTTP):
https://your-host/mcpSigning links:
https://your-host/tx/<id>
Bind a public interface with HOST=0.0.0.0 (or keep the default 127.0.0.1 and
put it behind a reverse proxy). When exposed publicly, set MCP_ALLOWED_HOSTS
and/or MCP_ALLOWED_ORIGINS to enable DNS-rebinding protection, and front it
with HTTPS and access control.
To host it as a custom connector (one-click Render, Vercel, Docker, or a quick
tunnel for testing) and wire it into Claude's Add custom connector dialog,
see the deployment guide. On stateless hosts like
Vercel, point the store at Redis (UPSTASH_REDIS_REST_URL /
UPSTASH_REDIS_REST_TOKEN) so the signing flow persists across requests.
Tools
Tool | Purpose |
| List supported networks and their chain ids. |
| Native-token balance for an address on a chain. |
| Call a read-only contract method (pass an |
| Create an unsigned transaction and return a signing URL. |
| Track a prepared transaction by id. |
read-contract is zero-config when you pass a human-readable ABI:
{
"chainId": "1",
"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"method": "balanceOf",
"args": ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"],
"abi": ["function balanceOf(address) view returns (uint256)"]
}Signing flow
The assistant calls
prepare-transaction. The server stores it and returnshttp://localhost:3000/tx/<id>.The user opens the link. The page shows the network, recipient, amount, and calldata.
The user connects their wallet and clicks Approve & Sign. The wallet signs and broadcasts (
eth_sendTransaction).The page reports the transaction hash back to the server, which watches for on-chain confirmation.
The assistant polls
get-transaction-statusuntil it isCONFIRMED.
The signing page is plain HTML + vanilla JS served by the same process — there is nothing extra to build or deploy.
Configuration
Everything is optional. Copy .env.example to .env to override defaults.
Variable | Default | Description |
|
|
|
|
| Port for the signing web server (and the |
|
| Interface to bind (localhost only by default). Set |
|
| Base URL used in signing links and the |
|
| Default chain (Sepolia testnet). |
|
|
|
|
| Where pending transactions are stored (file backend). |
| — | Use a Redis store instead of the file backend. Required on stateless hosts (Vercel). |
| built-in public RPC | Override the RPC for a chain, e.g. |
| — | If set, upgrades default RPCs to Infura. |
| — | If set, |
| — | Comma-separated Host allowlist for http mode (enables DNS-rebind protection). |
| — | Comma-separated Origin allowlist for http mode (enables DNS-rebind protection). |
Supported chains
Ethereum (1), Sepolia (11155111), Polygon (137), Polygon Amoy (80002),
Base (8453), Base Sepolia (84532), Arbitrum One (42161), OP Mainnet
(10). Each has a built-in public RPC; override any with RPC_URL_<chainId>.
Development
npm run dev # run from source with auto-reload (tsx)
npm run build # compile TypeScript to build/
npm start # run the compiled server
npm test # run the test suite (node:test)
npm run typecheck # type-check without emittingReleasing
CI (build + tests) runs on every push and PR. To publish a new version to npm:
Add an
NPM_TOKENrepository secret (an npm automation token) — once.Bump the version and tag:
npm version patch(orminor/major), thengit push --follow-tags.Create a GitHub Release for that tag. The release workflow runs the tests and publishes to npm (with provenance).
You can also publish manually: npm publish.
Security
Private keys never reach the server. It only prepares transactions; the user's wallet signs and broadcasts them.
The signing server binds to localhost by default and sets a strict, nonce-based Content-Security-Policy on the signing page.
All tool inputs (addresses, amounts, calldata) are validated before use.
Logs are written to stderr so they never corrupt the MCP stdio stream.
See docs/security.md for details.
Documentation
License
MIT — see LICENSE.
Available Tools
5 toolsget-balanceGet native balanceARead-only
Get an address's native-token balance (e.g. ETH) on a given chain.
Inputs: address (required), chainId (required).
get-chainsList supported chainsARead-only
List the blockchain networks this server supports, with their chain ids and native currencies.
Inputs: no named parameters.
get-transaction-statusGet transaction statusARead-only
Check the current status of a prepared transaction by its id.
Inputs: id (required).
prepare-transactionPrepare a transaction for signingA
Create an unsigned transaction and return a URL the user opens to review and sign it in their own wallet. Private keys never reach this server. Share the returned URL with the user.
Inputs: to (required), chainId (required), data, value, +1 more.
read-contractRead a smart contractARead-only
Call a read-only (view/pure) contract method. Provide abi as human-readable signatures (e.g. ["function balanceOf(address) view returns (uint256)"]) for zero-config use, or set ETHERSCAN_API_KEY to auto-fetch verified ABIs.
Inputs: method (required), address (required), chainId (required), abi, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool targets a distinct blockchain operation: balance query, chain listing, transaction status, transaction preparation, and contract reading. No functional overlap.
All tool names follow a consistent verb_noun pattern with snake_case (e.g., get-balance, prepare-transaction). No mixing of styles.
With 5 tools, the server covers core blockchain interactions without being excessive or too sparse. Each tool serves a clear purpose.
The tool set covers essential operations: balance, chain info, contract reading, and transaction lifecycle. Missing features like event log retrieval or gas estimation, but for basic blockchain interactions it is largely complete.
Maintenance
Related MCP Connectors
Crypto wallet for AI agents: balances, payments, swaps and trading with owner controls.
Provide AI agents and automation tools with contextual access to blockchain data including balance…
Security intelligence for AI agents monitoring Ethereum before actions.
Trusted execution infrastructure for AI agents. Proposal-only protocol with human consent.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI agents to check balances and send transactions across multiple blockchains with automatic spending limit protection and policy enforcement.3MIT
- AlicenseBqualityNot gradedmaintenanceNon-custodial TEE key management and signing for AI agents, supporting multiple blockchains.12MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to analyze Ethereum wallets, simulate transactions, and draft transfers with deterministic policy and risk scoring, requiring human approval before on-chain execution.12 npmISC

Signo MCP Serverofficial
AlicenseNot gradedqualityCmaintenanceEnables AI assistants to monitor DeFi positions, draft Notify or Prepare agents, and manage agents on a user's account. Wallet owners retain control by reviewing and signing every draft before anything runs.MIT