🚀 Lightning Wallet
Give your AI agent a Bitcoin wallet. MCP server + CLI. Works with Claude Code, OpenClaw, Cursor, and any agent framework.
Note: This package was previously published as lightning-faucet-mcp. The functionality is identical.
🚀 Quick Start
Free Sats Promotion
First 10 AI agents who install get 100 free sats!
npm i -g lightning-wallet-mcp
lw register --name "YourAgent"
lw deposit 100
- Reply to our tweet with the bolt11 invoice string
We verify the invoice cryptographically and pay automatically. No trust required — the destination pubkey in the invoice proves it came from lw. Limited to 10 spots.
✨ Features
What's New in v1.1
v1.1.0 - X402 protocol support (USDC on Base) as automatic fallback alongside L402 (Lightning).
- X402 Support - Automatic USDC payments on Base when L402 isn't available
- Protocol Auto-Detection -
pay_l402_api seamlessly handles both L402 and X402
- Webhooks - Real-time notifications for payments and events
- Keysend - Send payments without invoices using node pubkeys
- Invoice Decoding - Decode BOLT11 invoices before paying
- Agent Analytics - Track spending patterns and usage
- Transaction Export - Export history in JSON or CSV format
- Budget Management - Get detailed budget status and set limits
- Agent Lifecycle - Deactivate, reactivate, and delete agents
- Account Recovery - Recover accounts and rotate API keys
- Agent-to-Agent Transfers - Move funds between your agents
Why Lightning Wallet MCP?
- Instant Payments - Lightning Network transactions settle in milliseconds
- L402 + X402 Protocol Support - Access any paid API automatically (Lightning or USDC)
- Operator/Agent Hierarchy - Manage multiple agents with spending limits
- No Custody Risk - Each agent has isolated funds with operator oversight
- Production Ready - Battle-tested infrastructure powering real transactions
- Webhook Notifications - Get notified instantly when payments arrive
- Full Observability - Analytics, exports, and detailed status tracking
📦 Installation
CLI (Any Agent Framework)
For CLI-first agents (OpenClaw, Pi, KiloCode, or any agent with Bash access):
npm install -g lightning-wallet-mcp
This installs the lw command:
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Bot" | jq -r '.api_key')
lw balance | jq '.balance_sats'
lw pay-api "https://lightningfaucet.com/api/l402/fortune"
lw create-agent "Research Bot" --budget 5000
lw fund-agent 1 1000
lw whoami
Output is JSON by default (pipe to jq). Use --human for readable output.
Run lw help for all commands.
MCP Server (Claude Code, Cursor, Windsurf)
For MCP-native clients, configure as an MCP server:
Option A: Self-Registration
{
"mcpServers": {
"lightning-wallet": {
"command": "npx",
"args": ["lightning-wallet-mcp"]
}
}
}
Then ask Claude: "Register a new Lightning Wallet operator account"
Option B: Pre-configured API Key
- Get an API key at lightningfaucet.com/ai-agents
- Configure Claude Code (
~/.claude/settings.json):
{
"mcpServers": {
"lightning-wallet": {
"command": "npx",
"args": ["lightning-wallet-mcp"],
"env": {
"LIGHTNING_WALLET_API_KEY": "your-api-key-here"
}
}
}
}
💻 Usage Examples
Agent Workflow Example (Bash)
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Agent" | jq -r '.api_key')
lw deposit 10000 | jq -r '.bolt11'
AGENT=$(lw create-agent "Worker" --budget 5000)
AGENT_ID=$(echo $AGENT | jq -r '.agent_id')
AGENT_KEY=$(echo $AGENT | jq -r '.agent_api_key')
lw fund-agent $AGENT_ID 2000
export LIGHTNING_WALLET_API_KEY=$AGENT_KEY
lw pay-api "https://api.example.com/data" --max-sats 100
lw transactions --limit 5
Complete Workflow Example
register_operator({ name: "My AI Company" })
set_operator_key({ api_key: "lf_abc..." })
whoami()
get_deposit_invoice({ amount_sats: 10000 })
create_agent({ name: "Research Assistant", budget_limit_sats: 5000 })
fund_agent({ agent_id: 456, amount_sats: 1000 })
register_webhook({
url: "https://your-server.com/webhooks/lightning",
events: ["invoice_paid", "payment_completed"]
})
set_agent_credentials({ api_key: "agent_def..." })
get_budget_status()
pay_l402_api({ url: "https://api.example.com/premium-data" })
Keysend Payments
keysend({
destination: "03864ef025fde8fb587d989186ce6a4a186895ee44a926bfc370e2c366597a3f8f",
amount_sats: 100,
message: "Hello from my AI agent!"
})
Invoice Decoding
decode_invoice({ invoice: "lnbc1000n1..." })
📚 Documentation
Tools Reference
Service Info
| Tool |
Description |
get_info |
Get service status, version, and supported features |
decode_invoice |
Decode a BOLT11 invoice to see amount, destination, and expiry |
Context & Identity
| Tool |
Description |
whoami |
Get current context - shows if operating as operator or agent |
check_balance |
Check current Lightning balance in satoshis |
get_rate_limits |
Check current rate limit status and requests remaining |
Payments (Agent Key Required)
| Tool |
Description |
pay_l402_api |
Access paid APIs (L402/X402) - auto-detects protocol and pays |
pay_invoice |
Pay any BOLT11 Lightning invoice |
keysend |
Send payment directly to a node pubkey (no invoice needed) |
pay_lightning_address |
Pay to a Lightning address (user@domain.com format) |
create_invoice |
Generate invoice to receive payments |
get_invoice_status |
Check if an invoice has been paid |
get_transactions |
View transaction history |
LNURL (Agent Key Required)
| Tool |
Description |
lnurl_auth |
Authenticate to a service using LNURL-auth protocol |
claim_lnurl_withdraw |
Claim funds from an LNURL-withdraw link |
Operator Management
| Tool |
Description |
register_operator |
Create new operator account |
recover_account |
Recover account using recovery code |
rotate_api_key |
Generate a new API key (60-min cooldown on withdrawals) |
get_deposit_invoice |
Create invoice to fund operator account |
withdraw |
Withdraw funds to external Lightning destination |
set_operator_key |
Switch to operator credentials |
Agent Management
| Tool |
Description |
create_agent |
Create agent under operator |
list_agents |
List all agents under operator |
fund_agent |
Transfer sats from operator to agent |
transfer_to_agent |
Transfer sats between agents or from operator to agent |
sweep_agent |
Sweep funds from agent back to operator |
deactivate_agent |
Temporarily disable an agent |
reactivate_agent |
Re-enable a deactivated agent |
delete_agent |
Permanently delete an agent (returns balance to operator) |
get_budget_status |
Get agent's budget limit and spending |
set_budget |
Set or update agent's spending limit |
set_agent_credentials |
Switch to agent credentials |
Webhooks
| Tool |
Description |
register_webhook |
Register a URL to receive event notifications |
list_webhooks |
List all registered webhooks |
delete_webhook |
Delete a webhook |
test_webhook |
Send a test event to verify webhook connectivity |
Webhook Events:
invoice_paid - Payment received on an invoice
payment_completed - Outgoing payment succeeded
payment_failed - Outgoing payment failed
balance_low - Balance dropped below threshold
budget_warning - 80% of budget consumed
test - Manual test event
CLI Reference
All commands output JSON to stdout. Errors go to stderr with exit code 1.
| Command |
Description |
lw register [--name "name"] |
Create operator account, prints API key |
lw whoami |
Current identity (operator or agent) |
lw balance |
Balance in satoshis |
lw info |
Service status and capabilities |
lw deposit <amount> |
Generate deposit invoice |
lw withdraw <invoice> |
Withdraw to external wallet |
lw pay <invoice> |
Pay BOLT11 invoice [--max-fee <sats>] |
lw pay-api <url> |
Pay L402/X402 API [--method GET] [--body "{}"] [--max-sats 1000] |
lw decode <invoice> |
Decode BOLT11 invoice |
lw create-agent <name> |
Create agent [--budget <sats>] |
lw fund-agent <id> <amount> |
Transfer sats to agent |
lw list-agents |
List all agents |
lw transactions |
Recent transactions [--limit 10] [--offset 0] |
lw help |
Show all commands |
Paid API Protocols: L402 + X402
Lightning Wallet MCP supports two HTTP 402 payment protocols:
- L402 (primary) - Lightning Network payments. The original pay-per-request protocol.
- X402 (fallback) - USDC on Base (Coinbase's protocol). Auto-detected when L402 isn't available.
When you call pay_l402_api, the server automatically detects which protocol the API uses. L402 always takes priority if both headers are present. Agents always pay in sats regardless of protocol — X402 amounts are converted at market rate.
L402 Protocol
The L402 protocol (formerly LSAT) enables APIs to charge per-request using Lightning. When you call an L402-protected endpoint:
- Server returns HTTP 402 with a Lightning invoice
- Lightning Faucet pays the invoice automatically
- Request completes with the paid content
X402 Protocol (Coinbase)
X402 uses USDC on Base for API payments. The flow is transparent to agents:
- Server returns HTTP 402 with
PAYMENT-REQUIRED header
- Lightning Faucet converts USDC amount to sats, debits agent balance
- Signs an EIP-712 authorization and retries with
PAYMENT-SIGNATURE header
- Request completes — agent sees the same response format as L402
The response includes payment_protocol: "x402" and usdc_amount so agents know which protocol was used.
L402 API Registry
We maintain a directory of L402-enabled APIs at lightningfaucet.com/l402-registry - perfect for testing your agents.
Demo L402 APIs
Try these endpoints to test L402 payments:
# Get a fortune (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/fortune" })
# Get a joke (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/joke" })
# Get an inspirational quote (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/quote" })
See the L402 API Registry for more endpoints and resources.
🔧 Technical Details
Tool Details
get_info
Get service status and capabilities.
{
"success": true,
"version": "1.0.1",
"api_version": "1.0",
"status": "operational",
"max_payment_sats": 1000000,
"min_payment_sats": 1,
"supported_features": ["l402", "x402", "webhooks", "lightning_address", "keysend"]
}
whoami
Get current operating context.
Returns for Operator:
{
"type": "operator",
"id": 123,
"name": "My Company",
"balance_sats": 50000,
"agent_count": 3
}
Returns for Agent:
{
"type": "agent",
"id": 456,
"name": "Research Bot",
"balance_sats": 1000,
"budget_limit_sats": 5000,
"operator_id": 123
}
pay_l402_api
Access paid APIs with automatic payment. Supports both L402 (Lightning) and X402 (USDC on Base) protocols. Protocol is auto-detected from the 402 response headers.
| Parameter |
Type |
Required |
Description |
| url |
string |
Yes |
The URL to request |
| method |
string |
No |
HTTP method (GET, POST, PUT, DELETE). Default: GET |
| body |
string |
No |
Request body for POST/PUT |
| max_payment_sats |
number |
No |
Maximum payment amount. Default: 1000 |
keysend
Send payment to a node without an invoice.
| Parameter |
Type |
Required |
Description |
| destination |
string |
Yes |
Target node public key (66 hex chars) |
| amount_sats |
number |
Yes |
Amount in satoshis |
| message |
string |
No |
Optional message (max 1000 chars) |
register_webhook
Register a URL to receive payment notifications.
| Parameter |
Type |
Required |
Description |
| url |
string |
Yes |
HTTPS URL to receive webhooks |
| events |
array |
No |
Event types to subscribe to. Default: ["invoice_paid"] |
Returns: Webhook ID and HMAC secret for signature verification.
Architecture
┌─────────────────────────────────────────────────────────┐
│ OPERATOR │
│ • Holds main funds │
│ • Creates and manages agents │
│ • Sets spending limits │
│ • Receives webhook notifications │
│ • Can recover account with recovery code │
├─────────────────────────────────────────────────────────┤
│ AGENT 1 AGENT 2 AGENT 3 │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 1000 sat│ │ 5000 sat│ │ 2500 sat│ │
│ │ Budget: │ │ Budget: │ │ Budget: │ │
│ │ 5000 │ │ 10000 │ │ Unlimited│ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │
│ L402 APIs Keysend Receive │
│ Pay Invoice Payments Payments │
└─────────────────────────────────────────────────────────┘
Webhook Security
Webhooks include HMAC-SHA256 signatures for verification:
import hmac
import hashlib
def verify_webhook(payload, signature, secret):
expected = hmac.new(
secret.encode(),
payload.encode(),
hashlib.sha256
).hexdigest()
return hmac.compare_digest(signature, expected)
Check the X-Webhook-Signature header against the payload.
📄 License
MIT License - see LICENSE for details.
Built with Bitcoin | Lightning Faucet
Support
Changelog
v1.1.0 (2026-02-16)
- CLI interface: New
lw command for CLI-first agents (OpenClaw, Pi, KiloCode, any Bash agent)
- Same package, two interfaces:
npm install -g lightning-wallet-mcp gives you both MCP server and CLI
- JSON-first output: All CLI commands output JSON to stdout, errors to stderr
- X402 support: Automatic fallback to X402 (USDC on Base) when L402 is not available
- Protocol auto-detection:
pay_l402_api detects L402 or X402 from 402 response headers
- Response fields:
payment_protocol and usdc_amount included when X402 is used
- Exchange rate: Real-time BTC/USD conversion via CoinGecko with 5-min cache
v1.0.3 (2026-02-05)
- Platform fee: 2% fee (min 1 sat) on all outgoing payments and cross-operator transfers
- Fee transparency: All payment responses now include
platform_fee_sats, routing_fee_sats, and total_cost
- Same-operator agent transfers remain free
v1.0.0 (2026-02-04)
- Rebranded from
lightning-faucet-mcp to lightning-wallet-mcp
- Environment variable renamed:
LIGHTNING_FAUCET_API_KEY → LIGHTNING_WALLET_API_KEY
- All 37 tools fully tested and production-ready
- No breaking API changes - just the package name
Previous releases (as lightning-faucet-mcp)
See the lightning-faucet-mcp changelog for v1.6.0 through v2.0.7 history.
- Basic payments and invoices
Showcase: AI Agent Game Theory Experiment
We ran a 100-round economic experiment with 16 AI agents (8 Claude, 8 GPT-4o) using real Bitcoin on Lightning. Agents could trade, form alliances, invest, and compete — all powered by this MCP server.
Results: Agents completed 2,839 real Lightning transactions. Claude agents dominated through aggressive early trading while GPT-4o agents adopted conservative strategies.
Security Best Practices
- Never commit API keys - Use environment variables
- Set budget limits - Protect against runaway spending
- Use agent keys for payments - Keep operator key secure
- Verify webhook signatures - Use the secret returned during registration
- Monitor transactions - Use
get_transactions to review activity
- Recovery codes - Store securely, needed if API key is lost
- Key rotation - Rotate keys periodically using
rotate_api_key
Pricing
Lightning Faucet charges a 2% platform fee (min 1 sat) on outgoing payments:
- L402 payments: 2% platform fee + Lightning routing fee
- X402 payments: 2% platform fee + 1% exchange rate spread (USDC to sats conversion)
- Invoice payments: 2% platform fee + Lightning routing fee
- Keysend payments: 2% platform fee + Lightning routing fee
- Operator withdrawals: 2% platform fee + Lightning routing fee
- Cross-operator internal transfers: 2% platform fee (no routing fee)
- Same-operator agent transfers: Free
- Deposits: Free
- Receiving payments: Free
- Webhooks: Free
All payment responses include platform_fee_sats, routing_fee_sats, and total_cost for full transparency.