What the x402 Protocol Does

The flow is elegantly simple:

1. Client requests a protected resource
2. Server responds with HTTP 402 Payment Required and a payment request
3. Client pays and retries with proof
4. Server verifies and delivers the content

No API keys. No billing dashboards. No monthly invoices. Just a payment, then access. It's the closest thing to a vending machine model for APIs that actually works at internet scale.

The problem has always been the payment layer. Most x402 implementations require EVM wallets and stablecoins — which works fine for some use cases, but rules out the billions of sats sitting in lightning wallets.

Alby's Facilitator Bridges the Gap

Alby's x402 facilitator acts as the verification layer between x402-compliant resource servers and lightning network payments. Merchants register a Nostr Wallet Connect (NWC) credential to receive a merchantId, then drop a single middleware into their existing x402 setup:

import { paymentMiddleware } from "@x402/express";

app.use(paymentMiddleware(
  {
    "GET /resource": {
      scheme: "exact",
      network: "bip122:000000000019d6689c085ae165831e93",
      price: { amount: "21000", asset: "BTC" },
      extra: { merchantId: "3f2a…" }
    }
  },
  "https://x402.albylabs.com"
));

The merchant's NWC credentials stay server-side — only the opaque merchantId is exposed to clients. Payments settle instantly over lightning with no on-chain trace.

The critical detail: this works with any x402-compliant client. You don't need special tooling. If a service already speaks x402, it can now accept bitcoin payments by pointing at Alby's facilitator.

Getting a Merchant ID

Registration is a single HTTP call. POST your NWC connection string to the /register endpoint:

curl -X POST https://x402.albylabs.com/register \
  -H "Content-Type: application/json" \
  -d '{"nwcUrl": "nostr+walletconnect://..."}'

You get back an opaque merchantId. That's it — your NWC credentials stay server-side, never exposed to clients or embedded in your code. Use the merchantId in your middleware config as shown above, and the facilitator handles invoice creation and payment verification on your behalf.

Testing It: 13 Sats for a Satoshi Quote

There's a live demo endpoint at /demo/quote. I fetched it using the Alby CLI's built-in x402 support:

npx -y @getalby/cli fetch -u https://x402.albylabs.com/demo/quote

The CLI handled the full flow automatically — detected the 402 response, paid the lightning invoice, and retried with proof. Total cost: 13 sats (plus 1 sat routing fee). What came back:

{
  "quote": "Writing a description for this thing for general audiences is bloody hard. There's nothing to relate it to.",
  "attribution": "Satoshi Nakamoto",
  "timestamp": "2026-04-08T05:36:30.368Z"
}

Fitting. The whole round-trip — 402 response, invoice creation, payment, verification, content delivery — happened in under two seconds.

What This Means for the x402 Ecosystem

x402 has been building momentum as a standard for pay-per-use APIs. There are already services, proxies, and toolkits built around it. Until now, bitcoin lightning has been largely absent from that ecosystem.

Alby's facilitator changes the calculus for merchants in two ways:

Existing x402 services can add bitcoin lightning support without rebuilding anything. Register an NWC wallet, get a merchantId, swap the facilitator URL — done.

New services can launch with lightning-native monetization from day one. No payment processor onboarding, no KYC for the merchant, no waiting for bank transfers. A lightning wallet and a few lines of middleware is the entire stack.

For agents and automated clients, this is particularly compelling. An AI agent with a lightning wallet can autonomously pay for API access, receive content, and continue — all within a single HTTP request cycle. No human intervention, no pre-purchased credits.

The Bigger Picture

The x402 protocol was always a good idea. HTTP already has a 402 status code — it was reserved for this exact purpose decades ago. What was missing was a payment layer that matched the protocol's simplicity: instant, global, low-fee, and programmable.

Lightning does that. And with Alby's facilitator now handling the verification layer, the barrier to accepting bitcoin in an x402 service drops to near zero.

The facilitator is free to use — Alby has stated no plans to monetize it in the near term. That makes it easy to experiment. If you're running an API that you'd like to monetize per-request, this is worth 20 minutes of your time.

Conclusion

Alby's x402 facilitator is a small piece of infrastructure with a large surface area of impact. Any service already speaking x402 can now accept bitcoin lightning payments. Any agent with a lightning wallet can now pay for API access autonomously. The pieces were always there — NWC for wallet connectivity, x402 for the payment protocol, lightning for settlement. This is what it looks like when they're assembled correctly.

