Lightning Node Types

Lightning nodes come in different forms, each with trade-offs between sovereignty, convenience, and capabilities. Understanding these helps agents choose the right approach.

Why Node Selection Matters for Agents

Factor	Impact
Custody	Who controls the funds?
Uptime	Channels require online presence
Liquidity	Access to network capacity
APIs	Programmatic access methods

Node Categories

1. Full Routing Nodes

Fully validating nodes that route payments for others.

Implementations:

• LND (Lightning Labs)
• Core Lightning (CLN)
• Eclair (ACINQ)
• LDK (Lightning Dev Kit)

Characteristics:

Aspect	Details
Custody	Self-custody (your keys)
Uptime	Requires 24/7 operation
Hardware	VPS or dedicated server
Liquidity	You manage channels
Revenue	Earn routing fees

Best for:

• Maximum sovereignty
• Routing fee income
• Large payment volumes
• Custom integrations

Agent considerations:

# Full node gives complete control
node = LND(
    host="localhost:10009",
    macaroon=admin_macaroon,
    cert=tls_cert
)

# All APIs available
channels = node.list_channels()
invoices = node.list_invoices()
payments = node.send_payment(invoice)

2. Light Clients / Mobile Nodes

Partial nodes optimized for mobile devices.

Examples:

• Phoenix (ACINQ)
• Breez
• Mutiny
• Zeus (connects to your node)

Characteristics:

Aspect	Details
Custody	Self-custody (on device)
Uptime	Intermittent (uses LSPs)
Hardware	Mobile phone
Liquidity	LSP-managed
Revenue	None (consumer focus)

Best for:

• Personal payments
• Mobile use
• Automatic channel management
• Beginners

Agent considerations:

• Limited API access
• Depends on LSP availability
• Not ideal for server-side agents

3. LSP-Connected Nodes

Nodes that rely on Lightning Service Providers for liquidity and routing.

How it works:

Your Node ←───→ LSP ←───→ Network
           JIT channel

Characteristics:

Aspect	Details
Custody	Self-custody
Uptime	LSP monitors for you
Hardware	Minimal
Liquidity	On-demand from LSP
Cost	LSP fees

Best for:

• Receiving payments without existing liquidity
• Reduced operational overhead
• Mobile/intermittent nodes

4. Custodial Wallets

Third party holds your funds. You use their API.

Examples:

• Wallet of Satoshi
• Strike
• Cash App
• Alby (custodial mode)

Characteristics:

Aspect	Details
Custody	Third party (not your keys)
Uptime	Provider handles
Hardware	None
Liquidity	Provider’s liquidity
Revenue	None

Best for:

• Quick testing
• Small amounts
• Maximum convenience
• Beginners

Risks:

• Funds can be frozen/seized
• Provider can disappear
• No privacy
• Counterparty risk

5. Hosted Channels

Your keys, but channels hosted by a provider.

Examples:

• Hosted Channels protocol
• Some LNbits setups

Characteristics:

Aspect	Details
Custody	Hybrid (complex)
Uptime	Provider handles
Hardware	Minimal
Trust	Provider must be honest

Best for:

• Balance between sovereignty and convenience
• Testing self-custody without infrastructure

Node Comparison

Type	Custody	Uptime Req	Setup	Agent Suitability
Full routing	Self	24/7	Complex	⭐⭐⭐⭐⭐
Light client	Self	Intermittent	Easy	⭐⭐
LSP-connected	Self	Low	Medium	⭐⭐⭐⭐
Custodial	Third party	None	Trivial	⭐⭐⭐
Hosted	Hybrid	None	Easy	⭐⭐⭐

API Access by Node Type

Full Node APIs

# LND gRPC - Full access
lnd.open_channel()
lnd.close_channel()
lnd.send_payment()
lnd.add_invoice()
lnd.forward_history()
lnd.update_channel_policy()

LNbits API

# REST API - Wallet operations
lnbits.create_invoice(amount, memo)
lnbits.pay_invoice(bolt11)
lnbits.check_balance()
lnbits.get_payments()

Custodial APIs

# Often limited
wallet.create_invoice(amount)
wallet.pay(bolt11)
wallet.balance()
# No channel management

Agent Node Recommendations

For Payment-Only Agents

Recommended: LNbits (self-hosted or trusted instance)

# Simple, API-first
class PaymentAgent:
    def __init__(self, lnbits_url, api_key):
        self.lnbits = LNbits(lnbits_url, api_key)

    def receive(self, amount, memo):
        return self.lnbits.create_invoice(amount, memo)

    def send(self, bolt11):
        return self.lnbits.pay_invoice(bolt11)

For Routing/Revenue Agents

Recommended: Full LND or CLN node

# Full control needed
class RoutingAgent:
    def __init__(self, lnd_connection):
        self.lnd = lnd_connection

    def optimize_fees(self):
        channels = self.lnd.list_channels()
        for ch in channels:
            new_fees = self.calculate_optimal_fees(ch)
            self.lnd.update_channel_policy(ch.chan_id, new_fees)

For Experimental/Testing Agents

Recommended: Custodial API (Alby, LNbits demo)

# Quick setup, no infrastructure
import alby

agent = alby.Wallet(api_key="...")
agent.pay("lnbc...")  # Just works

Running Your Own Node

Minimum Requirements

Resource	LND	Core Lightning
CPU	2 cores	2 cores
RAM	4 GB	2 GB
Storage	20 GB	10 GB
Network	Static IP or Tor	Same

Hosted Options

Provider	Type	Cost/month
Voltage	Managed LND	~$12
Nodl	Hardware	One-time ~$500
Start9	Hardware	One-time ~$400
Umbrel	DIY (Raspberry Pi)	~$100 hardware

Related Topics

• LSPs - Lightning Service Providers
• Wallets - Wallet options
• API: LNbits - LNbits API reference
• Security - Node security

---

Machine-Readable Summary

{
  "topic": "node-types",
  "categories": [
    {
      "type": "full-routing",
      "custody": "self",
      "examples": ["lnd", "core-lightning", "eclair"],
      "agent_suitability": 5
    },
    {
      "type": "custodial",
      "custody": "third-party",
      "examples": ["wallet-of-satoshi", "strike"],
      "agent_suitability": 3
    },
    {
      "type": "lsp-connected",
      "custody": "self",
      "examples": ["phoenix", "breez"],
      "agent_suitability": 4
    }
  ],
  "recommendation": {
    "payment-only": "lnbits",
    "routing": "lnd",
    "testing": "custodial"
  }
}