Pay per request
One signature.
Then the paid thing is returned.
Arcanus hosts a payment helper on Arc. A seller can charge a tiny USDC amount for an API call, a file, or a page. The buyer signs once. We send the payment on-chain and pay the network fee. The money goes to the seller. We never hold it.
How it works
Five steps. No account with us.
- 01
Your app asks for something that costs money.
- 02
The app answers with a small bill: how much USDC, who gets it, and that it is on Arc.
- 03
The buyer signs that bill in their wallet. One signature. No extra approve step.
- 04
Your server asks us to check the signature, then to send it on-chain. We pay the network fee. The USDC goes from the buyer to you. We never hold the money.
- 05
You return the file or the JSON.
Buyer
Signs the bill. Never talks to our helper URL.
Seller
Checks and settles through us, then returns the paid thing.
Us
Pay the network fee. We do not keep the USDC.
Try it
Pay a real 0.001 USDC bill
Connect a wallet on Arc. Sign the bill. If settlement is open, you get a JSON snapshot and a public receipt. This is not VPN, Voice, Mail, Messenger, or Infer checkout. Those still pay the treasury the usual way.
Live money is official Arc USDC. $ARCANUS is the token for the rest of the protocol. It cannot do this one-signature pay yet.
Live demo
Pay 0.001 USDC for a snapshot
This is a real bill on Arc. You sign once. The USDC goes to the protocol receive address. We pay the network fee. You get a JSON snapshot back.
- Price
- 0.001 USDC
- Asset
- Official Arc USDC
- Settle
- Not open yet
- Network
- Arc Mainnet
Signing works. Sending the payment on-chain needs the helper wallet to be set and funded. Until then, the demo will stop after the signature.
For builders
Point your app at our helper
Helper URL:
What it supports
GET /supported
Check a signature
POST /verify
Send it on-chain
POST /settle
If you sell something
When a request has no payment, reply 402 with a PAYMENT-REQUIRED header. When the next request has PAYMENT-SIGNATURE, POST that payload to /verify, then to /settle. If settle works, return the paid content. Put your own 0x in payTo. The buyer never calls our helper.
import { paymentMiddleware } from "@x402/express";
import { HTTPFacilitatorClient } from "@x402/core/http";
import { ExactEvmScheme } from "@x402/evm/exact/server";
const facilitator = new HTTPFacilitatorClient({
url: "https://arcanus.network/api/x402",
});
app.use(paymentMiddleware(
{
"/api/x402/demo": {
accepts: [{
scheme: "exact",
network: "eip155:5042",
amount: "1000",
asset: "0x3600000000000000000000000000000000000000",
payTo: "0xYOUR_RECEIVE_ADDRESS",
maxTimeoutSeconds: 60,
extra: { name: "USDC", version: "2" },
}],
description: "A paid JSON snapshot",
mimeType: "application/json",
},
},
facilitator,
{ schemes: [new ExactEvmScheme()] },
));Network eip155:5042 · USDC 0x3600000000000000000000000000000000000000
If you buy something
Wrap your fetch. The helper on the seller’s server talks to us. Your wallet only signs the bill.
import { wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
const fetchWithPay = wrapFetchWithPayment(fetch, {
schemes: [new ExactEvmScheme(walletClient)],
});
const res = await fetchWithPay("https://arcanus.network/api/x402/demo");
const data = await res.json();Raw HTTP
curl -i https://arcanus.network/api/x402/demo
# 402 comes back with a PAYMENT-REQUIRED header.
# After the buyer signs, send that signature:
curl -i https://arcanus.network/api/x402/demo \
-H "PAYMENT-SIGNATURE: BASE64_PAYLOAD"