Quickstart

▶ पहले 402 flow देखें

इंटरैक्टिव टर्मिनल डेमो — अपने ब्राउज़र में live देखें: request → 402 → Lightning pay → 200 OK।

Option A — एक कमांड में पूरा सर्वर बनाएं (सबसे तेज़)

npx create-l402-app my-api

यह एक पूर्ण Express + l402-kit प्रोजेक्ट बनाता है: server.ts, .env.example, tsconfig.json, और एक /premium endpoint जो Lightning payments स्वीकार करने के लिए तैयार है।

my-api/
  src/server.ts      ← आपका API l402 middleware के साथ
  .env.example       ← Blink/OpenNode credentials टेम्पलेट
  package.json       ← npm install l402-kit + tsx
  tsconfig.json
  README.md

फिर:

cd my-api
cp .env.example .env   # अपनी Blink API key जोड़ें
npm install
npm run dev
# ⚡ l402-kit server running on http://localhost:3000
# curl http://localhost:3000/premium  →  402 Payment Required

Option B — किसी मौजूदा प्रोजेक्ट में जोड़ें

1. अपना mode चुनें

	Managed ⭐	Soberano
Setup समय	~2 मिनट	~5 मिनट
मासिक लागत	$0	$0
प्रति-transaction शुल्क	0.3%	0%
आपको क्या चाहिए	एक Lightning address	एक Blink / Alby / BTCPay account
10,000 sats प्रोसेस करने पर	30 sat शुल्क	$0 शुल्क
सबसे उपयुक्त	जल्दी शुरू करने के लिए	Volume / production

निश्चित नहीं हैं? Managed से शुरू करें — कोई node नहीं, कोई account नहीं, बस एक Lightning address। जब भी 0% fees चाहिए, Soberano पर एक लाइन के कोड से स्विच करें। स्विच के बाद पहले से paid tokens काम करते रहेंगे। Lightning address पाएं (मुफ़्त, 2 मिनट): dashboard.blink.sv पर साइन अप करें — आपको yourname@blink.sv मिलेगा। या Alby, Phoenix, या Wallet of Satoshi का उपयोग करें। Soberano setup: dashboard.blink.sv पर साइन अप करें → API Keys → key बनाएं → wallet पेज से अपना BTC Wallet ID कॉपी करें। अपनी .env में BLINK_API_KEY और BLINK_WALLET_ID सेट करें।

2. इंस्टॉल करें

npm install l402-kit

pip install l402kit

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

cargo add l402kit

3. अपने API में जोड़ें

Managed (⭐ Recommended)
Soberano (0% fee — Blink)

कोई Lightning node की ज़रूरत नहीं — बस आपका Lightning address।

import express from "express";
import { l402, ManagedProvider } from "l402-kit";

const app = express();
const lightning = ManagedProvider.fromAddress("you@yourdomain.com");

app.get("/premium", l402({ priceSats: 100, lightning }), (_req, res) => {
  res.json({ data: "You paid 100 sats. Here is your data." });
});

app.listen(3000);
// 0.3% fee · no node setup · works immediately

from fastapi import FastAPI, Request
from l402kit import l402_required, ManagedProvider

app = FastAPI()
lightning = ManagedProvider.from_address("you@yourdomain.com")

@app.get("/premium")
@l402_required(price_sats=100, lightning=lightning)
async def premium(request: Request):
    return {"data": "You paid 100 sats. Here is your data."}

package main

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

func main() {
    provider := l402kit.NewManagedProvider("you@yourdomain.com")
    http.Handle("/premium", l402kit.Middleware(l402kit.Options{
        PriceSats: 100,
        Lightning: provider,
    }, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, `{"data":"You paid 100 sats. Here is your data."}`)
    })))
    http.ListenAndServe(":8080", nil)
}

use axum::{middleware, routing::get, Router};
use l402kit::{l402_middleware, Options, ManagedProvider};
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let provider = ManagedProvider::new("you@yourdomain.com".into());
    let opts = Arc::new(Options::new(100, provider));
    let app = Router::new()
        .route("/premium", get(|| async { r#"{"data":"You paid 100 sats. Here is your data."}"# }))
        .route_layer(middleware::from_fn_with_state(opts, l402_middleware));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

आपका अपना Lightning wallet। dashboard.blink.sv पर साइन अप करें और अपना API Key + BTC Wallet ID कॉपी करें।

import express from "express";
import { l402, BlinkProvider } from "l402-kit";

const app = express();
const lightning = new BlinkProvider(
  process.env.BLINK_API_KEY!,
  process.env.BLINK_WALLET_ID!,
);

app.get("/premium", l402({ priceSats: 100, lightning }), (_req, res) => {
  res.json({ data: "You paid 100 sats. Here is your data." });
});

app.listen(3000);

import os
from fastapi import FastAPI, Request
from l402kit import l402_required, BlinkProvider

app = FastAPI()
lightning = BlinkProvider(
    api_key=os.environ["BLINK_API_KEY"],
    wallet_id=os.environ["BLINK_WALLET_ID"],
)

@app.get("/premium")
@l402_required(price_sats=100, lightning=lightning)
async def premium(request: Request):
    return {"data": "You paid 100 sats. Here is your data."}

package main

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

func main() {
    blink := l402kit.NewBlinkProvider(os.Getenv("BLINK_API_KEY"), os.Getenv("BLINK_WALLET_ID"))
    http.Handle("/premium", l402kit.Middleware(l402kit.Options{
        PriceSats: 100,
        Lightning: blink,
    }, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, `{"data": "You paid 100 sats. Here is your data."}`)
    })))
    http.ListenAndServe(":8080", nil)
}

