Particle Network MCP for AI. Manage complex Web3 identity and transactions.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Particle Network MCP manages complex Web3 development tasks like Account Abstraction, UserOperations, and identity management. Your AI agent can now build entire user flows—from checking a wallet's project membership to simulating gas fees and sending signed transactions across multiple EVM chains.
What AI agents can do with Particle Network Automation
Aa create sessions
Creates the initial transaction needed to set up a new session key for a smart account.
Aa create user op
Builds a complete UserOperation object from various underlying transactions.
Aa get fee quotes
Calculates and returns multiple options for gas payments for a UserOp, including different payment methods.
Retrieve detailed user profiles using UUIDs, tokens, or social identities, and check if a wallet belongs to your project.
Set up smart accounts by generating sessions and validating session keys for complex user experiences.
Construct, estimate gas costs for, and finally push signed UserOperations across supported EVM chains.
Check the available balance and generate signatures to pay for transactions using a Paymaster contract.
Ask an AI about this
Waiting for input…
What AI agents can do with Particle Network: 16 Tools for Web3 Development
These tools give your agent granular control over every stage of the blockchain process, from user verification and session management to estimating gas costs and submitting final transactions.
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 Particle Network on VinkiusAa Create Sessions
Creates the initial transaction needed to set up a new session key for a smart account.
Aa Create User Op
Builds a complete UserOperation object from various underlying transactions.
Aa Get Fee Quotes
Calculates and returns multiple options for gas payments for a UserOp, including...
Aa Get Smart Account
Retrieves core information about smart accounts like BICONOMY or SIMPLE wallets.
Aa Send User Op
Submits a finalized and signed UserOperation directly to the blockchain network.
Aa Validate Session
Checks if an existing session key is still valid on the network.
Eth Estimate User Operation Gas
Returns a gas cost estimate for a specific UserOperation, preventing unexpected transaction failures.
Eth Get User Operation By Hash
Fetches the full details of a UserOperation using its unique hash identifier.
Eth Get User Operation Receipt
Retrieves confirmation data, or the receipt, confirming that a UserOp was processed...
Eth Send User Operation
Submits a finalized UserOperation to the bundler service for processing.
Eth Supported Entry Points
Lists all recognized and supported EntryPoint addresses for the network.
Get User Info By Identity
Retrieves user profile details using a social identity like a JWT or UID.
Get User Info
Gets comprehensive user data by providing both a UUID and an associated token.
Is Project User
Checks if a given wallet address has been registered as a member of your specific...
Pm Paymaster Balance
Returns the current USD balance available in the project's Paymaster account.
Pm Sponsor User Operation
Generates a necessary signature allowing your Paymaster to sponsor and pay for the...
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 Particle Network, 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 16 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Managing user onboarding used to feel like writing an entire textbook on RPC calls., Solved with Vinkius AI Gateway
Today, getting a single user's profile often means hitting three or four separate endpoints: one for their UUID, another for their token balance, and yet a third to confirm if that address is even registered in the project. You spend time chaining these calls together, building error handling for every potential failure point, just to answer 'who is this?'
With this MCP, your agent handles the complexity of identity verification behind the scenes. Instead of writing multi-step code, you ask for user details using `get_user_info`, and it returns a complete profile, allowing you to focus on what the user actually sees.
User Operations: Submit complex blockchain tasks with confidence.
Before this MCP, submitting a UserOperation meant manually calculating gas estimates across chains and writing intricate logic to ensure that fees were covered by either the user or a sponsor. If any single calculation failed, the whole transaction pipeline broke down.
Now, you can let your agent use `aa_get_fee_quotes` to generate all payment options—native MATIC, Paymaster sponsorship, etc.—and then execute the final submission via `aa_send_user_op`. The entire process is encapsulated and reliable.
What your AI can actually do with this
This connector gives your AI client the power to handle complex Web3 infrastructure tasks directly through natural language commands. Instead of juggling dozens of RPC calls, you simply ask for what you need: user details, session validation, or a completed transaction. You can use tools like get_user_info to verify who a wallet belongs to and then build out the entire sequence of actions required for a modern DApp experience.
Whether you're building on Polygon, Ethereum, or Solana, this MCP handles the underlying complexity—like generating UserOperations and ensuring gas fees are covered via Paymaster sponsorship. When you connect it through Vinkius, all these advanced Web3 tools become available instantly to your agent, letting you focus purely on the user experience instead of the blockchain plumbing.
019ea5fd-4c06-7238-acca-d0f7f480f724 Here's how it actually works
The bottom line is that your agent handles the entire sequence of complex Web3 steps—from validation to submission—in one go.
First, subscribe to this MCP on Vinkius and provide your Particle Project Server Key.
Next, instruct your AI client to perform the necessary Web3 action—for example, 'Get user info for UUID X with token Y.'
The MCP executes the tool call, returning structured data about the user's profile or the status of the transaction.
Who is this actually for?
This MCP is for developers and architects building anything on modern decentralized apps. If you're tired of writing boilerplate code just to manage wallet connections, gas estimates, or user profiles across multiple chains, this tool saves hours.
Debugging transaction logic by calling eth_get_user_operation_receipt or simulating fees with aa_get_fee_quotes without writing raw RPC calls.
Designing the user flow and verifying session key validity using aa_validate_session before committing to a complex transaction build.
Investigating integration failures by running get_user_info_by_identity to quickly inspect user identities and project associations.
What Changes When You Connect
Eliminate manual RPC calls for user verification. Use get_user_info or get_user_info_by_identity to instantly check a wallet's status using social IDs, making onboarding faster.
Build robust smart account logic with Account Abstraction. You can use aa_create_sessions and aa_validate_session to manage user authentication flow without handling private keys yourself.
Handle transaction complexity with ease. The MCP allows you to build a UserOperation using aa_create_user_op, estimate the cost via eth_estimate_user_operation_gas, and send it all in one go.
Remove gas fee guesswork. Before submitting, check payment options and balances using pm_paymaster_balance or simulate costs with aa_get_fee_quotes to prevent failed transactions.
Track every step of the transaction lifecycle. Tools like eth_get_user_operation_receipt let you confirm that a UserOp was successfully processed by the chain, providing instant debugging feedback.
See it in action
Onboarding a new user to your DApp
A developer needs to verify a new wallet. They ask their agent to first run get_user_info using the provided UUID and token. The agent confirms the profile is active, then runs aa_validate_session to ensure the connected session key hasn't expired before proceeding.
Processing a multi-chain transaction
A user needs to send funds across different EVM chains. The agent uses aa_create_user_op to construct the full operation, then calls eth_estimate_user_operation_gas on Polygon to get quotes. Finally, it runs pm_sponsor_user_operation and submits via aa_send_user_op.
Debugging a failed transaction
A user reports that their transaction failed. The agent uses the hash to fetch details with eth_get_user_operation_by_hash, then retrieves the full outcome using eth_get_user_operation_receipt to pinpoint exactly where the failure occurred.
Verifying project membership
Before granting access, a service needs to confirm if a given wallet address belongs to the project. The agent uses the simple is_project_user tool, which returns a clear boolean result, allowing immediate gating of functionality.
The honest tradeoffs
Manually checking gas fees
The developer writes complex logic that must call multiple endpoints and handle varying fee structures (native vs. sponsored) just to know if a transaction will pass.
Use the MCP tools like aa_get_fee_quotes or pm_paymaster_balance. These functions consolidate all payment options, giving you clear choices without building custom financial logic.
Confusing user identity and wallet address
The developer assumes that knowing a wallet's public address is enough to confirm they are an active user or member of the project.
Always use get_user_info or get_user_info_by_identity. These tools connect the raw wallet data (the 'what') with the stored profile data (the 'who'), ensuring accuracy.
Sending transactions without validation
The developer builds a UserOperation and submits it immediately, only to find out later that the session key is invalid or expired.
Always validate first. Run aa_validate_session before any submission tool (aa_send_user_op) to guarantee the user's connection credentials are current.
When It Fits, When It Doesn't
Use this MCP if your application requires complex, multi-step interaction with blockchain state or identity management. Specifically, you need to handle Account Abstraction, simulate gas costs across different chains (Polygon, Ethereum, etc.), or verify a user's membership using advanced identifiers like UUIDs and tokens. Don't use it if all you need is simple data storage retrieval (like reading a single record from a traditional database). If your goal is basic CRUD operations on non-blockchain data, stick to standard API connectors; this MCP exists exclusively for managing the intricate mechanics of modern Web3 wallets and transactions.
Questions you might have
How does Particle Network MCP handle gas fees? +
The MCP provides tools like aa_get_fee_quotes to return multiple payment methods. It also lets you use the Paymaster functions (pm_sponsor_user_operation) to generate signatures that sponsor the transaction costs.
Can I check if a wallet is part of my project using Particle Network MCP? +
Yes, you can. Use the is_project_user tool. It simply checks if an address exists in your project's records and returns a clear status.
What is Account Abstraction, and how does Particle Network MCP help? +
AA manages complex smart account logic. You use tools like aa_create_sessions to set up the necessary session keys and validate them with aa_validate_session for a seamless user experience.
Does Particle Network MCP support all EVM chains? +
The MCP is built to interact with various EVM-compatible chains, providing consistent tools like eth_estimate_user_operation_gas regardless of the underlying network.
Is it possible to retrieve user info using only a social token? +
Yes. The tool get_user_info_by_identity allows you to fetch detailed profiles simply by providing a social identity, like a JWT or UID.
We've already built the connector for Particle Network. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 16 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.