Ankr Agent RPC
Provides token-efficient access to Ethereum blockchain data via Ankr RPC, including transactions, receipts, blocks, event logs, balances, NFTs, token holders, prices, and contract resolution, with ABI decoding and TORPC tier 2.
Provides tools for interacting with the Sui blockchain over gRPC, including querying Move objects, owned objects, dynamic fields, packages, function signatures, SuiNS name resolution, transaction simulation, and watching Move events.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Ankr Agent RPC what's the ETH balance of 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Ankr Agent RPC — MCP Server
A Model Context Protocol server that gives AI agents token-efficient access to blockchain data through Ankr RPC.
Reads go out with the TORPC Accept-Token-Tier: 2 header. Tier 1 already renames the fields, turns hex into decimal and drops the service fields (logsBloom, cumulativeGasUsed, header roots). Tier 2 adds the ABI decode on top, so contract calls and event logs come back as named arguments.
A live run over 21 methods and 25 Ethereum mainnet blocks, token-weighted and counted with o200k_base over the full HTTP body, came out 48.4% smaller at tier 2 and 35.3% smaller at tier 1. Decode-heavy reads save the most: eth_getTransactionByHash 69.0%, eth_getTransactionReceipt 64.5%, eth_getBlockReceipts 60.3%, the block methods 40.4%, eth_getLogs 28.9%; scalar reads save 9–19%. Per-method figures: live-token-savings-2026-07-17.md.
Quick start
Get a free API key at ankr.com/rpc.
Hosted (no install)
The server runs at https://mcp.ankr.com/rpc. Send your key as the x-ankr-api-key header (or Authorization: Bearer <key>); each request carries the caller's own key, and the server holds no credential of yours.
{
"mcpServers": {
"ankr-agent-rpc": {
"url": "https://mcp.ankr.com/rpc",
"headers": { "x-ankr-api-key": "<YOUR_KEY>" }
}
}
}Local (stdio)
{
"mcpServers": {
"ankr-agent-rpc": {
"command": "npx",
"args": ["-y", "@w3tech.io/agent-rpc-mcp"],
"env": { "ANKR_API_KEY": "<YOUR_KEY>" }
}
}
}That JSON goes in your client's MCP config: Claude Desktop (claude_desktop_config.json), Cursor, Windsurf, or any other MCP client. Cursor also accepts the command form:
env ANKR_API_KEY=<YOUR_KEY> npx -y @w3tech.io/agent-rpc-mcpRelated MCP server: Onchain MCP Server
Tools
Raw RPC, TORPC tier 2
Tool | What it answers |
| transaction + receipt by hash, ABI-decoded |
| event logs, decoded; wide block ranges are chunk-scanned and paged |
| block header, optionally with decoded transactions |
Indexed and mixed
Tool | What it answers |
| native coin + ERC-20 balances with USD |
| balances across many chains at once |
| an address's transaction history, paged |
| NFTs held by an address |
| holders of an ERC-20, paged |
| USD price with chain, asset and |
| historical price series for a token |
| which chains an address has touched, cross-chain |
| is-contract, best-effort ERC-20 metadata, EIP-1967 proxy |
| resolve a tx/block hash, an address, or a block number |
| continue any paged result from its cursor |
Discovery and escape hatch
Tool | What it answers |
| supported chains, max TORPC tier, indexer availability |
| the param shape and a worked example per JSON-RPC method, plus whether your key may call it on that chain |
| any read method the routed tools do not cover |
Sui
Sui is not an EVM chain and is not reached through the JSON-RPC proxy at all: a
Sui call goes out over gRPC. getBalances, getBlock, getTransaction,
getWalletActivity, getLogs and rpcCall take chain: "sui" and route
themselves — getLogs reads Move events over a checkpoint range, filtered by
emitting package or module, event type and sender. resolveContract and
searchChain are built from eth_* calls Sui has never had and refuse there,
naming the tool that answers instead. A Move event row is {contract, event, args}, the same shape an EVM tier-2 log has — but its args arrives at tier 0,
decoded by the node rather than from an ABI, so on this path it is not evidence
of a tier.
Eight tools serve what Sui has and an EVM chain does not:
Tool | What it answers |
| Move objects by id, batched, with their decoded fields |
| every object an address owns, paged, filterable by Move type |
| tables, bags and dynamic object fields under one object's UID |
| the modules a published Move package declares |
| one Move function's signature |
| a SuiNS name to its address, or an address to its name |
| what a transaction would do, run against current state, never submitted |
| Move events from the executed tip on, polled from a resumable cursor |
That is the whole set: 25 tools.
What rpcCall will and will not do
rpcCall is a read and data escape hatch, never a wallet. It is a write denylist, not a read allowlist: it refuses transaction broadcast and signing, transaction building, node and dev-node administration, mutating verbs, and the node-operation half of geth's debug_* namespace — on every chain family — and forwards everything else.
It therefore keeps no list of permitted reads. Which reads exist is decided per chain by the endpoint's blockchain schema and by what your tenant may call, so a forwarded read can still come back refused (Method disabled, reason: restricted by blockchain schema). That refusal is the authoritative answer; listChains reports coverage.
Sign and send transactions with your own wallet or signer.
Reading a response
Two fields decide how to read every result, and an agent that skips them will misread output that is technically correct.
_meta.tier — the TORPC tier is negotiated per call and is not guaranteed. On the proxy path a response comes back at tier 0 (raw, undecoded, no args) when it is above the proxy's compression budget, and also when the method is one the proxy does not compress at all, such as eth_call, eth_getCode and eth_getStorageAt. Every successful response carries the tier actually applied in _meta.tier, so check it before looking for decoded fields; an error result carries _meta.error_code instead and no tier at all. Some tools additionally report tier_degraded: true in the body, with a note on how to narrow the request, when they asked for tier 2 on your behalf and got less. Not all of them do, so _meta.tier is the field to rely on. _meta.tier_source says who applied the tier, and the shape rule above is the proxy's alone: on the Sui gRPC path (tier_source: "local") a Move event row carries contract, event and args at tier 0, because the node decodes a Move struct itself.
Decoded amounts are raw base units, with no decimals applied. args.value: "41695680" on a 6-decimal token is 41.69568, not 41 million. Read the token's decimals with resolveContract before reporting a human number.
_meta.token_count is a real o200k_base count of the emitted text, not a chars/4 estimate. It is exact up to 256 KB of emitted text, which covers every display-capped response; above that it is extrapolated and the response carries _meta.token_count_estimated: true. Responses are minified JSON, so a model with a different tokenizer sees a similar but not identical number.
Tool inputs are strict: an unknown argument is rejected with a validation error rather than silently dropped, so a misspelled argument name is reported instead of ignored. Block numbers above 2^53 must be passed as strings, because a JSON number that large is not exact.
TORPC tiers
Tier | Meaning |
0 | passthrough — standard JSON-RPC |
1 | field rename, hex → decimal, and the service fields dropped: |
2 | tier 1 plus the ABI decode — each log becomes |
Negotiation is by header: Accept-Token-Tier: 0|1|2 on the request, Token-Tier on the response. The proxy applies the requested tier only while the response stays inside its compression budget, and that budget is internal to the proxy — so this server never predicts the tier, it detects the applied one and reports it.
On a JSON-RPC batch that header describes the array, not any one element: a response array carries a single Token-Tier, and its value is the minimum tier applied across the elements. v1 defines no per-element tier signal, elements may sit above that floor, and a client reads each element's own tier from the shape the proxy left on it — renamed fields and decimal strings for tier 1, event/args for tier 2 — rather than from the header. So the header is a floor and a signal that a transform was applied; which methods reach tier 2 is declared per method in the descriptor at https://mcp.ankr.com/.well-known/torpc.json, which also ships in the npm package at static/.well-known/torpc.json.
Specification: w3tech/torpc, released under CC0-1.0, with the TORPC docs page as the narrative version. The reference decoder is published as @w3tech.io/torpc-decoder (Apache-2.0); its source and the benchmark harness live in w3tech/torpc-js, under codec/. The EVM tier-1 and tier-2 rules are normative in the spec today; the conformance suite is a scaffold, so no implementation, this one included, claims conformance yet.
Discovery
Two machine-readable documents describe this deployment. Both are public, carry no credential, and are readable cross-origin.
Document | Served at |
TORPC descriptor: protocol version, negotiation headers, tier meanings, method lists |
|
Agent card: an ERC-8004 registration file naming who answers, and at which MCP endpoints |
|
Both ship in this package under static/.well-known/, and the served copy is the deployment's own statement: a packaged copy can lag it. The card states x402Support: true, because /rpc without a key takes per-call payment over x402, and claims no on-chain registration and no trust mechanism, because there is none to claim.
Supported chains
Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, Avalanche and more, plus testnets. Indexed tools cover a wider set than the raw-RPC tools.
Call listChains for the live matrix rather than trusting a list in a README — coverage changes without a release here.
Managing your Ankr account
A second, separate MCP surface at https://mcp.ankr.com/mcp covers account management — API keys, allowlists, usage, billing reads and team membership — and authenticates with OAuth rather than an API key. Sign in when your client prompts. An RPC API key is not management authority and will be refused there.
Links
API keys and plans: ankr.com/rpc
Documentation: Agent RPC and account management on ankr.com/docs
TORPC specification: w3tech/torpc (CC0-1.0), narrated on the TORPC docs page
TORPC decoder:
@w3tech.io/torpc-decoder(Apache-2.0), source in w3tech/torpc-js undercodec/npm package:
@w3tech.io/agent-rpc-mcpDiscovery documents: TORPC descriptor and agent card
License
MIT — see LICENSE.
Available Tools
25 toolsdescribeMethodsDescribe JSON-RPC method shapes and availabilityARead-onlyInspect
What a JSON-RPC method takes, and whether this key can actually call it on this chain. Returns the positional param shape and a worked example for every method rpcCall can validate, plus rpcCall's own verdict (permitted, or refused as a write path). Pass probe:true with an explicit methods list (max 12) to also ask the node, so served reflects your key, your tenant and the chain's blockchain schema instead of a guess: yes, no, restricted, or unknown. A refused method is never sent. Without methods it returns the whole catalogue and does not probe. The catalogue is SHAPE guidance, not a coverage list: a method missing from it may still be served, and the chain's schema is the authority.
Inputs: chain (required), probe, methods.
expandResultExpand a truncated resultARead-onlyInspect
Continue a paged result using the opaque cursor returned by a previous tool call. Supported cursor sources: getWalletActivity, getLogs (a block range, or a Sui checkpoint scan), getBalances (asset offset), Sui views (tier 0 re-reads the view unshaped: a fresh upstream call, never a replay of the earlier answer). Returns the next page of compact items plus a new cursor if more remains.
Inputs: cursor (required).
getAccountBalanceAccount balance by chainARead-onlyInspect
Balance of an account across many blockchains, by 0x address or ENS name, via the Ankr Advanced API indexer.
Assets are ranked by USD value descending and only the top 20 are listed by default (a real wallet can hold 1000+ assets, over half of them priced at $0); tune that with maxTokens/minUsd, or call getBalances for structured JSON. Anything the indexer PRICED at zero or below minUsd is summarised as a dust count instead of being listed.
An asset with NO indexer price is not dust: it reads "USD value unknown" and ranks after every priced asset, so on a wallet holding more priced assets than maxTokens none appear here and the note says how many exist off-page. Unknown is not zero.
An implausibly large raw balance (typical of scam tokens minting max-uint) is flagged and its balance is withheld; never add it to a total.
Each line names the chain the asset is held on, which matters because omitting blockchains queries EVERY chain and interleaves the result across them.
Inputs: address (required), minUsd, maxTokens, blockchains.
getBalancesWallet balances, native and tokensARead-onlyInspect
An address's balances on ONE chain: native via eth_getBalance plus, by default, ERC-20 balances with USD from the Ankr Advanced API indexer (tier 0). ENS resolves for the token lookup only; a raw-RPC-only chain returns native alone.
Tokens rank by USD descending, top 20 by default; tune with maxTokens/minUsd. Anything PRICED at zero or below minUsd goes to dust (count + USD total); full_count is how many assets exist. UNPRICED assets are not dust: usd: null, unpriced: true, ranked after every priced one, counted by unpriced_on_page/unpriced_total, never summed. A raw balance >=2^128 is implausible: true, formatted balance WITHHELD.
Sui: none of that applies. Balances come from the node, RAW in base units; decimals/symbol only where the coin publishes metadata (first 10 types). No USD, dust or ENS; native is SUI, maxTokens caps the token rows, minUsd/includeTokens do nothing.
Inputs: chain (required), address (required), minUsd, maxTokens, +1 more.
getBlockBlock by number or tagARead-onlyInspect
Get a block by a 0x-64 hash, a block number (decimal or 0x-hex), or a tag (latest, finalized, safe, earliest, pending).
Tier 2 drops the verbose header roots and bloom and, with includeTxs, ABI-decodes and compacts the embedded transactions. A large block with includeTxs may come back raw (hex); _meta.tier says which, and dropping includeTxs gets the header decoded.
Sui: block is a checkpoint number or digest.
Inputs: block (required), chain (required), includeTxs.
getInteractionsChains an address has usedARead-onlyInspect
List the blockchains an address has interacted with, via the Ankr Advanced API indexer. Cross-chain, so there is no chain argument. Useful as a first step before fetching balances or activity per chain.
Inputs: address (required).
getLogsEvent logsARead-onlyInspect
Event logs on one chain, filtered by address and/or topics over a block range. Tier 2 emits each log as { contract, event, args }, dropping logsBloom and per-log block duplication; an undecodable one stays raw as { address, topics, data, _event_unknown }. Check tier_degraded before reading event or args.
With both bounds concrete block NUMBERS (toBlock may be omitted/"latest") the range is walked in ascending chunks, stopping once the display cap fills: the reply says range_fully_scanned: false, carries a cursor, and note says why. more_available means more logs were seen than shown; full_count appears only when the whole range was scanned. Any other bound is ONE unbounded eth_getLogs: no chunking, no cursor, liable to tier 0.
Sui: Move events over a CHECKPOINT range. fromBlock is required; address is the emitting package[::module]; eventType and sender narrow it; topics is refused, not ignored. Same body; rows add checkpoint/digest/index.
Inputs: chain (required), sender, topics, address, +4 more.
getNFTsNFTs held by an addressARead-onlyInspect
NFTs one wallet holds on one chain: collection, name, token id, contract, standard (ERC721/1155), image URL. For fungible tokens use getBalances.
Inputs: chain (required), address (required), pageSize, pageToken.
getTokenHoldersHolders of a tokenARead-onlyInspect
Who holds an ERC-20 token on one chain, largest balance first, plus the total holder count. balance already has decimals applied, so do not divide it again. For one wallet's tokens use getBalances.
Inputs: chain (required), contractAddress (required), pageSize, pageToken.
getTokenPriceToken priceARead-onlyInspect
USD price of a token on one blockchain: pass a contract address for an ERC-20, or leave it empty for the native coin. Returns { chain, asset, usd, priced_via_contract, as_of: { timestamp, blockNumber, lag, status } }. Read as_of before reporting a price; it says how stale the indexer's view is. A native-coin query is priced from the WRAPPED token, which is why priced_via_contract is a wrapped-token address rather than the coin itself.
Inputs: chain, blockchain, contractAddress.
getTokenPriceHistoryToken price historyARead-onlyInspect
Historical USD price series for a token contract on a chain, via the Ankr Advanced API indexer: a list of { timestamp, usd, block } quotes.
limit_applied reports the cap the call was actually made with (default 100, max 1000). When count reaches that cap the response sets possibly_truncated: true: this endpoint returns NO continuation token, so a clipped series and a series that simply ends are indistinguishable, and there is no cursor to page with. Treat such a series as incomplete-of-unknown-length rather than the full history; raise limit or walk fromTimestamp/toTimestamp yourself.
Inputs: chain (required), contractAddress (required), limit, interval, +2 more.
getTransactionTransaction by hashARead-onlyInspect
Get a transaction by its hash on one blockchain, with tier-2 decoding requested. Check tier_degraded before reading function or args.
By default the receipt is fetched too (status, gas used, decoded logs). Set include to "transaction" to skip it and halve the cost.
Tier-2 field names: tx, block, block_hash, from, to, value, gas_limit, gas_price, gas_used, status ("success"|"failed"), function, args (named object), logs[] ({ contract, event, args } when decoded, else { address, topics, data, _event_unknown }). All numeric values are decimal strings and all addresses are EIP-55 checksummed.
Sui: pass the digest; include is ignored.
Inputs: chain (required), txHash (required), include.
getWalletActivityWallet transaction activityARead-onlyInspect
An address's recent transactions on one blockchain, newest first, via the Ankr Advanced API indexer.
Items are returned under activity, exactly once per page, on this first page and on every continuation alike. There is no second alias key.
Each item: hash, from, to, value_wei (decimal string, RAW WEI, not ether and not token units), block (decimal), time { unix_seconds, iso }, status ("success"/"failed"), and selector (the raw 4-byte function selector, e.g. "0xa9059cbb"). The selector is NOT a resolved function name: this indexer does not return one, and mapping a selector to a name needs a signature registry this server does not have. A field is omitted rather than guessed when the upstream value is missing. time.unix_seconds is always the authoritative value; time.iso is present ONLY when the timestamp is a real calendar instant, and otherwise time.iso_unavailable says why, so new Date(time.iso) never yields an Invalid Date.
Sui: transactions SENT BY the address.
Inputs: chain (required), address (required), pageSize.
listChainsList supported chainsARead-onlyInspect
Discover chain support. Returns the chains where the Ankr Advanced API indexer is available (token balances, NFTs, holders, transfers, prices). IMPORTANT: the raw-RPC tools (getTransaction, getLogs, getBlock) and rpcCall are NOT limited to this list — they reach ANY chain Ankr serves (200+ EVM mainnets/testnets plus non-EVM like solana, btc, xrp, ton, near, aptos, and cosmos chains); just pass the chain slug as it appears in rpc.ankr.com/. suiChains are served over gRPC rather than by the proxy and have their own sui* tools. TORPC tier-2 compression is applied by the proxy on supported EVM chains, and other proxy chains pass through unchanged; suiChains are shaped in this server instead, so a Sui reply can be tier 1 or 2 with no proxy involved — check _meta.tier and _meta.tier_source for what was applied and by whom.
Inputs: no named parameters.
resolveContractIdentify a contractARead-onlyInspect
Inspect an address on a chain: whether it is a contract, best-effort ERC-20 token metadata (name, symbol, decimals), and EIP-1967 proxy detection (implementation address). Built from eth_getCode / eth_call / eth_getStorageAt, which are plain JSON-RPC passthrough. The metadata is best-effort and may be absent on a non-standard contract.
Inputs: chain (required), address (required).
rpcCallRaw JSON-RPC call, reads onlyARead-onlyInspect
Call ANY JSON-RPC method on a supported chain: the escape hatch beyond the routed tools (eth_call, eth_estimateGas, eth_getCode, debug_trace*, trace_*). Prefer getTransaction/getLogs/getBlock where they fit. TORPC tier is negotiated per call (contract 2); check meta.tier. This is a read/data tool, never a wallet. It REFUSES anything that would change state, on every chain family: transaction broadcast and signing (eth_sendRawTransaction, MEV bundle/private-tx, personal/eth_sign, Solana sendTransaction/requestAirdrop, BTC sendrawtransaction and bumpfee/psbtbumpfee, Sui sui_executeTransactionBlock, XRPL submit, Tron broadcasttransaction/createtransaction/triggersmartcontract, Cosmos broadcast_tx_*); transaction BUILDING, which returns an unsigned transaction rather than sending one (Sui's unsafe_* namespace); node administration and dev-node state (admin_*, miner_*, personal_*, hardhat_*, anvil_*, evm_*, engine_*); any mutating verb (set*, write*, start*, stop*, compact*), which refuses settxfee, debug_setHead and debug_writeBlockProfile; the node-operation half of geth's debug namespace (profilers, chaindb compaction, file-writing traces), which the verb rule cannot reach when the mutating word sits mid-camelCase; bitcoind's node and wallet state controls (invalidateblock, reconsiderblock, preciousblock, pruneblockchain, rescanblockchain, abortrescan, generateblock); and, on dot-namespaced chains, mempool submission and the node's own wallet, multisig and administration families (Filecoin.MpoolPush, Filecoin.WalletExport). Sign and send with your own wallet or signer. On sui this tool speaks gRPC, not JSON-RPC: a bridged method is answered there, any other is REFUSED rather than sent to Sui's JSON-RPC, which Sui removes in mid-October 2026. describeMethods says which are bridged. Everything else is FORWARDED: this tool keeps no list of permitted reads, because which methods exist is decided per chain by the endpoint's blockchain schema and what you may call by your tenant. A forwarded read can still come back refused ("Method disabled, reason: restricted by blockchain schema") — that is the authoritative answer. Call listChains for coverage.
Inputs: chain (required), method (required), tier, params.
searchChainSearch a chainARead-onlyInspect
Resolve an on-chain IDENTIFIER to the object it names. Accepts exactly THREE shapes, and nothing else:
0x + 64 hex -> transaction (falls back to block hash if there is no such tx)
0x + 40 hex -> address (reports contract vs EOA)
all digits -> block number NOT SUPPORTED: ticker symbols, token or contract NAMES, labels, or any other free-form text. "USDC", "uniswap" and "the biggest holder" all return kind:"unknown" with a note, because that needs a label registry this server does not have. ENS names (*.eth) are also NOT resolved; they return kind:"ens" with a note. Do not call this tool to look up an asset by name; get the contract address another way first. A transaction or block resolution requests tier-2 decoding; an address lookup is passthrough. Defaults to eth when no chain is given.
Inputs: query (required), chain.
suiGetFunctionMove function signatureARead-onlyInspect
One Move function's signature: visibility, whether it is an entry function, its type parameters, its parameter types and its return types — what a programmable transaction block needs in order to call it. Never capped or paged. Take the package and module names from suiGetPackage. A name the package does not declare is refused by the node rather than approximated.
Inputs: module (required), package (required), function (required).
suiGetObjectsSui objects by idARead-onlyInspect
Move objects by id, in ONE batch call: each answer carries the object's id, type, version, owner and its decoded Move fields under json. Up to 50 ids per request and nothing is trimmed from the reply, so no cursor is issued. An id the node cannot serve is reported POSITIONALLY under failed, with its request index, the id asked for and the gRPC status, never dropped in silence. Reads only.
Inputs: ids (required), version.
suiGetPackageMove modules in a Sui packageARead-onlyInspect
What a published Move package declares, so a caller can pick what to inspect next.
By default this answers with an INDEX: one row per module carrying its name and how many functions and datatypes it holds, capped at 50 rows (raise it with maxModules). Pass module to get that one module in full instead — every function signature and every datatype it declares.
The whole package is never returned; the 0x2 framework alone is around 484 KB. This method has no upstream paging, so a truncated index carries no cursor: the way past the cap is maxModules, then module, then suiGetFunction for a single signature.
Repeated addresses arrive as $n/@n handles, resolved by the ids and packages tables beside them.
Inputs: package (required), module, maxModules.
suiListDynamicFieldsDynamic fields of a Sui objectARead-onlyInspect
Whatever a Move package stored under one object's UID: tables, bags and dynamic object fields, listed from the parent id. A row names the field's own object id, its kind, the name it is keyed by and the Move type of its value. The value itself is a BCS blob and is left out of this answer; hand that field id to suiGetObjects and it comes back decoded. 50 rows unless asked otherwise and 200 at the outside, with a cursor for as long as the parent has more. Reads only.
Inputs: parent (required), pageSize.
suiListOwnedObjectsObjects owned by a Sui addressARead-onlyInspect
Every object an address owns, page by page, out of the node's own owner index. Narrow it with type: a bare Move type such as 0x2::coin::Coin matches any type parameter, while a fully applied one matches only that instantiation. A page holds 50 entries by default and 200 at most; when the node holds more, an opaque cursor comes back and expandResult returns the following page in this same shape. Reads only.
Inputs: owner (required), type, pageSize.
suiResolveNameSuiNS name and addressARead-onlyInspect
Resolve a SuiNS name (something.sui) to the address it points at, or an address back to its name. Give exactly one of name or address.
READ status BEFORE the record. It is one of: resolved, the registration is live and the record is good; expired, the registration lapsed and the record — target address included — is returned but must not be trusted as a destination; no_target_address, the name is registered and points nowhere; not_registered, the registry holds no record. All four are answers, not errors.
Reverse is NOT the inverse: an address answers with its OWN default name, which need not be a name pointing at it.
One record comes back, so nothing is capped, truncated or paged. Only .sui names.
Inputs: name, address.
suiSimulateTransactionSimulate a Sui transactionARead-onlyInspect
Run a transaction against current state and report what it WOULD do, without submitting it: whether it succeeds or which Move abort stops it and in which command, the gas it consumes, the objects it creates, mutates and deletes, the balance changes per address and coin, each command's return values decoded, and any events it would emit. Takes the base64 BCS TransactionData your wallet or SDK produces — the same argument sui_dryRunTransactionBlock takes; no signature, and none is accepted. Nothing is broadcast: this server cannot reach Sui's execute rpc at all. cursor re-runs it unshaped through expandResult. Reads only.
Inputs: transactionBytes (required).
suiWatchEventsWatch Sui Move eventsARead-onlyInspect
Follow Move events from now on, by POLLING — nothing is pushed. This first call only establishes a start position: it reads the executed tip from a Sui event subscription, returns NO events, and hands back a cursor. Each expandResult on that cursor lists what has been emitted since and returns the next one, so no event falls in the gap between two polls. That is the whole difference from getLogs, which scans a checkpoint range you name and cannot resume across calls. Filter by address (the emitting package[::module]), eventType and sender; rows and body keys are getLogs'. Sui executes about 4 checkpoints a second, so poll on that scale; more_available: true means the cap was already full, so poll again at once. 50 events a poll unless asked otherwise, 1000 at the outside. Reads only.
Inputs: sender, address, maxLogs, eventType.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 25 tools
Most tools have clearly distinct resource+action targets, and the sui* family is cleanly partitioned from the EVM/generic tools. A few pairs need the descriptions to separate them (getBalances vs getAccountBalance for one-chain vs multi-chain, getLogs vs suiWatchEvents for range scans vs polling), but those descriptions do resolve the ambiguity.
The set is nearly all camelCase verb_noun (getTransaction, listChains, resolveContract, searchChain), which reads predictably. The 'sui' prefix creates a parallel namespace rather than a style break, and expandResult/describeMethods are the only mild deviations.
25 tools is on the heavy side, but the server spans several genuinely different surfaces (generic EVM JSON-RPC, Ankr indexer analytics, and a Sui gRPC layer), so most entries earn their place. It sits at the upper bound of reasonable rather than being padded.
Coverage for a read-only chain-data server is strong: transactions, blocks, logs, events, balances, NFT/holders, prices and history, contract inspection, Sui objects/packages/functions, plus expandResult for cursor paging. Gaps are mostly deliberate or acknowledged dead ends (no write/broadcast path, no label or ENS registry, no continuation for getTokenPriceHistory).
Maintenance
Related MCP Connectors
ChainRay provides multi-chain blockchain data and intelligence for AI agents through 79 MCP tools across 57 supported networks, covering gas, chain data, wallets, DeFi, market, security, monitoring, and verifiable proofs. MCP access is available at https://mcp.chainray.online/mcp; paid HTTP capabilities settle via x402 on Base.
Provide AI agents and automation tools with contextual access to blockchain data including balance…
Pay-per-call on-chain data for AI agents: token, wallet, risk, whale, NFT, tx. No API keys.
Verified EVM, Aptos and finance tools for AI agents; gas for 14 chains. Pay per call (x402).
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAllows LLM agents and MCP clients to analyze blockchain data including wallet balances, token information, and transaction history across EVM and Solana chains through the Dune API.20 npm4MIT
- FlicenseNot gradedqualityDmaintenanceProvides tools for querying onchain data across 12+ blockchain networks, including token balances, transaction analysis, and smart contract security auditing. It enables users to interact with multiple EVM-compatible chains and perform deep contract evaluations through natural language interfaces.1-
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to resolve smart contract ABIs, read, encode, simulate, and prepare transactions across multiple blockchains via a REST API or MCP server, with no signing required.-
- AlicenseAqualityCmaintenanceEnables AI agents to fetch live multi-chain portfolio, token info, gas prices, and token prices across Ethereum, Base, Polygon, Arbitrum, and Optimism with a single call. No API key required.4MIT