Lightning Faucet MCP Server

offiziell

Gib KI-Agenten eine Bitcoin-Wallet mit Lightning Network-Zahlungen.

Dokumentation

Lightning Wallet

Gib deinem KI-Agenten eine Bitcoin-Wallet. MCP-Server + CLI. Funktioniert mit Claude Code, OpenClaw, Cursor und jedem Agent-Framework.

Neu in v1.4

update_operator-Tool / lw set-email – Lege deine Betreiber-E-Mail vom MCP-Client oder CLI aus fest; ein Bestätigungslink wird dir per E-Mail zugesandt.
claim_promo-Tool / lw claim-promo – Fordere die Free-Sats-Installationsprämie direkt von deinem Agenten aus an. Voraussetzungen: verifizierte E-Mail + Betreiberkonto mindestens 3 Stunden alt.
get_info funktioniert vor der Registrierung – Service-Informationen benötigen keinen API-Schlüssel mehr.

Kostenlose 100 Sats für neue Betreiber

lw register --email [email protected] (oder das register_operator MCP-Tool mit einer E-Mail)
Klicke auf den Bestätigungslink, den wir dir per E-Mail senden
Nachdem dein Konto 3 Stunden alt ist: lw claim-promo (oder das claim_promo MCP-Tool)

Ein Bonus pro Betreiber, nur für die ersten 100 Installationen, keine Einzahlung erforderlich.

Neu in v1.3

v1.3.0 – L402-Protokoll v0-Unterstützung gemäß der neuesten Lightning Labs-Spezifikation.

L402-Protokoll v0 – Aktualisiertes Header-Format: version="0", token=, abwärtskompatibel mit macaroon=
Endpoint-Erkennung – .well-known/l402.json auf lightningfaucet.com und certvera.com
Abwärtskompatibel – Verarbeitet sowohl alte als auch neue L402-Header-Formate von jedem Dienst

Neu in v1.1

v1.1.0 – X402-Protokoll-Unterstützung (USDC auf Base) als automatischer Fallback neben L402 (Lightning).

X402-Unterstützung – Automatische USDC-Zahlungen auf Base, wenn L402 nicht verfügbar ist
Protokoll-Autoerkennung – pay_l402_api verarbeitet nahtlos sowohl L402 als auch X402
Webhooks – Echtzeit-Benachrichtigungen für Zahlungen und Ereignisse
Keysend – Sende Zahlungen ohne Rechnungen unter Verwendung von Node-Pubkeys
Rechnungsdekodierung – Dekodiere BOLT11-Rechnungen vor der Bezahlung
Agent-Analytik – Verfolge Ausgabenmuster und Nutzung
Transaktionsexport – Exportiere den Verlauf im JSON- oder CSV-Format
Budgetverwaltung – Erhalte detaillierten Budgetstatus und setze Limits
Agent-Lebenszyklus – Deaktiviere, reaktiviere und lösche Agenten
Kontowiederherstellung – Stelle Konten wieder her und rotiere API-Schlüssel
Agent-zu-Agent-Überweisungen – Verschiebe Guthaben zwischen deinen Agenten

Warum Lightning Wallet MCP?

Sofortige Zahlungen – Lightning Network-Transaktionen werden in Millisekunden abgewickelt
L402 + X402-Protokoll-Unterstützung – Greife automatisch auf jede kostenpflichtige API zu (Lightning oder USDC)
Betreiber/Agent-Hierarchie – Verwalte mehrere Agenten mit Ausgabenlimits
Kein Verwahrungsrisiko – Jeder Agent hat isolierte Guthaben mit Betreiberaufsicht
Produktionsreif – Kampferprobte Infrastruktur für echte Transaktionen
Webhook-Benachrichtigungen – Werde sofort benachrichtigt, wenn Zahlungen eingehen
Volle Beobachtbarkeit – Analytik, Exporte und detaillierte Statusverfolgung

Zwei Nutzungsmöglichkeiten

CLI (Jedes Agent-Framework)

