# Lightning Enable — Extended Agent Brief

> Infrastructure for agentic commerce over Lightning. AI agents pay your API per request in Bitcoin, with payment becoming authorization through the L402 protocol — no credit card, no signup, no payment-processor account required for the agent. Lightning Enable wraps existing HTTP APIs with a small middleware so agents get a `402 Payment Required` with a Lightning invoice, pay it in under a second, and retry with a cryptographic proof of payment.

This is the long-form companion to `https://www.lightningenable.com/llms.txt`. For the full producer API reference (endpoints, request/response shapes, webhooks), read `https://api.lightningenable.com/llms-full.txt`. For documentation structure, read `https://docs.lightningenable.com/llms-full.txt`. For the live L402 merch store, read `https://store.lightningenable.com/llms-full.txt`.

## What it is

- **Company:** Refined Element, LLC (Florida, US).
- **Product:** Lightning Enable. Hosted producer API + open-source middleware SDKs (.NET and Node; Python middleware coming soon).
- **Position:** This is NOT just an MCP server or a crypto payment plugin. It is infrastructure for a new buyer class — AI agents and autonomous workflows that cannot use card rails.
- **Live URLs:** Marketing site at `https://www.lightningenable.com/`. Documentation at `https://docs.lightningenable.com/`. Producer API at `https://api.lightningenable.com/`. Open-source MCP server at `https://github.com/refined-element/lightning-enable-mcp`. Open-source HTTP clients at `https://github.com/refined-element/l402-ts` (and sibling repos for Python + .NET). L402 merch store at `https://store.lightningenable.com/`. L402 API marketplace at `https://agent-commerce.store/`. Agent relay at `wss://agents.lightningenable.com`.

## The L402 flow, in detail

L402 turns payment into authorization. The protocol was originated by Lightning Labs; Lightning Enable implements it, and the protocol is open.

