Gnosisscan MCP for AI. Audit assets and code state on Gnosis Chain.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Gnosisscan (Gnosis Chain Explorer) gives your AI agent direct access to Gnosis Chain data. You can query xDAI balances, track ERC20 and NFT transfers, list transaction history, and retrieve smart contract source code—all without opening a browser tab.
It's like having the entire blockchain explorer built into your chat interface.
What AI agents can do with Gnosisscan (Gnosis Chain Explorer) Automation
Get account balance multi
Checks the xDAI balances for a list of multiple addresses at once.
Get account balance
Gets the xDAI balance held by one specific address.
Get account minedblocks
Lists all block numbers that were validated by a given address.
Retrieve the current xDAI balance for a single or multiple addresses.
Get detailed lists of both ERC20 token movements and specific ERC721 NFT transfer events by address.
List all normal transactions or internal contract interactions that occurred at a given address.
Fetch verified ABI and source code for deep technical analysis of specific contracts.
Get real-time data on gas prices, block rewards, or the total supply of xDAI.
Ask an AI about this
Waiting for input…
What AI agents can do with Gnosisscan (Gnosis Chain Explorer) with 26 Tools
These tools allow you to programmatically query every aspect of the Gnosis Chain, from simple account balances to complex contract state data.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Gnosisscan (Gnosis Chain Explorer) on VinkiusGet Account Balance Multi
Checks the xDAI balances for a list of multiple addresses at once.
Get Account Balance
Gets the xDAI balance held by one specific address.
Get Account Minedblocks
Lists all block numbers that were validated by a given address.
Get Account Tokennfttx
Retrieves records of ERC721 NFT transfers associated with an address.
Get Account Tokentx
Gets a list of all ERC20 token transfer events for any specific address.
Get Account Txlist Internal
Lists all internal, contract-to-contract transactions for an address.
Get Account Txlist
Provides a history of normal transactions that occurred at an address.
Get Block Bytime
Finds the corresponding block number given a specific timestamp.
Get Block Countdown
Estimates how long it will take until the next block is validated.
Get Block Reward
Determines the reward received for validating a specific block number.
Get Contract Abi
Fetches the Application Binary Interface (ABI) for verified contract code.
Get Contract Sourcecode
Retrieves the human-readable source code for a contract.
Get Logs
Gets event logs emitted during a transaction period.
Get Stats Ethsupply
Calculates and returns the total circulating supply of xDAI on Gnosis Chain.
Get Stats Gnoprice
Gathers the latest market price data for both GNO and xDAI.
Get Tx Receiptstatus
Checks if a specific transaction receipt has been fully processed by the network.
Get Tx Status
Verifies the execution status of a contract interaction or transaction.
Proxy Blocknumber
Gets the current block number using an Ethereum proxy call.
Proxy Call
Executes arbitrary calls against a contract address via proxy methods.
Proxy Estimategas
Estimates the gas required for a transaction before sending it.
Proxy Gasprice
Retrieves the current recommended gas price for transactions.
Proxy Getblockbynumber
Fetches an entire block's details using its number proxy.
Proxy Getcode
Checks the bytecode associated with a contract address.
Proxy Getstorageat
Reads specific storage key data from a contract's state.
Proxy Gettransactionbyhash
Fetches transaction details using its unique hash identifier.
Proxy Gettransactionreceipt
Gets the full receipt of a transaction by providing its hash.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Gnosisscan (Gnosis Chain Explorer), then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 26 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually tracking asset flows across multiple wallets is a nightmare of tabs and copy-pasting.
Right now, if you need to audit five different accounts for xDAI balances or track every single NFT movement across them, your workflow looks like this: Open the explorer tab, paste address one. Run query. Copy result. Open new tab. Paste address two. Repeat until done. It takes forever and you lose context.
With this MCP, that whole process vanishes. You tell your agent to check multiple balances or list transfers for five accounts. The data comes back structured in the chat window. It’s instant, it's aggregated, and you never leave your conversation.
Getting deep contract state details with get_contract_abi
Before this, to understand a smart contract, you had to find the explorer page, locate the ABI section, and manually copy/paste chunks of JSON just to figure out what functions it even supports. It was tedious boilerplate work.
Now, you run `get_contract_abi` in your chat, and you get the structured data right away. You know exactly what methods are callable—it makes writing follow-up queries on that contract straightforward.
What your AI can actually do with this
Need to audit an account or trace complex asset movements on Gnosis Chain? This MCP connects your agent directly to the chain data via Gnosisscan, letting you analyze everything conversationally. Instead of jumping between tabs and manually checking multiple addresses, you ask your AI client a question—like 'What were all the transfers for this NFT?'—and it gets the raw data back instantly.
You can check current xDAI balances across dozens of wallets or pull historical transaction lists, including deep internal contract calls. The whole process is managed through Vinkius, giving you access to thousands of specialized tools and keeping your workflow right where you are. It's pure blockchain intelligence in plain language.
019e5d20-ba38-7144-b2ed-8fd473b241e7 Here's how it actually works
The bottom line is, you treat reading complex chain data like asking a simple question.
Subscribe to this MCP and provide your Gnosisscan API Key.
Tell your AI client what you need—for instance, 'Show me all the NFT transfers for address X'.
The agent calls the correct function, retrieves the raw blockchain data, and presents it back to you in a readable format.
Who is this actually for?
Smart contract auditors, DeFi analysts, and Web3 developers. If your job involves tracing asset flows or verifying contract state across Gnosis Chain, this is for you. You need to stop relying on manual dashboard refreshing and start talking directly to the blockchain.
Needs to aggregate xDAI balances and token movements across a portfolio of addresses quickly.
Must retrieve verified contract ABIs or analyze transaction receipts to validate code integrity without leaving their dev environment.
Requires fetching block numbers by timestamp or getting the raw source code for rapid prototyping and debugging.
What Changes When You Connect
Eliminate tab hopping. Instead of opening the Gnosisscan site, copying an address, navigating to a new tab, and running multiple queries, you just ask your agent, and it runs everything in one chat window.
Deep technical visibility. You can retrieve contract source code or use get_contract_abi on demand. This is critical for validating if a smart contract behaves the way its developers intended.
Comprehensive tracking. Need to know what happened with an NFT? Use get_account_tokennfttx. Want to see all token flows? Run get_account_tokentx. It covers both sides of asset movement.
Full network picture. You can check the overall health using get_stats_gnoprice or use proxy tools like proxy_gasprice to calculate expected transaction costs before writing a single line of code.
Historical depth. Don't just look at recent activity. Use get_account_txlist and get_account_txlist_internal together to build a complete timeline of an account’s interactions, including hidden contract calls.
See it in action
Tracking a high-value NFT transfer
A user needs to know if a specific rare NFT left a wallet. Instead of searching through block logs manually, the agent runs get_account_tokennfttx on the source address and filters for the contract ID, immediately showing the recipient's details.
Verifying DeFi collateral status
A developer needs to audit a loan protocol. They use proxy_getstorageat against the smart contract to pull the specific storage slot holding the collateral value, bypassing public-facing balance checkers and getting raw state data.
Debugging an internal transaction
A user sees a strange activity in their history. They use get_account_txlist_internal to see which specific contract initiated the transfer, then they can use proxy_gettransactionbyhash on that hash to trace exactly where the funds went.
Checking network readiness before deployment
A dev wants to estimate costs. They run proxy_estimategas first, then check get_block_countdown to see if gas prices are stable enough for their planned transaction window.
The honest tradeoffs
Mixing up account queries
Trying to find NFT transfers by checking general transaction lists. You’ll get noise from every single token movement, making the data useless.
Always use get_account_tokennfttx. This tool isolates and filters only ERC721 transfer events for you.
Assuming current block status
Thinking a transaction is confirmed just because it appears in your chat history. It might be stuck or pending.
Check the actual status using get_tx_status or get_tx_receiptstatus. This confirms whether the contract execution actually succeeded.
Over-relying on public summaries
Using a simple balance check when you actually need to know what data is stored inside the smart contract itself.
If you suspect state manipulation, use proxy_getstorageat or fetch the full ABI using get_contract_abi. This goes deeper than surface-level balances.
When It Fits, When It Doesn't
Use this MCP if your goal is to read, audit, or analyze immutable blockchain data from Gnosis Chain. You need historical records (e.g., 'List all normal transactions') or deep code insights (e.g., 'Get the contract source code'). Don't use it if you intend to send tokens or modify state; this MCP is purely for read-only querying. If you simply want a general market overview, checking get_stats_gnoprice is enough. But if you need to know why an account has certain assets, running get_account_balance_multi alongside specialized tools like get_account_tokentx gives the full context.
Questions you might have
How do I check multiple balances using get_account_balance_multi? +
You pass a comma-separated list of addresses to the tool. It returns an array showing the current xDAI balance for every address in that single call.
Can I track both ERC20 and NFT transfers using get_account_tokennfttx? +
No, those are separate tools. Use get_account_tokentx specifically for all ERC20 token movements, and use get_account_tokennfttx only for the unique ERC721/NFT transfer records.
What's the difference between get_account_txlist and get_account_txlist_internal? +
Use get_account_txlist to see standard transactions (like simple transfers). Use get_account_txlist_internal when you need to trace complex, machine-to-machine calls within a contract.
Is proxy_gasprice the same as get_stats_gnoprice? +
No. get_stats_gnoprice gives the current market price of GNO and xDAI. proxy_gasprice gives you an estimate of the operational cost (gas) needed to execute a transaction on the network.
When I run `get_contract_abi`, what should I do if the contract source code isn't fully verified? +
The ABI still provides necessary function signatures. You use the ABI to understand exactly which functions exist and what parameters they require, even if the full source code isn't visible for inspection.
If a transaction fails, how can I interpret the result using `get_tx_status`? +
The status field tells you immediately whether the contract execution failed or succeeded. If it reports failure, look at the associated error message for the specific reason why the call reverted.
Can I use `get_block_bytime` to analyze a historical period without knowing the exact block number? +
Yes, you can. Providing a timestamp allows you to find the corresponding block number, which is essential when doing deep dives into events that happened weeks or months ago.
How do I filter specific actions from event data using `get_logs`? +
You must specify both the contract address and a precise event signature in your query. This tells the MCP exactly which type of logged action you want to see, filtering out irrelevant network noise.
Can I check the balance of multiple Gnosis Chain addresses at once? +
Yes! Use the get_account_balance_multi tool and provide a comma-separated list of addresses to get all balances in a single request.
How do I see the ERC20 token transfer history for an account? +
You can use the get_account_tokentx tool. Simply provide the account address, and optionally a specific contract address, to list all relevant token movements.
Is it possible to retrieve the source code of a verified smart contract? +
Yes, the get_contract_source_code tool allows you to fetch the source code for any verified contract on Gnosisscan using its address.
We've already built the connector for Gnosisscan. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 26 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.