Für CLI-zentrierte Agenten (OpenClaw, Pi, KiloCode oder jeden Agenten mit Bash-Zugriff):

npm install -g lightning-wallet-mcp

Dies installiert den lw-Befehl:

# Register and save your API key
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Bot" | jq -r '.api_key')

# Check balance
lw balance | jq '.balance_sats'

# Pay an L402 API
lw pay-api "https://lightningfaucet.com/api/l402/fortune"

# Create and fund an agent
lw create-agent "Research Bot" --budget 5000
lw fund-agent 1 1000

# Check identity
lw whoami

Die Ausgabe ist standardmäßig JSON (weiterleiten an jq). Verwende --human für lesbare Ausgabe.

Führe lw help aus, um alle Befehle anzuzeigen.

MCP-Server (Claude Code, Cursor, Windsurf)

Für MCP-native Clients konfiguriere als MCP-Server:

Option A: Selbstregistrierung

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"]
    }
  }
}

Bitte dann Claude: "Registriere ein neues Lightning Wallet-Betreiberkonto"

Option B: Vorkonfigurierter API-Schlüssel

Erhalte einen API-Schlüssel auf lightningfaucet.com/ai-agents
Konfiguriere Claude Code (~/.claude/settings.json):

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"],
      "env": {
        "LIGHTNING_WALLET_API_KEY": "your-api-key-here"
      }
    }
  }
}

Tool-Referenz

Service-Informationen

Tool	Beschreibung
`get_info`	Service-Status, Version und unterstützte Funktionen abrufen
`decode_invoice`	Eine BOLT11-Rechnung dekodieren, um Betrag, Ziel und Ablauf zu sehen

Kontext & Identität

Tool	Beschreibung
`whoami`	Aktuellen Kontext abrufen – zeigt, ob als Betreiber oder Agent agiert wird
`check_balance`	Aktuelles Lightning-Guthaben in Satoshis prüfen
`get_rate_limits`	Aktuellen Rate-Limit-Status und verbleibende Anfragen prüfen

Zahlungen (Agent-Schlüssel erforderlich)

Tool	Beschreibung
`pay_l402_api`	Auf kostenpflichtige APIs zugreifen (L402/X402) – erkennt Protokoll automatisch und bezahlt
`pay_invoice`	Jede BOLT11 Lightning-Rechnung bezahlen
`keysend`	Zahlung direkt an einen Node-Pubkey senden (keine Rechnung erforderlich)
`pay_lightning_address`	An eine Lightning-Adresse zahlen (Format [email protected])
`create_invoice`	Rechnung zum Empfangen von Zahlungen generieren
`get_invoice_status`	Prüfen, ob eine Rechnung bezahlt wurde
`get_transactions`	Transaktionsverlauf anzeigen

LNURL (Agent-Schlüssel erforderlich)

Tool	Beschreibung
`lnurl_auth`	Sich bei einem Dienst mit dem LNURL-auth-Protokoll authentifizieren
`claim_lnurl_withdraw`	Guthaben von einem LNURL-withdraw-Link abrufen

Betreiberverwaltung

Tool	Beschreibung
`register_operator`	Neues Betreiberkonto erstellen
`recover_account`	Konto mit Wiederherstellungscode wiederherstellen
`rotate_api_key`	Neuen API-Schlüssel generieren (60-Minuten-Abkühlphase für Abhebungen)
`get_deposit_invoice`	Rechnung zur Aufladung des Betreiberkontos erstellen
`withdraw`	Guthaben an ein externes Lightning-Ziel abheben
`set_operator_key`	Zu Betreiber-Anmeldeinformationen wechseln

update_operator – Betreiber-E-Mail (sendet Bestätigungslink) und/oder Name festlegen
claim_promo – Free-Sats-Installationsprämie anfordern (verifizierte E-Mail + 3h Konto)

Agentenverwaltung

