Meet the Blockscout MCP Server

TL;DR.

• AI agents need on-chain context, but raw RPC is hostile and most indexers were built for dashboards, not agents.
• The Blockscout MCP Server exposes block-explorer data through the Model Context Protocol — a tool catalog any MCP-aware agent can call.
• It covers 3,000+ chains out of the box, with the same surface for Ethereum mainnet and the long tail.
• You can wire it into Claude, Cursor, or any MCP client and ask "what tokens does this address hold on Base?" — no glue code.
• It's open source, free to try, and pairs with the Pro API when you need higher rate limits.

Why agents need a different surface

If you've ever tried to give an AI agent on-chain context, you know the shape of the problem. JSON-RPC speaks a language designed for nodes, not models. eth_getTransactionByHash returns a wall of hex. Decoding a token transfer means knowing the ERC-20 ABI, parsing a log topic, looking up symbols and decimals somewhere else. Multiply that by the chain you're actually on, and the agent spends most of its tokens reading documentation instead of answering the question.

Block explorers already solved a lot of that — verified contracts, decoded events, token metadata, address labels. But the standard way to reach that data has been a REST API tuned for dashboards: pagination, query params, response shapes that humans skim. Agents don't skim. They want a tool, a docstring, and a structured payload.

That's the gap MCP fills.

What MCP is, in one paragraph

The Model Context Protocol is an open standard for connecting AI models to external data and actions. An MCP server publishes a list of tools — each with a name, a description, and a typed schema. An MCP client (Claude, Cursor, your own agent loop) reads that list, picks the tools it needs for the current task, and calls them. Think of it as function calling, but standardised so the same tool surface works across every model and IDE that speaks MCP.

What the Blockscout MCP Server adds

The server wraps Blockscout's indexed data — across every chain Blockscout supports — into MCP tools. The agent doesn't have to know which chain it's on, where the explorer is hosted, or how the underlying API paginates. It calls a tool, gets a structured result back, and moves on.

How the Blockscout MCP Server sits between AI agents and on-chain dataThree stacked planes: on the left, a chain layer representing 3,000+ chains; in the middle, the Blockscout MCP Server exposing a tool catalog; on the right, an AI agent connected through the Model Context Protocol.Chains3,000+ EVM networksBlockscout MCPTool catalogget_address_infoget_transaction_inforead_contractget_chains_listAI AgentClaude · Cursor · customFig. 1. The MCP Server sits between the chains and the agent. The agent never talks to RPC directly; it calls tools.

The catalog is grouped around the things you actually ask about on a block explorer:

• Addresses. Get an address summary, list its tokens, list its NFTs, pull token transfers, resolve an ENS name to an address.
• Transactions. Fetch a transaction by hash, list transactions for an address, decode the input data and logs.
• Blocks. Look up a block by number, get the latest block height, read the block's transactions.
• Contracts. Pull a verified ABI, inspect the source code, read a view function, look up a token by symbol.
• Chains. List every chain Blockscout indexes, switch context across them, drop down to a direct API call when you need a field a tool doesn't expose yet.

Every tool returns JSON the model can reason about — addresses lower-cased, amounts in both raw and human-readable form, tokens labelled with symbol and decimals. No hex archaeology.

What you can build with it

The interesting part is what stops being hard.

A research assistant that answers "how did this stablecoin move across L2s in the last 24 hours?" — three tool calls, one summary. A support bot that triages "my swap reverted, here's the tx hash" by pulling the transaction, decoding the trace, and pointing at the failing call. A portfolio agent that walks an address across Base, Arbitrum, and Optimism in the same conversation, because the tool surface is identical on all three.

We've also seen builders point Cursor at the MCP Server while writing contracts — "read the live ABI of this proxy and tell me which implementation it points to" — and watched the model produce a correct answer in one shot, where before it would have hallucinated three. That isn't magic; it's that the agent finally has a clean way to ask.

How to wire it up

The MCP Server runs as a small process that any MCP-compatible client connects to. In Claude Desktop and Cursor, that's a one-line entry in the MCP config. From there the model picks up the tool catalog automatically — you don't write any glue.

For programmatic agents, the same server exposes the same tools over the standard MCP transport. Drop it next to your model, register the connection, and the tools show up in the model's function list. The full setup, including config snippets for the most common clients, lives in the MCP Hub.

Heads up Public endpoints are fine for development and casual queries. Once your agent is in production traffic, plug in a Pro API key and the same MCP tools route through the higher-throughput tier.

Where the edges are

A few honest caveats.

The MCP surface is read-mostly. You can read state, decode transactions, inspect contracts, and call view functions — but signing or sending transactions is out of scope. That belongs to a wallet, not an explorer. If your agent needs to act on-chain, pair the MCP Server with a wallet-side MCP (or your own signing path) and keep the responsibilities separate.

Coverage tracks Blockscout's coverage. If a chain isn't on Blockscout yet, it isn't on the MCP Server yet. The good news is the list is long and growing — 3,000+ chains today, with chain teams onboarding through Autoscout regularly.

And like any agent surface, latency and rate limits matter. Public endpoints are fine for development and casual queries. Once your agent is in production traffic, plug in a Pro API key and the same MCP tools route through the higher-throughput tier.

What it means for the next year of agent-meets-chain

We think the next year of crypto tooling looks less like new dashboards and more like agents reading the chains we already have. The on-chain world is open data by default. The thing that's been missing is a clean, model-shaped way in.

The MCP Server is our bet on what that interface looks like. Open standard, open source, multichain by default, and easy to wire into the agent stack you're already using. We'll keep adding tools as agents push the edges — better contract introspection, richer cross-chain queries, smarter pagination. If there's a tool you wish the catalog had, open an issue and tell us.

The chains aren't going to read themselves.

Try the MCP Server today

Get a free Pro API key and wire the MCP Server into your agent in minutes. The MCP Hub has the config snippets for Claude Desktop, Cursor, and the rest.

Get a free Pro API key →