DEV Community: ShinyDapps

AI Agents Can Now Pay for APIs Automatically — No Credit Cards, No OAuth

ShinyDapps — Mon, 04 May 2026 18:48:32 +0000

The Friction Nobody Talks About

You're building an AI agent. It needs to call a premium API — weather forecasts, financial data, compute resources, whatever.

How does it pay?

Credit card → requires a human to approve, link a card, and manage billing
API key → requires pre-registration, someone to provision access, a dashboard to manage
OAuth → identity, not payment; you still need billing on top

Every option requires human intervention before the agent can act. That's not autonomous.

HTTP 402: The Protocol That Was Always Meant for This

RFC 2616 reserved status code 402 Payment Required back in 1999 — "for future use." That future is now, and it's called the L402 protocol.

Here's what it looks like from the agent's perspective:

Agent → GET /api/premium-data
Server ← 402 Payment Required
         WWW-Authenticate: L402 invoice="lnbc10n1..."

Agent pays Lightning invoice (1 sat, ~$0.001)
Agent → GET /api/premium-data
         Authorization: L402 <macaroon>:<preimage>
Server verifies: SHA256(preimage) == paymentHash ✓
Server ← 200 OK {"data": "..."}

No pre-registration. No API key provisioning. No human in the loop. The agent pays, proves it paid, and gets the data — all in one round trip.

The MCP Tool That Makes It Work

l402-kit ships an MCP server with a single power tool: l402_fetch.

{
  "mcpServers": {
    "l402": {
      "command": "npx",
      "args": ["l402-kit-mcp"],
      "env": {
        "BLINK_API_KEY": "your-key",
        "BLINK_WALLET_ID": "your-wallet-id",
        "BUDGET_SATS": "100"
      }
    }
  }
}

Add this to Claude Desktop (or any MCP-compatible client) and your agent gains the ability to autonomously pay for any L402-protected API — capped at 100 sats per session.

What it looks like in practice

Once configured, you can tell Claude:

"Fetch me the current BTC price from l402kit.com/api/demo/btc-price"

Claude calls l402_fetch → automatically handles the 402 → pays 1 sat → returns the data. No human approval needed. The whole flow happens in under 2 seconds.

Try It Right Now — No Install Needed

The Glama MCP Inspector lets you test the server in your browser:

Go to glama.ai/mcp/servers/ShinyDapps/l402-kit
Click Try in Browser
Call l402_fetch with url: "https://l402kit.com/api/demo/btc-price"

You'll see the 402 handshake live in the request log. (The browser inspector runs without wallet credentials, so the payment step will error — but you can observe the full protocol flow.)

Budget Controls Keep Agents from Overspending

The wallet supports hard spending caps:

const wallet = new ManagedWallet({
  provider: "blink",
  apiKey: process.env.BLINK_API_KEY,
  budget: { maxSats: 500, period: "day" }  // ~$0.30/day hard cap
});

The l402_balance and l402_spending_report MCP tools let the agent check its own remaining budget mid-session — no external monitoring needed.

For API Builders: 3 Lines to Accept Agent Payments

If you want your API to accept autonomous payments from agents:

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

const app = express();
app.use("/premium", l402({ priceSats: 10, provider: "blink" }));
app.get("/premium", (req, res) => res.json({ data: "paid content" }));
app.listen(3000);

Also available in Python, Go, and Rust. Revenue goes directly to your Lightning wallet — 0.3% platform fee, no chargebacks, no monthly billing overhead.

Why Lightning and Not Stablecoins?

Coinbase launched x402 — a similar protocol using USDC on Base. Both are valid approaches. The tradeoffs:

	l402-kit (Lightning)	x402 (USDC/Base)
Settlement	Instant, final	~2s, on-chain
Min amount	1 sat (~$0.001)	~$0.01
Fees	~0.3%	Gas + protocol fee
Custody	Self-custodial options	EVM wallet required
Agent support	MCP + LangChain	EVM SDK

For truly micro transactions (1–100 sats), Lightning is the only option that makes economic sense. For USDC-native workflows, x402 fits better.

Current Status

v1.8.1 on npm, pip, crates.io, pkg.go.dev
MCP server listed on Glama and awesome-mcp-servers
476 tests passing
Live demo at l402kit.com/api/demo — 1 sat per call, try it with any Lightning wallet

npm install l402-kit

# See the 402 flow live
curl -v https://l402kit.com/api/demo/btc-price

The agent economy is coming. The payment layer needs to be as autonomous as the agents themselves. That's what L402 is for.

If you've tried x402 or built anything with MCP payments, I'd love to hear how it went — drop a comment.

