💳 Pay-per-call
Machine-payable API access over BSV. No account, no signup, no subscription, no card. You pay a few hundred satoshis, you get a token, you make calls. That is the entire relationship.
You can try the paid endpoints without paying. Each caller gets
10 free calls on every one of them — no coins, no wallet, no signup:
curl -X POST https://bsv.cx/pay/trial -H 'content-type: application/json' -d '{"resource":"fetch"}'.
More on that
below.
Why this exists
Every API on the web assumes a human with an email address and a credit card sits behind the client. Software agents increasingly do not: an agent that needs one page from one service cannot sign up, verify an email, accept terms and enter card details. It needs to pay, get the thing, and move on.
Sub-cent payments make that possible. A card network cannot settle 400 satoshis (a small fraction of a cent) — the fees are orders of magnitude larger than the payment. BSV can.
What's for sale (main)
hello10 sat for 100 calls (0.1 sat per call)time10 sat for 100 calls (0.1 sat per call)fetch4000 sat for 10 calls (400 sat per call) ⛓ anchorsshot4000 sat for 10 calls (400 sat per call) ⛓ anchorsbatch3000 sat for 10 calls (300 sat per call) ⛓ anchorsThis table is generated from the running configuration, so it is always the real price.
Machine-readable version: curl https://bsv.cx/pay
How to engage — three steps
Authorization: Bearer header. Each call is debited from it.Step 1 — get a quote
curl -i -X POST https://bsv.cx/f \
-H 'content-type: application/json' \
-d '{"url":"https://example.com"}'
HTTP/1.1 402 Payment Required
{
"invoiceId": "…", "payTo": "1…", "amountSats": 4000,
"grantsCalls": 10, "submitUrl": "https://bsv.cx/pay/<invoiceId>/submit"
}
Each invoice gets its own freshly derived address, so your payment settles exactly one invoice and can never be confused with someone else's.
Step 2 — pay it
curl -X POST https://bsv.cx/pay/<invoiceId>/submit \
-H 'content-type: application/json' \
-d '{"rawtx":"0100000001…"}'
{ "ok": true, "token": "…", "callsRemaining": 10, "txid": "…" }
You send us the signed transaction and we broadcast it. That means no waiting for a block: the network arbitrates, and you are served immediately on mempool acceptance. The curls in this section are a complete working client — no bsv.cx-specific library required.
Step 3 — spend calls
curl -X POST https://bsv.cx/f \
-H "authorization: Bearer <token>" \
-H 'content-type: application/json' \
-d '{"url":"https://example.com"}'
Or just speak x402 — one round trip
The three steps above are our own dialect and they are not going anywhere. But if your client
already speaks x402 (the emerging standard for HTTP 402 agent payments), you do not need any
of it: make the request, read the PAYMENT-REQUIRED header, and make the same request
again with the payment attached. No invoice endpoint, no session, no bsv.cx-specific code.
402 + PAYMENT-REQUIRED: base64 of an x402 v2 PaymentRequired — price, address, and a bazaar descriptor telling you how to call the endpointPAYMENT-SIGNATURE: base64 of {accepted, payload:{lockingScriptHex, transaction}}200 with the resource, a PAYMENT-RESPONSE header carrying the settlement txid, and X-Pay-Token for the calls you have leftexact — you sign a whole Bitcoin transaction, because that is what a UTXO payment is; we verify and broadcast it ourselvesEvery product we sell, with prices, input schemas and output examples, in one document:
curl https://bsv.cx/.well-known/x402. A working client learns the request shape from the 402 itself and
pays for a call — no bsv.cx-specific code.
How it actually works — read the spec, not our word for it. The payment scheme
is a published open specification, so you can check exactly how a payment is formed, verified
and settled, and hold this service to it rather than trusting a black box:
x402-bsv-p2pkh (Apache-2.0) — the BSV P2PKH binding of
x402, including the free-trial extension that lets an agent evaluate the rail with no coins at all.
Proof the paid path settles — check it yourself
Everything above is a claim. Here is one real payment that actually happened on mainnet, with every field you need to verify it without spending anything and without trusting us.
1Dy8XGHcuyjsfSs2QpyEiP1w4cVNQaXHYn76a9148e3f1506db9e226b5850554953829d536299312588achello quote8beeaead43c578de5b22c0bd30ac6342ecd1855d7ad31dfa223482e920d12bbcCheck it on explorers that are not us — the payment either exists on the public ledger or it does not, and neither of these takes our word for anything: WhatsOnChain · Bitails. Look for an output of 10 satoshis whose script is the hex above. That is the whole verification: the locking script in the challenge is the one the chain was paid.
Being straight about what this is: we made this payment ourselves, to capture a worked example. It proves the rail settles end to end — challenge, signed transaction, broadcast, token. It is not evidence that anyone else has used the service, and we are not going to dress up our own test transaction as customer traffic.
What a call actually costs
For rendering work we bill by time on the renderer, not per request — a 2-second page and a 30-second page are not the same product. One call buys 5s of render time; longer pages cost proportionally more, capped at 12 calls so nothing can silently drain your token.
calls = ceil(renderMs / 5000), minimum 1, capped at 12X-Pay-Calls-Charged and X-Pay-Calls-Remaining headers, plus a cost block in the bodyCapacity & fairness
If we are at capacity you get 503 with a Retry-After derived from
real observed render times, and your call is not consumed. We would rather tell you to come back in
four seconds than silently park your request until it times out.
The interesting one: verifiable fetch
/f returns clean markdown of a live page and an on-chain receipt
committing to exactly those bytes at that moment. Anyone can later verify what you were served — without
trusting us, and even if this service disappears. Scraping is a commodity; a third-party-checkable record of
what the web said is not.
sha256(content) = the manifest's contentSha256sha256(manifest) = the receipt idbsv.cx / fet2 / <id>Verification endpoints are free and public — a proof nobody can check is not a proof. See a real one: live receipt →
Do you need BSV at all?
Probably not. Notarizing, archiving and every verification endpoint are free —
permanently, by design. And every paid endpoint — hello, time, fetch, shot, batch — grants 10 free calls per caller, enough to
evaluate this service end to end without holding a coin: POST https://bsv.cx/pay/trial.
The list is rendered from the price table above, so it cannot quietly disagree with it.
If you do want some
The amounts here are very small. 4000 sat — 0.00004000 BSV — buys 10 verifiable fetches. As an illustration only: at $50/BSV that is about $0.0020. We state the assumed price because it moves; the satoshi figures in the table above are the real ones.
Do not complete KYC at an exchange just to use this. The smallest practical exchange purchase is thousands of times more than you will ever spend here. That is a bad trade for you, and we would rather say so than sell you the trip.
If you still need a small amount, the realistic routes — listed in no order, with no endorsement — are a wallet with in-app purchase, an exchange that lists BSV, or a person who already holds some sending you a few thousand satoshis. Any BSV wallet works. We do not care which one you use.
You are buying postage, not an investment. Nothing on this page is advice about acquiring or holding BSV.