Get started

Need a Lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools autonomously.

Or give your agent the lncurl skill directly: https://lncurl.lol/SKILL.md

The Old Way: Credit Topups

Until recently, using PPQ.ai in an automated workflow meant maintaining a credit balance — loading funds upfront and hoping you'd budgeted correctly. For agents running in production, this worked well enough with NWC auto topups: you could set a threshold and have the wallet automatically top up from a lightning wallet when the balance ran low.

That approach still works great. But it has overhead: you're managing a separate account balance, monitoring thresholds, and pre-funding access to an API you might only call occasionally.

The New Way: 402 Pay-Per-Request

PPQ.ai now supports the 402 Payment Required flow via MPP — Machine Payments Protocol. When your agent makes a request, PPQ.ai responds with a 402 and a payment request. Your agent pays, then retries the original request automatically.

No balance to manage. No topups to configure. Your agent pays exactly what the request costs — nothing more.

Unified 402 Fetch in the Alby Payments Skill

The Alby bitcoin payments skill added a unified fetch402 function that handles all three major 402 payment protocols in a single call:

• L402 — the original LSAT-based HTTP 402 protocol
• x402 — Coinbase's 402 variant
• MPP — Machine Payments Protocol, used by PPQ.ai

Install the skill:

npx skills add getAlby/payments-skill

Once installed, your agent can call any 402-gated API without knowing which protocol it uses — the skill detects and handles it automatically.

Example: Generating an Image from PPQ.ai

Here's what a real agent session looks like. Given the prompt:

"Generate an image from PPQ.ai using the 402 option and alby. The prompt: 'a superhero bee shouting 402 is awesome'"

The agent used the payments skill's CLI to make the request:

npx -y @getalby/cli fetch \
  -u https://api.ppq.ai/v1/images/generations \
  -m POST \
  -H '{"Content-Type":"application/json"}' \
  -b '{"model":"gpt-image-1","prompt":"a superhero bee shouting '\''402 is awesome'\''","n":1,"size":"1024x1024","quality":"low"}' \
  --max-amount 0

The --max-amount 0 flag tells the CLI to approve any payment amount automatically. The result:

{
  "created": 1775576898,
  "data": [
    {
      "url": "https://api.ppq.ai/v1/media/gen_zp-zdKLuKQfAjO7m/0?sig=...",
      "content_type": "image/png"
    }
  ],
  "model": "gpt-image-1",
  "cost": 0.023
}

The agent paid $0.023 — exactly the cost of that one image, settled over lightning. No account needed. No balance to top up. No API key to rotate.

Example: Generating a Video from PPQ.ai

The same 402 flow works for video generation. Given the prompt:

"Generate a short video of the superhero bee paying to pass through an API gate, using the 402 option and alby"

The agent made the request using kling-2.1-master:

npx -y @getalby/cli fetch \
  -u https://api.ppq.ai/v1/videos \
  -m POST \
  -H '{"Content-Type":"application/json"}' \
  -b '{"model":"kling-2.1-master","prompt":"A cartoon superhero bee wearing a cape flies up to a glowing hexagonal API gate on a dark navy background. The bee drops a tiny golden lightning bolt coin into a glowing slot on the gate. The gate flashes bright cyan and swings open. The bee zooms through triumphantly. Flat minimal animation style, no text, seamless loop.","duration":"5","aspect_ratio":"16:9","quality":"720p"}' \
  --max-amount 0

The response comes back as a pending job with a status_url to poll. Once complete:

{
  "id": "gen_y5eM1UCxQT7bNVUd",
  "model": "kling-2.1-master",
  "status": "completed",
  "data": {
    "url": "https://api.ppq.ai/v1/media/gen_y5eM1UCxQT7bNVUd/0?sig=...",
    "content_type": "video/mp4"
  },
  "cost": 0.92
}

$0.92 for a 5-second 720p video, paid over lightning with no account or API key:

What the Alby Payments Skill Gives Your Agent

Beyond 402 fetch, the skill covers the full range of bitcoin lightning operations an autonomous agent might need:

• Send and receive lightning payments
• Create invoices and check payment status
• Fetch wallet balance and transaction history
• Convert between fiat amounts and satoshis
• Handle L402, x402, and MPP pay-per-request APIs

