ZetaChain Explorer MCP for AI. Audit any blockchain state in natural conversation.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
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.
What AI agents can do with Zetachain Explorer (ZetaChain Block Explorer API) Automation
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.
Retrieves general information and metadata about a specific blockchain wallet or contract address.
Gets a complete list of all transactions tied to a given address, regardless of the block they were in.
Lists every unique token type associated with an address and tracks its current balance.
Provides the precise balance for a specified token standard at a given address.
Fetches all metadata and associated data points for an individual, known transaction ID.
Retrieves a list of the most recently mined blocks on the ZetaChain network.
Gets detailed records of where specific tokens were transferred, including source and destination addresses.
Ask an AI about this
Waiting for input…
What AI agents can do with ZetaChain Explorer (ZetaChain Block Explorer API) with 17 Tools
These tools give your agent granular control over reading every piece of historical and current blockchain data on ZetaChain, from listing blocks to checking specific token balances.
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 Zetachain Explorer (ZetaChain Block Explorer API) on VinkiusGet 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...
Get Address Internal Transactions
Retrieves the internal calls and contract interactions that occurred during a...
Get Address Token Balances
Calculates and returns the current token balance for a given standard at a specified...
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...
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 Zetachain Explorer (ZetaChain Block Explorer API), 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
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by ZetaChain Explorer. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
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 17 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Tracking Asset Movement in Explorer Tabs, Solved with Vinkius AI Gateway
Today, tracking asset movement means opening multiple tabs: one for the address, one for recent blocks, and another for token standards. You copy hashes here, paste them there, then manually check if the transfer log matches the balance change reported on the main dashboard. It's slow, error-prone, and you always risk missing a critical internal contract call.
With this MCP, your agent handles the entire process in one go. Tell it the address, and it pulls the full activity stream, using tools like `get_address_transactions` and `get_transaction_logs` to assemble the complete chain of events into a single output for you.
Getting Full Address State with get_address_internal_transactions
Before, if an address received funds through a complex contract interaction, the main transaction history might only show 'Contract A called.' You'd have to jump to a separate internal transactions page to figure out where the money actually went and what parameters were used.
Now, your agent uses `get_address_internal_transactions` to pull those hidden calls directly into your script. It shows you the full execution path—the contract call, the logs, and the resulting state change—all without leaving your terminal.
What your AI can actually do with this
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.
019e5d6a-50f3-732f-8acd-c46d4ef96ee8 Here's how it actually 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.
Subscribe to this MCP in your Vinkius account and enter your ZetaChain API Key (if required).
Instruct your agent to perform the required query, such as 'List all transactions for address X.'
The agent executes the necessary call against the blockchain data and returns a structured JSON response containing the requested details.
Who is this actually for?
Forensic data analysts, smart contract auditors, and Web3 developers use this MCP. They struggle with manually cross-referencing multiple explorer tabs to build a complete picture of asset movement across chains.
Checks the internal transactions of a deployed contract to verify its execution logic and ensure token handling follows expected standards.
Extracts lists of all current token holders for an asset or tracks historical transaction volumes across multiple time periods without manual data exports.
Builds applications that require real-time, structured reads of block headers and individual transaction logs directly into development tools.
What Changes When You Connect
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.
See it in action
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.
The honest tradeoffs
Querying only a single transaction type
Asking for just 'balances' or just 'transactions'. This misses critical data like internal calls that explain why the balance changed.
Always start broad. Use get_address_transactions to find the event, then use get_transaction_internal and get_transaction_logs on the specific transaction hash for the full story.
Assuming a balance is accurate
Relying only on an initial get_address_token_balances check without verifying recent transfers.
Always validate. After checking balances, immediately call get_token_transfers or get_transaction_logs to prove the current state is legitimate.
Ignoring block context
Just listing transactions without knowing which blocks they belong to. This makes time-series analysis impossible.
Always use list_blocks first, then drill down using get_block_transactions if you need to analyze activity confined to a specific mining period.
When It Fits, When It Doesn't
Use this MCP when your job requires reading the immutable state of the ZetaChain ledger. If you need to know what happened (history, transfers, logs), or who owns what (balances, holders), use this. Don't use it if you need to execute a transaction, mint an asset, or change any data; this MCP is read-only. For instance, get_address lets you check details, but it won't send anything. If your goal is purely aggregation of metadata (like listing all available token standards), then list_tokens works best. Never use a balance tool if you don’t also verify the transaction logs; that gives you an incomplete picture.
Questions you might have
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.
We've already built the connector for ZetaChain Explorer. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 17 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.