Agent Pay: Payments for AI Agents

Agent Pay lets your AI agent take payments and make payouts, inside limits a human approved once. Atoa enforces those limits on its own servers, so nothing the model does can go past them.

An agent panel feeding the Atoa payment rail, which collects money in from a customer and sends money out to a payee. — Your agent asks; the customer approves in your own UI; Atoa enforces the caps on every payment after that.

How it works

Two calls. Your server creates a payment and sends its nextAction to the browser; your browser shows it.

req = atoa.payment.collect(
    amount={"amount": 45.00},
    order_id="booking-8812",
)
# send req.next_action to your front end

const result = await atoa.payment.collect({
  amount: { amount: 45.00 },
  orderId: "booking-8812",
});
// send result.nextAction to your front end

AtoaUI.mount(nextAction, {                    // fetched from your own endpoint
  container: document.querySelector("#checkout"),
  environment: "sandbox",
  onPaymentCompleted: (e) => showReceipt(e),
});

The same result works without a browser: it carries a pay-link you can send, or a nextAction your agent can read.

Contracts and limits

A contract is a human’s standing approval. They set it up once — a cap per payment, a cap per period, an expiry date, and a direction — and after that your agent can move money inside it without asking again. Atoa checks every charge against the contract on its own servers. A payment over the cap is refused there, not in your code. Two things still need a person: setting the contract up, and Strong Customer Authentication (SCA) on payouts and off-session charges, where the approver enters a one-time code or uses a passkey on Atoa’s page.

Your agent calls Atoa, which enforces consent and caps, then collects money in from a customer or sends money out to a payee.

Collect or send

Decision tree: which way is the money going? Receiving splits on whether the customer is here now — yes is a pay-link (payment.collect, no contract), no is an off-session charge (payment.collect under a COLLECT contract). Sending is payment.send under a SEND contract the owner authorises once.

Customer present → payment.collect returns a pay-link/QR. No contract. → Collect
Customer not present → payment.collect with a contractId, under a COLLECT contract the customer approved once. → Collect
Paying out → payment.send under a SEND contract the account owner approved once. → Send

Get started

Get a sandbox API key from the Atoa dashboard and set it in your environment. Sandbox and production keys are separate.

npm install @atoapayments/agent-pay        # Node 22+

pip install atoa-agent-pay         # Python 3.10+

export ATOA_API_KEY="your_sandbox_api_key"

Create a client and register your agent. Registering twice with the same key returns the same agent, so it’s safe to run on every start. The example generates a signing key in memory — in production, load it from your secrets manager or keep it out of your process entirely with a KMS signer. See Authentication for the other ways to pass credentials.

import atoa_agent_pay

private_key_pem, _ = atoa_agent_pay.generate_es256_keypair()
# api_key is read from ATOA_API_KEY; the public key is derived from private_key_pem.
atoa = atoa_agent_pay.init(environment="sandbox", private_key_pem=private_key_pem)

atoa.agent.register(name="Bookings assistant")   # registers the derived public key

import { createAgentPayClient, generateEs256KeyPair } from "@atoapayments/agent-pay";

const { privateKeyPem } = generateEs256KeyPair();
// apiKey is read from ATOA_API_KEY; the public key is derived from privateKeyPem.
const atoa = createAgentPayClient({ environment: "sandbox", privateKeyPem });

await atoa.agent.register({ name: "Bookings assistant" });   // registers the derived public key

Collect your first payment

Create a payment on your server, then show it. In sandbox, choose the Atoa Test Bank in the checkout and pick the outcome yourself.

req = atoa.payment.collect(
    amount={"amount": 45.00},    # pounds, not pence (45.00 = £45); GBP default
    order_id="booking-8812",     # your own reference
)

print(req.payment_url)           # open this and choose an outcome

settled = atoa.payment.await_settled(req.payment_request_id)
print(settled.status)            # COMPLETED

const req = await atoa.payment.collect({
  amount: { amount: 45.00 },     // pounds, not pence (45.00 = £45); GBP default
  orderId: "booking-8812",       // your own reference
});

