OpenNode MCP for AI. Process Bitcoin and Lightning Payments from your Agent.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
OpenNode MCP Server handles Bitcoin and Lightning Network payments directly from your AI client. Use it to create charges (BOLT11 invoices or on-chain addresses), initiate withdrawals, and manage refunds for crypto payouts.
It lets your agent process real money movement without leaving the chat window.
What your AI can do
Get account balance
Retrieves the current total balance across all connected crypto assets.
List activity
Lists all historical account activity records in chronological order.
Create address
Generates and records a static on-chain Bitcoin address for receiving funds.
The agent generates a new Bitcoin charge using either an on-chain address or a BOLT11 invoice.
You trigger fund withdrawals to specific Lightning invoices or BTC addresses, which the client then confirms for execution.
The agent retrieves real-time data, listing charges (list_charges), payouts (list_withdrawals), and general account activity (list_activity).
You create static on-chain addresses or LNURL-Pay endpoints for recurring payment collection.
The agent can generate a refund (create_refund) if a charge was underpaid.
Ask an AI about this
Waiting for input…
OpenNode: 22 Tools for Crypto Payment Management
Use these tools to programmatically handle the full lifecycle of Bitcoin and Lightning payments—from generating charges to confirming payouts.
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 OpenNode on VinkiusGet Account Balance
Retrieves the current total balance across all connected crypto assets.
List Activity
Lists all historical account activity records in chronological order.
Create Address
Generates and records a static on-chain Bitcoin address for receiving funds.
List Addresses
Retrieves a list of static, long-term on-chain addresses you have set up.
Create Charge
Creates a new charge, generating the necessary BOLT11 invoice or on-chain payment...
Get Charge
Fetches specific details and status information for a known charge ID.
List Charges
Lists all successfully processed and paid charges for review.
Get Currencies
Lists every cryptocurrency supported as an originating payment currency.
Initiate Exchange
Starts an exchange process between BTC and fiat currency equivalents.
Create Lnurl Pay
Generates and records a static Lightning Network address (LNURL-Pay) for payments.
List Lnurl Pay
Retrieves a list of static Lightning Network payment URLs (LNURL-Pay).
Initiate Lnurl Withdrawal
Initiates a withdrawal payout using the LNURL-Pay system.
Get Rates
Provides current exchange rates between various crypto pairs.
Create Refund
Creates a refund record for a charge that was paid in excess of the amount due.
Get Refund
Retrieves specific information regarding a refund transaction.
List Refunds
Lists all recorded refund transactions.
Set Scheduled Withdrawals
Sets or updates the status for scheduled bank withdrawals.
Confirm Chain Withdrawal
Confirms a withdrawal payout destined for a Bitcoin (on-chain) address.
Confirm Ln Withdrawal
Confirms a withdrawal payout destined for a Lightning Network invoice.
Get Withdrawal
Fetches the full details and status of a previously initiated withdrawal payout.
Initiate Withdrawal
Starts the process for a fund withdrawal, supporting both Lightning and Chain...
List Withdrawals
Retrieves a paginated list of all initiated and completed withdrawal payouts.
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 OpenNode, 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 OpenNode. 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
Works with 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 22 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manual crypto payments are messy. You're stuck copying and pasting addresses and invoices.
Today, processing a payment requires juggling multiple systems: generating an invoice in one dashboard, manually getting the corresponding BTC address from another tool, then feeding that into your billing system. It’s slow, prone to copy-paste errors, and leaves you without a clean record of what actually happened.
With this server, you simply tell your agent, 'Charge 100 BTC.' The `create_charge` tool handles the whole process: it generates both the BOLT11 invoice and the necessary on-chain address in one step. You get structured data that your systems can actually use.
OpenNode MCP Server: Streamline payments using OpenNode.
You no longer have to open the payment dashboard, find the withdrawal button, and then manually confirm the transaction details across two different screens. The agent manages that state for you.
The result is immediate execution. You call `initiate_withdrawal`, and the server handles the complex sequence—including calling the necessary confirmation tool like `confirm_chain_withdrawal`—giving you a clean, final status code in chat.
What your AI can actually do with this
Listen up. This OpenNode MCP Server lets your agent handle Bitcoin and Lightning Network payments right inside the chat window. You won't need to jump into a separate dashboard; it manages real money movement for you.
Processing Payments and Charges
When you gotta take payment, the server handles it. If you know the customer needs to pay via BOLT11 or an on-chain address, use create_charge to generate that new charge record—it'll give you the right details whether they need a specific Lightning invoice or just standard BTC details.
You can also check out all your paid charges anytime by running list_charges. Need cash back? If a client overpaid on a charge, run create_refund, and the server records that refund for you.
Moving Funds (Withdrawals)
When it's time to pay out, the agent kicks off the process. You initiate fund withdrawals using initiate_withdrawal—this covers both Lightning invoices and standard BTC addresses, and it even lets you preview what a payout will look like first. Once that initial request is made, you confirm the actual payout: for Lightning Network payments, use confirm_ln_withdrawal; if it's going to an on-chain Bitcoin address, run confirm_chain_withdrawal.
For specific payouts, you can check the status using get_withdrawal, or look up details about a past charge with get_charge and track any recorded refund by calling get_refund. To get the full picture of money coming in and going out, list all historical account activity records chronologically with list_activity; you'll also get a paginated rundown of every payout attempt through list_withdrawals, or see a complete history of charges using list_charges.
Setting Up Infrastructure & Accounts
You don't have to set up payment endpoints manually. You can tell the server to generate and record static on-chain Bitcoin addresses for receiving funds via create_address. If you need a recurring payment collection point, use create_lnurl_pay to generate and save a static Lightning Network address (LNURL-Pay).
The server keeps track of all these endpoints; grab your list of long-term BTC addresses with list_addresses, or see every LNURL-Pay endpoint you've set up by calling list_lnurl_pay. You can also review every refund transaction that ever happened using list_refunds.
Monitoring and Rates
Always know what your books look like. Use get_account_balance to pull the current total balance across all connected crypto assets. Need to see what currencies are accepted for payments? Run get_currencies to list them out, or check the current exchange rates between various crypto pairs with get_rates. You can also set up future payouts by using set_scheduled_withdrawals to manage bank withdrawal statuses.
Managing Exchanges and Records
If you gotta swap assets, start an exchange process between BTC and fiat currency equivalents using initiate_exchange. The server tracks every single transaction. You can see a rundown of all your initiated payouts by calling list_withdrawals, or check the status of any specific withdrawal payout with get_withdrawal.
019ea5fc-a22a-7035-8b79-c994bb53fb26 Here's how it actually works
The bottom line is that you control complex financial transactions by passing specific commands to the OpenNode API through your AI client.
Subscribe to the server and input your OpenNode API Key.
Your AI client calls a specific function (e.g., get_account_balance).
The server executes the payment action and returns structured data—like an invoice, balance amount, or transaction ID—to your chat.
Who is this actually for?
E-commerce operations managers who handle crypto payments daily. Backend developers integrating payment rails into custom apps. FinOps engineers needing a single source of truth for tracking blockchain transaction history and payouts.
Running end-of-day reports by using list_charges and list_withdrawals to reconcile payments across multiple channels.
Testing payment flows by having the AI client execute a full cycle: calling create_charge, then listing that charge with get_charge.
What Changes When You Connect
Automated Charge Creation: Use create_charge to instantly generate payment requests. Your agent handles the complexity—it returns both a BOLT11 invoice and a usable on-chain BTC address, eliminating manual data entry.
Full Payout Visibility: Never guess where your funds went. The combination of list_withdrawals, get_withdrawal, and list_activity lets you audit every payout status, from initiation to completion.
Multi-Network Support: You don't need separate tools for BTC or LN. The server supports both through functions like initiate_withdrawal and dedicated confirmation calls (confirm_ln_withdrawal).
Refund Management: If a payment is short, you don't have to manually calculate credits. Just run create_refund, and the system tracks the necessary adjustments.
Recurring Collection: Set up permanent collection points using create_address or create_lnurl_pay. Your agent generates these static addresses so customers always pay the right way.
See it in action
Reconciling a Failed Payment Batch
The team ran 50 payments, but some failed or were underpaid. Instead of downloading CSVs and cross-referencing IDs, the agent first runs list_charges. Then, for any identified short payment, it calls create_refund to flag the necessary credit adjustment. This completes the audit trail in minutes.
Setting up Merchant Payout Rails
A new merchant needs payouts every Friday. The ops engineer uses get_account_balance first, confirming funds are available. Then, they use initiate_withdrawal, followed by the required confirmation call (e.g., confirm_chain_withdrawal), making the payout automated and auditable.
Onboarding a New Client/Service
A new service needs payments. The agent runs create_lnurl_pay to generate a permanent LNURL-Pay endpoint, followed by list_addresses to ensure the corresponding on-chain address is also set up for maximum collection flexibility.
Immediate Payment Inquiry
A customer claims they paid but their order isn't marked. The agent uses get_charge with the transaction ID, instantly confirming if the payment arrived and showing details like the amount received and creation date.
The honest tradeoffs
Treating payments as simple transactions
Thinking you just need to send money. You forget that crypto requires specific network instructions, separate charges for underpayments, and confirmation steps.
You must follow the full flow: Use get_account_balance first. Then, use create_charge (for incoming funds) or initiate_withdrawal (for outgoing funds). Always check status with list_activity.
Ignoring refund requirements
A customer overpays and you manually process a bank transfer. You lose the audit trail, and OpenNode has no record of the credit.
When an underpayment occurs, run create_refund. This records the exact amount and reason within the blockchain payment system, maintaining perfect accountability.
Assuming a single payout tool works everywhere
Calling one general 'send money' function when the destination could be either Bitcoin or Lightning. The transaction will fail.
Check the target network type. If it's LN, use initiate_lnurl_withdrawal. If it's BTC, use initiate_withdrawal and then confirm with confirm_chain_withdrawal.
When It Fits, When It Doesn't
Use this server if your business relies on accepting or sending funds using Bitcoin or Lightning Network. You need to programmatically handle the full payment lifecycle: generating invoices, recording incoming charges (create_charge), and executing structured payouts (initiate_withdrawal).
Don't use this if you only process payments via credit card rails (Stripe/Adyen) or ACH transfers; those require different API types. If your core need is simply checking account balance without initiating a flow, get_account_balance is enough, but for any transaction—incoming, outgoing, or refunding—you must use the full set of tools to maintain auditability.
Questions you might have
How do I handle payments that were underpaid using create_charge? +
You don't have to worry about it. After identifying the shortfall, simply run create_refund. This generates a record for the exact amount needed, keeping your ledger accurate and auditable.
Can I list all past payments using list_charges? +
Yes. list_charges retrieves every successfully processed charge ID. You can then pass these IDs to get_charge if you need the specific details or payment status for an individual record.
What's the difference between initiate_withdrawal and confirm_chain_withdrawal? +
initiate_withdrawal starts the process and can show a preview. confirm_chain_withdrawal is the final, explicit call needed to execute the payout on the Bitcoin chain after you have reviewed the details.
How do I get my current BTC balance? +
Use get_account_balance. This tool provides a single figure for your total account holdings across all monitored assets. It's the first step before any payout attempt.
How do I use `create_address` to generate a static Bitcoin receiving address? +
You call create_address when you need a stable, on-chain wallet point for incoming payments. This generates predictable BTC addresses that don't change frequently, simplifying your payment collection setup.
Before I process an exchange, how do I use `get_rates`? +
Use get_rates to fetch the current market data between BTC and Fiat currencies. Checking these rates first ensures you calculate the precise payout amount before initiating the transfer via initiate_exchange.
What is the process for generating an LNURL-Pay address using `create_lnurl_pay`? +
create_lnurl_pay generates a static Lightning Network URL payment request. This method provides a standardized, easy-to-read address format ideal for quick and reliable payments on the Lightning network.
How do I manage scheduled payouts with `set_scheduled_withdrawals`? +
You use set_scheduled_withdrawals to define when and how frequently your fiat bank withdrawals should occur. This tool allows you to automate payout timing, giving you control over disbursement schedules.
How do I generate a new Bitcoin payment request? +
Use the create_charge tool. Provide the amount in satoshis (or specify a currency like USD) and an optional description. The tool returns a BOLT11 Lightning invoice and an on-chain address.
Can I preview a withdrawal before confirming it? +
Yes. Call initiate_withdrawal with auto_confirm set to false. This generates a preview. You can then finalize it using confirm_chain_withdrawal or confirm_ln_withdrawal depending on the type.
How do I check my past withdrawals? +
You can use the list_withdrawals tool to retrieve a list of past withdrawals, with optional filters for page size, page number, and withdrawal type (like 'ln' or 'chain').
We've already built the connector for OpenNode. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 22 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.