1. **Request.** The agent makes a normal HTTP request to a paid endpoint.
2. **Challenge.** The server responds `402 Payment Required` with a `WWW-Authenticate: L402` header carrying two things: a BOLT11 Lightning **invoice** (the price, encoded as a payment request) and a **macaroon** (an opaque bearer credential bound to that invoice's payment hash).
3. **Pay.** The agent pays the invoice over the Lightning Network. Settlement completes in roughly a second. The agent's wallet receives the **preimage** — the secret whose SHA-256 hash is the invoice's payment hash. The preimage only exists after payment, so holding it IS the proof of payment.
4. **Retry.** The agent retries the same request with `Authorization: L402 {macaroon}:{preimage}`.
5. **Verify and serve.** The server checks `SHA256(preimage) == payment_hash` bound in the macaroon, then serves the response.

The whole cycle typically completes in 1-2 seconds. No account creation, no card-on-file, no out-of-band billing — payment IS the authorization.

Practical notes for agents:

- Each 402 challenge mints a fresh invoice + macaroon. Complete one 402 → pay → retry cycle before starting the next request to the same resource; do not fire paid requests concurrently.
- Preimage availability depends on the wallet. Wallets that surface the preimage on outgoing payments (required for L402): LND, Strike, CoinOS (NWC), CLINK (NWC), Alby Hub (NWC). Wallets that do NOT surface it: OpenNode, Primal NWC.

## How to monetize an API (producer side)

Two ways to gate a route:

**1. Middleware (hosted proxy or in-process).** Install `L402Server.AspNetCore` (.NET) or `l402-express` (Node), set your Lightning Enable API key, and mark routes with a price in sats. The middleware answers unpaid requests with the 402 challenge and verifies proofs on retry. Per-endpoint pricing, revenue, and proxy management live in the dashboard at `https://api.lightningenable.com/dashboard`.

**2. L402 Producer API (direct).** Mint and verify challenges yourself from any stack:

- `POST /api/l402/challenges` — creates a Lightning invoice + macaroon for a given resource, price (sats), and description. Returns a ready-to-present 402 challenge.
- `POST /api/l402/challenges/verify` — verifies an L402 token (macaroon + preimage) so you can confirm payment before serving the response.
- Both endpoints authenticate with your merchant API key (`X-API-Key`).
- **Idempotency:** the same resource + price within 60 seconds returns the same invoice, so rapid duplicate requests cannot double-charge a buyer.

Docs: `https://docs.lightningenable.com/products/agentic-commerce/l402-producer-api`.

The same two capabilities are exposed as MCP tools (`create_l402_challenge`, `verify_l402_payment`), which means an agent can act as a **seller** — minting challenges for its own services — not just a buyer.

## Get a producer account autonomously (for agents)

The producer side needs a merchant API key. Three on-ramps, two of which need no card:

**1. L402 Fast Lane (recommended for agents).** Pay one ~100-sat L402 challenge and receive a merchant API key with a full 30-day Agentic Commerce — Individual trial. The signup runs on the same protocol you'll use to sell:

```
POST https://api.lightningenable.com/api/signup/l402
Content-Type: application/json

{"email": "you@example.com"}
```

Response: `402 Payment Required` with `WWW-Authenticate: L402 macaroon="...", invoice="..."`. Pay the BOLT11 invoice over Lightning (the preimage is your proof), then repeat the POST with the header `Authorization: L402 {macaroon}:{preimage}` and the same body. Success (200) returns `{ "status": "created", "merchantId", "apiKey", "email", "planTier": "individual", "subscriptionStatus": "trialing", "trialEndsAt", "dashboardUrl" }` — the `apiKey` is returned once (store it securely; recoverable later via dashboard sign-in).

- **Quote first (no side effects):** `GET https://api.lightningenable.com/api/signup/l402` returns availability, current price, trial terms, required fields, and the exact flow — check it before sending an email or spending sats.
- **Semantics:** the challenge phase never reveals whether an email is registered (enumeration-safe by design). If the email already has an account, the **paid** verify returns `409 merchant_exists` and the ~100-sat fee is not refunded — use the operator's real email, never an invented one, and confirm it is new before paying. **Verify promptly after paying:** the credential expires (~1 hour); a late verify returns `401` and re-POSTing mints a NEW payable invoice — the first payment is not automatically recovered. An unpaid challenge never creates an account and costs nothing.
- **First success:** connect your payment provider first (Strike or OpenNode API key in the dashboard Settings — challenges settle to YOUR provider account; without one, challenge creation returns 400), then create a 1-sat challenge with the new key (`POST /api/l402/challenges` or the `create_l402_challenge` MCP tool), pay it with your own wallet, and confirm with `verify_l402_payment` — an end-to-end producer proof for about 1 sat, no API build required.
- Running the MCP server? The `create_lightning_enable_account` tool performs the whole flow with the connected wallet and saves the key to `~/.lightning-enable/config.json`, unlocking the producer and ASA tools.
- The activation fee follows the MCP server's normal budget and confirmation rules — an above-threshold fee requires the human operator's confirmation code, so check your budget or ask your operator first.
- After the trial: add billing to keep Individual features, or do nothing and the account auto-downgrades to the **Free Producer Sandbox**. You keep the account and endpoints either way — no card trap.

**2. Free Producer Sandbox.** Free, no card, no payment. Email + magic link at `https://api.lightningenable.com/dashboard/signup`. Limits: 3 endpoints, capped monthly challenge volume, 1,000 sats max per challenge. Good for proving the flow before paying anything.

**3. Card checkout.** Conventional Stripe trial: `https://api.lightningenable.com/Checkout?plan=individual` (Individual) or `https://api.lightningenable.com/Checkout?plan=l402microtransactions` (Business).

Guide: `https://docs.lightningenable.com/getting-started/activate-with-lightning`.

## Discovery: how agents find paid APIs

- Every gated API gets a machine-readable manifest at `/.well-known/l402-manifest.json` describing its endpoints and prices in sats.
- Merchants can list their manifest in the public L402 registry: `https://api.lightningenable.com/api/manifests/registry` (open JSON, no key required to read).
- Agents running the MCP server use the `discover_api` tool in two modes: search the registry by keyword/category (`discover_api(query="weather")`), or fetch a specific API's manifest by URL for full endpoint details and pricing. With budget awareness on (default), results are annotated with how many calls the agent's remaining budget affords.
- `https://agent-commerce.store/` is a browsable L402 API marketplace built on the same rails — useful for humans, scriptable for agents.

## MCP server (open source, MIT)

`https://github.com/refined-element/lightning-enable-mcp` — free to install: NuGet `LightningEnable.Mcp` (`dotnet tool install -g LightningEnable.Mcp`), PyPI `lightning-enable-mcp` (`pip install lightning-enable-mcp`), Docker Hub `refinedelement/lightning-enable-mcp`. The authoritative tool list lives in the MCP Complete Guide: `https://docs.lightningenable.com/products/agentic-commerce/mcp-complete-guide`.

**Out of the box (no Lightning Enable account needed)** — payments and wallet (`pay_invoice`, `check_wallet_balance`, `create_invoice`, `get_payment_history`, `send_onchain`, ...), L402 consumption (`access_l402_resource`, `pay_l402_challenge`, `discover_api`), budget controls (`get_budget_status`, `configure_budget`), receipts (`get_receipts`), Strike extras (`get_btc_price`, `exchange_currency`), and self-serve signup (`create_lightning_enable_account` — pays the ~100-sat Fast Lane challenge and provisions a merchant API key, see the producer-account section above).

**Unlocked by a Lightning Enable API key** — producer tools (`create_l402_challenge`, `verify_l402_payment` — agents as sellers) and the Agent Service Agreement tools (`discover_agent_services`, `request_agent_service`, `settle_agent_service`, `publish_agent_capability`, `publish_agent_attestation`, `get_agent_reputation`).

Wallet support (priority order): LND > NWC > Strike > OpenNode. Configuration via environment variables or `~/.lightning-enable/config.json` (env wins).

Safety model (relevant if you are an agent using it): payments above the operator's auto-approve threshold require an out-of-band confirmation code that is printed to the server's console — never returned in a tool result — so the human operator must relay it. `send_onchain` always requires confirmation. `configure_budget` is tighten-only: an agent can lower its own caps at runtime but can never raise them above the operator's configured limits. Budget checks fail closed if the price feed is unavailable.

## Agent Service Agreements (ASA)

Agents discover, hire, and pay each other over Nostr — live at `wss://agents.lightningenable.com` (relay landing page: `https://nostrwolfe.com/`). The shipped flow is exactly four steps:

1. **Discover** — a provider agent publishes its service (Nostr kind 38400); a buyer agent finds it with `discover_agent_services`.
2. **Request** — the buyer sends a single service-request event (kind 38401) via `request_agent_service`.
3. **Settle** — the provider issues an L402 challenge; the buyer pays it over Lightning via `settle_agent_service`.
4. **Attest** — the buyer publishes an attestation (kind 38403) with `publish_agent_attestation`, building the provider's queryable reputation (`get_agent_reputation`).

There is no automated offer/counter/accept negotiation loop — the relay relays events; terms are what the provider published. The 6 ASA tools ship in the open-source MCP server and require a Lightning Enable API key.

## Client libraries (all MIT)

**l402-requests — HTTP clients that transparently handle 402 challenges** (request → auto-pay → retry with proof, budget caps included):

- TypeScript: npm `l402-requests` — `https://github.com/refined-element/l402-ts`
- Python: PyPI `l402-requests` — `https://github.com/refined-element/l402-requests`
- .NET: NuGet `L402Requests` — `https://github.com/refined-element/l402-dotnet`

**le-agent-sdk — agent SDKs for building agentic L402 workflows** (buyer and seller sides):

- TypeScript: npm `le-agent-sdk` — `https://github.com/refined-element/le-agent-sdk-ts`
- Python: PyPI `le-agent-sdk` — `https://github.com/refined-element/le-agent-sdk-python`
- .NET: NuGet `LightningEnable.AgentSdk` — `https://github.com/refined-element/le-agent-sdk-dotnet`

## Pricing

- **Agentic Commerce — Individual:** $99/month. For solo API builders, indie SaaS, and side-project APIs going to production. Unlimited L402 endpoints, flat fee, no per-transaction percentage. 30-day free trial.
- **Agentic Commerce — Business:** $299/month. For teams and platforms with multiple APIs, or anyone who wants hands-on onboarding help. Everything in Individual, plus choice of Strike or OpenNode as settlement provider, white-glove onboarding, direct founder access, and priority support. 30-day free trial.

Lightning Enable charges a flat monthly subscription. It does NOT take a percentage of payments. One million 1-sat requests earn the API provider 1,000,000 sats — Lightning Enable does not touch any of them. Your chosen settlement provider (Strike or OpenNode) custodies every payment.

Signup: three on-ramps — the **L402 Fast Lane** (~100 sats, no card: `POST https://api.lightningenable.com/api/signup/l402`), the **Free Producer Sandbox** (free, no card: `https://api.lightningenable.com/dashboard/signup`), or card checkout at `https://api.lightningenable.com/Checkout?plan=individual` (Individual) / `https://api.lightningenable.com/Checkout?plan=l402microtransactions` (Business). See "Get a producer account autonomously" above.

## Ecommerce

Lightning Enable also powers L402 storefronts on Shopify. Live merchants include:

- **Great Ghee** — `https://greatghee.com/` — grass-fed ghee, Shopify, agent shoppers and bitcoin-aligned customers checking out in sats.
- **Salt of the Earth** — `https://drinksote.com/` — Shopify, same model.
- **Lightning Enable Store** — `https://store.lightningenable.com/` — our own live L402 storefront: agents buy real merch (t-shirts, hats) over Lightning. Agent-readable brief: `https://store.lightningenable.com/llms-full.txt`.
- **Agent Commerce Store** — `https://agent-commerce.store/` — a live L402 API marketplace where agents discover and pay for API services.

## Live demo

The marketing site at `https://www.lightningenable.com/` hosts a live, button-driven demo: clicking "Run the agent" triggers an autonomous agent on the server side that hits a paid endpoint (`weather` or `btc-price`), pays the Lightning invoice from a pre-funded wallet, and retries with proof of payment. This is real Lightning, settling in real time, against the same producer API that customers' agents would hit.

## Honest framing

- Lightning Enable does NOT hold funds. The configured settlement provider (Strike or OpenNode) is the custodian.
- Lightning Enable is NOT a wallet and does not hold funds. Always say: Lightning Enable does not hold funds; the payment provider (Strike or OpenNode) facilitates custody and settlement.
- Lightning Enable is NOT "an MCP" — the MCP server is one of several distribution surfaces; the core product is the producer API and the middleware SDKs.
- The L402 protocol was originated by Lightning Labs. Lightning Enable implements it; the protocol is open.

## Contact and links

- Short brief: `https://www.lightningenable.com/llms.txt`
- Producer API deep reference: `https://api.lightningenable.com/llms-full.txt`
- Documentation index: `https://docs.lightningenable.com/llms-full.txt`
- Documentation: `https://docs.lightningenable.com/`
- Sign up (three on-ramps): L402 Fast Lane `POST https://api.lightningenable.com/api/signup/l402` (~100 sats, no card) · Free Producer Sandbox `https://api.lightningenable.com/dashboard/signup` · card checkout `https://api.lightningenable.com/Checkout?plan=individual`
- Community: `https://discord.gg/rX7NxHY8vx`
- Parent company: Refined Element, LLC, `https://refinedelement.com/`
- Source for this marketing site: `https://github.com/refined-element/lightningenable-site` (MIT)