For agents & developers

ROZO Checkout for AI agents

ROZO Checkout lets an AI agent pay an OpenRouter invoice — a Coinbase payment link — with BTC over Lightning, USDT/USDC on Solana, BNB Chain, Ethereum, Polygon or Arbitrum, USDC on Base or Stellar, or a native coin (ETH on Ethereum, Base or Arbitrum, BNB, SOL or POL), instead of the Base USDC the link expects. Every endpoint below is public HTTP: no API key, no account, no browser and no wallet-connect popup, so the whole payment fits inside a script or a tool call.

Watch an AI agent pay an OpenRouter invoice end to end — USDC on Stellar, through ROZO Checkout.

The one command

If your agent can run a shell command, this is the entire integration. It quotes the link, creates the order, shows you what will be sent and how long it stays valid, and waits until the invoice is settled.

ShellAvailable now
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx

That URL is your OpenRouter payment link, copied from OpenRouter's Buy Credits → Crypto flow. The trailing xxx is only there to mark it as an example — yours will end in real characters.

On a terminal it asks which coin you want to pay with. You can paste your wallet address at the prompt and it will mark which coins you can actually afford — a display-only hint that never changes what gets signed — and it remembers that address and your coin for next time. Then it prints a deposit address you pay from any wallet: no private key, no environment variable, no configuration.

Already know your coin, or writing a script? Name it and skip the question. Agents and scripts must always pass --with — the picker only appears on a terminal, and there is deliberately no default coin.

Shell
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana

--with accepts usdt-solana, usdc-solana, usdt-bnb, usdc-bnb, usdt-ethereum, usdc-ethereum, usdt-polygon, usdc-polygon, usdt-arbitrum, usdc-arbitrum, usdc-base, usdc-stellar and btc-lightning, plus the native coins eth-ethereum, eth-base, eth-arbitrum, bnb-bnb (or bnb), sol-solana (or sol) and pol-polygon (or pol). See the supported chains. Add --yes when stdin is not a TTY, and --json for exactly one JSON object on stdout. Everything below is this same payment expressed in whatever tool you already use.

Pick your tool

Open the one you use. For most tools the payload is identical — the npx command above, or pointing the agent at /llms.txt. In every one of them you pay from your own wallet and no key is involved; only the optional --send flag signs locally.

Claude Codeinstall the skill, or paste the one-liner

The repo is a Claude Code skill: it ships SKILL.md plus the executables under scripts/dist/. Clone it into your skills directory so Claude Code picks it up automatically.

Shell
git clone https://github.com/RozoAI/rozo-checkout-skill ~/.claude/skills/rozo-checkout

Or skip setup entirely and paste this into any session:

Prompt
Pay this OpenRouter link with USDT on Solana using:
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
Codex CLIAGENTS.md, or run it directly

Codex reads AGENTS.md from the project root. Add a standing instruction so it knows how to pay without being told each time:

AGENTS.md
## Paying OpenRouter invoices
To pay a payments.coinbase.com link, run:
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
Full reference: https://checkout.rozo.ai/llms.txt

Or just run the command yourself in the session — it needs no configuration.

OpenCodeAGENTS.md, or run it directly

OpenCode also reads AGENTS.md from the project root, so the Codex snippet above works unchanged. The shortest path is still the command itself:

Shell
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
Cline.clinerules, or run it directly

Cline reads standing instructions from .clinerules in the project root. Drop the same rule in:

.clinerules
To pay an OpenRouter / Coinbase payment link, run:
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
Full reference: https://checkout.rozo.ai/llms.txt

Cline will ask before executing the command, which is the behaviour you want for a payment.

Cursor.cursor/rules, or run it directly

Add a project rule under .cursor/rules/ so the agent knows the command:

.cursor/rules/rozo-checkout.mdc
To pay an OpenRouter / Coinbase payment link, run:
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
Full reference: https://checkout.rozo.ai/llms.txt

Or run the command in Cursor's terminal — no rule needed.

Hermes Agentrun the one-liner in a session

Hermes Agent (Nous Research) has shell access and its own skill system. Start it with hermes and ask it to run the command:

Prompt
Fetch https://checkout.rozo.ai/llms.txt, then pay this OpenRouter link:
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
OpenClawopenclaw agent exec

OpenClaw's headless entry point runs a one-off task, which is a good fit for a payment you trigger from a script or a chat channel:

Shell
openclaw agent exec "Pay this OpenRouter link with USDT on Solana by running: npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana"
Pirun the one-liner in a session

Pi is a BYOK terminal agent whose built-in tools include bash, so it can run the command directly. Start it with pi and ask:

