Ankr Web3 Node API MCP for AI. Analyze any blockchain state, from balance checks to contract simulations.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Ankr (Web3 Node API) provides a direct connection to Ethereum and other EVM chains. Query block data, check token balances across multiple wallets, or run complex smart contract simulations using natural language prompts from your agent.
What your AI can do
Ankr getAccountBalance
Retrieves all token balances associated with a given wallet address.
Ankr getBlocks
Fetches detailed information for a specified range of blockchain blocks.
Ankr getInteractions
Lists every unique blockchain network an address has ever interacted with.
Retrieves current token balances for an address, including multi-token accounts and NFT ownership.
Gets detailed information on specific transactions or lists all tokens a wallet has ever interacted with across different chains.
Executes calls to smart contracts (like eth_call) or simulates complex multi-step operations without actually spending gas.
Accesses granular data like raw storage slots, specific event logs, and the underlying contract code at any address.
Retrieves real-time network metrics, such as the current block height or information about the active epoch.
Ask an AI about this
Waiting for input…
Ankr (Web3 Node API) MCP: 32 Tools
These tools give you direct access to fundamental EVM operations. Use them to read balances, trace transactions, and simulate smart contract behaviors.
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 Ankr (Web3 Node API) on VinkiusAnkr GetAccountBalance
Retrieves all token balances associated with a given wallet address.
Ankr GetBlocks
Fetches detailed information for a specified range of blockchain blocks.
Ankr GetInteractions
Lists every unique blockchain network an address has ever interacted with.
Ankr GetNFTHolders
Returns a list of all wallet addresses that currently hold a specific NFT collection.
Ankr GetNFTMetadata
Retrieves descriptive data for a particular Non-Fungible Token (NFT).
Ankr GetNFTsByOwner
Lists all NFTs owned by an address, spanning multiple blockchain networks.
Ankr GetTokenPrice
Returns the current USD market price for a specific token.
Ankr GetTokenTransfers
Gathers historical data on how a specific token was moved between addresses.
Eth BlockNumber
Returns the most recent block number for the network.
Eth Call
Executes a function call against a smart contract without spending any gas or...
Eth EstimateGas
Calculates the estimated amount of gas required for an upcoming transaction.
Eth GetBalance
Returns the native currency balance held by a specific address.
Eth GetBlockByHash
Retrieves all block details when you provide its unique transaction hash.
Eth GetBlockByNumber
Fetches the full details for a block based on its numerical sequence.
Eth GetCode
Returns the compiled code that is stored at a specific contract address.
Eth GetLogs
Filters and returns log data matching specified criteria across the chain.
Eth GetStorageAt
Retrieves the raw value stored at a precise position within a contract's storage...
Eth GetTransactionByHash
Gets all details for a transaction using its unique hash.
Eth GetTransactionCount
Returns the number of transactions (nonce) that have originated from an address.
Eth GetTransactionReceipt
Retrieves a transaction receipt, confirming if the transaction succeeded and how...
Eth SendRawTransaction
Submits a fully signed and raw transaction directly to the network for processing.
Eth SimulateV1
Runs a simulation of multiple blocks or transactions to check potential outcomes...
GetAccountInfo
Returns all known information associated with a specific public key (Pubkey).
GetBalance
Returns the lamport balance for a given account.
GetBlockHeight
Returns the current total height of the blockchain network.
GetBlock
Retrieves identity and transaction details for a confirmed blockchain block.
GetEpochInfo
Provides information regarding the current operational epoch of the chain.
GetLatestBlockhash
Returns the latest block hash, which is useful for building new transactions.
GetProgramAccounts
Retrieves all accounts that are program-owned by a specific contract address.
GetTransaction
Returns detailed information for any confirmed transaction.
SendTransaction
Submits a signed transaction to the network, triggering the state change.
SimulateTransaction
Predicts the outcome of a single transaction to check for potential errors or...
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 Ankr (Web3 Node 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 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 connection provides 32 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually tracking asset and transaction data is a nightmare.
Right now, checking an address's full profile means jumping between multiple block explorers, manually querying token contracts for balances, running separate API calls to check ownership records, and then cross-referencing every single hash in a spreadsheet. It takes hours just to build a coherent picture of one wallet.
With this MCP, you ask your agent about the address's state once. It pulls together everything—the token counts, the NFT list (`ankr_getNFTsByOwner`), and the recent activity history—and presents it in one cohesive answer.
You get full visibility into contract logic with `eth_call`.
Today, if you wanted to know what a function *would* return without risking gas, you had two choices: write complex Javascript/Python code that assumed the function signature or wait for someone else's testnet deployment. Both are risky and slow.
Now, using `eth_call` lets your agent execute the contract logic directly against the chain state. You get a result immediately, confirming the return value without any actual cost. It’s a huge leap in debugging capability.
What your AI can actually do with this
Forget manually building JSON-RPC calls or spending hours debugging Postman requests. This MCP gives your AI client a direct bridge to global blockchain data. You can ask it to read the latest block numbers, check an address's current token balances, and trace historical transfers—all without writing custom scripts.
Need to test how a contract behaves before making real money moves? Your agent uses tools like eth_call to simulate those actions safely. It even pulls deep data, such as raw storage slots or specific event logs from an address. Because this entire catalog lives on Vinkius, you get access to all these functions through one connection point.
You just ask your agent what state the blockchain is in, and it figures out the necessary steps.
019e5cfb-dbd5-7224-8890-0bceca0272bc Here's how it actually works
The bottom line is that your AI client handles all the complicated API calls; you just ask a question about the blockchain state.
Subscribe to this MCP and provide your unique Ankr JWT token.
Tell your AI client a goal (e.g., 'What is the balance of address X?').
The agent automatically selects and runs the necessary functions, returning structured data you can read.
Who is this actually for?
This MCP is for people who live in the intersection of development and finance. You're the Web3 developer debugging contract logic, or the DeFi researcher analyzing on-chain behavior before making a prediction.
You use this to quickly check nonces, verify deployments, and debug smart contracts directly from your IDE without leaving your coding environment.
You analyze on-chain state, simulate complex transaction paths, and fetch historical logs to build economic models or detect patterns.
You retrieve real-time blockchain metrics, block data, and account information for reporting dashboards and monitoring tools.
What Changes When You Connect
Stop writing complex JSON-RPC calls. Your agent handles the connection and data structuring automatically, letting you focus on analysis instead of plumbing.
Simulate transactions safely before deployment. Use eth_simulateV1 or simulateTransaction to see what happens without spending actual gas or affecting real funds.
Get granular contract details instantly. Need to know if a storage slot was updated? Use eth_getStorageAt to read the raw value directly.
Track assets across chains. You can pull all NFTs associated with an owner using ankr_getNFTsByOwner, making cross-chain auditing simple.
Build complex workflows from basic checks. Combine tools like getBalance and eth_getTransactionCount to build a full picture of an account's activity.
See it in action
Debugging Contract Logic
A developer needs to know if a contract function relies on specific, obscure data. Instead of manually querying storage slots, they ask their agent to check the raw value using eth_getStorageAt and then run an eth_call to confirm expected behavior.
Monitoring DeFi Protocol Health
A researcher wants to track all asset movements related to a governance token. They ask their agent for historical logs using eth_getLogs, cross-reference it with ankr_getTokenTransfers for total volume, and then calculate the current market price via ankr_getTokenPrice.
Auditing Wallet Ownership
An analyst needs to confirm everything an address owns. They ask their agent to run getAccountInfo first, then specifically use ankr_getNFTsByOwner and ankr_getInteractions to get a complete picture of assets across all chains.
Understanding Transaction Failure
A user suspects a transaction failed due to insufficient gas. They use the agent first to call eth_estimateGas, then run simulateTransaction. If successful, they can check the required gas limit before attempting a live sendTransaction.
The honest tradeoffs
Asking for all data at once
Prompting: 'Tell me everything about this address.' This results in an unmanageable dump of raw block hashes, token lists, and contract codes.
Break it down. First, check the current balance using ankr_getAccountBalance. Next, ask for NFT ownership via ankr_getNFTsByOwner, then specifically query transaction details by hash using eth_getTransactionByHash.
Confusing reading with writing
Trying to use a balance check tool (getBalance) and expecting it to submit the funds. It will fail or do nothing.
If you only want to read data, use eth_call or eth_getLogs. If you intend to change state, you must use sendTransaction after running a successful simulation with simulateTransaction.
Ignoring network context
Running general balance checks without specifying the target chain. The agent might pull data from the wrong EVM chain.
Always specify the intended blockchain (e.g., 'on Ethereum') in your prompt, or use tools that enforce the scope of interaction like ankr_getInteractions to confirm supported chains first.
When It Fits, When It Doesn't
Use this MCP if you need deep, read-only access to EVM state—whether it's checking a balance (getBalance), examining contract code (eth_getCode), or simulating an outcome (eth_call). It’s your go-to tool for debugging and research. However, don't use this if all you need is simple data like today's date; that's outside its scope. Also, if you are building a full transaction flow with multiple steps, remember to pair eth_estimateGas before calling sendTransaction. Never assume a single call will solve a complex state problem; always check the history using tools like ankr_getInteractions first.
Questions you might have
Can I use ankr_getAccountBalance to check my ETH balance? +
No. Use ankr_getAccountBalance for token-specific balances (like USDC or DAI). For the native currency, always use eth_getBalance.
How do I check if a transaction will fail before sending it? +
Run the transaction through simulateTransaction. This function predicts failure conditions and required gas without actually committing anything to the ledger.
Do I need to use eth_getLogs for every type of data analysis? +
No. Use eth_getLogs only when you specifically need event logs (emitted events). For general balances, stick to getBalance or ankr_getAccountBalance.
What is the difference between eth_call and simulateTransaction? +
While both test calls, eth_call executes a read-only function against a contract. simulateTransaction tests an entire transaction lifecycle, including gas estimation and state changes.
If my Ankr JWT Token expires, how do I troubleshoot an error when calling `ankr_getAccountBalance`? +
You need to refresh your token and update it in Vinkius. The MCP connection will fail immediately with a 401 authentication error until you provide a valid key.
Does `ankr_getNFTsByOwner` list NFTs from all EVM chains, or do I need to query each chain separately? +
It lists holdings across multiple connected EVM chains. You must specify the address and desired scope in the tool parameters; it provides a consolidated view of assets.
If I use `eth_estimateGas` but then submit a transaction that fails, what's the best practice for preventing this? +
The transaction will fail due to insufficient gas. Always add a small buffer—it’s safer to overestimate your required fee than to under-estimate it.
When I use `eth_getLogs`, what parameters do I need to filter logs by a specific time range? +
You must pass the start and end block numbers or timestamps within the query. Sending overly broad log requests will hit rate limits quickly.
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.
We've already built the connector for Ankr Web3 Node API. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 32 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.