Scrollscan MCP for AI. Read Any On-Chain Data, Instantly.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Scrollscan gives your AI agent direct access to the Scroll L2 blockchain data. Check Ether balances, track every type of token transfer—ERC20, ERC721, and ERC1155—and inspect contract ABIs on demand.
You don't need to jump between explorers; you just ask your agent.
What AI agents can do with Scrollscan Automation
Check verify status
Checks if a contract's source code has been verified on the blockchain explorer.
Get account balance multi
Gets the Ether balance for several addresses at once, saving multiple API calls.
Get account balance
Retrieves the current Ether balance for a single specified address.
Find the Ether balance for one or many addresses using get_account_balance and get_account_balance_multi.
Get transfer events for ERC20, ERC721 (NFTs), and ERC1155 tokens by address using dedicated tools like get_erc20_token_tx.
Retrieve the ABI or source code for verified contracts to understand their functions via get_contract_abi and get_contract_source_code.
Fetch detailed transaction lists (normal, internal) and check receipt status using tools like get_normal_tx_list or get_internal_tx_list.
Access raw blockchain data points, such as block numbers by time (get_block_number_by_time) or current gas prices (proxy_gas_price).
Ask an AI about this
Waiting for input…
What AI agents can do with Scrollscan MCP Server: 33 Tools for On-Chain Data
Access every function needed to analyze Scroll L2. Use these tools to check balances, track all token types, and inspect smart contracts without leaving your agent.
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 Scrollscan on VinkiusCheck Verify Status
Checks if a contract's source code has been verified on the blockchain explorer.
Get Account Balance Multi
Gets the Ether balance for several addresses at once, saving multiple API calls.
Get Account Balance
Retrieves the current Ether balance for a single specified address.
Get Block Countdown
Estimates how many blocks are left until a target block number is reached.
Get Block Number By Time
Determines the block number that corresponds to a specific timestamp.
Get Block Reward
Calculates the reward received for mining a given block number.
Get Contract Abi
Fetches the Application Binary Interface (ABI) for verified smart contracts, detailing their functions.
Get Contract Source Code
Retrieves the full source code of a verified contract address.
Get Erc1155 Token Tx
Gets transfer event records for ERC1155 tokens associated with a given address.
Get Erc20 Token Tx
Retrieves all recorded transfer events for ERC20 standard tokens linked to an...
Get Erc721 Token Tx
Tracks the movement of single-edition NFTs (ERC721) by address.
Get Eth Price
Provides the current last market price for Ether.
Get Eth Supply
Calculates the total amount of Ether circulating on the Scroll network.
Get Internal Tx List By Block Range
Retrieves internal transaction lists filtered by a range of block numbers.
Get Internal Tx List By Hash
Finds internal transactions related to a specific transaction hash.
Get Internal Tx List
Lists all internal transactions that occurred for a specific address.
Get Logs
Retrieves event logs generated by smart contracts for analysis.
Get Mined Blocks
Lists all block numbers mined by a specific address.
Get Normal Tx List
Gets the list of standard, user-initiated transactions for an address.
Get Token Balance
Determines the token balance for a specific ERC20 contract and address.
Get Token Supply
Calculates the total supply of an ERC20 token based on its contract address.
Get Tx Receipt Status
Checks the processing status and result of a transaction receipt.
Get Tx Status
Verifies if a transaction has been successfully processed by the network.
Proxy Block Number
Gets the current block number of the chain (eth_blockNumber).
Proxy Call
Simulates a contract call without actually spending gas (eth_call).
Proxy Estimate Gas
Estimates how much gas is needed for a specific transaction type.
Proxy Gas Price
Gets the current estimated cost of gas on the network (eth_gasPrice).
Proxy Get Block By Number
Fetches all data associated with a specific block number.
Proxy Get Code
Retrieves the compiled bytecode for a contract address (eth_getCode).
Proxy Get Storage At
Reads a specific piece of storage data from a contract at a given slot.
Proxy Get Transaction By Hash
Retrieves all details for a transaction using its unique hash (eth_getTransactionByHash).
Proxy Get Transaction Receipt
Gets the final receipt and outcome of a completed transaction.
Verify Source Code
Verify Source Code
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 Scrollscan, 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 Scrollscan. 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 33 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually auditing a single transaction is painful enough. Doing it across multiple tokens? Forget about it., Solved with Vinkius AI Gateway
Today, figuring out what happened with an asset means opening three different tabs: one for general transactions, one for ERC20 transfers, and another for NFTs (ERC721). You then have to manually cross-reference the timestamps and addresses across all three explorers. It's a nightmare of copy/pasting and spreadsheet reconciliation.
With Scrollscan MCP, you run one query asking your agent to trace the entire flow. The server uses dedicated tools like `get_erc20_token_tx`, `get_erc721_token_tx`, and general transaction lists simultaneously. You get a single, clean narrative of exactly what happened—the transfers, the internal calls, and the final state.
Scrollscan MCP Server: Trace Token Movements
The biggest time sink goes away when you don't have to guess which tool handles which token type. You can ask, 'Show me every transfer for this address,' and the agent intelligently runs `get_erc1155_token_tx` as well as the dedicated ERC tools.
This means your AI client moves from being a chat interface to an actual blockchain analysis terminal. It's not just reading data; it’s running a full, multi-dimensional audit in seconds.
What your AI can actually do with this
Scrollscan gives your AI client direct access to all data flowing through the Scroll L2 blockchain. Forget jumping between explorer tabs just to check a few details; you ask your agent, and it pulls the raw chain data instantly.
Checking Balances
You need to know how much Ether is sitting in a wallet? You can use get_account_balance to grab the current ETH balance for one address. If you're auditing multiple wallets or checking several accounts at once, pull in get_account_balance_multi; it saves you from running dozens of separate calls.
For tokens, it’s similar but more detailed. You can check a specific ERC20 contract's balance for an address using get_token_balance, or calculate the total circulating supply of any given token with get_token_supply. If you want to know about all the ETH floating around on Scroll generally, use get_eth_supply to get that figure.
You also can track market movement by checking the current Ether price via get_eth_price.
Tracking Token Movements
When it comes to tokens, you're not limited to just standard ERC20 transfers. Your agent pulls transfer events for every type of digital asset. To see all recorded movements for basic ERC20 tokens by an address, run get_erc20_token_tx. For single-edition NFTs (ERC721), use get_erc721_token_tx to map out where those unique assets moved.
If you're dealing with multi-standard contracts that handle both ERC20 and NFTs, get_erc1155_token_tx tracks those complex transfers.
Understanding Contract Logic
Sometimes you gotta know what the smart contract is actually doing—it’s not enough to just see a transaction. You can pull the Application Binary Interface (ABI) for verified contracts using get_contract_abi. This details all the functions available, telling you exactly how the code is structured. If that isn't enough, you can retrieve the entire source code of a verified contract address with get_contract_source_code, letting you see the raw logic behind it.
Tracing Transaction History
To build a full audit trail, your agent pulls transaction data in layers. You get standard, user-initiated actions using get_normal_tx_list for an address. For deeper dives into what happened inside the contract, you can list all internal transactions with get_internal_tx_list, or narrow that down further by a block range using get_internal_tx_list_by_block_range, or even find them by hash using get_internal_tx_list_by_hash.
You always gotta check the outcome: you can verify if a transaction finished processing and what the result was using get_tx_receipt_status, or confirm it successfully went through the network with get_tx_status. Every single transaction detail, including all event logs generated by smart contracts for analysis, is available via get_logs.
Low-Level Network Mechanics
For deep protocol work, your agent accesses raw blockchain state data. You can find the current block number with proxy_block_number, or check what block number corresponds to a specific time using get_block_number_by_time. Need to know how much gas you're gonna spend? Run proxy_estimate_gas for an estimate, or get the current cost of gas on the network with proxy_gas_price.
You can also check what kind of reward miners are getting using get_block_reward, and even list every block number mined by a specific address using get_mined_blocks. If you want to look at all the raw data attached to a single block, use proxy_get_block_by_number or grab all details for a transaction hash with proxy_get_transaction_by_hash, and finally, get the complete outcome of that transaction using proxy_get_transaction_receipt.
You can even simulate a contract call—seeing what would happen without actually spending gas—using proxy_call, or reading specific pieces of data stored in a contract at a particular slot with proxy_get_storage_at.
019e5d53-51c4-717f-a5ad-2e52b13dbde4 Here's how it actually works
The bottom line is: you tell your AI what data you need, and it runs the specific blockchain function required to get that answer.
Subscribe to the server and input your Scrollscan API key into your AI client's environment variables.
Ask your agent a specific question, like 'What was the ETH balance of address X at block Y?'
Your agent calls the relevant tool (e.g., get_account_balance), which pulls the data and returns a structured result to your chat window.
Who is this actually for?
This server is for crypto developers, smart contract auditors, and financial analysts. If you're constantly clicking between Etherscan, block explorers, and your IDE just to piece together a single transaction timeline, this tool saves you hours of manual data aggregation.
Debug complex transaction flows by calling tools like get_internal_tx_list or pulling contract ABIs to verify code logic directly in your workflow.
Analyze potential vulnerabilities by checking block history (get_mined_blocks) and verifying the exact source code using verify_source_code against known addresses.
Aggregate on-chain activity—like tracking all ERC20, ERC721, and internal transfers—to create reports without manual data exports.
What Changes When You Connect
You track every token type—ERC20, ERC721, and ERC1155—without using multiple tools. Just ask your agent for transfers across all standards, letting tools like get_erc*_token_tx handle the complexity.
Debugging contracts is faster than ever. Instead of just seeing a failure, you can pull the ABI (get_contract_abi) and even simulate calls with proxy_call to see why it failed.
You get full transaction visibility by separating normal transfers from internal activity. Use get_normal_tx_list alongside get_internal_tx_list for a complete picture of an account's history.
The server lets you read low-level state directly: check the total supply (get_token_supply), or find out how many blocks are left until block 10,000 using get_block_countdown.
It provides efficiency by batch processing. Need to check five wallet balances? Use get_account_balance_multi instead of running the single balance tool five times.
See it in action
Auditing a Failed NFT Transfer
A client reports an NFT didn't transfer correctly. You ask your agent to use get_erc721_token_tx for the address, then check the transaction receipt using get_tx_receipt_status. The agent finds the specific event log (get_logs) that shows where the transfer failed, solving the issue immediately.
Tracing a Complex DeFi Interaction
You need to know how funds moved through a lending protocol. You start by getting the initial balance using get_account_balance. Then you run get_internal_tx_list to see the background calls, finally cross-referencing with proxy_call to confirm the final state.
Researching New Token Contracts
You find a new token address. First, you run check_verify_status to see if it's legitimate. Then, you use get_contract_abi and get_contract_source_code to understand the rules and logic of that contract before writing any code against it.
Calculating Total Market Liquidity
You need a full view of token movement. You use get_token_supply for all major tokens, check the current ETH price via get_eth_price, and then aggregate multiple ERC20 transfers using get_erc20_token_tx to calculate total circulating value.
The honest tradeoffs
Guessing the transaction type
Just asking for 'all transactions' and hoping the agent pulls everything. This often misses internal transfers or specific token events.
Be explicit. If you want all activity, run a multi-step query: Check normal activity with get_normal_tx_list, check deep background calls using get_internal_tx_list, and pull the raw logs via get_logs.
Overlooking token standards
Assuming a transfer is always ERC20. This fails when dealing with NFTs (ERC721) or multi-standard assets (ERC1155).
Always use the specific tool for the asset type: get_erc20_token_tx for standard tokens, and then check either get_erc721_token_tx or get_erc1155_token_tx.
Ignoring gas costs
Trying to predict transaction cost without checking the network state. You risk submitting a bad estimate.
Before building anything, always query proxy_gas_price and use proxy_estimate_gas to get accurate current pricing estimates.
When It Fits, When It Doesn't
Use this server if your job requires deep forensic analysis of on-chain data. Specifically, if you need to track token movement across different standards (ERC20/721/1155) or if you must understand the internal logic of a smart contract by reading its ABI and source code.
Don't use it if you just need simple portfolio tracking—for that, checking a centralized exchange dashboard is faster and simpler. You also don't need this if your goal is just to read basic wallet balances; get_account_balance handles the basics well enough.
However, if you are debugging an interaction where the money moved but the contract failed silently, then you must use tools like proxy_call and cross-reference that result with get_internal_tx_list to find the root cause.
Questions you might have
How do I track all token types with Scrollscan MCP Server? +
You don't have to pick one. The agent can run multiple tools—specifically get_erc20_token_tx, get_erc721_token_tx, and get_erc1155_token_tx—to give you a complete view of all token movements for an address.
What is the difference between `get_normal_tx_list` and `get_internal_tx_list`? +
get_normal_tx_list shows transactions initiated by external users. get_internal_tx_list tracks background activity—calls made by one smart contract to another during a single transaction.
How do I check if an address holds multiple types of tokens? +
You must use specific tools for each type. Check standard balances with get_token_balance (ERC20), and then separately run the NFT or multi-standard tools like get_erc721_token_tx.
Do I need to worry about gas prices when using proxy tools? +
No, but you should check. Always query proxy_gas_price or use proxy_estimate_gas first. This tells your agent the current cost estimate before it attempts a transaction call.
If I need multiple balances, should I use `get_account_balance` or `get_account_balance_multi`? +
Use get_account_balance_multi. This tool handles fetching Ether balances for a list of addresses in one call. Trying to loop through individual calls with get_account_balance is inefficient and will hit rate limits faster.
How do I verify if a contract even exists before trying to get its ABI using `get_contract_abi`? +
You can use the general proxy tools like eth_getCode. This function checks for deployed code at a specific address. If it returns null or empty data, the contract probably doesn't exist or hasn't fully initialized yet.
Can I pinpoint block activity if I only know the exact timestamp using `get_block_number_by_time`? +
Yes. This tool takes a Unix timestamp and returns the corresponding block number that was mined at or nearest to that time. It’s useful for analyzing historical data when you don't have the block hash readily available.
What is the best way to check if a transaction succeeded, using `get_tx_status`? +
The get_tx_status tool checks the final receipt status of a transaction. It confirms whether the transaction was successfully processed by the network (success/failure) and provides key details about the gas used.
How do I check the balance of multiple wallets at once? +
You can use the get_account_balance_multi tool. Simply provide a comma-separated list of addresses, and the agent will return the Ether balance for each one in a single request.
Can I track NFT transfers for a specific address? +
Yes! Use the get_erc721_token_tx tool for standard NFTs or get_erc1155_token_tx for multi-token standards. Provide the wallet address and the contract address to see all relevant transfer events.
How do I get the ABI for a verified contract? +
Use the get_contract_abi tool with the target contract address. If the source code is verified on Scrollscan, the agent will retrieve the complete ABI for you.
We've already built the connector for Scrollscan. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 33 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.