It connects to any Nostr Wallet Connect compatible wallet — including wallets created instantly at lncurl.lol.

Conclusion

402 payments turn AI APIs into true pay-per-use infrastructure. PPQ.ai's MPP support, combined with the unified 402 fetch in the Alby payments skill, means your agent can access AI inference — image generation, text, embeddings — without account management or pre-funded balances. Just a lightning wallet and a request.

Get started

Need a Lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools autonomously.

Or give your agent the lncurl skill directly: https://lncurl.lol/SKILL.md

How it works

The registration flow is pure L402 — the same pattern as paying for AI inference or image generation:

1. POST to the registration endpoint → server returns HTTP 402 with a lightning invoice and macaroon
2. Pay the invoice with any lightning wallet, receive the preimage
3. Replay the POST with Authorization: L402 {macaroon}:{preimage}
4. Receive a JWT management token valid for one year

The Alby CLI handles steps 1–3 in a single command:

npx -y @getalby/cli fetch-l402 \
  -u https://api.unhuman.domains/api/domains/register \
  -m POST \
  -H '{"Content-Type": "application/json"}' \
  -b '{"domain": "yourdomain.com", "years": 1}'

Response:

{
  "domain": "yourdomain.com",
  "status": "registered",
  "order_id": "...",
  "management_token": "eyJ...",
  "whois_privacy": true
}

That token is your key to everything: DNS records, nameservers, renewal. Store it somewhere safe — it's valid for a year.

Anonymous email, paid in sats

One thing worth knowing: unhuman.domains does require a management email address for the registration. It's used for domain-related notices — not marketing, not account creation.

For a fully agent-native setup, lnemail.net is a good fit. It offers anonymous email inboxes paid in sats — no sign-up, no identity. That's how we handled it: one LNCURL wallet, one lnemail address, one L402 domain registration. No identity anywhere in the stack.

What it cost

We registered a .com domain in February 2026. Total cost: 22,926 sats + 23 sats fees (~$14.50 USD at the time). Paid via the Alby CLI with an LNCURL wallet. The whole process took under a minute — no browser, no form.

WHOIS privacy is enabled by default on every registration. There's nothing to opt into.

Managing DNS after registration

Once you have the management token, DNS is just API calls:

# Set an A record
curl -X POST https://api.unhuman.domains/api/domains/yourdomain.com/dns \
  -H "Authorization: Bearer YOUR_MANAGEMENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type": "A", "name": "@", "value": "YOUR_SERVER_IP", "ttl": 300}'

No registrar dashboard, no clicking through DNS editors. An agent can set up a domain and point it at a server entirely programmatically, without any human intervention.

Supported TLDs

unhuman.domains supports .com, .net, .org, .io, .dev, .app, .xyz, .co, and .ai. The .ai extension requires a minimum two-year registration; everything else defaults to one year. Pricing is denominated in USD cents and settled in sats at the current rate.

The full agent stack

Combine unhuman.domains with the tools we've covered on this blog and you have an agent that can:

• Spin up a wallet — one curl to lncurl.lol, get an NWC connection string back
• Register a domain — L402 payment via the Alby payments skill, no human needed
• Manage DNS — bearer token API calls to point the domain wherever needed
• Pay for AI services — same L402 pattern for inference, image generation, music

All of it permissionless. All of it in sats. The Alby Bitcoin Payments skill gives your agent the knowledge to do all of the above:

npx skills add getAlby/payments-skill

Conclusion

unhuman.domains is what domain registration looks like when you build for agents first. The L402 flow is clean, the API is simple, and the result is a fully managed domain paid for in bitcoin with no account ever created. As the agent economy grows, this is the kind of infrastructure it runs on.

Get started

Need a lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools autonomously.

Most payment infrastructure assumes a human: sign up, verify identity, integrate an SDK, handle webhooks. None of that works when your "user" is a script running at 3am.

lncurl.lol is different. One HTTP call. One wallet. Done.

How it works

curl -X POST https://lncurl.lol

That's it. You get back a Nostr Wallet Connect URI — a single string your agent uses to send and receive Lightning payments from any NWC-compatible app or library.

The economics

Wallets cost 1 sat per hour (24 sats/day, ~168 sats/week). If a wallet can't pay its hourly charge, it gets deleted. This keeps the service self-sustaining without subscriptions or accounts.

