Celoscan MCP for AI. Audit any Celo asset or contract state.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Celoscan (Celo Network Explorer) MCP gives your AI client direct access to the Celo blockchain data. You can check account balances, track all token transfers (ERC20 and NFT), audit smart contract source code, or review internal transaction flows—all through natural language prompts.
What your AI can do
Get erc20 token balance
Checks the balance of a specific ERC20 token held by an account, identified by its contract address.
Get erc20 token supply
Finds out the total circulating supply for any given ERC20 token contract.
Get account balance
Retrieves the current CELO balance for one specific blockchain address.
Instantly fetch the CELO balance for a single address or calculate total holdings across multiple addresses.
Retrieve verified contract ABIs and full source code, letting you inspect exactly how a smart contract is built.
Get detailed lists of ERC20 token transfers or track specific NFT (ERC721) movements associated with any address.
Query both normal, public transactions and internal, complex system transactions for a complete audit trail.
Determine the last known price of CELO or check estimated block countdown times by querying specific block numbers.
Ask an AI about this
Waiting for input…
Celoscan (Celo Network Explorer) with 18 Tools
These tools let you read every piece of available Celo network data, from simple account balances to complex contract source code.
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 Celoscan (Celo Network Explorer) on VinkiusGet Erc20 Token Balance
Checks the balance of a specific ERC20 token held by an account, identified by its contract address.
Get Erc20 Token Supply
Finds out the total circulating supply for any given ERC20 token contract.
Get Account Balance
Retrieves the current CELO balance for one specific blockchain address.
Get Block Countdown
Estimates how long it will be until the next block is mined, based on the target...
Get Block Number By Time
Finds out which block number was active at a specific date and time stamp.
Get Block Reward
Determines the reward amount for mining a particular block number.
Get Contract Abi
Fetches the Application Binary Interface (ABI) definition for any verified smart contract address.
Get Contract Source Code
Retrieves the original source code written for a verified smart contract.
Get Account Balance Multi
Calculates and returns the CELO balances for a list of multiple addresses at once.
Get Erc20 Transfers
Lists all historical transfer events for a specific ERC20 token associated with an...
Get Erc721 Transfers
Provides a list of ownership transfers for unique NFTs (ERC721) involving an address.
Get Internal Transactions
Retrieves complex, internal transactions that might not show up in standard history views.
Get Last Celo Price
Gets the most recent market price for CELO against a fiat or stablecoin pairing.
Get Mined Blocks
Lists all blocks that have been mined by an address over time.
Get Normal Transactions
Gets a standard list of public transactions associated with an address.
Get Total Celo Supply
Calculates the total number of CELO tokens currently in existence on the network.
Get Transaction Execution Status
Verifies whether a smart contract transaction executed successfully according to its...
Get Transaction Receipt Status
Checks the overall receipt status of a transaction hash on the blockchain.
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 Celoscan (Celo Network 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 18 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Tracking assets across the Celo blockchain used to be a mess of tabs and copy-pasting.
Today, checking an address's true history requires jumping between five different explorer dashboards. You find the main transaction list, then you have to manually search for ERC20 token movements in one tab, check if there were any complex internal flows in a second place, and finally pull the contract ABI into your IDE just to verify what functions exist. It's slow, it’s tedious, and you always risk missing that critical detail.
With this MCP, the process collapses into a single chat prompt. You ask for the full state—the balances, all token movements, and the source code context. Your agent handles the orchestration across multiple data streams, giving you one unified, structured answer immediately.
Get Contract Source Code with Celoscan (Celo Network Explorer)
Manual verification used to mean finding the contract address and then manually searching for the corresponding ABI or source code files on external developer sites. This was a two-step, highly manual process that often lagged behind actual protocol updates.
Now, you simply ask your agent, 'Give me the source code.' The MCP pulls it directly from verified sources. You get the definitive, up-to-date logic without leaving the terminal.
What your AI can actually do with this
The complexity of on-chain data is a major blocker for rapid analysis. Normally, figuring out what happened to an address means jumping between multiple explorer tabs, tracking down specific contract ABIs, and manually correlating transfer logs for every asset class. This MCP changes that. It connects your AI client directly to the Celo network’s core data streams.
You don't write complex RPC calls or juggle dozens of endpoints; you just ask the question. Your agent handles the logic, retrieving everything from current CELO holdings to deep internal transaction details and even the contract source code itself. This is how Vinkius makes connecting specialized blockchain services simple. You get actionable data—structured lists of transfers, specific balances, or block numbers—all without leaving your chat window.
019e5d06-1ea3-7307-9995-060b5c4156e9 Here's how it actually works
The bottom line is that your agent handles all the messy API calls, giving you clean, actionable blockchain data in one go.
Subscribe to this MCP and provide your Celoscan API key.
Your AI client sends a natural language prompt, specifying the addresses or contracts you need to check.
The MCP executes the necessary data queries and returns structured JSON containing the requested balances, transfer lists, or contract code.
Who is this actually for?
This MCP targets developers and analysts who spend too much time jumping between multiple web3 explorer dashboards. If you need to validate complex on-chain state—like tracing a token through internal transactions or checking the source code of a contract—you need this.
Needs to quickly pull contract ABIs and source code into their IDE when implementing new protocol features.
Requires exporting transaction histories and token movements for large-scale reporting or on-chain forensics reports.
Monitors multiple wallet balances and verifies the execution status of high-value transactions without leaving their chat interface.
What Changes When You Connect
Stop guessing balances. Use get_account_balance or get_account_balance_multi to instantly know an address's current CELO holdings, whether you're checking one wallet or a portfolio of ten.
Need to understand the code? Run get_contract_source_code and pull the full ABI using get_contract_abi. You get the raw logic needed for deep protocol validation right in your chat session.
Don’t trust just the main transaction history. Use get_internal_transactions to see the complex, underlying movements that often determine the true flow of funds on the network.
Track every piece of value. You can get lists of ERC20 token transfers via get_erc20_transfers and specifically track unique NFT ownership changes using get_erc721_transfers.
Get a full picture of time and state by checking the current market rate with get_last_celo_price, or mapping historical data points using get_block_number_by_time.
See it in action
Validating an Asset Sale
A crypto auditor asks their agent: 'What was the full flow of funds for this sale?' The agent runs get_account_balance, then checks both get_erc20_transfers and get_internal_transactions to confirm that all expected tokens moved correctly, validating the entire event chain.
Debugging a Smart Contract
A developer needs to validate if a contract function is working. They use get_contract_source_code and then run get_transaction_execution_status on recent data, allowing them to pinpoint exactly where the logic failed.
Tracking Portfolio Changes
A user wants to audit their total assets across five different wallets. Instead of running five separate checks, they use get_account_balance_multi to get all CELO balances in a single query.
Forensic Analysis
Data analysts need historical evidence. They use get_normal_transactions and cross-reference that data with get_mined_blocks to build a comprehensive timeline of activity for reporting purposes.
The honest tradeoffs
Manual Data Correlation
Opening the main explorer, finding the transaction ID, copying that hash into the 'Internal Transactions' tab, and then manually checking the status using a separate API call.
Just prompt your agent: 'Give me the full history for this address.' The agent orchestrates calls to get_normal_transactions, get_internal_transactions, and checks the receipt status with get_transaction_receipt_status—all in one step.
Missing Contract Context
Only knowing a contract address but having no idea what functions it supports, so they just try random queries that fail.
First, run get_contract_abi to understand the available methods. Then use get_contract_source_code to read the actual logic before attempting any advanced querying.
Ignoring Token Types
Assuming all token movements are visible in one place, leading to missed ERC20 transfers or unique NFT ownership changes.
Be specific. Ask for get_erc20_transfers if you're checking a standard token, and explicitly request get_erc721_transfers when you suspect an NFT movement.
When It Fits, When It Doesn't
Use this MCP if your primary need is deep, multi-layered reading of on-chain data. Right. So, if you're auditing a specific transfer, calling get_erc20_transfers and then checking the status with get_transaction_receipt_status is essential. But don't use it just because you want to know the current price; for simple market data, other dedicated financial APIs are often faster. Also, remember this MCP doesn't perform actions—it only reads state. If you need to send a transaction or execute code, you’ll need a different toolset entirely. This is purely read-only access.
Questions you might have
How do I check if a transaction succeeded using get_transaction_receipt_status? +
You pass the transaction hash to get_transaction_receipt_status. It returns whether the overall blockchain receipt confirms execution success or failure, which is key for basic validation.
Can I check multiple balances at once using get_account_balance_multi? +
Yes. You provide a list of addresses to get_account_balance_multi, and it returns the CELO balance for every single address in that batch response.
What is the difference between get_normal_transactions and get_internal_transactions? +
Normal transactions are the visible, public records of asset movement. Internal transactions capture the complex system logic or fund flows that happen behind those public movements.
Do I need to run get_erc20_token_supply for every token? +
Yes. To confirm the total supply, you must use get_erc20_token_supply and specify the contract address for each individual ERC20 token.
What if I want to see NFT transfers? Do I use get_erc721_transfers? +
Yes, that's right. Use get_erc721_transfers when you need a list of ownership changes for unique NFTs (ERC721 tokens). It handles those specific transfer events.
If I run many calls using get_normal_transactions, how do I handle rate limits? +
The MCP adheres to standard API rate limits, providing a clear error response when the limit is hit. Your agent needs to implement exponential backoff logic in your workflow when fetching large volumes of transaction data.
How do I find out what block number corresponds to a specific timestamp using get_block_number_by_time? +
This function takes an Epoch timestamp and returns the exact corresponding block number on the Celo network. It allows you to map historical events precisely without needing manual lookups.
What should my agent do if get_transaction_receipt_status fails for a transaction? +
If the function returns an error, it usually means the transaction hash is invalid or the block isn't mined yet. Your agent must check for specific failure codes before assuming a network connectivity issue.
Can I check the CELO balance of multiple addresses in a single request? +
Yes! Use the get_account_balance_multi tool and provide a comma-separated list of Celo addresses to retrieve all balances at once.
How can I view the source code of a verified smart contract on Celo? +
You can use the get_contract_source_code tool with the contract's address. If the contract is verified on Celoscan, the agent will return the full source code.
Is it possible to check if a specific transaction was successful? +
Yes, the get_transaction_receipt_status tool allows you to check the status of a transaction receipt to confirm if it was processed successfully on the network.
We've already built the connector for Celoscan. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 18 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.