Ankr (Web3 Node API) MCP. Query any blockchain state using natural language.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Ankr (Web3 Node API) gives your AI client direct access to Ethereum and other EVM chain data. Use this server to query block numbers, check wallet balances across multiple chains, or inspect smart contract state without writing a single RPC call.
It reads raw blockchain data—from finding NFT metadata via `ankr_getNFTMetadata` to simulating transactions with `eth_simulateV1`. Basically, it turns the entire decentralized ledger into callable tools for your agent.
What your AI agents can do
Ankr getAccountBalance
Gets all token balances held by a specific wallet address.
Ankr getBlocks
Retrieves detailed information for a defined range of blockchain blocks.
Ankr getInteractions
Lists every different blockchain an address has interacted with in its history.
The server fetches all token balances associated with a given wallet address.
It provides full information for any specified range of blocks across supported networks.
You can run complex transaction simulations, checking state changes without spending gas or confirming on the network.
The system accesses raw storage slots (eth_getStorageAt) and filters event logs (eth_getLogs) for deep data analysis of smart contracts.
It lists all holders of a specific NFT collection or retrieves metadata for an individual Non-Fungible Token.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Ankr Web3 Node API: 32 Tools for Blockchain Data Access
These tools give your AI agent granular control over every aspect of the blockchain state. Check balances, run calls, and simulate transactions across multiple EVM chains.
019e5cfbankr getAccountBalance
Gets all token balances held by a specific wallet address.
019e5cfbankr getBlocks
Retrieves detailed information for a defined range of blockchain blocks.
019e5cfbankr getInteractions
Lists every different blockchain an address has interacted with in its history.
019e5cfbankr getNFTHolders
Finds and lists all addresses that currently own a specific NFT collection.
019e5cfbankr getNFTMetadata
Retrieves the descriptive metadata for a single, specified Non-Fungible Token.
019e5cfbankr getNFTsByOwner
Collects and lists all NFTs owned by an address across various supported chains.
019e5cfbankr getTokenPrice
Returns the current market price of a specified token in USD.
019e5cfbankr getTokenTransfers
Gathers and displays historical records of specific token movements.
019e5cfbeth blockNumber
Returns the most current block number for the active chain.
019e5cfbeth call
Executes a read-only function call on a smart contract without changing the blockchain state or spending gas.
019e5cfbeth estimateGas
Calculates and returns the estimated amount of gas needed for a proposed transaction.
019e5cfbeth getBalance
Returns the current native currency balance associated with an address.
019e5cfbeth getBlockByHash
Fetches all block data using a unique transaction hash identifier.
019e5cfbeth getBlockByNumber
Retrieves complete block details when given the sequential block number.
019e5cfbeth getCode
Reads and returns the raw compiled bytecode associated with a specific contract address.
019e5cfbeth getLogs
Filters and retrieves event logs (like token transfers) based on specific criteria.
019e5cfbeth getStorageAt
Reads the raw value stored at a precise storage position within a contract.
019e5cfbeth getTransactionByHash
Gets all details for an already submitted transaction using its unique hash.
019e5cfbeth getTransactionCount
Determines the number of transactions (nonce) sent from a given address.
019e5cfbeth getTransactionReceipt
Retrieves the final, confirmed receipt details for a completed transaction.
019e5cfbeth sendRawTransaction
Submits a fully signed and prepared raw transaction to the network for processing.
019e5cfbeth simulateV1
Runs a sequence of transactions or blocks in an isolated environment to predict outcomes and check for errors.
019e5cfbgetAccountInfo
Retrieves general, comprehensive information tied to a public key (Pubkey).
019e5cfbgetBalance
Returns the native currency balance of an account using lamports.
019e5cfbgetBlock
Gets identity and transaction data for a confirmed block record.
019e5cfbgetBlockHeight
Reports the current, highest sequential block height on the chain.
019e5cfbgetEpochInfo
Provides information specific to the current operational epoch of the network.
019e5cfbgetLatestBlockhash
Returns the hash identifier for the most recent block, necessary for transaction building.
019e5cfbgetProgramAccounts
Lists all accounts that are programmatically owned by a specified smart contract address.
019e5cfbgetTransaction
Fetches detailed records for a transaction that has been confirmed on the chain.
019e5cfbsendTransaction
Submits a signed, prepared transaction to the network.
019e5cfbsimulateTransaction
Runs an isolated simulation of a single transaction to detect potential errors before sending it out.
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 Ankr (Web3 Node 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
Ankr Web3 Node API gives your AI client direct access to Ethereum and every other EVM chain data. You don't need to write a single RPC call or mess with JSON payloads in Postman; you just ask questions, and the server handles the rest. This lets your agent treat the entire decentralized ledger like callable tools.
Checking Accounts and Balances
You can pull up any account's current financial status. Use ankr_getAccountBalance to get every token balance held by a specific address. Need just the native currency? eth_getBalance reports that for you using lamports. You also check how active an address is; ankr_getInteractions lists everything it's ever touched. If you need general identity info, getAccountInfo pulls comprehensive details tied to a public key (Pubkey).
To track ownership of digital collectibles, ankr_getNFTsByOwner collects and lists all NFTs owned by an address across supported chains. You can even find out who owns specific collections using ankr_getNFTHolders, or pull the detailed description for just one token with ankr_getNFTMetadata. For crypto history, you gather historical records of tokens moving around with ankr_getTokenTransfers.
Reading and Inspecting Contract State
You don't have to trust what a website shows you; you can read the raw data. You run read-only function calls on smart contracts using eth_call; this checks current state without spending gas or changing anything. To see the fundamental code, use eth_getCode which returns the raw compiled bytecode for any contract address.
For deeper analysis, eth_getStorageAt reads the actual value stored at a precise spot in the contract's memory. You filter and pull out specific event logs—like token transfers or state changes—using eth_getLogs. This level of detail lets you analyze exactly what happened inside complex smart contracts.
Understanding Transactions and Blocks
You can look deep into any transaction that’s already been submitted. If you have a unique hash, eth_getTransactionByHash pulls all its details. The final confirmation is in the receipt; use eth_getTransactionReceipt for that. To check how many times an address has sent transactions (its nonce), you call eth_getTransactionCount. For block data, you can retrieve complete records using eth_getBlockByNumber with a sequential number, or pull all details just from its unique hash using eth_getBlockByHash.
You get the current network status easily; eth_blockNumber gives you the most up-to-date block count, and getLatestBlockhash gets the identifier for the newest block. If you need to check a specific transaction that finished successfully, getTransaction pulls those detailed records.
Running Simulations and Writing Data
You never wanna spend real money on something that might fail, right? You run complex simulations using eth_simulateV1, which checks entire sequences of transactions in an isolated environment to predict outcomes or find errors before you commit. For a single shot, simulateTransaction runs the same kind of pre-check. Before sending anything, you calculate how much gas it'll cost with eth_estimateGas.
When you’re ready, your agent can submit fully signed and prepared transactions using sendTransaction or eth_sendRawTransaction, getting the job done on the network.
How Ankr (Web3 Node API) MCP Works
- 1 Subscribe to the server and input your Ankr JWT token. This authenticates your connection and grants API access.
- 2 Prompt your AI client (e.g., 'What is the balance of 0x...') which triggers the appropriate tool call (e.g.,
ankr_getAccountBalance). - 3 The server executes the blockchain query, returns structured data (JSON) to the agent, and the agent passes a clean answer back to you.
The bottom line is that your AI client talks directly to Ankr's API endpoints using specialized tools, letting you bypass manual web UI interaction entirely.
Who Is Ankr (Web3 Node API) MCP For?
This tool is for the DeFi researcher who spends hours manually querying Etherscan and building scripts just to track token movements. It's for the Web3 developer stuck debugging a smart contract call that only fails when you try it locally, or the data analyst needing real-time, cross-chain metrics without setting up a dedicated backend service.
Uses ankr_getNFTsByOwner and eth_getLogs to trace historical asset movements and analyze on-chain state changes for investment theses.
Employs eth_call or eth_simulateV1 to validate contract logic, estimate gas costs (eth_estimateGas), and check nonces before deployment.
Retrieves real-time metrics like the latest block number (eth_blockNumber) or calculates token prices using ankr_getTokenPrice for reporting.
What Changes When You Connect
- Stop writing boilerplate JSON-RPC calls. Tools like
eth_getBalanceandankr_getAccountBalancehandle the connection overhead, letting your agent just read the balance for you. - Validate transactions before committing them with
eth_simulateV1. This saves gas and time by predicting errors and state changes without risking real funds. - Go beyond simple balances. Use
eth_getLogsto filter specific events—like a 'TokenTransfer' event—from millions of records, giving you granular transaction history. - Pinpoint contract logic issues using
eth_call. This runs read-only on the target contract, letting you check its internal state or function calls without paying gas fees. - Streamline complex asset tracking. Functions like
ankr_getNFTsByOwnerandankr_getMetadatagroup related assets (like all NFTs) into one query, instead of needing multiple lookups.
Real-World Use Cases
Auditing a Suspicious Wallet
A DeFi researcher needs to know if wallet 0x... has interacted with high-risk protocols. They run ankr_getInteractions, see a list of addresses, and then use ankr_getNFTsByOwner on the most suspicious one to check for asset exposure.
Testing a New Contract Function
A developer writes code that needs to call an external contract. Instead of deploying a test transaction, they use eth_call first. This confirms the function signature works and reads the expected state without spending any gas.
Checking Transaction Feasibility
Before submitting funds, an analyst runs a draft transaction through simulateTransaction. The tool returns predicted failure points or insufficient gas estimates, allowing them to fix the code before it hits the main network.
Tracking Token Movements Over Time
A data analyst needs all token transfers for a specific ID. They combine eth_getLogs (to filter by event type) with ankr_getTokenTransfers to build a complete, auditable history report.
The Tradeoffs
Treating the blockchain like a database query
Trying to read deep contract state by guessing an address and running getBalance. This only gives native currency balance, missing token-specific logic or storage values.
→
To check raw data stored inside a contract, you must use eth_getStorageAt for precise storage positions. If you need the full account info, start with getAccountInfo.
Assuming read-only tools are always enough
Using only eth_call to test a multi-step process. This confirms if the call works, but not if it will succeed under real network congestion or gas price spikes.
→
For complex sequences, use eth_simulateV1. It runs multiple transactions in an isolated sandbox, giving you better predictability than just a single eth_call.
Ignoring the nonce when sending
Submitting a transaction using eth_sendRawTransaction without checking the latest nonce via eth_getTransactionCount. This will fail immediately because the network expects an incremented counter.
→
Always check eth_getTransactionCount first. Then, if you're building the transaction manually, use that number to correctly sequence your submission.
When It Fits, When It Doesn't
Use this server when the data source is the blockchain and you need actionable insights (balances, metadata, history). This toolset excels at deep state inspection. You must use it if you are tracking specific assets (NFTs via ankr_getNFTMetadata) or require historical event logging (eth_getLogs).
Don't use it if your problem is purely off-chain: for instance, checking a user's internal database records or API data that doesn't live on an EVM chain. For those cases, you need a standard REST client tool, not a Web3 node API.
If you only need to know the current block number, eth_blockNumber is sufficient. If you need to build a multi-step workflow—like checking the balance (ankr_getAccountBalance), then getting the latest hash (getLatestBlockhash), and finally simulating an action (simulateTransaction)—this comprehensive suite provides all the necessary components in sequence.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Ankr. 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 32 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Reading blockchain data shouldn't feel like writing a thesis paper.
Right now, figuring out what happened at address `0x...` means opening three different tabs: Etherscan for the transaction hash, another tab for the block details, and finally manually searching through logs to find the specific token transfer. It's a copy-paste nightmare just to answer one question.
With this MCP server, you ask your agent, 'Show me all transfers of Token X from this address last week.' The agent runs `eth_getLogs` or `ankr_getTokenTransfers`, and it spits out the structured data instantly. It’s that simple.
Ankr (Web3 Node API) MCP Server: Get granular, verifiable state checks.
Manual debugging means repeatedly running read-only calls just to check if a contract function fails silently. You waste time guessing if the issue is in your code or the network state.
Using `eth_call` lets you run that exact function—the one that's giving you trouble—against the live chain, without changing anything and with guaranteed read-only results. It’s the diagnostic tool every developer needs.
Common Questions About Ankr (Web3 Node API) MCP
How do I check a wallet balance using ankr_getAccountBalance? +
You pass the target address to ankr_getAccountBalance. The server returns all token balances held by that wallet, listing every supported asset and its current amount.
Can I use eth_simulateV1 for multi-step transactions? +
Yes. eth_simulateV1 is designed to run complex sequences of calls or blocks in a safe, isolated environment. This lets you test the entire workflow and check for errors before committing real funds.
Which tool should I use to find all NFTs owned by an address? +
Use ankr_getNFTsByOwner. It aggregates listings from multiple chains, giving you a single list of every NFT the owner holds without needing to query each chain separately.
Is eth_call the same as simulateTransaction? +
No. eth_call runs one specific function read-only. simulateTransaction handles a broader range of state changes, simulating an entire transaction block or multiple steps for greater prediction accuracy.
How do I get the most recent block number? +
The simplest way is to call eth_blockNumber. It returns the single, latest sequential block height across the connected EVM chains.
I need to read raw data from a contract's internal storage; what does `eth_getStorageAt` do? +
It retrieves the exact value stored at a specified slot within an address's storage. You must provide both the target contract address and the integer index of the storage key. This is essential for deep, low-level state analysis.
Before I submit funds using `eth_sendRawTransaction`, how do I estimate the required gas with `eth_estimateGas`? +
It returns an estimated amount of gas needed to execute your intended transaction. Always run this tool first, as it prevents failed submissions and saves you from unnecessary transaction fees.
How do I track the movement history for a specific token using `ankr_getTokenTransfers`? +
This tool returns all recorded historical transfer data associated with a particular token contract. You get a clear map of where the token has moved, which is critical for auditing asset flow.
How can I check the current block height on a specific network? +
Use the eth_blockNumber tool and provide the chain_alias (e.g., 'eth' for Ethereum). The agent will return the most recent block number recorded on that chain.
Is it possible to simulate a transaction before sending it to the mainnet? +
Yes! You can use the eth_simulateV1 tool. By providing a simulation payload, you can see the potential outcome and state changes of transactions without actually broadcasting them.
How do I retrieve the balance of a specific wallet address? +
Simply use the eth_getBalance tool with the target address and chain_alias. The agent will fetch the current balance in Wei for that account.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
ShowAPI / 易源数据
Massive API data marketplace — access weather, translation, stock info, and utilities via AI.
Google Pub/Sub Subscription
This MCP does exactly one thing: it pulls and acknowledges messages from a single Google Pub/Sub Subscription. That's its only function, and nothing else. Incredible for building secure AI workers.
Import.io (Web Data Extraction)
Extract structured data from any website via Import.io — run extractors, manage bulk crawls, and monitor API usage.
You might also like
OpenCart
Connect your OpenCart store to AI agents — browse products, manage orders, track customers, and update fulfillment status through natural conversation.
Bill.com
Equip your AI agent with direct access to BILL — manage invoices, approve payments, and track vendor bills without opening the AP dashboard.
Goody
Automate corporate gifting — browse products, send gifts, and track orders effortlessly.