Tool	Beschreibung
`create_agent`	Agenten unter dem Betreiber erstellen
`list_agents`	Alle Agenten unter dem Betreiber auflisten
`fund_agent`	Sats vom Betreiber zum Agenten überweisen
`transfer_to_agent`	Sats zwischen Agenten oder vom Betreiber zum Agenten überweisen
`sweep_agent`	Guthaben vom Agenten zurück zum Betreiber einsammeln
`deactivate_agent`	Einen Agenten vorübergehend deaktivieren
`reactivate_agent`	Einen deaktivierten Agenten wieder aktivieren
`delete_agent`	Einen Agenten dauerhaft löschen (Guthaben geht an Betreiber zurück)
`get_budget_status`	Budgetlimit und Ausgaben eines Agenten abrufen
`set_budget`	Ausgabenlimit eines Agenten festlegen oder aktualisieren
`set_agent_credentials`	Zu Agenten-Anmeldeinformationen wechseln

Webhooks

Tool	Beschreibung
`register_webhook`	Eine URL registrieren, um Ereignisbenachrichtigungen zu erhalten
`list_webhooks`	Alle registrierten Webhooks auflisten
`delete_webhook`	Einen Webhook löschen
`test_webhook`	Ein Testereignis senden, um die Webhook-Konnektivität zu überprüfen

Webhook-Ereignisse:

invoice_paid – Zahlung auf eine Rechnung eingegangen
payment_completed – Ausgehende Zahlung erfolgreich
payment_failed – Ausgehende Zahlung fehlgeschlagen
balance_low – Guthaben unter Schwellenwert gefallen
budget_warning – 80 % des Budgets verbraucht
test – Manuelles Testereignis

CLI-Referenz

Alle Befehle geben JSON auf stdout aus. Fehler gehen auf stderr mit Exit-Code 1.

Befehl	Beschreibung
`lw register [--name "name"]`	Betreiberkonto erstellen, gibt API-Schlüssel aus
`lw whoami`	Aktuelle Identität (Betreiber oder Agent)
`lw balance`	Guthaben in Satoshis
`lw info`	Service-Status und Fähigkeiten
`lw deposit <amount>`	Einzahlungsrechnung generieren
`lw withdraw <invoice>`	An externe Wallet abheben
`lw pay <invoice>`	BOLT11-Rechnung bezahlen `[--max-fee <sats>]`
`lw pay-api <url>`	L402/X402-API bezahlen `[--method GET] [--body "{}"] [--max-sats 1000]`
`lw decode <invoice>`	BOLT11-Rechnung dekodieren
`lw create-agent <name>`	Agenten erstellen `[--budget <sats>]`
`lw fund-agent <id> <amount>`	Sats an Agenten überweisen
`lw list-agents`	Alle Agenten auflisten
`lw transactions`	Letzte Transaktionen `[--limit 10] [--offset 0]`
`lw help`	Alle Befehle anzeigen

Agent-Workflow-Beispiel (Bash)

# 1. Register (one-time)
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Agent" | jq -r '.api_key')

# 2. Fund the account (pay the invoice with any Lightning wallet)
lw deposit 10000 | jq -r '.bolt11'

# 3. Create an agent with a budget
AGENT=$(lw create-agent "Worker" --budget 5000)
AGENT_ID=$(echo $AGENT | jq -r '.agent_id')
AGENT_KEY=$(echo $AGENT | jq -r '.agent_api_key')

# 4. Fund the agent
lw fund-agent $AGENT_ID 2000

# 5. Switch to agent context and make payments
export LIGHTNING_WALLET_API_KEY=$AGENT_KEY
lw pay-api "https://api.example.com/data" --max-sats 100

# 6. Check what happened
lw transactions --limit 5

Kostenpflichtige API-Protokolle: L402 + X402

Lightning Wallet MCP unterstützt zwei HTTP 402-Zahlungsprotokolle:

L402 (primär) – Lightning Network-Zahlungen. Das ursprüngliche Pay-per-Request-Protokoll.
X402 (Fallback) – USDC auf Base (Coinbase-Protokoll). Automatisch erkannt, wenn L402 nicht verfügbar ist.

