# Corescan MCP > Corescan (Core DAO Blockchain Explorer) lets your AI agent read the Core DAO network directly. Check account balances, track every ERC-20 or NFT transfer, and inspect smart contract source code in one go. You get real-time on-chain data—everything from total supply metrics to transaction status. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** core-dao, blockchain-explorer, smart-contracts, web3, crypto-tracking ## Description This MCP connects your agent to the entire Core DAO ecosystem. Instead of opening a browser, navigating to multiple tabs, and copying addresses, you ask your AI client for specific blockchain data. It pulls account balances, traces token movements (both ERC-20 and NFTs), and provides details on how smart contracts actually function by retrieving their source code and ABIs. You can also monitor the network's health, checking block rewards or current total supply. If you’re already using Vinkius to manage other APIs, adding this MCP gives your agent a complete picture of asset flow, all from a single conversational prompt. ## Tools ### get_account_balance_multi Gets the CORE balance for several blockchain addresses in a single request. ### get_account_balance Retrieves the Core DAO (CORE) balance for one specified blockchain address. ### get_block_countdown Provides an estimate of how long until the next block is mined into the network. ### get_block_reward Returns the CORE reward amount associated with a specific block number. ### get_contract_abi Retrieves the Application Binary Interface (ABI) for verified smart contract source code. ### get_contract_source_code Gets the actual source code used by a verified smart contract. ### get_erc20_transfers Lists all transfer events for ERC-20 tokens associated with a given address. ### get_erc721_transfers Tracks transfer events for non-fungible tokens (NFTs) using the ERC-721 standard. ### get_internal_transactions Fetches a list of internal transactions that occurred involving a specific address. ### get_last_price Provides the most recent recorded price point for CORE. ### get_logs Retrieves generalized event logs emitted by smart contracts. ### get_normal_transactions Fetches a list of standard, user-initiated transactions associated with an address. ### get_total_supply Returns the current total circulating supply amount for CORE. ### get_tx_receipt_status Checks the confirmation status and details of a specific transaction receipt. ### get_tx_status Determines if a contract execution attempt was successful or failed. ## Prompt Examples **Prompt:** ``` What is the CORE balance of address 0x393849...? ``` **Response:** ``` The address 0x393849... currently holds 150.25 CORE on the Core DAO network. ``` **Prompt:** ``` List the last 5 normal transactions for address 0xabc123... ``` **Response:** ``` I've retrieved the last 5 transactions for 0xabc123... The most recent was a transfer of 10 CORE to 0xdef... in block 1234567. ``` **Prompt:** ``` Get the ABI for the smart contract at 0x789ghi... ``` **Response:** ``` I have successfully fetched the ABI for the contract at 0x789ghi... It includes functions like 'transfer', 'balanceOf', and 'mint'. Would you like me to explain any specific function? ``` ## Capabilities ### Check Core DAO balances Retrieve the CORE balance for one or many addresses in a single query. ### Trace token movements Monitor specific transfers of ERC-20 tokens and non-fungible NFTs (ERC-721) across accounts. ### Analyze contract logic Fetch the verified source code and Application Binary Interface (ABI) for smart contracts. ### Review transaction history Get a full list of both standard wallet transactions and complex internal contract calls. ### Monitor network health Check key metrics like the total supply, block rewards, or estimated block countdown time. ## Use Cases ### Investigating a suspicious transfer A user sees an unexpected dip in their portfolio. They ask the agent for details, and it uses `get_erc721_transfers` to pinpoint which NFT was moved, followed by `get_internal_transactions` to see if the movement was related to a smart contract interaction. ### Auditing a new DeFi protocol A developer needs to check a new lending platform. They ask the agent to use `get_contract_abi` and `get_contract_source_code`. This lets them read the contract's logic directly, verifying functions like borrowing or collateral requirements. ### Reporting on total market activity A data analyst needs to report on asset liquidity. They ask for `get_account_balance_multi` across 20 major wallet addresses and combine that with the overall network health metrics from `get_total_supply`. ### Debugging a failed deployment A developer runs into an error. They ask the agent to check the status using `get_tx_status` on the latest transaction hash, immediately determining if the contract execution simply failed or hit a logic bug. ## Benefits - You stop guessing about an account’s state. Instead of just checking the balance with `get_account_balance`, you can use `get_normal_transactions` and `get_internal_transactions` to see exactly how that CORE was moved. - Contract deep-dives are fast. For a developer, using `get_contract_abi` or `get_contract_source_code` lets you understand the underlying logic of any smart contract without leaving your code editor. - Tracking assets is simple. You can monitor every type of movement—from stable ERC-20 tokens via `get_erc20_transfers` to unique NFTs using `get_erc721_transfers`. All in one prompt. - You get a full picture of network health. Need to know if the CORE supply is growing? Use `get_total_supply` or check block rewards with `get_block_reward` for real-time metrics. - Status checks are built-in. Don't wait on confirmations; you can use `get_tx_status` and `get_tx_receipt_status` to verify if a transaction succeeded or failed instantly. ## How It Works The bottom line is you tell your AI what asset or address you're interested in, and it gets the raw, up-to-date blockchain facts. 1. Subscribe to this MCP and provide your Corescan API Key within Vinkius. 2. Direct your AI client (Claude, Cursor, etc.) to use the blockchain tools for a specific task. 3. Your agent sends a query, and the MCP returns structured data detailing balances, transactions, or contract code. ## Frequently Asked Questions **How do I check multiple addresses for their CORE balance using get_account_balance_multi?** You pass a list of up to 20 addresses directly into the `get_account_balance_multi` tool. It returns all balances in one structured response, saving you many individual calls. **Can I use get_erc721_transfers for any NFT?** No, this MCP only tracks transfers on the Core DAO network. You must provide an address that uses the ERC-721 standard and has recent activity to track. **Is get_contract_abi enough to understand a smart contract?** No, the ABI only tells you what functions *exist*. To know how they work, you also need to call `get_contract_source_code` and read the actual underlying logic. **What’s the difference between get_normal_transactions and get_internal_transactions?** Normal transactions are direct user actions. Internal transactions show the complex, back-end calls made by smart contracts themselves when processing an action. **If I use get_tx_status, how do I know if a contract execution failed or was pending?** The function confirms the final outcome of an executed transaction. It returns specific status codes that indicate success, failure, or if the transaction is still waiting for confirmation on the blockchain. **Why should I use get_logs instead of just listing transactions?** Event logs provide granular data points a simple list can't capture. They show exactly what happened when a smart contract fired an event, giving you deep insight into the transaction's internal logic. **Are there rate limits if I query historical data using get_normal_transactions?** Yes, the API enforces usage quotas. If you exceed the allowed number of calls in a given time frame, your agent will receive a specific error code telling you when you can try again. **How does calling get_total_supply help me analyze the CORE economy?** This function provides a single metric for the entire network's supply. It helps analysts track total circulating tokens and gauge market health, independent of any specific wallet activity. **Can I check the balance of multiple Core DAO addresses at once?** Yes! Use the `get_account_balance_multi` tool and provide a comma-separated list of up to 20 addresses to get all balances in a single response. **How can I see the source code of a smart contract on Core DAO?** You can use the `get_contract_source_code` tool with the contract's address. If the contract is verified on Corescan, the AI will retrieve the full source code for you. **Does this server support tracking NFT transfers?** Absolutely. Use the `get_erc721_transfers` tool to list all NFT transfer events associated with a specific wallet address or contract.