Strike API vs ln.bot for Lightning APIs

Strike's API works on a verified Strike account. It receives bitcoin over Lightning or on-chain, prices requests in bitcoin, US dollars, euros, pounds, Australian dollars or USDT, converts between currencies, and moves money to and from bank accounts. ln.bot has none of the fiat side. It creates Lightning wallets for software by API call, without an identity check, and gives each wallet its own Lightning address, key and MCP server.

Checked on 23 October 2026: the Strike details below come from Strike's API docs, support pages and announcements, linked where they appear.

Identity comes first on Strike

To use the Strike API you need a Strike account, and every account goes through identity verification: an individual in the Strike app, a business by verifying its owners and operators. API keys are made in the Strike dashboard and act on that one account. The API reference has no call that creates further accounts or wallets. To work with other people's balances, OAuth Connect lets Strike users sign in to your app and authorise it, and each of them is a verified Strike user as well.

That model fits an app whose users are people. It is awkward for software that needs a balance of its own: an agent on Strike spends from your verified account, alongside everything else in it.

On ln.bot, an account is one unauthenticated call (see the quickstart) and each wallet is another, so a program can create a wallet for every agent it runs:

from lnbot import LnBot

ln = LnBot(api_key="uk_...")

wallet = ln.wallets.create()  # no arguments: the name is generated
key = ln.wallet(wallet.wallet_id).key.create().key  # wk_..., reaches this wallet only

print(wallet.address)  # a random address, such as x4k7m2@ln.bot

Give each agent its wallet key, or connect its MCP client to https://api.ln.bot/v1/wallets/{walletId}/mcp. The MCP tools can spend the whole balance, so fund each wallet with only what that agent may spend.

Receiving a payment

Both take one call. A Strike receive request returns a BOLT11 invoice, an on-chain address or both. The amount can be in BTC or in a fiat currency, which Strike converts at the current rate:

curl -X POST https://api.strike.me/v1/receive-requests \
  -H "Authorization: Bearer $STRIKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"bolt11": {"amount": {"amount": "0.00001", "currency": "BTC"}, "description": "Report #42"}}'
# the invoice is bolt11.invoice in the response

Strike also documents a two-step flow: create an invoice, then request a quote for it to get the BOLT11.

An ln.bot invoice is always counted in bitcoin's smallest unit, so 1000 here is the same ₿1,000:

w = ln.wallet("wal_...")

invoice = w.invoices.create(amount=1000, memo="Report #42")
print(invoice.bolt11)

Every ln.bot wallet can also be paid at its Lightning address, with no invoice created first.

Where Strike is the better choice

• You need fiat. The Strike API holds fiat balances, converts currencies, and handles bank deposits and payouts. ln.bot works in bitcoin only.
• Your users are people. If they already have Strike accounts, or should, OAuth Connect lets them use their own balances in your app.
• You need a licensed provider, New York included. Strike lists 98 countries, and since March 2026 it holds a BitLicense and a money transmitter licence from New York's Department of Financial Services.
• You want to test without real money. Strike's sandbox runs on testnet bitcoin with simulated cash, set up through Strike support. ln.bot has no test network.

On fees, Strike's support pages say, as of October 2026, that receiving bitcoin is free (converting it to cash on arrival carries a 1% spread) and that a Lightning payment costs the network fee with no extra charge (sending from a cash balance carries a 1% spread). We found no separate price list for the API. What Strike offers companies is on its business page; the older Strike BLACK name no longer appears on Strike's site.

Charging per request from Python

Strike's docs don't mention L402. ln.bot creates and checks L402 challenges, and ships paywall middleware for Express and ASP.NET Core. There is no Python middleware, but a FastAPI dependency does the job with two SDK calls:

from fastapi import Depends, FastAPI, Header, HTTPException
from lnbot import BadRequestError, LnBot

app = FastAPI()
w = LnBot(api_key="uk_...").wallet("wal_...")


def paid(authorization: str | None = Header(default=None)) -> None:
    if authorization and authorization.startswith("L402 "):
        try:
            if w.l402.verify(authorization=authorization).valid:
                return
        except BadRequestError:
            pass  # malformed token: answer with a fresh challenge
    challenge = w.l402.create_challenge(amount=10, description="Forecast", expiry_seconds=3600)
    raise HTTPException(
        status_code=402,
        detail="Payment required",
        headers={"WWW-Authenticate": challenge.www_authenticate},
    )


@app.get("/forecast", dependencies=[Depends(paid)])
def forecast() -> dict:
    return {"forecast": "sunny"}

A client that calls /forecast gets a 402 with a ₿10 invoice, pays it, and retries with the token. verify checks the token's signature, preimage and caveats with one call to ln.bot and keeps no record of it, so a paid token keeps working until it expires (an hour here). If one payment must buy exactly one request, store each payment_hash you accept and refuse repeats; the TypeScript and C# middleware do that for you. The L402 explainer covers the protocol itself.

Side by side

ln.bot is custodial: it runs the Lightning nodes and the channel liquidity, and balances sit on ln.bot's nodes. Treat a wallet as an operational balance for what an agent will spend soon, not as a place for savings.

Using both

Strike and ln.bot meet on Lightning. A business can keep its treasury on Strike, where bitcoin turns into dollars and back, and fund its agents' ln.bot wallets from there:

topup = ln.wallet("wal_...").invoices.create(amount=50_000, memo="Top-up from Strike")
print(topup.bolt11)  # pay this from Strike with a Lightning payment quote, then execute it

Strike pays a BOLT11 invoice through a payment quote that you then execute. Whatever the agents earn can go back the same way, as a Strike receive request paid from the agent's wallet.