# ZetaChain Explorer MCP > ZetaChain Explorer provides deep, read-only access to the ZetaChain blockchain. Your AI agent can query real-time data for any wallet or contract address, listing token balances, transaction histories, and smart contract details instantly. Stop clicking through explorer dashboards; get structured blockchain state directly into your workflow. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** zetachain, block-explorer, smart-contracts, web3, crypto-api ## Description This MCP lets your AI client talk directly to the raw data of the ZetaChain network. You can ask it specific questions—like 'What tokens does this wallet own?' or 'Show me every transaction associated with this contract address.' It pulls transaction histories, smart contract source code, and token balances on demand. The power comes from combining these reads into complex forensic analyses. For instance, you don't just see a balance; you can trace the exact internal transactions that led to it, including event logs and token movements across contracts. Since every action taken by your agent generates a cryptographically signed audit trail, you always know exactly what data flowed through the system. This makes auditing complex financial interactions reliable, because nothing happens in the dark. You connect once from any compatible client, and ZetaChain becomes one source of truth for all your analysis. ## Tools ### get_block_transactions Fetches all transactions that were included within one specified block. ### get_block Retrieves the header and core data for a specific block, identified by its hash or number. ### get_address_internal_transactions Retrieves the internal calls and contract interactions that occurred during a transaction involving an address. ### get_address_token_balances Calculates and returns the current token balance for a given standard at a specified address. ### get_address_tokens Lists all different types of tokens (standards) held by an address. ### get_address Gets general metadata about a specified blockchain address. ### get_address_transactions Gets a full list and details of every transaction linked to an address. ### get_smart_contract Retrieves the source code, ABI, and details for a specific smart contract address. ### get_token_holders Lists all addresses that currently hold a specific, identified token. ### get_token Provides detailed metadata about a token standard (e.g., its name or symbol). ### get_token_transfers Provides the historical records for specific token movements between accounts. ### get_transaction_internal Identifies and retrieves contract calls triggered by an initial transaction across the blockchain. ### get_transaction_logs Extracts all emitted event logs from a specific transaction, useful for tracing state changes. ### get_transaction Gets all details about a single transaction, using its unique hash identifier. ### list_blocks Retrieves a list of the most recent block identifiers on ZetaChain. ### list_tokens Lists all recognized token standards available on the ZetaChain network. ### list_transactions Retrieves a list of recent transactions that occurred across the entire ZetaChain network. ## Prompt Examples **Prompt:** ``` List the most recent blocks on ZetaChain. ``` **Response:** ``` I've retrieved the latest blocks. The most recent block is #5829102, mined 12 seconds ago with 45 transactions. Would you like to see the transactions for a specific block? ``` **Prompt:** ``` Show me the token balances for address 0x1234...abcd. ``` **Response:** ``` For address 0x1234...abcd, I found balances for 3 tokens: 150 ZETA, 0.5 WETH, and 1,200 USDC. Would you like to see the recent transaction history for this address? ``` **Prompt:** ``` Get the event logs for transaction 0xabc123... ``` **Response:** ``` I've fetched the logs for transaction 0xabc123... It emitted 2 events: a 'Transfer' event from the USDC contract and a 'Swap' event from the DEX router. Do you need the decoded parameters for these logs? ``` ## Capabilities ### Fetch address details Retrieves general information and metadata about a specific blockchain wallet or contract address. ### Analyze transaction history by address Gets a complete list of all transactions tied to a given address, regardless of the block they were in. ### Determine token holdings Lists every unique token type associated with an address and tracks its current balance. ### View specific token balances Provides the precise balance for a specified token standard at a given address. ### Get transaction details by hash Fetches all metadata and associated data points for an individual, known transaction ID. ### List recent blocks Retrieves a list of the most recently mined blocks on the ZetaChain network. ### Trace token movements Gets detailed records of where specific tokens were transferred, including source and destination addresses. ## Use Cases ### Investigating suspicious fund movement A forensic analyst needs to know if funds came from a specific source. They ask their agent to run `get_transaction` on the destination hash, and then use `get_address_internal_transactions` to see which contracts were called during the transfer. ### Auditing contract deployment A developer needs to verify if a new token behaves correctly. They run `get_smart_contract` first, then use `get_token_balances` on an address to confirm initial state, and finally track transfers using `get_token_transfers`. ### Building a dashboard of top holders A data analyst wants a list of the top 50 token owners. They use `list_tokens` to find the relevant asset, and then call `get_token_holders` to gather the required addresses for reporting. ### Verifying network health A researcher wants to know if transaction volume spiked recently. They use `list_transactions` combined with `get_block_transactions` to pull data from the last 24 hours and compare it against historical averages. ## Benefits - Trace every asset movement. Use `get_token_transfers` and `get_transaction_logs` to reconstruct the exact path a token took, providing forensic-level visibility into fund flow. - Analyze complex addresses. Get a full view of an address's activity by chaining `get_address_transactions` with `get_address_internal_transactions`, showing both external and internal contract calls. - Check asset ownership instantly. Use `get_address_token_balances` to get the exact current balance for any token standard, saving time over manual dashboard checks. - Monitor network activity at scale. By running `list_blocks` or `list_transactions`, your agent pulls aggregate data sets, letting you analyze trends without needing multiple manual queries. - Understand contract mechanics. Use `get_smart_contract` to pull the ABI and source code, allowing your agent to understand *how* a deployed smart contract actually executes logic. ## How It Works The bottom line is that you treat complex blockchain reads like simple API calls: ask your agent, and it fetches the raw truth from ZetaChain. 1. Subscribe to this MCP in your Vinkius account and enter your ZetaChain API Key (if required). 2. Instruct your agent to perform the required query, such as 'List all transactions for address X.' 3. The agent executes the necessary call against the blockchain data and returns a structured JSON response containing the requested details. ## Frequently Asked Questions **How do I check token balances using get_address_token_balances?** You pass two inputs: the target address and the specific token standard (e.g., ZETA). The tool returns the precise current balance, making it easy to track ownership. **What is the difference between get_address_transactions and list_transactions?** `list_transactions` shows recent activity across the entire network. `get_address_transactions` filters that view down to only show events tied specifically to a single address. **Can I see what happened inside a transaction using get_transaction_internal?** Yes, this tool pulls internal contract calls triggered by the main transaction. It's crucial for understanding complex interactions that aren't visible in the primary transaction record. **How do I find out who owns a specific token using get_token_holders?** You call `get_token_holders` and provide the token standard. The MCP returns a list of all addresses that currently hold that asset on the ZetaChain network. **What should I do if my connection to get_block fails?** If you hit an error, first check your API key and ensure it hasn't expired. Failures often mean the requested block hash or number doesn't exist on the network yet. **Does get_smart_contract provide more than just the ABI?** Yes, beyond the Application Binary Interface (ABI), this tool gives you key details about the contract itself, like its creation address and total supply. This is crucial when debugging logic. **How are the logs from get_transaction_logs different from transactions in a block?** Logs track specific emitted events (like 'Transfer'), while `get_block_transactions` shows the entire list of executed transfers and calls. They capture two distinct types of data. **Can I limit results when using list_tokens for performance?** You can specify a parameter to paginate or filter the token listing, preventing massive data dumps. This keeps your queries efficient and under rate limits. **Can I inspect the internal calls triggered by a specific transaction?** Yes. Use the `get_transaction_internal` tool with the transaction hash to retrieve all internal contract calls and operations associated with that transaction. **How do I check all token balances for a specific wallet address?** Simply provide the wallet address to the `get_address_token_balances` tool. It will return a comprehensive list of all tokens held by that address on ZetaChain. **Is it possible to view the source code or ABI of a smart contract?** Yes, the `get_smart_contract` tool allows you to fetch the metadata and details of a verified smart contract using its address.