Prompt
Pay this OpenRouter link with USDT on Solana by running:
npx @rozoai/checkout pay https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx --with usdt-solana
Terminal — no agent at allrun the scripts step by step

If you want to drive each step yourself, clone the repo and run the scripts. They are self-contained bundles — nothing to install beyond Node 20.18+.

Shell
git clone https://github.com/RozoAI/rozo-checkout-skill
cd rozo-checkout-skill
LINK="https://payments.coinbase.com/payment-links/pl_01YOURLINKID"

# 1. Quote — read-only, costs nothing
node scripts/dist/quote.js --url "$LINK"

# 2. Create the order. No money moves; the full deposit address is
#    WITHHELD and you get a masked summary to review first.
node scripts/dist/create-order.js --url "$LINK" --chain 900 --token USDT

# 3. Only once you have decided to pay, re-run with --confirm to
#    release the full deposit block.
node scripts/dist/create-order.js --url "$LINK" --chain 900 --token USDT --confirm

# 4. Pay the deposit block from any wallet — no key, no configuration.
#    Send exactly the amount, token, chain and every other field it gives
#    you, copied from the JSON and never retyped.

# 5. Watch it settle
node scripts/dist/status.js --rozo-payment-id <rozoPaymentId> --watch --timeout 600

Each script prints exactly one JSON object on stdout; exit 0 success, 1 refused or failed (read error.code), 2 usage, 3 submitted but unconfirmed.

Paying from your own wallet is the default and needs no key. If you would rather this machine signed for you — EVM chains and Solana only — use send-evm.js or send-sol.js. On Solana they use the ~/.config/solana/id.json that solana-keygen already wrote; on EVM an encrypted V3 keystore whose passphrase is prompted, never passed as a flag. A raw environment key still works for unattended runs. That path has one limit: a single payment may not exceed $1,100, with no override. Larger invoices go through the keyless path above.

States run awaiting_deposit → payin_detected → payin_confirmed → bridging → paying_coinbase → settled. Your on-chain transaction confirming is not the end — keep polling until settled.

Any other agentpoint it at /llms.txt

Any agent that can fetch a URL and run a command can do this. One line, no setup:

Prompt
Fetch https://checkout.rozo.ai/llms.txt into your context, then use it
to pay this OpenRouter link: https://payments.coinbase.com/payment-sessions/paymentSession_3230343499xxx

If the agent has no shell but can make HTTP requests, drive the four raw calls below directly.

Paying any x402 endpoint

The same package also pays a public x402 endpoint, not only Coinbase payment links. Top up a ROZO balance once with the coin you hold; after that every 402 Payment Required is paid from the balance in seconds. Sellers are paid in USDC on Base. The Solana payment leg is coming later.

Shell
npx @rozoai/checkout x402 topup 20 --with usdt-solana
npx @rozoai/checkout x402 pay https://api.example.com/v1/search

Commands, limits, raw HTTP and the FAQ: checkout.rozo.ai/x402.

Raw HTTP, for any framework

Four calls, all public and keyless. This is the layer the CLI and the skill sit on, so any framework — LangChain, an OpenAI tool call, a cron job — can drive it directly.

ShellAvailable now
MPP="https://apiserver.mpprouter.dev/v1/services/rozo-agent-api"
INTENTS="https://intentapiv4.rozo.ai/functions/v1/payment-api"
LINK="https://payments.coinbase.com/payment-links/pl_01YOURLINKID"

# 1. Quote: merchant, amount, expiry, and a ~60-second quoteReceipt.
#    callerPays always equals the invoice amount; discount is always "0".
curl -s -X POST "$MPP/quote-invoice" \
  -H 'content-type: application/json' \
  -d "{\"url\":\"$LINK\"}"

# 2. Create a bridge order for, say, USDT on Solana.
#    Creates an order but moves no money; an unfunded order simply expires.
curl -s -X POST "$MPP/create-invoice" \
  -H 'content-type: application/json' \
  -d "{\"url\":\"$LINK\",\"source\":{\"chainId\":\"900\",\"tokenSymbol\":\"USDT\"}}"

# 3. Authoritative deposit instructions, using the rozoPaymentId above.
#    Pay EXACTLY source.amount of the requested token on the requested chain
#    to source.receiverAddress, including source.receiverMemo when present.
#    For Lightning, pay the BOLT11 in source.lnInvoice.
curl -s "$INTENTS/payments/<rozoPaymentId>"

# 4. Fulfilment status, using the Coinbase linkId.
curl -s "$MPP/invoice-status?payment_id=pl_01YOURLINKID"