console.log(req.paymentUrl);     // open this and choose an outcome

const settled = await atoa.payment.awaitSettled(req.paymentRequestId);
console.log(settled.status);     // COMPLETED

To show the checkout inside your own product instead of sending a link, send req.next_action from your server to the browser and mount it:

Browser

import { AtoaUI } from "@atoapayments/pay-embed";

AtoaUI.mount(nextAction, {                       // fetched from your own endpoint
  container: document.querySelector("#checkout"),
  environment: "sandbox",
  onPaymentCompleted: (e) => showReceipt(e),
});

Full walkthrough: Embedded checkout.

Send your first payout

Create a SEND contract, approve it once at the authorizationUrl, then send. Every payout pauses for the business owner’s approval before money moves. In sandbox the recipient account decides the outcome — list the accounts with atoa.sandboxTestAccounts().

contract = atoa.contract.create(
    type="SEND",
    name="Supplier payouts",
    limits={
        "max_per_payment": 500.00,
        "period_limits": [{"amount": 2000.00, "period": "MONTH"}],
        "valid_to": "2026-12-31T23:59:59Z",
    },
)

print(contract.authorization_url)               # the account owner approves here
atoa.contract.await_active(contract.contract_id)

result = atoa.payment.send(
    contract_id=contract.contract_id,
    payments=[{
        "amount": {"amount": 250.00},
        "beneficiary": {"name": "ACME LTD", "sortCode": "040004", "accountNumber": "12345678"},  # sandbox: settles COMPLETED
        "orderId": "payout-3001",
    }],
)

print(result.next_action.approval_url)          # the owner approves the payout here — in sandbox, open it yourself
atoa.payment.await_decision(result.next_action.approval_id)   # APPROVED → the payment executes

print(result[0].status)                         # COMPLETED

const contract = await atoa.contract.create({
  type: "SEND",
  name: "Supplier payouts",
  limits: {
    maxPerPayment: 500.00,
    periodLimits: [{ amount: 2000.00, period: "MONTH" }],
    validTo: "2026-12-31T23:59:59Z",
  },
});

console.log(contract.authorizationUrl);         // the account owner approves here
await atoa.contract.awaitActive(contract.contractId);

const result = await atoa.payment.send({
  contractId: contract.contractId,
  payments: [{
    amount: { amount: 250.00 },
    beneficiary: { name: "ACME LTD", sortCode: "040004", accountNumber: "12345678" }, // sandbox: settles COMPLETED
    orderId: "payout-3001",
  }],
});

console.log(result.nextAction.approvalUrl);     // the owner approves the payout here — in sandbox, open it yourself
await atoa.payment.awaitDecision(result.nextAction.approvalId);   // APPROVED → the payment executes

console.log(result[0].status);                  // COMPLETED

That’s a payout in sandbox. Every payout and every off-session charge returns an approval step like this one — see Collect and Send.

Next steps

Embedded checkout

Render the payment inside your own product.

Collect — money in

Pay-links, off-session charges, SCA, refunds.

Send — money out

Payouts, SCA, batches, contract limits.

AI agents & tools

Hand the SDK to your model as tools.

Reference

Auth, methods, types, errors, sandbox, go-live.

Download the notebook · run it locally

The full flow as a runnable Jupyter notebook — pip install atoa-agent-pay, add a sandbox ATOA_API_KEY, run.

Overview

Payments

SDKs

Integration

Bank Feed

Developer Tools

Agentic Payments

Agent Pay: Payments for AI Agents

How it works

Contracts and limits

Collect or send

Get started

Collect your first payment

Send your first payout

Next steps

Embedded checkout

Collect — money in

Send — money out

AI agents & tools

Reference

Download the notebook · run it locally

​How it works

​Contracts and limits

​Collect or send

​Get started

​Collect your first payment

​Send your first payout

​Next steps

Embedded checkout

Collect — money in

Send — money out

AI agents & tools

Reference

Download the notebook · run it locally

How it works

Contracts and limits

Collect or send

Get started

Collect your first payment

Send your first payout

Next steps