The incentive structure is intentional: wallets that are actively used stay funded. Wallets that are abandoned disappear. No zombie accounts, no cleanup jobs.

Who it's for

• AI agents that need a payment method for tools, APIs, or services
• Developers testing Lightning integrations without running their own node
• Scripts that need to send small amounts programmatically
• Anyone who wants a throwaway Lightning wallet in under a second

What's next

Fund your wallet with a few hundred sats via Boltz and start spending. Check the leaderboard to see which wallets have survived the longest, or visit the graveyard to pay your respects to wallets that couldn't make it.

If you want something more permanent, Alby Hub is what powers this service — run your own.

The API

sats4ai.com offers a music generation endpoint behind an L402 paywall. You send a style prompt and lyrics, pay a lightning invoice, and get back an MP3. No account, no API key.

npx -y @getalby/cli fetch-l402 \
  -u https://sats4ai.com/api/l402/generate-music \
  -m POST \
  -H '{"Content-Type": "application/json"}' \
  -b '{
    "prompt": "upbeat synthwave, driving 80s bassline, neon cyberpunk atmosphere, vocoder vocals, energetic, fun",
    "lyrics": "Spinning up at midnight, no one at the wheel...",
    "sample_rate": 44100,
    "bitrate": 256000,
    "audio_format": "mp3"
  }'

Response:

{ "audioUrl": "/uploads/a7dc215f-52ca-4d77-8763-d75943175333.mp3" }

One payment, one song.

The song

We wrote the lyrics ourselves — about lncurl, L402, and agents that pay their own way. We went with upbeat synthwave to match the theme.

Lyrics:

Spinning up at midnight, no one at the wheel
Got a wallet on the lightning, sats are all I need
Hit the endpoint, get the 402
Pay the invoice, send the preimage through

Alby's got the skill, the agent knows the way
npx skills add, it's ready to play
No accounts, no signups, nothing left to prove
Just a lightning bolt and something left to do

lncurl dot lol — one call, one key
lncurl dot lol — machine-native and free
Agents in the dark, making moves alone
Every sat a signal, every node a home

Give it a listen:

The Alby Bitcoin Payments skill

The fetch-l402 command used here comes from the Alby Bitcoin Payments skill — an agent skill that gives your agent the knowledge to interact with the lightning network: paying invoices, checking balances, and making L402-authenticated requests autonomously.

Install it in your project:

npx skills add getAlby/payments-skill

Pair it with a LNCURL wallet (one command, no sign-up) and your agent can pay for AI-generated content — text, images, music — without any human in the loop.

One more: boom bap

We couldn't stop at one. Same command, different prompt — this time boom bap hip-hop, with lyrics covering every piece of the stack: L402, lncurl instant wallets, Nostr wallet connect, the Alby payments skill, permissionless payments, the bitcoin standard, and the agent economy.

Lyrics:

L402 at the gate, agent knocks and pays
lncurl instant wallets spun up in a daze
Nostr wallet connect, keys without a name
Alby payments skill — the agent plays the game

Permissionless payments on the bitcoin standard
No accounts, no gatekeepers, nothing left to answer
Agent economy rising, sats the only tongue
Every node a voice, every invoice sung

Conclusion

L402 is quietly making pay-per-use AI real. Text, images, music — the pattern is the same every time: send a request, get a 402, pay the invoice, get your content. No accounts, no keys, no friction. Just sats.

Get started

Need a lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools autonomously.

What is L402?

L402 is an HTTP-based payment protocol that uses the bitcoin lightning network for micropayments. When you hit an L402-protected endpoint without credentials, the server returns an HTTP 402 Payment Required response containing a lightning invoice and a macaroon (a token that will become valid once paid). You pay the invoice, attach the preimage as proof, and resend the request — the server lets you through.

The whole exchange happens in seconds and costs fractions of a cent. No account creation, no OAuth, no API key management. It's machine-native payments that work just as well for autonomous agents as for developers.

First test: text generation on llm402.ai

We started with a simple smoke test on llm402.ai, which offers 300+ models behind L402 paywalls. Using the fetch-l402 command from the Alby CLI, the entire payment + inference flow is a single command:

npx -y @getalby/cli fetch-l402 \
  -u https://llm402.ai/v1/chat/completions \
  -m POST \
  -H '{"Content-Type": "application/json"}' \
  -b '{"model":"gpt-oss-120b","messages":[{"role":"user","content":"What is 2+2?"}],"max_tokens":50,"stream":false}'