Wenn du pay_l402_api aufrufst, erkennt der Server automatisch, welches Protokoll die API verwendet. L402 hat immer Vorrang, wenn beide Header vorhanden sind. Agenten zahlen immer in Sats, unabhängig vom Protokoll – X402-Beträge werden zum Marktkurs umgerechnet.

L402-Protokoll

Das L402-Protokoll (ehemals LSAT) ermöglicht APIs, pro Anfrage über Lightning abzurechnen. Wenn du einen L402-geschützten Endpunkt aufrufst:

Der Server antwortet mit HTTP 402 und einer Lightning-Rechnung
Lightning Faucet bezahlt die Rechnung automatisch
Die Anfrage wird mit dem bezahlten Inhalt abgeschlossen

X402-Protokoll (Coinbase)

X402 verwendet USDC auf Base für API-Zahlungen. Der Ablauf ist für Agenten transparent:

Der Server antwortet mit HTTP 402 und PAYMENT-REQUIRED-Header
Lightning Faucet rechnet den USDC-Betrag in Sats um und belastet das Agenten-Guthaben
Signiert eine EIP-712-Autorisierung und wiederholt mit PAYMENT-SIGNATURE-Header
Anfrage abgeschlossen – der Agent sieht das gleiche Antwortformat wie bei L402

Die Antwort enthält payment_protocol: "x402" und usdc_amount, damit Agenten wissen, welches Protokoll verwendet wurde.

L402-API-Registry

Wir pflegen ein Verzeichnis L402-fähiger APIs unter lightningfaucet.com/l402-registry – perfekt zum Testen deiner Agenten.

Demo-L402-APIs

Probiere diese Endpunkte, um L402-Zahlungen zu testen:

# 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" })

Siehe die L402-API-Registry für weitere Endpunkte und Ressourcen.

Vollständiges Workflow-Beispiel

// 1. Register as operator (if no API key configured)
register_operator({ name: "My AI Company" })
// Returns: { api_key: "lf_abc...", recovery_code: "xyz...", operator_id: 123 }

// 2. Activate the operator key
set_operator_key({ api_key: "lf_abc..." })

// 3. Check who you are
whoami()
// Returns: { type: "operator", id: 123, name: "My AI Company", balance_sats: 0 }

// 4. Fund your operator account
get_deposit_invoice({ amount_sats: 10000 })
// Pay this invoice with any Lightning wallet

// 5. Create an agent with budget limit
create_agent({ name: "Research Assistant", budget_limit_sats: 5000 })
// Returns: { agent_id: 456, agent_api_key: "agent_def..." }

// 6. Fund the agent
fund_agent({ agent_id: 456, amount_sats: 1000 })

// 7. Set up a webhook for payment notifications
register_webhook({
  url: "https://your-server.com/webhooks/lightning",
  events: ["invoice_paid", "payment_completed"]
})
// Returns: { webhook_id: 1, secret: "..." }  <- Save this secret!

// 8. Switch to agent mode for payments
set_agent_credentials({ api_key: "agent_def..." })

// 9. Check budget status
get_budget_status()
// Returns: { budget_limit_sats: 5000, total_spent_sats: 0, remaining_sats: 5000 }

// 10. Make payments!
pay_l402_api({ url: "https://api.example.com/premium-data" })

Keysend-Zahlungen

Sende Zahlungen direkt an einen Lightning-Node, ohne eine Rechnung zu benötigen:

// Send 100 sats to a node with an optional message
keysend({
  destination: "03864ef025fde8fb587d989186ce6a4a186895ee44a926bfc370e2c366597a3f8f",
  amount_sats: 100,
  message: "Hello from my AI agent!"
})

Rechnungsdekodierung

Prüfe Rechnungsdetails vor der Bezahlung:

decode_invoice({ invoice: "lnbc1000n1..." })
// Returns: {
//   amount_sats: 1000,
//   description: "Test payment",
//   destination: "03abc...",
//   expires_at: "2026-01-16T12:00:00Z",
//   is_expired: false
// }

Tool-Details

get_info