use axum::{middleware, routing::get, Router};
use l402kit::{l402_middleware, Options, BlinkProvider};
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let provider = BlinkProvider::new(
        std::env::var("BLINK_API_KEY").unwrap(),
        std::env::var("BLINK_WALLET_ID").unwrap(),
    );
    let opts = Arc::new(Options::new(100, provider));
    let app = Router::new()
        .route("/premium", get(|| async { r#"{"data":"You paid 100 sats. Here is your data."}"# }))
        .route_layer(middleware::from_fn_with_state(opts, l402_middleware));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

4. परीक्षण करें

curl http://localhost:3000/premium

Response:

{
  "error": "Payment Required",
  "price_sats": 100,
  "invoice": "lnbc1u1p...",
  "macaroon": "eyJoYXNo..."
}

किसी भी Lightning wallet से invoice का भुगतान करें, फिर:

curl http://localhost:3000/premium \
  -H "Authorization: L402 <macaroon>:<preimage>"

Response:

{ "data": "You paid 100 sats. Here is your data." }

आपका API अब Bitcoin payments स्वीकार करता है।

असली sats के बिना परीक्षण करें

अपने integration को test करने के लिए आपको Lightning wallet की ज़रूरत नहीं है। एक mock provider का उपयोग करें — यह locally valid cryptographic token pairs बनाता है, बिना किसी network call के:

import { createHash, randomBytes } from "crypto";
import { l402 } from "l402-kit";
import type { LightningProvider, Invoice } from "l402-kit";

// Drop-in mock — generates real SHA256 hash/preimage pairs
function makeMockProvider(): LightningProvider & { preimage: string } {
  const preimage = randomBytes(32).toString("hex");
  const paymentHash = createHash("sha256").update(Buffer.from(preimage, "hex")).digest("hex");
  return {
    preimage, // use this in your test Authorization header
    async createInvoice(amountSats: number): Promise<Invoice> {
      const macaroon = Buffer.from(
        JSON.stringify({ hash: paymentHash, exp: Date.now() + 3_600_000 })
      ).toString("base64");
      return { paymentRequest: "lnbc_mock", paymentHash, macaroon, amountSats };
    },
    async checkPayment(): Promise<boolean> { return true; },
  };
}

// Usage in tests:
const mock = makeMockProvider();
app.get("/premium", l402({ priceSats: 10, lightning: mock }), handler);

// Step 1 — unauthenticated → 402
const res402 = await request(app).get("/premium");
// res402.body.macaroon  ← use this

// Step 2 — pay with mock preimage → 200
const res200 = await request(app)
  .get("/premium")
  .set("Authorization", `L402 ${res402.body.macaroon}:${mock.preimage}`);
// res200.status === 200 ✓

sandbox के साथ असली पैसों का परीक्षण करने के लिए, OpenNode का testMode उपयोग करें:

const lightning = new OpenNodeProvider(process.env.OPENNODE_KEY!, true); // testMode: no real sats

पूरी testing गाइड → Testing

Getting Started

SDKs

Agent SDK

Agent Integrations

Guides

Reference

Built with l402-kit

🇧🇷 Português

🇪🇸 Español

🇨🇳 中文

🇸🇦 العربية

🇮🇳 हिंदी

🇫🇷 Français

🇩🇪 Deutsch

🇷🇺 Русский

🇯🇵 日本語

🇮🇹 Italiano

▶ पहले 402 flow देखें

Option A — एक कमांड में पूरा सर्वर बनाएं (सबसे तेज़)

Option B — किसी मौजूदा प्रोजेक्ट में जोड़ें

1. अपना mode चुनें

2. इंस्टॉल करें

3. अपने API में जोड़ें

4. परीक्षण करें

असली sats के बिना परीक्षण करें

▶ पहले 402 flow देखें

​Option A — एक कमांड में पूरा सर्वर बनाएं (सबसे तेज़)

​Option B — किसी मौजूदा प्रोजेक्ट में जोड़ें

​1. अपना mode चुनें

​2. इंस्टॉल करें

​3. अपने API में जोड़ें

​4. परीक्षण करें

​असली sats के बिना परीक्षण करें

Option A — एक कमांड में पूरा सर्वर बनाएं (सबसे तेज़)

Option B — किसी मौजूदा प्रोजेक्ट में जोड़ें

1. अपना mode चुनें

2. इंस्टॉल करें

3. अपने API में जोड़ें

4. परीक्षण करें

असली sats के बिना परीक्षण करें