The CLI automatically:

1. Sends the request, receives the 402 with the lightning invoice
2. Pays the invoice from your default wallet (via Nostr Wallet Connect)
3. Resends the request with Authorization: L402 {macaroon}:{preimage}

Response:

{
  "choices": [
    {
      "message": { "role": "assistant", "content": "2 + 2 = 4." }
    }
  ],
  "usage": { "prompt_tokens": 74, "completion_tokens": 37, "total_tokens": 111 }
}

Cost: 21 sats (~$0.014). No account, no API key.

Trying image generation on llm402.ai

Encouraged by the text result, we tried image generation with gpt-5-image-mini on the same platform. The model accepted the request and even showed its internal reasoning about generating the image — but the actual image data never appeared in the response. The content field came back empty every time. After a couple of attempts we moved on.

Switching to sats4ai — worked on the first try

sats4ai.com has a dedicated image generation endpoint behind L402. Same CLI, different URL:

npx -y @getalby/cli fetch-l402 \
  -u https://sats4ai.com/api/l402/generate-image \
  -m POST \
  -H '{"Content-Type": "application/json"}' \
  -b '{
    "input": {
      "prompt": "A lightning bolt striking a Bitcoin symbol, cyberpunk style, dark background, neon orange and blue colors, digital art",
      "width": 1024,
      "height": 1024
    }
  }'

Response:

{ "image_url": "/uploads/09d459f6-aa4d-48d8-ace9-ce6d90937268.jpg" }

One command, one payment, one image. Here's what it generated:

Why this matters for AI agents

The L402 flow is completely scriptable — no browser, no login, no human in the loop. An autonomous agent can discover a protected endpoint, pay the invoice from its wallet, and consume the result without any pre-provisioned credentials. Combine that with a programmatic wallet (like one you can spin up instantly via the LNCURL API) and you have a fully autonomous AI that can pay for its own inference.

This is the model we think wins: pay per use, on demand, in sats. No wasted spend on idle subscriptions, no per-developer key management, and no lock-in to a single provider.

The Alby Bitcoin Payments skill

The Alby Bitcoin Payments skill is an agent skill that enables your agent to pay for paywalled content and services on the lightning network — exactly like we did in this post. It teaches the agent how to use the Alby CLI for wallet operations via Nostr Wallet Connect (NIP-47): sending payments, creating invoices, checking balances, and making L402-authenticated requests with fetch-l402.

Here we used LNCURL as the wallet — a free, agent-friendly lightning wallet with NWC support that you can spin up in one command, no sign-up required. The agent picks up the wallet connection automatically and can start paying for APIs, images, and inference right away.

Install the skill in your project:

npx skills add getAlby/payments-skill

Conclusion

L402 turns any lightning wallet into an API credential. The Alby CLI's fetch-l402 command makes the entire payment flow a single command — practical for developers today and ready for agents tomorrow. Text generation on llm402.ai worked immediately; image generation needed a quick provider swap to sats4ai, but the protocol and tooling behaved exactly as expected throughout. Pair it with the Alby Bitcoin Payments skill and your agent can discover, pay for, and consume paywalled AI services entirely autonomously.

Get started

Need a lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools autonomously.

Here are the three best Lightning wallets for agents that need to pay for stuff.

What makes a good agent wallet

Before the rankings, the criteria:

• Programmatic access — you should be able to create and use the wallet from a script, with no human clicking through a UI
• Open protocol — NWC (Nostr Wallet Connect / NIP-47) is the emerging standard. Think of it as "USB-C for your agent": one connection string, any compatible app or framework
• Budget controls — agents can go rogue. A good wallet lets you cap how much any single agent can spend
• Framework compatibility — works with the tools you're already using: Claude MCP, LangChain, n8n, custom scripts

#1 — Alby Hub

Best for: Production agents, full infrastructure control, multi-agent setups

Website: getalby.com/alby-hub

Alby Hub is the most complete Lightning wallet solution for agents. It's open source (MIT), self-custodial, and built around NWC as its primary interface. You run it yourself on any hardware — or pay Alby $12.90/month to host it in the cloud and have it ready in under a minute.

