Cronoscan Block Explorer MCP for AI. Trace any asset movement or contract state change.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Cronoscan (Cronos Block Explorer) lets you analyze any data on the Cronos blockchain through conversation. Check CRO balances, track NFT transfers, inspect smart contract code, or run advanced RPC calls like `eth_call`—all without leaving your AI client.
What your AI can do
Get balance multi
Retrieves CRO balances for several addresses at once.
Get balance
Checks the current CRO balance held by one address.
Get eth price
Gets the current market price data for CRO.
Check the current CRO balance for single or multiple addresses.
View all ERC-20 and NFT transfers, check total supply metrics, or retrieve specific transaction logs for an address.
Fetch contract source code, read the ABI, or run deep Ethereum calls to simulate function execution on a given contract.
Get real-time data points like current gas prices, block rewards, and market pricing for CRO.
Ask an AI about this
Waiting for input…
Cronoscan (Cronos Block Explorer) with 24 Tools
You can query contract ABIs, balances, transaction logs, token transfers, and network metrics directly through this full suite of specialized tools.
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 Cronoscan (Cronos Block Explorer) on VinkiusGet Balance Multi
Retrieves CRO balances for several addresses at once.
Get Balance
Checks the current CRO balance held by one address.
Get Eth Price
Gets the current market price data for CRO.
Get Eth Supply
Determines the total circulating supply of CRO on the Cronos network.
Get Abi
Retrieves the Application Binary Interface (ABI) for a specific smart contract.
Get Block Reward
Finds out the block rewards associated with a specific block number.
Get Logs
Retrieves raw, detailed event logs for a contract's activity.
Get Source Code
Fetches the original source code of verified smart contracts.
Get Tx Receipt Status
Confirms the final status and receipt details of a transaction hash.
Proxy Eth Block Number
Retrieves the current block number on the network.
Proxy Eth Call
Simulates calling a contract function without actually executing it, useful for...
Proxy Eth Estimate Gas
Predicts the estimated gas cost required to execute a transaction.
Proxy Eth Gas Price
Gets the current recommended gas price for transactions.
Proxy Eth Get Block By Number
Fetches all data contained within a specific block number.
Proxy Eth Get Code
Reads the compiled bytecode of a contract at a given address.
Proxy Eth Get Storage At
Checks the value stored at a specific key within a contract's storage slots.
Proxy Eth Get Transaction By Hash
Retrieves all details about a transaction using its unique hash.
Proxy Eth Get Transaction Receipt
Fetches the final, detailed receipt confirming if and how a transaction finished.
Get Token Balance
Checks how much a specific ERC-20 token is held by an account, given the contract address.
Get Token Nft Tx
Lists all transfer events for NFTs (ERC-721) associated with an address.
Get Token Supply
Calculates the total supply of a specific ERC-20 token using its contract address.
Get Token Tx
Lists all standard transfer events for an ERC-20 token by address.
Get Tx List Internal
Retrieves internal transactions for an address, showing deeper contract interactions.
Get Tx List
Gets a list of normal transactions that occurred at a specified address.
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 Cronoscan (Cronos Block 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
Works with 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 24 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Today, checking asset history is a painful process of copy-pasting and clicking through dashboards.
Right now, to understand a full picture—say, tracking all the tokens leaving an address—you have to jump between three different explorer tabs. You pull up the main transaction list, then open a separate tab for ERC-20 tokens, and finally look at the NFT section just to see if anything was burned or transferred off-chain. It's tedious, slow, and you inevitably lose track of which data point came from where.
With this MCP, your agent handles that entire sequence in one prompt. You ask for a full report on token movements, and it synthesizes the information across normal transactions (`get_tx_list`), specific ERC-20 transfers (`get_token_tx`), and NFT changes (`get_token_nft_tx`). You get the answer without touching five different web pages.
Getting Contract Details with Cronoscan (Cronos Block Explorer) MCP
Previously, getting a contract's full picture meant finding its address, then navigating to the 'Code' tab for the source code, and opening another section just to get the ABI. If you wanted to know if it had specific functions, you were mostly guessing or relying on limited documentation that might be outdated.
Now, your agent handles this setup instantly. You ask for the contract details, and it gives you both `get_source_code` and `get_abi`. It's a unified data stream. This means your AI client can immediately use those blueprints to plan out complex calls using `proxy_eth_call`.
What your AI can actually do with this
Need to figure out what actually happened with a token transfer? This MCP connects directly to the Cronos network data, letting you analyze everything from simple wallet balances to deep contract logic. You talk to it naturally, and it returns raw blockchain facts. Instead of digging through explorer tabs for transaction history or spending hours trying to locate source code, your agent handles the query.
It monitors ERC-20 token movements, tracks NFT ownership changes, and even lets you run complex Ethereum calls—all in one place. If you're building tools that interact with Web3 data, Vinkius makes this MCP available so any compatible AI client can use it.
019e5d0e-78e8-7093-aff0-48d60c2241d8 Here's how it actually works
The bottom line is: it turns complex blockchain queries into simple natural language prompts.
Subscribe to this MCP on Vinkius and provide your Cronoscan API key.
Instruct your AI client what data you need—for example, 'What was the balance of this address last week?'
The agent uses the appropriate tools to query the blockchain and returns the analyzed result directly in chat.
Who is this actually for?
Web3 developers, crypto analysts, and DeFi users need this. It's for anyone who spends time cross-referencing data across multiple dashboards or needs to validate a contract interaction without setting up local node connections.
Debugging transaction failures by using proxy_eth_get_transaction_by_hash and inspecting raw event logs from get_logs.
Building on-chain reports to track asset movement, monitoring specific token transfers via get_token_nft_tx, or calculating total supply using get_token_supply.
Validating user account status by checking multiple balances with get_balance_multi and confirming contract eligibility using get_abi.
What Changes When You Connect
Stop jumping between tools. You can check a user's total portfolio value by combining get_balance and get_token_balance in one conversation flow.
Don't guess if a contract will work. Use proxy_eth_call to simulate function execution before committing gas, saving you time and money.
When debugging complex transactions, you don't just see the outcome; you get raw data logs via get_logs, which is crucial for finding subtle failures.
You can track asset ownership changes by combining transfers using get_token_nft_tx with standard transaction lists from get_tx_list.
It gives you a full picture of network costs, letting you use proxy_eth_estimate_gas alongside get_eth_price to budget accurately.
Getting the contract blueprint is simple. You can fetch both the source code via get_source_code and its structure using get_abi instantly.
See it in action
Investigating a Failed Transfer
A user sees an asset transfer failed. Instead of manually checking the explorer, they ask their agent to use proxy_eth_get_transaction_by_hash and then check the final status using get_tx_receipt_status. This confirms if the failure was due to gas limits or contract logic.
Auditing a Smart Contract
A developer needs to audit a new smart contract. They first use get_abi and get_source_code to understand its intent, then run proxy_eth_call multiple times with edge-case inputs to test every function before writing any code.
Tracking Whale Movements
An analyst wants to know if a large wallet is moving assets. They ask the agent to list all recent transfers using get_token_nft_tx and cross-reference that with CRO balances reported by get_balance_multi.
Calculating Total Portfolio Value
A DeFi user wants a total value report. They prompt the agent to check all holdings, triggering checks for both native tokens (get_balance) and multiple ERC-20 types (get_token_balance), providing one consolidated number.
The honest tradeoffs
Only checking current balances
Thinking that asking for a balance via get_balance is enough to understand why an account is low on funds.
Don't stop at the balance. Always follow up by requesting the full transaction list using get_tx_list and then checking internal movements with get_tx_list_internal. That shows you what caused the change.
Ignoring contract structure
Trying to call a function on a contract without knowing its required arguments or data types, leading to simulation failure.
Always start by calling get_abi for that address. That gives you the structured guide you need before attempting any calls with proxy_eth_call.
Assuming finality
Relying only on a successful read from proxy_eth_get_transaction_by_hash, which might show an initial state but miss later changes.
To be sure, you must cross-reference the transaction hash with both get_tx_receipt_status and raw event data using get_logs. That's how you guarantee consistency.
When It Fits, When It Doesn't
Use this MCP if your job requires deep state analysis or forensics. You need to know why a token moved, not just that it moved. For instance, if you only care about the current price of CRO, get_eth_price is faster and sufficient. But if you're debugging why an NFT failed to transfer, you must use the full suite: start with get_token_nft_tx, check the transaction details via proxy_eth_get_transaction_by_hash, and finally validate the resulting state change using get_logs. Don't try to do complex simulations like checking storage slots (proxy_eth_get_storage_at) without first reviewing the contract definition using get_abi; you might be querying a key that simply doesn't exist.
Questions you might have
How do I check multiple wallet balances with Cronoscan (Cronos Block Explorer) MCP? +
Use the get_balance_multi tool. This is much faster than calling get_balance repeatedly for every single address you need to track.
Can I simulate a contract call without actually paying gas using proxy_eth_call? +
Yes, that's exactly what proxy_eth_call does. It simulates the function execution logic and result without spending any real network funds or affecting the state.
What is the difference between get_logs and get_source_code? +
get_logs provides raw, technical event data emitted during contract activity. get_source_code gives you the human-readable code written by the developer.
How do I track internal transactions for an address using Cronoscan (Cronos Block Explorer) MCP? +
Use the get_tx_list_internal tool. This shows you the deeper, nested calls that happen when one contract interacts with another.
How do I calculate the required gas limit using proxy_eth_estimate_gas? +
It returns an estimate of the maximum gas needed for a transaction. You use this number to set your gas limit, preventing failed transactions due to insufficient funds.
When should I use proxy_eth_get_storage_at? +
You run this when you need to read data stored directly at a specific slot within the contract's storage. This lets you check internal state variables not exposed by standard functions.
How does get_tx_receipt_status help me debug a failed transaction? +
It checks the full receipt status, telling you if the transaction succeeded or reverted. This is crucial for debugging when simple listing tools don't provide enough detail.
How can I track all NFT movements using get_token_nft_tx? +
This tool tracks every ERC-721 transfer event associated with a specific address. It gives you a complete, chronological history of ownership changes for your NFTs.
Can I check the CRO balance of multiple wallet addresses in a single request? +
Yes! Use the get_balance_multi tool by providing a comma-separated list of addresses. The AI will return the current balance for each address in the list.
How do I retrieve the source code of a verified smart contract on Cronos? +
You can use the get_source_code tool with the contract's address. If the contract is verified on Cronoscan, the AI will fetch the source code, compiler version, and other optimization details.
Is it possible to track NFT transfers for a specific user? +
Absolutely. Use the get_token_nft_tx tool with the user's wallet address. You can also filter by a specific NFT contract address to narrow down the results.
We've already built the connector for Cronoscan Block Explorer. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 24 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.