Toda API^ⓘ é uma troca.
Paga via Lightning^ⓘ — sem intermediário.

// npm install l402-kit  — protect your API (sovereign, 0% fee)
import express from "express";
import { l402, AlbyProvider } from "l402-kit";

const app = express();
const lightning = new AlbyProvider(
  process.env.ALBY_TOKEN!,   // hub.getalby.com — self-custodial
  process.env.ALBY_URL!
);

app.get("/premium", l402({ priceSats: 100, lightning }), (req, res) => {
  res.json({ data: "Payment confirmed ⚡" });
});

app.listen(3000);
// 0% fee. Your node. Every sat goes directly to you.

// npm install l402-kit  — managed mode: no node, no wallet setup
import express from "express";
import { l402, ManagedProvider } from "l402-kit";

const app = express();

// l402kit.com hosts the Lightning node — no setup needed
const lightning = ManagedProvider.fromAddress("you@yourdomain.com");
// ↑ payments go directly to your Lightning address (99.7% of each sat)

app.get("/api/data", l402({ priceSats: 10, lightning }), (req, res) => {
  res.json({ data: "Payment confirmed ⚡" });
});

app.listen(3000);
// Fee: 0.3% to l402kit.com · 99.7% to you · TypeScript only

# pip install l402kit  — protect your FastAPI endpoint (sovereign)
from fastapi import FastAPI
from l402kit import l402_required, BlinkProvider

app = FastAPI()
lightning = BlinkProvider(
    api_key="your_blink_key",    # dashboard.blink.sv — free
    wallet_id="your_wallet_id"
)

@app.get("/premium")
@l402_required(price_sats=100, lightning=lightning)
async def premium():
    return {"data": "Payment confirmed ⚡"}

// go get github.com/shinydapps/l402-kit/go
package main

import (
    "fmt"; "net/http"
    l402kit "github.com/shinydapps/l402-kit/go"
)

func main() {
    http.Handle("/premium", l402kit.Middleware(l402kit.Options{
        PriceSats: 100,
        Provider:  l402kit.NewBlinkProvider(os.Getenv("BLINK_KEY"), os.Getenv("BLINK_WALLET")),
    }, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, `{"data":"Payment confirmed ⚡"}`)
    })))
    http.ListenAndServe(":8080", nil)
}

// Cargo.toml: l402kit = "0.1"
use axum::{middleware, routing::get, Router};
use l402kit::{l402_middleware, Options};
use std::sync::Arc;

async fn handler() -> &'static str {
    "{\"data\":\"Payment confirmed ⚡\"}"
}

#[tokio::main]
async fn main() {
    let opts = Arc::new(
        Options::new(100).with_address("you@yourdomain.com"),
    );
    let app = Router::new()
        .route("/premium", get(handler))
        .route_layer(middleware::from_fn_with_state(opts, l402_middleware));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}