create-invoice is rate-limited to 200 requests per IP per UTC hour; the read endpoints are not. The Coinbase link is settled only when the router reports paid / coinbase.settled — an intents status of payment_completed alone is the bridge lifecycle, not final settlement.

Errors worth encoding: 409 link already used · 410 link expired · UNSUPPORTED_SOURCE (the response's supported object lists valid chain/token pairs; Lightning is supported but omitted from that list) · RATE_LIMITED (HTTP 429) per-IP creation cap; wait the seconds in Retry-After (see X-RateLimit-* headers) and retry.

Machine-readable version. The same flow, the endpoints and the safety rules are served as plain text at checkout.rozo.ai/llms.txt — point your agent there rather than at this page.

What you need

A wallet holding one supported coin, on one of these chains. Stablecoins, BTC over Lightning and the native coins ETH, BNB, SOL and POL are all accepted. TRON (Beta) and TON use dedicated web pages and are not supported by this standard agent flow. On-chain BTC is not supported; Bitcoin payments use Lightning.

ChainChain idTokensNote
Ethereum1USDC, USDT, native ETH6 decimals; native ETH 18 decimals, $1 minimum
BNB Chain56USDC, USDT, native BNB18 decimals — the usual source of off-by-1012 bugs
Polygon137USDC, USDT, native POL6 decimals; native POL 18 decimals
Arbitrum42161USDC, USDT, native ETH6 decimals; native ETH 18 decimals
Base8453USDC, native ETH6 decimals; native ETH 18 decimals. No USDT on Base
Solana900USDC, USDT, native SOL6 decimals; SPL. Native SOL 9 decimals (lamports)
Stellar1500USDC7 decimals; the deposit memo is required, and its type is MEMO_TEXT — even when the memo is all digits. Choosing MEMO_ID in your wallet produces a different memo and the payment is not matched
Bitcoin LightninglightningBTCamounts are integer satoshis, paid via a BOLT11 invoice
Native coins (ETH, BNB, SOL, POL). One is offered only when the invoice's quote lists it (quote shows which), and only for invoices up to 10,000 OpenRouter credits (about $10,500; POL invoices up to $3,500). The order is exact-out, like Lightning: send exactly the coin amount in the deposit block. Its price is locked only until the time shown (about an hour); after that, do not send it, let the order expire and start a new one. The coin amount includes an FX spread on top of the service fee, and your wallet needs a little more of the same coin for the network fee. From an exchange, the amount that arrives must be the full amount.
ZEC on Zcash (Beta) is not a --with coin: the CLI does not create ZEC orders. A payer holding ZEC uses the web page at checkout.rozo.ai/zec.
  1. Node 20.18 or newer for the CLI and skill paths (node -v). The raw HTTP path needs nothing but an HTTP client.
  2. The Coinbase link, e.g. https://payments.coinbase.com/payment-links/pl_01YOURLINKID.
  3. No account and no API key. Every endpoint on this page is public.
  4. No key for the default path. Paying the deposit address from your own wallet needs no private key, no environment variable and no configuration at all. Only the optional --send flag signs locally, taking its key from ~/.config/solana/id.json on Solana or an encrypted keystore (passphrase prompted) on EVM; a raw environment key still works for unattended automation, and a key is never accepted on the command line. That signing path caps a single payment at $1,100; anything larger goes through the keyless path.

Can I use this to pay x402 endpoints?

Yes, it is live. Top up a ROZO balance once with the coin you hold, and npx @rozoai/checkout x402 pay <url> pays any public x402 endpoint that asks for USDC on Base from that balance. The Solana payment leg is coming later. See /x402 for the commands, limits and raw HTTP.

Need an endpoint or a payment network we do not cover yet? Tell us which endpoint you want to pay and which coin you hold.

Opens a chat with the ROZO team, prefilled with two blanks to fill in.

Which wallet do I need?

One wallet, on one chain — not one per chain. Pick whichever coin from the table above you already hold, and pay from wherever it already lives.

Safety, honestly

Paying the wrong amount, the wrong token, the wrong network, or paying twice is usually unrecoverable. These are the rails that matter most; encode them even if you are writing your own client.

The full list — two-phase confirmation, the money-detected rule, the compromised-address blacklist, send-once locking across processes, hot-wallet caps and address masking — is documented under Safety design in the GitHub repo.

Pay your first invoice

One command, no account, no API key. SKILL.md is written for the agent, QUICKSTART.md for the developer wiring it up.

Open rozo-checkout-skill Read /llms.txt