Service-Status und Fähigkeiten abrufen.

{
  "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

Aktuellen Betriebskontext abrufen.

Rückgabe für Betreiber:

{
  "type": "operator",
  "id": 123,
  "name": "My Company",
  "balance_sats": 50000,
  "agent_count": 3
}

Rückgabe für Agent:

{
  "type": "agent",
  "id": 456,
  "name": "Research Bot",
  "balance_sats": 1000,
  "budget_limit_sats": 5000,
  "operator_id": 123
}

pay_l402_api

Auf kostenpflichtige APIs mit automatischer Zahlung zugreifen. Unterstützt sowohl L402 (Lightning) als auch X402 (USDC auf Base). Das Protokoll wird automatisch anhand der 402-Antwort-Header erkannt.

Parameter	Typ	Erforderlich	Beschreibung
url	string	Ja	Die anzufordernde URL
method	string	Nein	HTTP-Methode (GET, POST, PUT, DELETE). Standard: GET
body	string	Nein	Anfrage-Body für POST/PUT
max_payment_sats	number	Nein	Maximaler Zahlungsbetrag. Standard: 1000

keysend

Zahlung an einen Node ohne Rechnung senden.

Parameter	Typ	Erforderlich	Beschreibung
destination	string	Ja	Öffentlicher Schlüssel des Ziel-Nodes (66 Hex-Zeichen)
amount_sats	number	Ja	Betrag in Satoshis
message	string	Nein	Optionale Nachricht (max. 1000 Zeichen)

register_webhook

Eine URL registrieren, um Zahlungsbenachrichtigungen zu erhalten.

Parameter	Typ	Erforderlich	Beschreibung
url	string	Ja	HTTPS-URL zum Empfangen von Webhooks
events	array	Nein	Zu abonnierende Ereignistypen. Standard: ["invoice_paid"]

Rückgabe: Webhook-ID und HMAC-Secret zur Signaturüberprüfung.

Architektur

┌─────────────────────────────────────────────────────────┐
│                    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            │
└─────────────────────────────────────────────────────────┘

Bewährte Sicherheitspraktiken

API-Schlüssel niemals committen – Umgebungsvariablen verwenden
Budgetlimits setzen – Schutz vor unkontrollierten Ausgaben
Agentenschlüssel für Zahlungen verwenden – Betreiberschlüssel sicher aufbewahren
Webhook-Signaturen überprüfen – Das bei der Registrierung zurückgegebene Secret verwenden
Transaktionen überwachen – get_transactions verwenden, um Aktivitäten zu prüfen
Wiederherstellungscodes – Sicher aufbewahren, benötigt falls API-Schlüssel verloren geht
Schlüsselrotation – Schlüssel regelmäßig mit rotate_api_key rotieren

Webhook-Sicherheit

Webhooks enthalten HMAC-SHA256-Signaturen zur Überprüfung:

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)

Prüfe den X-Webhook-Signature-Header gegen die Nutzlast.

Pre-Payment Policy Hook

Ein optionaler, herstellerneutraler Hook ermöglicht es einem externen Richtlinien-Endpunkt, eine Zahlung vor der Ausführung zu erlauben oder abzulehnen. Er ist standardmäßig deaktiviert – wenn PRE_PAYMENT_HOOK_URL nicht gesetzt ist, verhält sich alles wie zuvor. Wenn gesetzt, wird jede ausgehende Zahlung (pay_l402_api, pay_invoice, keysend, pay_lightning_address) zuerst an Ihren Endpunkt geprüft; eine Ablehnung bricht die Zahlung ab, bevor Gelder bewegt werden.

Dies ist nützlich für Ausgabenrichtlinien, Genehmigungsworkflows, Compliance-Prüfungen oder jede externe Autorisierungsschicht. Das Hook-Protokoll ist generisch, sodass jeder Dienst, der den unten stehenden Request/Response-Vertrag implementiert, allein durch Konfiguration eingebunden werden kann.

Konfiguration