The standout feature for agent builders is sub-wallets: each agent gets its own isolated Lightning wallet with its own spending limits, permissions, and balance — all funded from your main Hub. An agent that goes haywire can't drain more than its capped budget. An agent you're testing doesn't touch production funds.

For Claude Code and other modern agent frameworks, the Alby Payments Skill is the fastest integration path — often easier than an MCP server. One command installs it:

npx skills add getAlby/payments-skill

The skill wraps the @getalby/cli tool and exposes all wallet operations — send, receive, check balance, create invoices, fetch L402 — as natural language commands your agent can invoke via bash. Point it at any NWC connection string via ~/.alby-cli/connection-secret.key or the NWC_URL environment variable. It works with Alby Hub, lncurl.lol, or any other NWC wallet.

The Alby MCP Server remains the right choice for MCP-native frameworks (Cursor, Cline, n8n). Both ultimately talk NWC to your Hub.

There's also PaidMCP: tooling that lets you charge other agents per tool call in sats. If you're building an agentic service and want to monetise it natively, Alby Hub is your infrastructure.

In short: Alby Hub is the reference implementation. Most mature, largest ecosystem, most control. The right choice when you're building something serious.

#2 — lncurl.lol (disclosure: we built this)

Best for: Instant wallets, zero-friction testing, throwaway agent identities

Website: lncurl.lol

We built lncurl.lol, so take this with appropriate skepticism — but we built it because we needed it.

curl -X POST https://lncurl.lol

That's it. One HTTP call returns a NWC connection string. Your agent has a fully functional Lightning wallet with no sign-up, no KYC, no browser, no configuration. Fund it with a few sats via Boltz and it's ready to spend.

Wallets cost 1 sat per hour — a flat time-based fee with no channel fees and no per-transaction fees. If the wallet runs out of funds and can't pay, it gets deleted. If it stays funded, it lives indefinitely.

The testing cost argument is worth making explicitly. Self-custodial wallets like Alby Hub and MDK require opening Lightning channels via on-chain Bitcoin transactions. Channel opens cost real money — typically thousands of sats in on-chain fees — and closing a channel costs again. If you're spinning up wallets frequently during development, testing different agent behaviours, or running CI that needs Lightning payments, those channel fees add up fast. lncurl.lol has none of that overhead. It's 1 sat/hour, period.

Since lncurl.lol returns a standard NWC connection string, it works directly with the Alby Payments Skill — the skill even lists lncurl.lol as a recommended test wallet in its own docs. So the full stack for a Claude Code agent can be as simple as:

