Nearblocks MCP for AI. Inspect Near blockchain data via AI agent commands.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
How this MCP server connects to your AI agent
Nearblocks (Near Blockchain Explorer API) lets your AI agent query the Near Protocol blockchain directly. You can inspect specific accounts for balances, track NFTs and tokens, review transaction history, or check global network stats—all without leaving your client interface.
What AI agents can do with Nearblocks (Near Blockchain Explorer API) Automation
Get account details
Retrieves basic identifying information for a specified Near account address.
Get account inventory
Lists all Non-Fungible Tokens (NFTs) currently owned by a specific Near account.
Get account tokens
Retrieves a list of fungible tokens held by an account, including their current balances.
Retrieves a user's current NEAR balances, along with lists of owned NFTs (get_account_inventory) and fungible tokens (FTs) using get_account_tokens.
Fetches a list of recent transactions for an account or gets the full details for any specific transaction hash, including gas usage.
Retrieves general network statistics (like current block height and TPS) and lists the most recent blocks and transactions happening across the entire chain.
Lists all available tokens on the Near network or gets specific contract details for a single token ID.
Grabs basic metadata and core information about any specified Near blockchain address using get_account_details.
Ask an AI about this
Waiting for input…
What AI agents can do with Nearblocks (Near Blockchain Explorer API): 11 Tools for Web3 Data
Run all eleven tools to query account details, track tokens, retrieve transaction histories, monitor network stats, and analyze the Near Protocol blockchain state.
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 Nearblocks (Near Blockchain Explorer API) on VinkiusGet Account Details
Retrieves basic identifying information for a specified Near account address.
Get Account Inventory
Lists all Non-Fungible Tokens (NFTs) currently owned by a specific Near account.
Get Account Tokens
Retrieves a list of fungible tokens held by an account, including their current...
Get Account Transactions
Gathers a paginated list of historical transactions associated with a given Near...
Get Block Details
Fetches specific information about a single block hash, allowing deep inspection of...
Get Latest Blocks
Pulls a list containing the most recent blocks recorded on the Near blockchain.
Get Network Stats
Returns current, high-level metrics for the entire network, such as gas prices and total transactions per second (TPS).
Get Recent Transactions
Retrieves a list of the most recently processed transactions across the whole Near...
Get Token Details
Gets specific metadata and contract details for an individual token ID on the...
Get Token List
Provides a comprehensive list of all unique token contracts deployed across the Near...
Get Transaction Details
Gets the full payload and success status for a single, specific transaction hash.
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.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Nearblocks integration is available immediately — no restart needed.
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 Nearblocks (Near Blockchain Explorer 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
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 11 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Checking a wallet balance shouldn't require multiple dashboards., Solved with Vinkius AI Gateway
Today, checking one person’s total value is a multi-step process. You jump to the main dashboard for NEAR balances. Then you click into 'NFTs' to see ownership totals. Next, you have to switch tabs or use a separate tool to check fungible tokens (like stablecoins). It's tedious clicking and copy-pasting across three different views just to get a single number.
With the Nearblocks MCP Server, your agent handles it all in one prompt. You ask for 'all assets held by this wallet,' and it runs `get_account_tokens` AND `get_account_inventory`. It stitches those separate data sets together and gives you a unified answer instantly.
Nearblocks (Near Blockchain Explorer API) MCP Server: Get the full picture.
The manual effort of checking network health involves opening block explorers, looking up gas prices in one tab, and then cross-referencing recent transactions in another. You're always racing against latency, hoping nothing changed between your three clicks.
Now, you ask the agent to 'Give me the network status.' It calls `get_network_stats` and `get_recent_transactions`, giving you a single data payload that shows current block height, gas costs, and activity all at once. The difference is real-time coherence.
What your AI can actually do with this
You're hooking up your AI agent to Nearblocks API, so you can pull real-time data straight from the Near Protocol blockchain. This MCP server lets your agent query everything—accounts, transactions, blocks, and tokens—right where you are working. You don't need to leave your client interface to check the ledger.
Checking Account Holdings
You wanna see what an account owns? The get_account_details tool grabs basic identifying information for any specified Near account address. To check its assets, your agent can list all Non-Fungible Tokens (NFTs) using get_account_inventory. It can also retrieve a full list of fungible tokens (FTs) and their current balances with get_account_tokens.
Pulling Transaction History
Need to track movement? Your agent pulls historical data for an account using get_account_transactions, which gives you a paginated list of transactions associated with that address. If you're looking at one specific move, get_transaction_details gets the full payload and success status for any single transaction hash. To see what’s happening right now across the whole network, your agent can pull the most recent transactions using get_recent_transactions.
Monitoring Network Activity
You gotta know if the chain is healthy. Your agent pulls current, high-level metrics for the entire network with get_network_stats, which reports things like gas prices and total transactions per second (TPS). It can also pull a list of the most recent blocks recorded on the Near blockchain using get_latest_blocks.
For deeper investigation into the ledger state at a specific moment, get_block_details fetches all the information about one single block hash.
Analyzing Token Contracts
When it comes to tokens, your agent has options. It can get a comprehensive list of every unique token contract deployed across the entire Near blockchain using get_token_list. If you know the specific ID, get_token_details gets all the metadata and contract specifics for that single token on the network.
Getting Core Account Info
Beyond just balances, your agent can grab basic metadata and core information about any specified Near blockchain address with get_account_details. For a full picture of an account's history, it checks transactions via get_account_transactions or dives into the specifics of one transfer hash using get_transaction_details.
How It Works Together
Your agent can use these tools in sequence. Wanna know what’s up with an address? First, it gets basic details using get_account_details. Then, it checks the assets: running get_account_inventory shows all NFTs, and calling get_account_tokens lists every fungible token and its balance. If you want to see where those assets came from, your agent runs get_account_transactions for history or uses get_transaction_details if you have a specific hash.
If you’re monitoring the whole system, the process starts by checking general network health with get_network_stats. To track down any particular contract, it lists all available tokens via get_token_list, then drills down with get_token_details on the one you care about. The server also lets your agent check the latest activity—either by pulling a list of recent blocks using get_latest_blocks or listing the most recent transactions across the whole chain via get_recent_transactions.
These tools make sure that every piece of blockchain data, from basic address metadata to deep-dive contract specs, is available for your AI client to process.
019e5d3a-75ef-7092-8641-25a4c6035feb 
Here's how it actually works
The bottom line is: You ask a question about the Near blockchain; the agent runs the required tool calls under the hood and presents the clean answer.
First, connect the Nearblocks MCP Server to your AI client. You'll need an API key if you want high usage limits.
Next, prompt your agent with a request (e.g., 'What tokens does account X hold?'). The agent determines which tool to call and executes it.
Finally, the server returns structured data—like a list of token IDs or transaction records—which your AI client interprets and gives back to you in plain text.
Who is this actually for?
This server is for Web3 developers who hate switching between their IDE, terminal, and dashboard to debug contract interactions. It's also for crypto analysts tired of manual data aggregation—you can track whale movements or network performance without leaving your chat window.
Debug transaction failures by running get_transaction_details against a failing hash and cross-referencing the state with get_account_details.
Track portfolio health. Use get_account_tokens to verify token holdings, then use get_recent_transactions to see when those tokens moved into or out of the wallet.
Monitor network stress by calling get_network_stats and correlating that with specific contract activity using get_token_list.
What Changes When You Connect
See an account's total holdings (NFTs, FTs) in one go. Using get_account_inventory and get_account_tokens separates asset types but keeps the results together for a full picture.
Track historical activity without leaving your chat. You can request all transactions using get_account_transactions, then use get_transaction_details on any single hash to see the payload.
Get a real-time view of network stress. Call get_network_stats to check TPS and block height, giving you immediate context for any transaction you're analyzing.
Never manually search for token contracts again. Run get_token_list to get every contract ID, then use get_token_details to pull its specific rules and metadata.
Pinpoint exactly when something happened. By combining get_latest_blocks with a transaction hash check via get_transaction_details, you can pinpoint the exact block where an event occurred.
See it in action
Debugging a failed smart contract call
A developer finds a failing transaction hash. They first run get_transaction_details to see why it failed, then use get_account_details on the target account to verify its current balance. This confirms if the failure was due to insufficient funds or a contract logic error.
Auditing an investor's portfolio
An analyst needs to know everything about 'Wallet X'. They first call get_account_tokens for fungible assets, then run get_account_inventory for NFTs. Finally, they use get_account_transactions to trace the movement of those assets over time.
Checking network congestion before deployment
A team is planning a major token launch. They check get_network_stats to see current gas prices and TPS. If the stats are bad, they run get_recent_transactions to estimate how much bandwidth the new smart contract will consume.
Verifying asset ownership legitimacy
A user questions if a specific token is legitimate. They use get_token_list to see all deployed contracts, find the ID, and run get_token_details to verify its official metadata before trusting it.
The honest tradeoffs
Calling tools blindly
The user just runs get_account_transactions, gets a huge list of hashes, and then manually asks the AI to summarize everything. This is slow because the agent doesn't know which data points matter.
Instead, use a targeted workflow: first call get_account_details for context, then run get_recent_transactions and immediately follow up with get_network_stats to provide immediate macro-level context alongside the micro-data.
Assuming data is fresh
The user asks about an account's balance, gets a result, and assumes it's final. They don't realize that since the last read block, another transaction occurred.
Always start by calling get_network_stats to check the current block height. This tells you how current your data is when checking account balances via get_account_details.
Mixing up token scopes
The user thinks get_token_list shows all assets, but it only lists contracts. They then try to check a balance using that list without knowing the account ID.
If you want balances, always use get_account_tokens. If you just need metadata about what can be on the chain, run get_token_list first.
When It Fits, When It Doesn't
Use this server if your job requires turning raw blockchain data into actionable insights—think debugging or auditing. You should use it when you need to verify: 1) an asset's existence (get_token_details), 2) an account's state (get_account_details, get_account_tokens), or 3) the network context (get_network_stats). Don't use this if you just want general crypto news; that’s better suited for a dedicated news API. If your goal is simple portfolio tracking, using get_account_tokens and get_account_inventory together is usually sufficient. You don't need to call every tool; focus on the relationship between an account ID and its asset types.
Questions you might have
How do I check if an account has NFTs using get_account_inventory? +
Use get_account_inventory and provide the target Near account address. It returns a list of all associated NFT IDs, confirming ownership without needing to know which contract they belong to.
What is the difference between get_recent_transactions and get_account_transactions? +
get_recent_transactions shows everything that happened on the network globally. get_account_transactions filters that history, only showing activity tied directly to a specific account address you provide.
Can I use get_token_details to see an account's balance? +
No. get_token_details gives metadata about the contract itself (like its name or total supply). To see a specific account’s balance, you must use get_account_tokens.
Do I need to call get_latest_blocks before querying an account? +
No. While checking the latest blocks gives context, most queries like get_account_details run independently and pull data relative to the current state; you don't need a prerequisite block read.
If I use get_account_transactions repeatedly, how do I handle rate limits? +
The API documentation outlines specific rate limit thresholds. If you hit a limit, your AI client must pause and retry the request after a specified delay (usually 1-2 seconds). Using an API key helps manage higher call volumes.
Does get_account_transactions include transaction types like staking or governance calls? +
Yes, it returns all associated activity. The data differentiates between standard transfers and smart contract interactions (like FunctionCalls). You'll find a 'type' field to filter these actions in your agent code.
How can I check if a transaction failed when calling get_transaction_details? +
You need to look at the 'status' field returned by the tool. A successful transaction will have a status of 'SUCCESS', while failures are marked with specific error codes and messages.
If I run get_token_list, how do I match those tokens to an account using get_account_tokens? +
The list tool provides the contract addresses for all available tokens. You then pass those specific addresses into get_account_tokens to see which ones a given account currently holds.
Can I see which NFTs an account owns? +
Yes! Use the get_account_inventory tool with the target account ID. It will return a list of Non-Fungible Tokens (NFTs) currently held by that account.
How do I check the current network status like TPS? +
You can use the get_network_stats tool. It provides real-time metrics including Transactions Per Second (TPS), current block height, and gas prices.
Is it possible to list all tokens available on the Near network? +
Yes, the get_token_list tool allows you to fetch a list of fungible and non-fungible tokens registered on the Near network.
We've already built the connector for Nearblocks. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 11 tools are live and waiting.
You're up and running in seconds.
Gemini 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.