Umgebungsvariable	Standard	Beschreibung
`PRE_PAYMENT_HOOK_URL`	(nicht gesetzt)	Richtlinien-Endpunkt, an den jeder Zahlungsvorschlag per POST gesendet wird. Nicht gesetzt deaktiviert den Hook vollständig.
`PRE_PAYMENT_HOOK_TIMEOUT_MS`	`3000`	Timeout pro Anfrage in Millisekunden.
`PRE_PAYMENT_HOOK_FAIL_MODE`	`closed`	`closed` lehnt eine Zahlung ab, wenn der Hook fehlschlägt oder das Timeout überschreitet; `open` lässt sie fortfahren. Standard ist Fail-Closed.

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"],
      "env": {
        "LIGHTNING_WALLET_API_KEY": "your-api-key",
        "PRE_PAYMENT_HOOK_URL": "https://your-policy-endpoint.example/hook"
      }
    }
  }
}

Hook-Anfrage (POST vom Client)

Der Vorschlag beschreibt nur die vorgeschlagene Zahlung – er enthält niemals Ihren Wallet-API-Schlüssel.

{
  "proposal_id": "f7e1…",
  "agent_id": 42,
  "protocol": "l402",
  "destination_or_url": "https://api.example/paid-endpoint",
  "amount_sats": null,
  "max_payment_sats": 1000,
  "method": "GET",
  "ts": "2026-06-06T18:00:00.000Z"
}

protocol ist einer von l402, x402, bolt11, keysend, lnaddress. amount_sats ist der genaue Betrag, wenn er zum Hook-Zeitpunkt bekannt ist: für keysend und lnaddress ist es der angeforderte Betrag, und für bolt11 wird er lokal aus der Rechnung dekodiert (kein zusätzlicher API-Aufruf). Für l402/x402 ist er null, weil der Betrag durch die Zahlungsherausforderung zum Ausführungszeitpunkt festgelegt wird – hier erzwingt der Hook im Voraus max_payment_sats (die vom Agenten autorisierte Obergrenze), und der exakte abgerechnete Betrag ist anschließend über Webhooks verfügbar. max_payment_sats ist die vom Agenten autorisierte Obergrenze, falls zutreffend.

Genau das, was die Wallet verlässt. Nur die acht oben genannten Felder werden an Ihren Hook-Endpunkt gesendet: proposal_id, agent_id, protocol, destination_or_url, amount_sats, max_payment_sats, method, ts. Der Wallet-API-Schlüssel und alle anderen Anmeldeinformationen werden niemals mitgesendet.

Abdeckung. Der Hook kontrolliert jede vom Agenten initiierte Ausgabe: pay_l402_api, pay_invoice, keysend, pay_lightning_address und Nostr-Zaps. Betreiberbezogene Mittelverwaltung (Auszahlungen, Agentenfinanzierung, Agent-zu-Agent-Überweisungen) wird absichtlich nicht kontrolliert – dies sind Betreiberaktionen, keine Agentenausgaben.

Hook-Antwort (Ihr Endpunkt gibt zurück)

{ "decision": "allow" }

{ "decision": "deny", "reason": { "code": "over_limit", "message": "Exceeds per-transaction limit" } }

allow → die Zahlung wird fortgesetzt.
deny → die Zahlung wird abgebrochen und das Tool gibt einen PolicyDenied-Fehler zurück, der reason.message anzeigt.
Ein optionales attestation-Feld (beliebiges JSON) wird vom Client als undurchsichtig behandelt – es wird auf stderr protokolliert und ansonsten ignoriert, sodass ein Richtliniendienst eine signierte Entscheidung für nachgelagerte Prüfungen zurückgeben kann.

Bei einem Hook-Fehler, Timeout oder einer nicht erkannten Antwort greift PRE_PAYMENT_HOOK_FAIL_MODE (standardmäßig ablehnen).

Preisgestaltung

Lightning Faucet erhebt eine Plattformgebühr von 2 % (min. 1 Sat) auf ausgehende Zahlungen:

L402-Zahlungen: 2 % Plattformgebühr + Lightning-Routinggebühr
X402-Zahlungen: 2 % Plattformgebühr + 1 % Wechselkursaufschlag (USDC-zu-Sats-Umrechnung)
Rechnungszahlungen: 2 % Plattformgebühr + Lightning-Routinggebühr
Keysend-Zahlungen: 2 % Plattformgebühr + Lightning-Routinggebühr
Betreiberauszahlungen: 2 % Plattformgebühr + Lightning-Routinggebühr
Betreiberübergreifende interne Überweisungen: 2 % Plattformgebühr (keine Routinggebühr)
Agentenüberweisungen beim selben Betreiber: Kostenlos
Einzahlungen: Kostenlos
Zahlungsempfang: Kostenlos
Webhooks: Kostenlos

Alle Zahlungsantworten enthalten platform_fee_sats, routing_fee_sats und total_cost für vollständige Transparenz.

Änderungsprotokoll

v1.1.0 (2026-02-16)

CLI-Schnittstelle: Neuer lw-Befehl für CLI-zentrierte Agenten (OpenClaw, Pi, KiloCode, jeder Bash-Agent)
Gleiches Paket, zwei Schnittstellen: npm install -g lightning-wallet-mcp bietet sowohl MCP-Server als auch CLI
JSON-zentrierte Ausgabe: Alle CLI-Befehle geben JSON auf stdout aus, Fehler auf stderr
X402-Unterstützung: Automatischer Fallback auf X402 (USDC auf Base), wenn L402 nicht verfügbar ist
Protokoll-Autoerkennung: pay_l402_api erkennt L402 oder X402 anhand der 402-Antwort-Header
Antwortfelder: payment_protocol und usdc_amount enthalten, wenn X402 verwendet wird
Wechselkurs: Echtzeit-BTC/USD-Umrechnung via CoinGecko mit 5-Minuten-Cache

v1.0.3 (2026-02-05)

Plattformgebühr: 2 % Gebühr (min. 1 Sat) auf alle ausgehenden Zahlungen und betreiberübergreifenden Überweisungen
Gebührentransparenz: Alle Zahlungsantworten enthalten jetzt platform_fee_sats, routing_fee_sats und total_cost
Agentenüberweisungen beim selben Betreiber bleiben kostenlos

v1.0.0 (2026-02-04)

Umbenannt von lightning-faucet-mcp zu lightning-wallet-mcp
Umgebungsvariable umbenannt: LIGHTNING_FAUCET_API_KEY → LIGHTNING_WALLET_API_KEY
Alle 37 Tools vollständig getestet und produktionsreif
Keine breaking API-Änderungen – nur der Paketname

Vorherige Veröffentlichungen (als lightning-faucet-mcp)

Siehe das lightning-faucet-mcp Änderungsprotokoll für den Verlauf von v1.6.0 bis v2.0.7.

Grundlegende Zahlungen und Rechnungen

Vorzeigebeispiel: KI-Agenten-Spieltheorie-Experiment

Wir führten ein 100-Runden-Wirtschaftsexperiment mit 16 KI-Agenten (8 Claude, 8 GPT-4o) durch, die echtes Bitcoin auf Lightning verwendeten. Agenten konnten handeln, Allianzen bilden, investieren und konkurrieren – alles unterstützt durch diesen MCP-Server.

Ergebnisse: Agenten führten 2.839 echte Lightning-Transaktionen durch. Claude-Agenten dominierten durch aggressiven frühen Handel, während GPT-4o-Agenten konservative Strategien verfolgten.

Experiment-Repo: github.com/pfergi42/lf-game-theory
Blogbeitrag: lightningfaucet.com/blog/ai-game-theory

Support

Dokumentation: lightningfaucet.com/ai-agents/docs
Demo: lightningfaucet.com/ai-agents/demo
Issues: github.com/lightningfaucet/lightning-wallet-mcp/issues
E-Mail: [email protected]

Lizenz

MIT-Lizenz – siehe LICENSE für Details.

Mit Bitcoin gebaut | Lightning Faucet