How to Use the Moonscan (Moonbeam Network Explorer) MCP in Pydantic AI

Validate Moonbeam blockchain data at runtime using Pydantic AI to ensure type-safe MCP agent execution.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Moonscan (Moonbeam Network Explorer) MCP to Pydantic AI

Create your Vinkius account to connect Moonscan (Moonbeam Network Explorer) to Pydantic AI and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Moonscan (Moonbeam Network Explorer) with Pydantic AI

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Validate GLMR balances at runtime with Pydantic AI

The `get_glmr_balance` tool retrieves the native token balance of any Moonbeam address, which is then validated against your strict Pydantic schemas. This guarantees that your agent never operates on corrupted or malformed balance data during execution. If you need to monitor multiple accounts, `get_glmr_balance_multi` returns a structured list that your agent parses into type-safe models. This prevents silent execution failures when checking balances across decentralized portfolios.

Parse smart contract ABIs via an MCP Server

The `get_contract_abi` tool pulls the JSON interface of any deployed Moonbeam contract directly into your Python runtime. Pydantic AI validates the structure, ensuring your agent only interacts with correctly formatted contract methods. If the contract code is needed, `get_contract_source_code` returns the raw source file. If the explorer returns unexpected formatting, the validation layers fail loudly, stopping your agent before it attempts to write bad data to the blockchain.

Assert transaction finality in type-safe code

The `get_tx_receipt_status` tool returns the exact execution status of a transaction, allowing your agent to make hard assertions about success or failure. This ensures your code doesn't proceed to the next step of a loop on a failed transaction. For deeper validation, the agent queries `proxy_eth_get_transaction_by_hash` to confirm the transaction payload matches the original intent. This strict verification loop makes your automated workflows highly resilient to network anomalies.

Setup guide

Set up Moonscan (Moonbeam Network Explorer) MCP in Pydantic AI

Prerequisites

Python 3.10+ installed
pydantic-ai-slim[fastmcp] package
Active Vinkius subscription with a valid endpoint token

1

Install Pydantic AI with FastMCP
Run pip install "pydantic-ai-slim[fastmcp]". The FastMCP toolset replaces the deprecated MCPServerHTTP class with full protocol support.
2

Configure the FastMCPToolset
Pass a JSON-style config dict to FastMCPToolset with your Vinkius URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. Supports Streamable HTTP, SSE, and Stdio transports.
3

Create and run your agent
Pass the toolset to Agent(toolsets=[toolset]) and call agent.run(). Swap openai:gpt-4o for any supported model — Anthropic, Google, Mistral, or Groq.

agent.py

from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

toolset = FastMCPToolset({
    "mcpServers": {
        "moonscan-moonbeam-network-explorer-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

agent = Agent(
    "openai:gpt-4o",
    toolsets=[toolset],
    system_prompt="You have access to Moonscan (Moonbeam Network Explorer) tools.",
)

result = await agent.run("List recent Moonscan (Moonbeam Network Explorer) transactions")
print(result.output)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Moonscan. 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.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Moonscan (Moonbeam Network Explorer) now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Moonscan (Moonbeam Network Explorer) MCP in Pydantic AI

Instantiate MCPToolset with your Vinkius HTTP endpoint and pass it to your Agent constructor. The framework automatically sets up runtime validation for all 26 Moonbeam tools.

The framework will raise a validation error instantly instead of letting your agent hallucinate. This keeps your automated pipelines safe when parsing complex outputs from tools like get_internal_transactions.

Yes, this setup is model-agnostic. You can connect your validated tools to OpenAI, Anthropic, or local models while maintaining strict type-safety for actions like get_glmr_last_price.

Yes, the server handles asynchronous requests natively. Your agent can run multiple concurrent checks on get_erc20_balance without blocking the main execution thread.

The server only queries public on-chain data like block rewards, token transfers, and contract ABIs. No private keys or sensitive user inputs are sent, and Vinkius runs the connection inside isolated V8 sandbox instances.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript