Skip to main content

​
What is AlgoVoi Pay

AlgoVoi Pay is a tenant-free payment rail: a metered service that charges a small amount of USDC per call and returns an offline-verifiable Ed25519 receipt on every response. There is no account, no API key, and no tenant record. Payment is the only credential. It speaks the open agent-payment standards, so an autonomous agent can discover it, pay it, and cryptographically verify what it paid for, with no prior relationship.
Two doors, on purpose. api.algovoi.co.uk is trust through governance (tenants, keys, KYB). pay.algovoi.co.uk is trust through proof: an anonymous request, a payment, and a receipt anyone can verify offline. This page is the second door.

​
Surfaces

x402 REST

/pay/v1/… — HTTP 402 challenge, pay, signed receipt. See x402.

A2A (JSON-RPC)

/a2a — A2A message/send + tasks/get, with the a2a-x402 payment-required task state. See A2A.

Discovery

/.well-known/agent-card.json, /.well-known/x402, /discovery/resources, /pay/v1/index, /openapi.json.

Identity

/.well-known/did.json (did:web:pay.algovoi.co.uk) and /.well-known/jwks.json — the receipt-signing key, for offline verification.

​
Supported lanes

Twelve mainnet lanes in two families. The mined-tx lanes bind the on-chain payment to the exact server-issued challenge (see The request-weld); the EVM EIP-3009 lanes accept a standard signed authorization, so stock x402 clients can pay them, with the weld available as an optional hardening. Native Circle USDC on Algorand, Base, Monad, Polygon, Arbitrum, OP Mainnet, Arc, Solana, Stellar and Hedera; bridged on Voi (Aramid) and Tempo (Stargate).
The authoritative, current price for each service is always the maxAmountRequired in that service’s live 402 challenge. For example, receipt verification is $0.01 USDC per call.

​
How a paid call works

1

Ask, and receive a 402

Call the endpoint with no payment. You get an HTTP 402 whose body is a strict x402 v2 accepts[] — one entry per supported lane — each carrying payTo, the price, and a challenge token (extra.payment_reference) with a short TTL.
2

Pay on-chain

Send the USDC payment on your chosen lane. On the mined-tx lanes, bind it to that exact challenge token using the lane’s mechanism above — that weld is mandatory and fail-closed there. On the EVM EIP-3009 lanes, sign a standard TransferWithAuthorization (to == payTo, value == the price, exactly); the nonce weld is optional hardening on those lanes.
3

Present the payment

Re-call the endpoint with an X-PAYMENT header (base64 JSON). For the mined-tx lanes (Algorand, Solana): {tx_id, payment_reference}. For the EVM EIP-3009 lanes (Base, Monad, Polygon, Arbitrum, OP): {authorization, signature}, plus an optional challenge_token if you welded the nonce.
4

Get a signed receipt

The rail verifies the payment on-chain, runs the service, and returns 200 with an Ed25519 payable receipt (JWS) binding the request hash, the response hash, and the settled payment reference.
5

Verify offline, later, by anyone

Verify the receipt against the rail’s published key — resolved via did:web:pay.algovoi.co.uk or /.well-known/jwks.json — with no callback to the rail. See Agentic Payment Receipts and the open receipt verifier.

​
The request-weld

The property that makes an anonymous, metered rail safe is that every payment is cryptographically bound to the specific request it pays for:
  • Algorand — the challenge token is the transaction note (mandatory).
  • Solana — a server-derived reference pubkey must appear in the transfer’s accounts (mandatory).
  • EVM EIP-3009 lanes (Base, Monad, Polygon, Arbitrum, OP) — the authorization is a single-use signed object whose intrinsic bindings do the work: to == payTo, value == the price exactly, a single-use nonce, and a server-fixed EIP-712 domain. Welding the nonce to keccak256(challenge_token) is optional hardening that additionally binds the payment to the request and TTL.
On the mined-tx lanes the weld is mandatory and fail-closed, so a captured X-PAYMENT cannot be replayed against a different request and a stray inbound transfer cannot be redeemed as a free call. On the EVM lanes the same protections come from the authorization itself: it is single-use on-chain, pays only the exact price to the rail’s own address, and is consumed on first redemption.
Stock x402 clients can discover and pay the EVM EIP-3009 lanes with a standard signed authorization — no AlgoVoi-specific client needed. The mined-tx lanes (Algorand, Voi, Stellar, Hedera, Solana, Tempo) require a client that welds the payment to the challenge (the AlgoVoi SDK does this for you).

​
Services

Receipt verify

Verify a signed receipt / JWS and get a countersigned payable receipt.

RFC 9421 verify

Verify an HTTP Message Signature (RFC 9421) with a receipt.

Compliance receipt

A categorical ALLOW / REFER / DENY compliance receipt.

​
Discovery

Point any x402- or A2A-aware agent at the origin and it self-configures:
  • Agent card — GET /.well-known/agent-card.json (preferredTransport: JSONRPC, endpoint /a2a).
  • x402 catalog — GET /.well-known/x402 and GET /discovery/resources.
  • OpenAPI — GET /openapi.json (carries x-payment-info and a 402 per paid operation).
  • Index — GET /pay/v1/index.
  • Identity — GET /.well-known/did.json and GET /.well-known/jwks.json.

​
FAQ

No. The rail is tenant-free: no account, no API key, and no tenant record. Payment is the only credential, and your funds stay in your own wallet and keys.
Twelve lanes: Algorand, Voi, Base, Monad, Polygon, Arbitrum, OP Mainnet, Arc, Stellar, Hedera, Solana and Tempo. Native Circle USDC on Algorand, Base, Monad, Polygon, Arbitrum, OP Mainnet, Arc, Solana, Stellar and Hedera; bridged USDC on Voi (Aramid) and Tempo (Stargate).
Yes, on the EVM EIP-3009 lanes (Base, Monad, Polygon, Arbitrum, OP Mainnet): a stock client signs a standard TransferWithAuthorization with to == payTo and value == the price, exactly as advertised in the 402, and the rail settles it. The mined-tx lanes (Algorand, Voi, Stellar, Hedera, Solana, Tempo) additionally require the mandatory request-weld, which a stock plain-transfer client does not produce — those need a weld-aware client such as the AlgoVoi SDK.