> ## Documentation Index
> Fetch the complete documentation index at: https://docs.algovoi.co.uk/llms.txt
> Use this file to discover all available pages before exploring further.

# AlgoVoi Pay

> AlgoVoi Pay (pay.algovoi.co.uk) is a tenant-free, cross-protocol payment rail that charges USDC per call and returns an offline-verifiable signed receipt on every response.

## What is AlgoVoi Pay

[AlgoVoi Pay](https://pay.algovoi.co.uk) 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.

<Note>
  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.
</Note>

## Surfaces

<CardGroup cols={2}>
  <Card title="x402 REST" icon="credit-card">
    `/pay/v1/…` — HTTP 402 challenge, pay, signed receipt. See [x402](/protocols/x402).
  </Card>

  <Card title="A2A (JSON-RPC)" icon="robot">
    `/a2a` — A2A `message/send` + `tasks/get`, with the `a2a-x402` payment-required task state. See [A2A](/protocols/a2a).
  </Card>

  <Card title="Discovery" icon="magnifying-glass">
    `/.well-known/agent-card.json`, `/.well-known/x402`, `/discovery/resources`, `/pay/v1/index`, `/openapi.json`.
  </Card>

  <Card title="Identity" icon="fingerprint">
    `/.well-known/did.json` (`did:web:pay.algovoi.co.uk`) and `/.well-known/jwks.json` — the receipt-signing key, for offline verification.
  </Card>
</CardGroup>

## 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-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).

| Chain                        | Asset                                | Binding mechanism                                                      |
| ---------------------------- | ------------------------------------ | ---------------------------------------------------------------------- |
| [Algorand](/chains/algorand) | USDC (ASA `31566704`)                | transaction **note** carries the challenge token                       |
| [Voi](/chains/voi)           | aUSDC (Aramid-bridged, ASA `302190`) | transaction **note** carries the challenge token                       |
| [Base](/chains/base)         | USDC (`0x8335…2913`)                 | EIP-3009 signed authorization (stock-payable; **optional** nonce weld) |
| Monad                        | USDC (`0x7547…b603`)                 | EIP-3009 signed authorization (stock-payable; **optional** nonce weld) |
| Polygon PoS                  | USDC (`0x3c49…3359`)                 | EIP-3009 signed authorization (stock-payable; **optional** nonce weld) |
| Arbitrum One                 | USDC (`0xaf88…5831`)                 | EIP-3009 signed authorization (stock-payable; **optional** nonce weld) |
| OP Mainnet                   | USDC (`0x0b2C…Ff85`)                 | EIP-3009 signed authorization (stock-payable; **optional** nonce weld) |
| [Stellar](/chains/stellar)   | USDC                                 | **MEMO\_TEXT** carries the challenge token                             |
| [Hedera](/chains/hedera)     | USDC (HTS `0.0.456858`)              | transaction **memo** carries the challenge token                       |
| [Solana](/chains/solana)     | USDC (`EPjFW…Dt1v`)                  | server-derived **reference** account included in the transfer          |
| [Tempo](/chains/tempo)       | USDC.e (Stargate-bridged)            | TIP-20 **transferWithMemo** carries the challenge token                |

<Note>
  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.
</Note>

## How a paid call works

<Steps>
  <Step title="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.
  </Step>

  <Step title="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.
  </Step>

  <Step title="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.
  </Step>

  <Step title="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.
  </Step>

  <Step title="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](/agentic-payment-receipts) and the open
    [receipt verifier](/receipt-verifier).
  </Step>
</Steps>

## 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.

<Note>
  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).
</Note>

## Services

<CardGroup cols={3}>
  <Card title="Receipt verify" icon="receipt">
    Verify a signed receipt / JWS and get a countersigned payable receipt.
  </Card>

  <Card title="RFC 9421 verify" icon="signature">
    Verify an HTTP Message Signature (RFC 9421) with a receipt.
  </Card>

  <Card title="Compliance receipt" icon="shield-check">
    A categorical ALLOW / REFER / DENY compliance receipt.
  </Card>
</CardGroup>

## 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

<AccordionGroup>
  <Accordion title="Do I need an AlgoVoi account to use AlgoVoi Pay?">
    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.
  </Accordion>

  <Accordion title="Which chains can I pay on?">
    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).
  </Accordion>

  <Accordion title="Can a stock x402 client pay the rail?">
    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.
  </Accordion>
</AccordionGroup>