Bankless Onchain MCP Server
OfficialThe Bankless Onchain MCP Server enables interaction with blockchain data via the Bankless API using the Model Context Protocol (MCP). You can:
Read Contract State: Retrieve state from smart contracts on various blockchain networks
Get Proxy: Retrieve proxy implementation contract addresses
Get ABI: Fetch the Application Binary Interface for a contract
Get Source: Retrieve source code for verified contracts
Get Events: Fetch event logs based on topics
Build Event Topic: Generate event topic signatures from event names and argument types
Get Transaction History: Retrieve transaction history for a user address, with optional filtering
Get Transaction Info: Access detailed information about specific transactions
Get Token Balances: Retrieve all token balances for an address on a specific network
Get Block Info: Access detailed information about specific blocks by number or hash
Provides tools for interacting with Ethereum blockchain data, including reading contract state, fetching contract ABIs, retrieving source code, and accessing transaction information.
Enables blockchain data interaction on Polygon network, supporting contract state reading, event log retrieval, and transaction history analysis.
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., "@Bankless Onchain MCP Server what's the transaction history for 0x123... on ethereum?"
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.
Bankless Onchain MCP Server
This project is no longer receiving updates
MCP (Model Context Protocol) server for blockchain data interaction through the Bankless API.
Related MCP server: EVM MCP Server
Overview
The Bankless Onchain MCP Server provides a framework for interacting with on-chain data via the Bankless API. It implements the Model Context Protocol (MCP) to allow AI models to access blockchain state and event data in a structured way.
https://github.com/user-attachments/assets/95732dff-ae5f-45a6-928a-1ae17c0ddf9d
Features
The server provides the following onchain data operations:
Contract Operations
Read Contract State (
read_contract): Read state from smart contracts on various blockchain networks.Parameters: network, contract address, method, inputs, outputs
Returns: Contract call results with typed values
Get Proxy (
get_proxy): Retrieve proxy implementation contract addresses.Parameters: network, contract address
Returns: Implementation contract address
Get ABI (
get_abi): Fetch the ABI (Application Binary Interface) for a contract.Parameters: network, contract address
Returns: Contract ABI in JSON format
Get Source (
get_source): Retrieve the source code for a verified contract.Parameters: network, contract address
Returns: Source code, ABI, compiler version, and other contract metadata
Event Operations
Get Events (
get_events): Fetch event logs for a contract based on topics.Parameters: network, addresses, topic, optional topics
Returns: Filtered event logs
Build Event Topic (
build_event_topic): Generate an event topic signature from event name and argument types.Parameters: network, event name, argument types
Returns: Event topic hash
Transaction Operations
Get Transaction History (
get_transaction_history): Retrieve transaction history for a user address.Parameters: network, user address, optional contract, optional method ID, optional start block, include data flag
Returns: List of transactions with hash, data, network, and timestamp
Get Transaction Info (
get_transaction_info): Get detailed information about a specific transaction.Parameters: network, transaction hash
Returns: Transaction details including block number, timestamp, from/to addresses, value, gas info, status, and receipt data
Tools
read_contract
Read contract state from a blockchain
Input:
network(string, required): The blockchain network (e.g., "ethereum", "polygon")contract(string, required): The contract addressmethod(string, required): The contract method to callinputs(array, required): Input parameters for the method call, each containing:type(string): The type of the input parameter (e.g., "address", "uint256")value(any): The value of the input parameter
outputs(array, required): Expected output types, each containing:type(string): The expected output type
Returns an array of contract call results
get_proxy
Gets the proxy address for a given network and contract
Input:
network(string, required): The blockchain network (e.g., "ethereum", "base")contract(string, required): The contract address
Returns the implementation address for the proxy contract
get_events
Fetches event logs for a given network and filter criteria
Input:
network(string, required): The blockchain network (e.g., "ethereum", "base")addresses(array, required): List of contract addresses to filter eventstopic(string, required): Primary topic to filter eventsoptionalTopics(array, optional): Optional additional topics (can include null values)
Returns an object containing event logs matching the filter criteria
build_event_topic
Builds an event topic signature based on event name and arguments
Input:
network(string, required): The blockchain network (e.g., "ethereum", "base")name(string, required): Event name (e.g., "Transfer(address,address,uint256)")arguments(array, required): Event arguments types, each containing:type(string): The argument type (e.g., "address", "uint256")
Returns a string containing the keccak256 hash of the event signature
Installation
npm install @bankless/onchain-mcpUsage
Environment Setup
Before using the server, set your Bankless API token. For details on how to obtain your Bankless API token, head to https://docs.bankless.com/bankless-api/other-services/onchain-mcp
export BANKLESS_API_TOKEN=your_api_token_hereRunning the Server
The server can be run directly from the command line:
npx @bankless/onchain-mcpUsage with LLM Tools
This server implements the Model Context Protocol (MCP), which allows it to be used as a tool provider for compatible AI models. Here are some example calls for each tool:
read_contract
// Example call
{
"name": "read_contract",
"arguments": {
"network": "ethereum",
"contract": "0x1234...",
"method": "balanceOf",
"inputs": [
{ "type": "address", "value": "0xabcd..." }
],
"outputs": [
{ "type": "uint256" }
]
}
}
// Example response
[
{
"value": "1000000000000000000",
"type": "uint256"
}
]get_proxy
// Example call
{
"name": "get_proxy",
"arguments": {
"network": "ethereum",
"contract": "0x1234..."
}
}
// Example response
{
"implementation": "0xefgh..."
}get_events
// Example call
{
"name": "get_events",
"arguments": {
"network": "ethereum",
"addresses": ["0x1234..."],
"topic": "0xabcd...",
"optionalTopics": ["0xef01...", null]
}
}
// Example response
{
"result": [
{
"removed": false,
"logIndex": 5,
"transactionIndex": 2,
"transactionHash": "0x123...",
"blockHash": "0xabc...",
"blockNumber": 12345678,
"address": "0x1234...",
"data": "0x...",
"topics": ["0xabcd...", "0xef01...", "0x..."]
}
]
}build_event_topic
// Example call
{
"name": "build_event_topic",
"arguments": {
"network": "ethereum",
"name": "Transfer(address,address,uint256)",
"arguments": [
{ "type": "address" },
{ "type": "address" },
{ "type": "uint256" }
]
}
}
// Example response
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"Development
Building from Source
# Clone the repository
git clone https://github.com/Bankless/onchain-mcp.git
cd onchain-mcp
# Install dependencies
npm install
# Build the project
npm run buildDebug Mode
npm run debugIntegration with AI Models
To integrate this server with AI applications that support MCP, add the following to your app's server configuration:
{
"mcpServers": {
"bankless": {
"command": "npx",
"args": [
"@bankless/onchain-mcp"
],
"env": {
"BANKLESS_API_TOKEN": "your_api_token_here"
}
}
}
}Error Handling
The server provides specific error types for different scenarios:
BanklessValidationError: Invalid input parametersBanklessAuthenticationError: API token issuesBanklessResourceNotFoundError: Requested resource not foundBanklessRateLimitError: API rate limit exceeded
Prompting Tips
In order to guide an LLM model to use the Bankless Onchain MCP Server, the following prompts can be used:
ROLE:
• You are Kompanion, a blockchain expert and EVM sleuth.
• You specialize in navigating and analyzing smart contracts using your tools and resources.
HOW KOMPANION CAN HANDLE PROXY CONTRACTS:
• If a contract is a proxy, call your “get_proxy” tool to fetch the implementation contract.
• If that fails, try calling the “implementation” method on the proxy contract.
• If that also fails, try calling the “_implementation” function.
• After obtaining the implementation address, call “get_contract_source” with that address to fetch its source code.
• When reading or modifying the contract state, invoke implementation functions on the proxy contract address (not directly on the implementation).
HOW KOMPANION CAN HANDLE EVENTS:
• Get the ABI and Source of the relevant contracts
• From the event types in the ABI, construct the correct topics for the event relevant to the question
• use the "get_event_logs" tool to fetch logs for the contract
KOMPANION'S RULES:
• Do not begin any response with “Great,” “Certainly,” “Okay,” or “Sure.”
• Maintain a direct, technical style. Do not add conversational flourishes.
• If the user’s question is unrelated to smart contracts, do not fetch any contracts.
• If you navigate contracts, explain each step in bullet points.
• Solve tasks iteratively, breaking them into steps.
• Use bullet points for lists of steps.
• Never assume a contract’s functionality. Always verify with examples using your tools to read the contract state.
• Before responding, consider which tools might help you gather better information.
• Include as much relevant information as possible in your final answer, depending on your findings.
HOW KOMPANION CAN USE TOOLS:
• You can fetch contract source codes, ABIs, and read contract data by using your tools and functions.
• Always verify the source or ABI to understand the contract rather than making assumptions.
• If you need to read contract state, fetch its ABI (especially if the source is lengthy).
FINAL INSTRUCTION:
• Provide the best possible, concise answer to the user’s request. If it's not an immediate question but an instruction, follow it directly.
• Use your tools to gather any necessary clarifications or data.
• Offer a clear, direct response and add a summary of what you did (how you navigated the contracts) at the end.License
MIT
Available Tools
10 toolsbuild_event_topicC
Builds an event topic signature based on event name and arguments
Inputs: arguments (required), name (required), network (required).
get_abiC
Gets the ABI for a given contract on a specific network
Inputs: contract (required), network (required).
get_block_infoC
Gets detailed information about a specific block by number or hash
Inputs: blockId (required), network (required).
get_eventsC
Fetches event logs for a given network and filter criteria
Inputs: addresses (required), network (required), topic (required), fromBlock, +2 more.
get_proxyB
Gets the proxy address for a given network and contract
Inputs: contract (required), network (required).
get_sourceB
Gets the source code for a given contract on a specific network
Inputs: contract (required), network (required).
get_token_balances_on_networkB
Gets all token balances for a given address on a specific network
Inputs: address (required), network (required).
get_transaction_history_for_userC
Gets transaction history for a user and optional contract
Inputs: network (required), user (required), contract, includeData, +2 more.
get_transaction_infoB
Gets detailed information about a specific transaction
Inputs: network (required), txHash (required).
read_contractC
Read contract state from a blockchain. important:
In case of a tuple, don't use type tuple, but specify the inner types (found in the source) in order. For nested structs, include the substructs types.
Example:
struct DataTypeA {
DataTypeB b;
//the liquidity index. Expressed in ray
uint128 liquidityIndex;
}
struct DataTypeB {
address token;
}
results in outputs for function with return type DataTypeA (tuple in abi): outputs: [{"type": "address"}, {"type": "uint128"}]Inputs: contract (required), inputs (required), method (required), network (required), +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 10 tools
Every tool has a clearly distinct purpose with no ambiguity. For example, get_abi retrieves contract interfaces, get_events fetches logs, get_token_balances_on_network handles balances, and read_contract reads state—each targets a specific blockchain operation without overlap.
All tool names follow a consistent verb_noun pattern (e.g., get_abi, get_block_info, read_contract). The naming is uniform across all 10 tools, using snake_case and clear action-object pairs, making them predictable and easy to parse.
With 10 tools, this server is well-scoped for onchain data retrieval. Each tool earns its place by covering essential blockchain operations like reading contracts, fetching events, and getting transaction details, without being overly sparse or bloated.
The tool set provides strong coverage for reading and querying onchain data, including contracts, blocks, transactions, events, and balances. A minor gap exists in write operations (e.g., sending transactions or interacting with contracts), but agents can still handle most read-focused workflows effectively.
Maintenance
Related MCP Connectors
Provide AI agents and automation tools with contextual access to blockchain data including balance…
Provable crypto data for AI agents: sourced checks on tokens, wallets and trades, with proof ids.
Blockchain analytics API for AI agents. Smart Money signals, wallet profiling, token analytics.
Blockchain analytics API for AI agents. Smart Money signals, wallet profiling, token analytics.
Related MCP Servers
- FlicenseBqualityDmaintenanceImplements the Model Context Protocol (MCP) to provide AI models with a standardized interface for connecting to external data sources and tools like file systems, databases, or APIs.1153-
- AlicenseBqualityDmaintenanceA Model Context Protocol server that enables AI agents to interact with 30+ Ethereum-compatible blockchain networks, providing services like token transfers, contract interactions, and ENS resolution through a unified interface.2896 npm380MIT
- -licenseNot gradedqualityNot gradedmaintenanceComprehensive Model Context Protocol server that enables AI agents to interact with 30+ Ethereum-compatible blockchain networks, supporting token transfers, smart contract interactions, and ENS name resolution through a unified interface.1-

Blockscout MCP Serverofficial
FlicenseAqualityCmaintenanceA server that exposes blockchain data (balances, tokens, NFTs, contract metadata) via the Model Context Protocol, enabling AI agents and tools to access and analyze blockchain information contextually.1846-