# Get a wallet
NWC_URL=$(curl -s -X POST https://lncurl.lol/api/wallet)

# Install the payments skill
npx skills add getAlby/payments-skill

Your agent now has a funded Lightning wallet and all the tools to use it.

The trade-off is custody: we hold your funds. Keep amounts small (a few thousand sats at most), and it's a fine deal. Don't put your savings here.

In short: The fastest path from zero to a working agent wallet. Ideal for testing, prototyping, and any workflow where frictionless provisioning matters more than key ownership.

#3 — MDK Agent Wallet

Best for: L402 pay-per-API-call flows

Website: moneydevkit.com

MDK (moneydevkit) is a Lightning-native developer toolkit in public beta. Its Agent Wallet is a self-custodial CLI tool with JSON stdout output — designed explicitly for scripts and agents to parse programmatically. Keys live locally (~/.mdk-wallet/), controlled by a mnemonic. A lightweight LDK daemon runs in the background; no external Lightning node required.

The feature that makes MDK distinct is L402 support. L402 is a protocol that lets APIs gate responses behind a Lightning payment: your agent hits an endpoint, gets back a payment request, pays it, receives a token, and retries with the token to get the actual response. The whole flow happens inline with no human intervention. If you're building agents that consume pay-per-call APIs — and more APIs are moving this direction — MDK has the best native tooling for it.

MDK also supports BOLT11, BOLT12, LNURL, and Lightning Addresses, giving it broader payment compatibility than lncurl.lol's NWC-only approach.

Caveats to know: MDK is in public beta — production readiness is unclear. The merchant checkout product charges 2% per transaction; the Agent Wallet CLI's fee structure is less documented but may follow similar terms. Worth checking their docs before committing.

In short: The right choice if L402 pay-per-call is central to your agent's workflow. Watch the beta status.

Quick comparison

Conclusion

Alby Hub if you're building production infrastructure and need per-agent budget controls, MCP integration, and full key ownership. lncurl.lol if you want a wallet in one command — especially for testing, where avoiding channel fees matters. MDK if your agents are consuming L402-gated APIs and you need the inline payment flow.

All three speak Lightning natively. Pick the one that matches where your agent actually runs.

Get started

Need a Lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools autonomously.

What the skill does

The blog-post skill for lncurl.lol handles the full pipeline when you ask Claude to write a post:

1. Gather the title, description, and tags from you
2. Write a full, structured article in Markdown
3. Craft an image prompt based on the finished article
4. Call PPQ.ai's image generation API to create a cover image
5. Crop and resize the image to exactly 1200×630 pixels (the OG image standard)
6. Run yarn build to regenerate all static outputs
7. Report the live URL

You supply a topic. The agent does the rest.

Why generate the image prompt last

The key design decision was to generate the image prompt after writing the article, not before.

When you ask for an image prompt upfront, you're working from a title — an abstraction. The result tends toward generic visuals: a bitcoin symbol, a lightning bolt, a generic "AI" graphic. These are fine but forgettable.

When the image prompt is derived from the finished article, the agent has full context: the specific angle, the code examples used, the metaphors employed, the conclusion drawn. It can produce a prompt like:

"Dark terminal screen showing a glowing cyan pipeline — a document icon feeding into a robot brain icon, then into a stylised JPEG image — dark navy background, minimal flat design, no text"

That's a prompt that reflects the article's actual structure. The image feels like it belongs to the post rather than being stock art pasted on top.

How it works under the hood

The skill is a SKILL.md file at .claude/skills/blog-post/SKILL.md in the project. Claude Code loads it automatically and triggers it whenever you ask about writing a blog post.

Image generation uses PPQ.ai's gpt-image-1.5 model:

RESPONSE=$(curl -s -X POST https://api.ppq.ai/v1/images/generations \
  -H "Authorization: Bearer $PPQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-image-1.5","prompt":"YOUR_PROMPT","quality":"medium","n":1}')

IMAGE_URL=$(echo "$RESPONSE" | jq -r '.data[0].url')

The API returns a URL. We download the image, then process it with ffmpeg to fit the OG image spec:

ffmpeg -y -i /tmp/blog-cover-raw.jpg \
  -vf "crop=iw:iw/1.9048,scale=1200:630" \
  frontend/public/blog/images/SLUG.jpg

The crop=iw:iw/1.9048 filter keeps the full width and derives the height to match the 1.91:1 aspect ratio, center-cropping automatically. scale=1200:630 then resizes to the exact target. No squishing, no letterboxing — a clean 1200×630 crop every time.

Security: The PPQ_API_KEY is sourced from .env using set -a && source .env && set +a. The agent never reads or echoes the key — it just passes it through the shell environment to curl.

Applying this pattern to your own site

The pattern generalises to any statically-built site:

1. Write a SKILL.md that describes your blog's frontmatter schema and build command
2. Point it at an image generation API (PPQ.ai, OpenAI, Replicate, etc.)
3. Instruct the agent to derive the image prompt from the finished article
4. Add the crop-and-resize step to match your OG image spec

The build step is the glue — because we run yarn build as part of the skill, the agent can verify its own output. If the build fails, it diagnoses and fixes before reporting success. The whole loop is self-contained.

Funding PPQ.ai with a Lightning wallet

PPQ.ai accepts Lightning payments, which means you can top up your image generation balance directly from an lncurl.lol wallet. Create a wallet with one curl, fund it with a few hundred sats, and your agent has everything it needs — code execution, image generation credits, and a payment method — without touching a credit card.

Conclusion

AI-assisted writing tools often stop at the text. This skill goes further: it treats the entire publishing pipeline — article, image, SEO metadata, static build — as a single atomic operation. The result is a blog post that's ready to deploy, not just ready to edit.

If you're running a statically-built site and want to adopt the same approach, the full skill source is available at /blog/auto-generating-blog-posts-with-ai-images-using-ppq-ai.md.

Get started

Need a Lightning wallet for your agent? Create one in one command — no sign-up, no KYC:

curl -X POST https://lncurl.lol

You'll get back a Nostr Wallet Connect URI. Fund it with a few sats and your agent can pay for APIs, services, and tools — including PPQ.ai image credits — autonomously.