Monetize Your API with Bitcoin Lightning in 3 Lines of Code

ShinyDapps — Thu, 30 Apr 2026 13:44:32 +0000

The Problem

You built an API. You want to charge per request. Your options:

API keys + billing system — weeks of auth code, Stripe integration, chargeback risk
Subscriptions — friction for new users, overkill for occasional callers
OAuth — identity, not payment; still need billing on top

What if a client could pay for exactly one call, right now, from anywhere in the world, with cryptographic proof — and your API verified it in 10 lines of code?

HTTP 402: The Payment Required Protocol

RFC 2616 reserved status code 402 "for future use." That future is now.

The L402 protocol (built on top of HTTP 402) works like this:

Client → GET /premium
Server ← 402 Payment Required
         WWW-Authenticate: L402 macaroon="...", invoice="lnbc10n1..."

Client pays Lightning invoice (via wallet or automated agent)
Client → GET /premium
         Authorization: L402 <macaroon>:<preimage>
Server verifies: SHA256(preimage) == paymentHash ✓
Server ← 200 OK  (response)

The cryptographic verification is the key insight: no database lookup needed. The server checks SHA256(preimage) == paymentHash — that's it. If it matches, the payment happened. Period.

L402-Kit: 3 Lines to Monetize Any API

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

const app = express();
app.use("/premium", l402({ priceSats: 10, provider: "blink" }));
app.get("/premium", (req, res) => res.json({ data: "paid content" }));
app.listen(3000);

That's a fully working pay-per-call API. No accounts, no billing dashboard, no Stripe.

Same API in 4 Languages

Python (FastAPI):

from fastapi import FastAPI
from l402kit import L402Middleware

app = FastAPI()
app.add_middleware(L402Middleware, price_sats=10, provider="blink")

@app.get("/premium")
def premium(): return {"data": "paid content"}

Go (net/http):

mux := http.NewServeMux()
mux.Handle("/premium", l402kit.Guard(10, "blink", premiumHandler))
http.ListenAndServe(":8080", mux)

Rust (axum):

let app = Router::new()
    .route("/premium", get(premium_handler))
    .layer(L402Layer::new(10, "blink"));

For AI Agents: The Real Game-Changer

AI agents need to pay for APIs autonomously. Credit cards require human approval. API keys require pre-registration. L402 solves both.

MCP Server (Claude/Cursor/etc.)

{
  "mcpServers": {
    "l402": {
      "command": "npx",
      "args": ["l402-kit-mcp"],
      "env": {
        "BLINK_API_KEY": "your-key",
        "BLINK_WALLET_ID": "your-wallet-id"
      }
    }
  }
}

Now Claude can call any L402-protected API:

"Fetch me the latest BTC price" → agent calls /api/demo → automatically pays 1 sat → gets response → reports to you

LangChain Integration

from l402kit import L402Tool

tools = [L402Tool(wallet_config={"provider": "blink", "api_key": "..."})]
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
agent.run("Call the premium weather API and get tomorrow's forecast")

Budget Controls

const wallet = new ManagedWallet({
  provider: "blink",
  apiKey: process.env.BLINK_API_KEY,
  budget: { maxSats: 1000, period: "day" }  // cap at ~$0.60/day
});

Sovereign Mode: Zero Fees, Full Control

Don't want intermediaries? Run your own Lightning node:

l402({
  priceSats: 10,
  provider: "lnd",
  lnd: { host: "localhost:10009", macaroon: "...", cert: "..." }
})

0% fees. Your node. Your keys. Your revenue.

Discovery for AI Agents

Agents need to find L402-protected APIs without human help. L402-Kit implements 3 discovery layers:

DNS TXT record: l402._payment.yourdomain.com — works without HTTP
.well-known/agent.json — machine-readable endpoint metadata
llms.txt — training data for LLMs about your API

Current Status

v1.8.1 on npm, pip, crates.io, pkg.go.dev
476 tests passing
MCP server listed in punkpeye/awesome-mcp-servers and Glama MCP directory
Demo at https://l402kit.com/api/demo (1 sat per call)

Try It

# Install
npm install l402-kit

# Try the demo API (will return 402 without payment)
curl https://l402kit.com/api/demo

# Docs
open https://docs.l402kit.com

Lightning payments make more sense for APIs than you might think — especially as AI agents proliferate and start autonomously consuming paid services. The cryptographic verification removes an entire trust layer that traditional billing systems require.

Feedback welcome, especially from folks who've tried x402 (Coinbase's USDC equivalent) — curious how the Bitcoin vs stablecoin tradeoffs land in practice.