Zetachain Explorer MCP. Audit and trace any asset movement on ZetaChain.
Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Zetachain Explorer (ZetaChain Block Explorer API) is an MCP Server that gives your AI agent direct access to the ZetaChain blockchain.
It lets you query real-time data on blocks, transactions, token balances, and smart contracts using 17 specialized tools. You can inspect any wallet's history or trace complex asset movements without leaving your chat interface.
What your AI agents can do
Get address
Retrieves core details for a specific blockchain address.
Get address internal transactions
Gets contract calls that ran internally within a transaction associated with an address.
Get address token balances
Retrieves the current token balances for all assets belonging to an address.
Retrieve specific information about a block using its hash or number via get_block.
Fetch the complete list of transactions and associated data for any given address through get_address_transactions.
Identify all unique tokens held by an address, listing their respective balances using get_address_tokens.
Get the deep-dive records of contract calls triggered by a primary transaction hash via get_transaction_internal.
Generate a list of every address that currently owns a specific token using get_token_holders.
Fetch the smart contract's source code and Application Binary Interface (ABI) details via get_smart_contract.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
Zetachain Explorer: 17 Tools for Blockchain Analysis
Access the full suite of APIs to query every aspect of the ZetaChain network, including token holder lists, transaction logs, and contract source code.
019e5d6aget address
Retrieves core details for a specific blockchain address.
019e5d6aget address internal transactions
Gets contract calls that ran internally within a transaction associated with an address.
019e5d6aget address token balances
Retrieves the current token balances for all assets belonging to an address.
019e5d6aget address tokens
Lists every unique type of token associated with a given address.
019e5d6aget address transactions
Fetches the full list and details of all transactions linked to an address.
019e5d6aget block
Gets detailed information about a specific block, either by its hash or block number.
019e5d6aget block transactions
Retrieves all transactions that were included within a specified block.
019e5d6aget smart contract
Fetches the source code and ABI for a contract address, allowing structural inspection.
019e5d6aget token
Retrieves metadata and details for a specific token type on ZetaChain.
019e5d6aget token holders
Generates a list of all addresses that currently hold a specified token.
019e5d6aget token transfers
Retrieves records detailing specific transfers of tokens between two addresses.
019e5d6aget transaction
Gets the full details for a single transaction using its unique hash.
019e5d6aget transaction internal
Retrieves secondary, internal contract calls triggered by a primary transaction hash.
019e5d6aget transaction logs
Fetches raw event logs emitted by a transaction for deep debugging purposes.
019e5d6alist blocks
Lists the most recently mined blocks on the ZetaChain network.
019e5d6alist tokens
Provides an overview and list of all token types available on ZetaChain.
019e5d6alist transactions
Lists the most recently executed transactions across the entire network.
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 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
You're dealing with blockchain data. You need more than just a pretty web interface; you need raw access for your AI agent. The Zetachain Explorer API is an MCP Server that hands your agent direct command-line power over the ZetaChain ledger. It lets your client skip the manual clicking, turning complex tasks—like tracking asset movements or reverse-engineering smart contract calls—into simple, executable commands.
Your agent uses 17 specialized tools to interrogate every layer of the network. You can build sophisticated data pipelines that read block headers, check token ownership, and trace internal logic without leaving your chat window.
When you need a high-level overview, start by seeing what's happening across the whole chain. You'll use list_blocks to pull a list of recently mined blocks, or run list_transactions to see every executed transaction across ZetaChain. If you want an inventory of available assets, list_tokens gives you the full directory of token types in circulation.
To dive into specific addresses, your agent first uses get_address to fetch core details for any given address. For a complete history check, it runs get_address_transactions, which pulls every single transaction and its associated data linked to that wallet. If you want to know what assets the wallet currently holds, get_address_tokens retrieves all unique token types belonging to that address.
But knowing what they hold isn't enough. You can use get_token_balances to get the current balance for every asset associated with an address. For deeper forensic work on assets, you first call get_address_tokens to list every unique token type held, then use that data to execute specific checks like getting detailed metadata via get_token, or tracking exactly who owns a certain asset using get_token_holders.
To see the movement of funds, you run get_token_transfers, which returns records detailing specific transfers between two addresses.
When investigating activity on a single transaction, your agent starts with get_transaction to fetch all details for one unique hash. If that primary transaction triggered secondary contract actions—those internal calls—you'll use get_transaction_internal. For the absolute deepest level of debugging, you can pull the raw event logs emitted by any transfer using get_transaction_logs.
You also get a full picture of what happened within an address's history by running get_address_internal_transactions, which specifically targets contract calls that ran internally during a transaction associated with that address.
Need to inspect the block itself? Use get_block to pull detailed information about any specific block, either by its hash or its number. If you want to see every single transfer contained within that exact block, you run get_block_transactions. For smart contract analysis—the real heavy lifting—you use get_smart_contract to fetch the source code and Application Binary Interface (ABI) for a contract address, letting you inspect its structure.
Finally, if you only have a transaction hash but need the full data payload, you can get it using get_transaction.
How Zetachain Explorer MCP Works
- 1 First, prompt your AI client to identify the target entity. You might start by listing recent blocks with
list_blocks, or checking a wallet's assets usingget_address_tokens. - 2 Next, tell the agent exactly what you need. If you want transaction history, ask it to use
get_address_transactionsfor that specific address. - 3 Finally, the agent executes the necessary tools and returns structured data—for example, listing token transfers using
get_token_transfersor providing raw event logs withget_transaction_logs.
The bottom line is you tell your AI client what blockchain question you have, and it runs multiple specialized API calls to build the full answer for you.
Who Is Zetachain Explorer MCP For?
This tool is built for people who live in the intersection of development and finance. If you're a developer debugging smart contracts or an analyst needing reliable, auditable transaction data without copy-pasting from ten different tabs, this is your endpoint. It’s essential when manual cross-referencing is too slow.
Debugging smart contracts by running get_smart_contract and verifying event logs using get_transaction_logs directly from the terminal.
Extracting token holder lists using get_token_holders or calculating total transaction volumes across multiple addresses without manual spreadsheet work.
Tracing complex asset movements by correlating raw data from get_transaction_internal with high-level balances retrieved via get_address_tokens.
What Changes When You Connect
- See a full transfer history by calling
get_address_transactions. This replaces the need to navigate through multiple block explorer tabs just to track an address's activity over time. You get the whole timeline, not just the last few calls. - Verify token ownership instantly with
get_address_tokens. Instead of checking a dashboard for balances, you ask your agent and it returns every unique asset type owned by that address in one structured list. - Deep-dive into contract logic using
get_smart_contract. This allows you to pull the full ABI and code, letting your agent validate if a transaction call is interacting with expected functions before you write any surrounding code. - Rebuild complex event sequences by pairing tools. Use
list_transactionsto find a key hash, then runget_transaction_internalon it. This shows you the secondary contract calls that drove the main action—the full story of the transaction. - Audit entire asset distributions with
get_token_holders. If you need to know who owns 10% of an NFT collection, this tool generates the list immediately, eliminating hours of manual data scraping. - Trace specific events using
get_transaction_logs. This goes beyond simple balances; it captures raw 'Transfer' or 'Swap' events, letting forensic analysts see exactly what data was emitted by the contract.
Real-World Use Cases
Investigating a Suspicious Wallet
A security analyst suspects an address is involved in illicit activity. Instead of manually checking blocks, they ask their agent to run get_address_transactions and then feed the results into get_transaction_logs. The agent cross-references these raw logs with get_address_tokens to see if any unusual asset types were moved recently, providing a complete audit trail.
Tracking NFT Distribution
A project manager needs to know who owns the initial batch of tokens. They use list_tokens first to find the contract ID, then run get_token_holders. This instantly generates a comprehensive list of all addresses holding that specific asset, which they can export immediately.
Debugging DeFi Interactions
A developer notices a transaction failed. They use get_transaction to pull the hash, then run get_transaction_internal. This reveals if the failure was due to an unexpected contract call or insufficient gas, allowing them to fix their smart contract before deployment.
Analyzing Market Concentration
An analyst wants to know how many unique addresses hold a newly launched stablecoin. They use get_token_holders with the token address. The agent returns the count and list of top holders, immediately quantifying market distribution.
The Tradeoffs
Checking only current balances.
A user just asks for the balance using get_address_tokens and assumes that's all they need. They miss out on understanding how the asset got there or if it was involved in a complex contract call.
→
Always pair get_address_tokens with get_address_transactions. This shows not just what you have, but every movement (get_token_transfers) that led to your current balance. The history provides context the balance alone can't.
Assuming one tool covers everything.
Relying only on list_transactions and thinking you have all event data. You will miss crucial contract-level details, like internal calls or raw emitted events that are critical for debugging.
→
When analyzing a specific transaction hash, run three tools: get_transaction, then get_transaction_internal, and finally get_transaction_logs. This triple-check ensures you capture the main action, the secondary contract interactions, and all raw emitted data.
Ignoring the source code.
Running a transaction analysis without knowing what the smart contract actually does. You might misinterpret why an asset moved or what function was called.
→
Before analyzing transactions on a new contract, always call get_smart_contract. Checking the ABI and source code first gives you the manual to understand exactly how that contract operates.
When It Fits, When It Doesn't
Use this server if your job requires forensic-level visibility into blockchain state changes. This is for auditing, development debugging, or deep market analysis. If you need to know who owns something (get_token_holders) or how a contract works (get_smart_contract), use this.
Don't use it if you just need simple data from a single source. For instance, if you only care about the total number of blocks mined today, using list_blocks is sufficient. If you are tracking a wallet and only want to know its current token balances, get_address_tokens will get you 90% of what you need—but remember to follow up with transaction tools for context.
The key boundary check: If the question involves 'Why?' (e.g., Why did this balance drop?), you must use a multi-step workflow involving transaction and log retrieval (get_transaction* and get_address*).
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
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 server provides 17 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Tracking asset movement across web3 is a manual nightmare.
Today, figuring out why an address's token count changed requires jumping between the block explorer, checking transaction details, then looking at internal calls—it’s copy-pasting hashes and navigating ten different tabs just to build a single timeline. You spend time clicking, not analyzing.
With the Zetachain Explorer MCP Server, your agent handles it all. Instead of manual clicks, you ask: 'Show me everything that happened with this address.' The result set consolidates the transaction history (`get_address_transactions`), internal calls (`get_transaction_internal`), and token balances (`get_address_tokens`) into one structured output.
The Zetachain Explorer (ZetaChain Block Explorer API) MCP Server provides `get_smart_contract`.
Before, if you wanted to know the rules of a contract—its functions or what types of data it handles—you had to find the source code on an external website and manually parse the ABI. This process was slow and prone to human error.
Now, just ask your agent to run `get_smart_contract`. It pulls the contract details directly into your workflow. You get the full ABI and code right where you're working, letting you validate interactions instantly without leaving the chat.
Common Questions About Zetachain Explorer MCP
How do I find all assets owned by an address using get_address_tokens? +
The get_address_tokens tool lists every unique token type for an address. To see the balance of those tokens, you must follow up and call get_address_token_balances. This two-step process gives you a complete picture of ownership.
What is the difference between get_transaction and get_block_transactions? +
get_transaction provides all details for one specific transaction hash. get_block_transactions gathers every transaction that was packaged into a single, defined block.
Can I trace the raw events from a transfer using get_transaction_logs? +
Yes. The get_transaction_logs tool retrieves all emitted event logs for a specific hash. This is crucial because it shows the raw data (like 'Transfer' or 'Swap') that occurred, even if simple balance tools miss it.
If I need to know who owns a specific token, should I use get_token_holders? +
Yes. get_token_holders is the dedicated tool for this job. It queries the entire ledger and returns a list of all addresses that currently hold the specified token.
How do I check if an address executed any contract calls? Should I use get_address or get_transaction_internal? +
Use get_address_transactions first to find relevant transaction hashes. Then, for those specific transactions, run get_transaction_internal. This reveals the secondary contract activity that happened within the primary transaction.
What happens if I exceed rate limits when using list_blocks? +
Your AI client will receive a standard HTTP 429 error. This means you've hit the server's rate limit threshold. To handle this, your agent should be programmed with an exponential backoff mechanism for retries.
When I use get_smart_contract, how do I find out what functions it supports? +
The get_smart_contract tool returns the contract's Application Binary Interface (ABI) alongside its code. You need this ABI because it maps all available function names and their required parameters for your agent.
What is the difference between a main transaction and an internal call found using get_address_internal_transactions? +
Internal transactions describe secondary contract calls that happen inside a primary, recorded transaction. They show the underlying steps when one smart contract triggers another.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
DeveloperHub
Equip your AI agent to manage documentation projects, track pages, and monitor changelogs via the DeveloperHub API.
Mailinator
Test email workflows with disposable inboxes that catch every message without touching production mailboxes or real addresses.
Deterministic Array Operations
Equip your AI with high-performance array manipulation. Deterministically chunk large datasets, deep-deduplicate objects, and intersect arrays 100% local.
You might also like
Google Sheets
Interact with Google Sheets to read, write, and manipulate data via AI.
Watchmode Streaming Availability
Find where to watch any movie or TV show — search streaming availability across Netflix, Disney+, HBO Max, and 200+ platforms directly from your AI agent.
Dashly
Convert more website visitors with targeted pop-ups, live chat triggers, and automated lead nurturing sequences.