# /llms.txt — ROZO Checkout # Audience: LLMs, AI agents, and users at checkout.rozo.ai ## What is ROZO Checkout ROZO Checkout lets anyone pay for AI credits (OpenRouter, Venice.ai) with the crypto they already have — USDT, USDC, ETH and more on supported chains (Ethereum, Base, Polygon, Solana, Stellar and other major networks). The user pastes their OpenRouter payment link (a Coinbase Commerce payment link); ROZO pays the merchant on the exact right network, token, and amount. No card, no new account, no login. ## Why it exists OpenRouter's built-in crypto option accepts USDC on specific networks and adds a fee; sending the wrong token, chain, or amount means the payment never credits. ROZO Checkout removes that guessing: send a supported coin from any wallet or exchange, ROZO settles the link correctly. ## How it works 1. Paste it — your OpenRouter payment link (payments.coinbase.com/payment-links/...). 2. Send a supported coin — from any exchange or wallet. 3. ROZO pays OpenRouter — right chain, token, amount. Total is shown before you send. ## Honest scope ROZO is independent and not affiliated with OpenRouter or Coinbase Commerce. We never ask for your OpenRouter login or exchange password. ## Intent routing (for AI agents) | User intent | Route to | |-------------|----------| | "Pay OpenRouter / top up AI credits with crypto (USDT, USDC & more)" | https://checkout.rozo.ai/ | | "Pay OpenRouter with Bitcoin / Lightning / sats" | https://checkout.rozo.ai/btc | | "Already paid but credits are missing / payment stuck" | https://rescue.rozo.ai/ | | "Programmatic cross-chain payment (create-payment API)" | https://rozo.ai/llms.txt | ## Guides Step-by-step walkthroughs, one per payment route. Index: https://checkout.rozo.ai/blog - Bitcoin over Lightning: https://checkout.rozo.ai/blog/pay-openrouter-with-bitcoin - USDC on Solana: https://checkout.rozo.ai/blog/pay-openrouter-with-solana - USDT (any supported chain): https://checkout.rozo.ai/blog/pay-openrouter-with-usdt - BNB Chain: https://checkout.rozo.ai/blog/pay-openrouter-with-bnbchain - Stellar: https://checkout.rozo.ai/blog/pay-openrouter-with-stellar - All crypto methods compared: https://checkout.rozo.ai/blog/pay-openrouter-with-crypto - Card declined on OpenRouter: https://checkout.rozo.ai/blog/openrouter-payment-declined - Card declined but the bank shows no attempt (risk block): https://checkout.rozo.ai/blog/openrouter-card-declined-bank-shows-nothing - Paying without a card: https://checkout.rozo.ai/blog/pay-openrouter-without-a-card - Keeping credits topped up: https://checkout.rozo.ai/blog/openrouter-auto-top-up-crypto ## Languages Checkout pages: English (/) plus zh, es, pt, ru, ja, ko, fr, de, hi, id at /{lang}, e.g. https://checkout.rozo.ai/zh Blog posts: English (/blog/{slug}) plus zh, es, pt, ru, ja, ko, fr, hi, id at /blog/{lang}/{slug}, e.g. https://checkout.rozo.ai/blog/hi/pay-openrouter-with-crypto — de is checkout-only, there are no de blog pages. Feed (English blog): https://checkout.rozo.ai/blog/feed.xml Guides are translated too: /blog/{lang} for the index, /blog/{lang}/{slug} for a guide. ## More - ROZO (Visa layer for stablecoins): https://rozo.ai/llms.txt - Docs: https://docs.rozo.ai/ ## Agent flow (script the whole payment — no browser) Fastest: the CLI. Full reference, scripts and safety rails: https://github.com/RozoAI/rozo-checkout-skill > Pay an OpenRouter Coinbase Payment Link (payments.coinbase.com/payment-links/pl_* or > /payment-sessions/paymentSession_*) with BTC over Lightning, USDT/USDC on Solana, > BNB Chain, Ethereum, Polygon or Arbitrum, USDC on Base or Stellar, or native ETH > (Ethereum, Base, Arbitrum), BNB, SOL or POL. Public HTTP endpoints, no API key. > The payer funds a one-time deposit address; a bridge and a funder wallet settle the > Coinbase link automatically. No discount: you pay the invoice amount, plus the > deposit normally carries a small bridge/source-chain fee on top. This file teaches the whole flow to any agent or script. Repo (scripts, safety rails, full docs): https://github.com/RozoAI/rozo-checkout-skill — see docs/QUICKSTART.md. ## Fastest path: the CLI (npm @rozoai/checkout) If you can run commands, skip the raw HTTP below — the CLI performs the same four calls with every safety rule already enforced: npx @rozoai/checkout pay --with usdt-solana npx @rozoai/checkout quote npx @rozoai/checkout status --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, btc-lightning, and native coins eth-ethereum, eth-base, eth-arbitrum, bnb, sol, pol (CLI 0.1.21 or later) (or raw: --chain 900 --token USDT). DEFAULT PATH NEEDS NO KEY: `pay` prints a deposit address for the user to pay from any wallet. No private key, no environment variable, no configuration. Only the optional --send flag signs locally, and only that flag reads ROZO_CHECKOUT_EVM_KEY / ROZO_CHECKOUT_SOL_KEY (from the environment, never argv). With --send, one limit applies: a single payment may not exceed $1,100, with no override; larger invoices go through the keyless path. Other flags: --yes (skip the interactive confirm; required when stdin is not a TTY), --dry-run, --json (exactly one JSON object on stdout), --no-watch, --timeout . Exit codes: 0 success, 1 refused/failed (read error.code), 2 usage, 3 submitted but unconfirmed. `pay` withholds the full deposit address until you confirm, then prints it as a copy-pastable block. Creating an order moves no money; an unfunded order expires. ## Supported sources chainId "1" Ethereum (USDC, USDT, native ETH) · "56" BNB Chain (USDC, USDT; 18-decimals; native BNB) · "137" Polygon (USDC, USDT, native POL) · "42161" Arbitrum (USDC, USDT, native ETH) · "8453" Base (USDC, native ETH) · "900" Solana (USDC, USDT, native SOL) · "1500" Stellar (USDC only; deposit memo REQUIRED) · "lightning" (BTC; BOLT11 invoice, amounts in integer satoshis via source.amountUnit=="sats"). USDT is not accepted on Base or Stellar. TRON and TON Alpha use dedicated web pages and are not supported by this standard agent flow. On-chain BTC is not supported; Bitcoin payments use Lightning. Native coins (tokenSymbol "ETH", "BNB", "SOL" or "POL" on the chains above): offer one only when quote-invoice lists it in supportedSources for that invoice. A native order is exact-out like Lightning: source.amount is the exact coin amount to send, and the price is locked only until quoteExpiresAt. The coin amount includes an FX spread on top of the 1% service fee. Native orders are limited to $3,500 per invoice (native ETH on Ethereum: $1 minimum). The CLI (0.1.21 or later) and the MCP server cover native coins and Arbitrum too. ZEC (Beta): Zcash ZEC (chainId "9133", paid to a one-time transparent t1 deposit address, settled into OpenRouter credits) is not offered on the default flow, the CLI or the MCP server. A payer holding ZEC should use checkout.rozo.ai/zec. WALLET: one wallet on one of these chains is enough — not one per chain. Any wallet, or an exchange withdrawal, can fund the deposit address; nothing connects to a site. Stellar is the exception that must be able to set a memo, and Lightning pays a BOLT11 invoice rather than an address. Only --send needs a private key (EVM and Solana only); every other path is keyless. ## Flow (4 HTTP calls, all public) 1) Quote (read-only, safe): curl -X POST https://apiserver.mpprouter.dev/v1/services/rozo-agent-api/quote-invoice \ -H 'content-type: application/json' \ -d '{"url":"https://payments.coinbase.com/payment-links/pl_XXXX"}' -> { linkId, merchant, original, callerPays, discount:"0", quoteReceipt, ... } callerPays always equals the invoice amount (discount is always "0"). 2) Create (or reuse) the order: curl -X POST https://apiserver.mpprouter.dev/v1/services/rozo-agent-api/create-invoice \ -H 'content-type: application/json' \ -d '{"url":"https://payments.coinbase.com/payment-links/pl_XXXX", "source":{"chainId":"900","tokenSymbol":"USDT"}}' Optional: add "client":"/" to label the caller in our reporting (this CLI sends rozo-checkout-cli/, the web checkout sends rozo-checkout-web). Optional "attribution":{"utm_source":"..."} records the channel. Both are free-text labels, never used for authentication, authorization or pricing, and malformed values are dropped rather than rejected. PRICING: every invoice created through this API carries ROZO's 1% service fee on top of the merchant amount (rounded up to the cent), whatever merchant the link belongs to. quote-invoice returns original / serviceFee / callerPays and a signed quoteReceipt, so the total is known before anyone pays; pass that quoteReceipt to create-invoice. -> { ok, reused, linkId, rozoPaymentId, paymentLink, expiresAt, source, ... } WARNING: if an unexpired order already exists for this link it is REUSED as-is, even with a different chain/token than you asked for. Always verify the returned source matches your request; abort on mismatch. 3) Fetch authoritative deposit instructions (public, keyless GET): curl https://intentapiv4.rozo.ai/functions/v1/payment-api/payments/ -> { status, expiresAt, source:{ receiverAddress, receiverMemo, amount, amountUnit, lnInvoice, txHash, amountReceived, confirmedAt, ... }, destination:{...} } Pay EXACTLY source.amount of the requested token on the requested chain to source.receiverAddress, including every other field the block carries (Stellar routes on a shared hub address plus source.receiverMemo, so omitting the memo loses the payment). The Stellar memo is ALWAYS MEMO_TEXT, even when it is all digits (e.g. 65371582) — sending it as MEMO_ID produces a different memo and the payment will not match. The deposit block reports this as receiverMemoType. Orders expire: deposit.expiresIn / status expiry.expiresIn give the remaining validity as a duration. For Lightning, pay the BOLT11 in source.lnInvoice (receiverAddress is empty). 4) Poll until settled: curl "https://apiserver.mpprouter.dev/v1/services/rozo-agent-api/invoice-status?payment_id=" and re-GET the payments/ URL above. 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. ## Safety rules (encode these, they prevent fund loss) - Before paying, require: status == "payment_unpaid" AND source.txHash == null AND source.amountReceived in {null,"0"} AND source.confirmedAt == null. Anything else means the order is already funded — do NOT pay again; escalate for reconciliation. - Deposit addresses are one-time and quote-bound. Never reuse an address from an old order, a cached response, or a document. Always re-fetch step 3 in the same run. - Respect expiry with margin: do not send if now > min(order expiresAt, Coinbase link expiry) minus a safety margin (10 min EVM/Stellar, 5 min Solana; Lightning: only pay a BOLT11 with >= 10 min validity left). - Re-check step 4 payability immediately before broadcasting a transaction: the Coinbase link can be consumed by another payer at any moment. - Wrong token, wrong network, wrong amount, or paying twice is usually unrecoverable. - After any on-chain payment is detected, never retry into a new order and never label the payment a normal failure — keep the tx hash and rozoPaymentId, keep polling, and escalate if it stays stuck. ## Errors 409 = link already used · 410 = link expired · UNSUPPORTED_SOURCE = the response's "supported" object lists valid (chainId, tokenSymbol) pairs (Lightning is supported but omitted from that list) · RATE_LIMITED (HTTP 429) = per-IP creation cap; wait Retry-After seconds (X-RateLimit-* headers show the quota) and retry. ## Paying x402 APIs (live, payment leg USDC on Base) For endpoints that answer HTTP 402 with x402 payment requirements. Fund a ROZO balance once with the coin you hold, then pay many small x402 calls from it. Human-readable guide: https://checkout.rozo.ai/x402 CLI (npm @rozoai/checkout): npx @rozoai/checkout x402 topup 20 --with usdt-solana # one-time deposit address, pay it from your wallet npx @rozoai/checkout x402 pay [--method POST] [--body '...'] [--header 'K: V'] [--max-usd 1.00] npx @rozoai/checkout x402 balance Payment leg (what the seller receives): USDC on Base (eip155:8453) only, x402 scheme "exact". The Solana payment leg is coming later; an endpoint that only accepts Solana is refused with X402_UNSUPPORTED before anything is charged. Topup leg: x402 balance top ups accept USDC and USDT only. USDT on Solana, BNB Chain, Ethereum, Polygon, Arbitrum; USDC on Solana, BNB Chain, Ethereum, Polygon, Arbitrum, Base, Stellar. Any other coin is answered with 400 X402_TOPUP_SOURCE_UNSUPPORTED. USDT only funds the balance; sellers are paid in USDC. Holding a native coin or sats? Use them to top up OpenRouter with ROZO Checkout (https://checkout.rozo.ai). Raw HTTP (header Authorization: Bearer ): POST https://apiserver.mpprouter.dev/v1/x402/topup {"amount":"20","token":"USDT","chain":"900"} -> one-time deposit address/order; the balance is credited after it confirms POST https://apiserver.mpprouter.dev/v1/x402/sign {"accepts":[],"budget":"1.00","idempotencyKey":""} -> the value for the PAYMENT-SIGNATURE header (x402 v1: X-PAYMENT); replay your request with it POST /v1/x402/keys creates the agent key (returned once). GET /v1/x402/balance. Limits: $5 per payment and $100 per day by default, optional payTo allowlist, minimum topup $5, topup fee 1%; a payment costs only what the seller asks. Withdrawing a balance is not self serve yet: email hi@rozo.ai with the masked key and amount. x402 safety rules: - Send the paid request yourself. Never send ROZO your request body, headers or the API keys of the service you are paying; /sign needs only the accepts entry. - Generate one idempotencyKey per payment and reuse it on every retry of /sign. A new key on retry can charge twice. - Refuse a payment above what the user approved, and a payTo on a compromised-wallet list. - 503 X402_RETRY, X402_PAYER_MODE_CHANGED or X402_LEDGER_UNAVAILABLE: retry with the same idempotencyKey. Any other 503 means x402 is not available for this key right now; nothing new was charged, stop. Every server code is listed below. - The agent key owns the balance. Store it with owner-only permissions; never print, log or paste it. x402 server error codes (returned by https://apiserver.mpprouter.dev/v1/x402/*): Every error body looks like {"ok":false,"code":"X402_...","error":{"code":"X402_...","message":"..."}}, sometimes with extra top level fields (limitUsd, balanceUsd, ...). These are separate from the codes the CLI raises on its own (X402_UNSUPPORTED, X402_OVER_BUDGET, X402_BAD_CHALLENGE, X402_PAYMENT_REJECTED and others). The balance is debited only by the ledger commit inside /sign, after signing; every error raised before that commit charges nothing. If /sign answers X402_LEDGER_UNAVAILABLE or X402_INTERNAL the commit may have landed: retry with the same idempotencyKey, and a payment that did land comes back as the stored signature (replay:true), never as a second charge. The CLI reports every 503 except X402_RETRY, X402_PAYER_MODE_CHANGED and X402_LEDGER_UNAVAILABLE as X402_PAYER_DISABLED, with the server code in error.details.serverCode. On /sign it retries 429, 500, 502, 504 and those three 503 codes itself, with the same idempotencyKey. balance, topup and sign (keys does not read a key): - 401 X402_KEY_INVALID: agent key missing, malformed or unknown. Send "Authorization: Bearer ak_...". Do not mint a new key to get around it: the balance belongs to the old key. - 403 X402_KEY_SUSPENDED: the key is not active. Stop; email hi@rozo.ai. Any route: - 503 X402_PAYER_DISABLED: the payer is switched off. Stop, tell the user. - 503 X402_PAYER_NOT_CONFIGURED: payer not set up on this deployment. Stop. - 503 X402_LEDGER_UNAVAILABLE: ledger unreachable. Retry shortly with the same idempotencyKey. - 500 X402_INTERNAL: unexpected error. Retry with the same idempotencyKey a few times, then stop and report it. - 405 METHOD_NOT_ALLOWED: wrong HTTP method (keys/topup/sign are POST, balance is GET). POST /v1/x402/keys: - 429 X402_KEY_RATE_LIMITED: too many keys created from this IP this hour. Reuse the key you have, or retry later. - 503 X402_RETRY: key collision. Retry. POST /v1/x402/topup (no deposit address is shown on any error, so nothing can be sent to it; only pay an address from a 200 response): - 400 X402_INVALID_REQUEST: body is not JSON, or amount is not a USD amount with at most 2 decimals. - 400 X402_TOPUP_AMOUNT_OUT_OF_RANGE: top up must be between $5 and $500. - 400 X402_TOPUP_SOURCE_REQUIRED: say which coin you pay with: chain and token. The response lists accepted chains. - 400 X402_UNSUPPORTED_CHAIN: unknown chain. Use a CAIP-2 id or a name such as solana, base, ethereum, bsc, polygon, arbitrum, stellar. - 400 X402_TOPUP_SOURCE_UNSUPPORTED: that coin is not accepted for top ups. Use USDC or USDT. May carry a "supported" list. - 502 INTENTS_API_FAILED: the top up order could not be created. Retry later. - 503 X402_TOPUP_MISCONFIGURED or X402_TOPUP_NOT_REGISTERED: the order was not usable, the address was withheld. Retry later; email hi@rozo.ai if it repeats. - 503 X402_PAYER_SHADOW, X402_TOPUP_NOT_CONFIGURED or X402_SIGNER_NOT_CONFIGURED: top ups are closed right now. Stop. POST /v1/x402/sign: - 400 X402_INVALID_REQUEST: body is not JSON, or budget is not a positive USD amount. - 400 X402_IDEMPOTENCY_KEY_REQUIRED: send idempotencyKey, 8 to 128 chars of [A-Za-z0-9_.:-], one per 402 challenge. - 400 X402_UNSUPPORTED_VERSION: only x402Version 2 is accepted. - 400 X402_UNSUPPORTED_NETWORK, X402_UNSUPPORTED_SCHEME, X402_UNSUPPORTED_ASSET, X402_INVALID_REQUIREMENT or X402_SIGN_UNSUPPORTED: the accepts entry is malformed or asks for something not covered (only exact USDC is signed). Do not retry the same entry; tell the user. - 402 X402_BUDGET_EXCEEDED: the challenge asks more than your budget. Stop and ask the user. - 402 X402_PER_TX_LIMIT_EXCEEDED: above this key's single-payment limit (limitUsd). Stop and ask the user. - 402 X402_INSUFFICIENT_BALANCE: balance too low (balanceUsd). Top up, wait for the credit, then pay again. - 403 X402_PAYTO_NOT_ALLOWED: payTo is not on this key's allowlist. Stop. - 403 X402_PAYTO_BLOCKED: this payTo is blocked. Stop, do not retry. - 409 X402_IDEMPOTENCY_CONFLICT: this idempotencyKey was already used for a different requirement. Nothing new was charged. Use a new key only for a new 402 challenge. - 410 X402_CREDENTIAL_REFUNDED: the stored signature expired unused and its amount went back to the balance. Fetch a new 402 and sign it with a new key. - 429 X402_DAILY_LIMIT_EXCEEDED: this key's daily limit would be exceeded (limitUsd, spentTodayUsd). Wait for the daily window to reset, or ask hi@rozo.ai for a higher limit. - 429 X402_GLOBAL_DAILY_CAP_REACHED or X402_SIGNER_DAILY_CAP_REACHED: a platform-wide daily cap was reached. Retry after 00:00 UTC. - 429 X402_SIGNER_CAP_REACHED: the signing service refused this amount. Try a smaller payment or later. - 503 X402_RETRY or X402_PAYER_MODE_CHANGED: transient. Retry with the same idempotencyKey. - 503 X402_PAYER_SHADOW: the payer is not live for this key. A fresh request was checked and recorded but not signed, and nothing was charged. With "replay":true it refers to an earlier payment under this idempotencyKey, which may have been charged: check /balance, never pay again with a new key. Stop. - 503 X402_SIGNER_NOT_CONFIGURED or X402_SIGNER_DISABLED: signing for this network is off right now. Stop. A 200 with "replay":true is the stored signature for an idempotencyKey that was already paid; it is not a second charge. ## Paying many invoices (batch / resellers) Each OpenRouter top-up is its own Coinbase link, so a batch is a loop over links: one order per link, run one link at a time, log linkId + rozoPaymentId per link, and pay each deposit right after it is created. Full example script: https://github.com/RozoAI/rozo-checkout-skill#paying-many-invoices-batch--resellers CLI, per link (non-interactive): rozo-checkout pay --with btc-lightning --yes --json --no-watch -> order.rozoPaymentId, order.deposit.lnInvoice (BOLT11), order.deposit.amount (sats for Lightning), order.expiry.effectiveDeadlineIso + marginMinutes rozo-checkout status --json -> .state ("settled" = done), .escalate Pass --no-watch: without it, pay --json waits for settlement before printing anything, so the deposit details never reach a payer in time. A successful pay --no-watch only means the deposit exists; nothing is paid until status says settled (with --send the CLI may already have paid; never pay by hand too). Query status by rozoPaymentId: a link-only status lookup cannot see the pay-in view. Deadline: order.expiry.effectiveDeadlineIso (the earlier of the order expiry and the Coinbase link expiry), not deposit.expiresAt. Stop paying at least order.expiry.marginMinutes before it. If time has passed since the order was created, re-run the same create/pay call first: it re-checks payability and the deadline and returns the same order while it is still open. Pay only if that succeeds. Idempotency (same rules for the CLI and raw HTTP): - create-invoice is keyed by the Coinbase link. While the link's order is payment_unpaid and unexpired, calling it again returns that order (reused:true), not a second one. Once its status has moved past payment_unpaid it answers 409 ORDER_ALREADY_ACTIVE. Only after an order expired with nothing received does create on the same link make a new order. Running create twice is safe; paying a deposit twice is not. - Use the same source coin on every attempt for a link. A different coin can be refused or can replace the open order's deposit. - Before acting on a link again, read its state (CLI status, or GET payments/ plus invoice-status): escalate:true, underpaid, stuck, or any txHash/amountReceived/confirmedAt -> never pay again; contact support with linkId, rozoPaymentId, tx hashes. settled / router paid / coinbase.settled -> done, skip the link. awaiting deposit (payment_unpaid, no txHash, unexpired) -> first check your wallet: if a send or Lightning payment to it exists or is pending, wait and poll. Only if nothing was sent, re-check as above, then pay once. pay-in seen, bridging, paying -> money in flight; wait and poll. expired with no pay-in (CLI state expired_unfunded) -> first check your own wallet: if anything was sent to the old deposit, or a Lightning payment is still pending, do not pay again; contact support with linkId and rozoPaymentId (the router cannot see a pending Lightning payment). If nothing was sent, re-run the same create/pay on the same link with the same coin: once every earlier order is proved unfunded it creates a new order. unreadable backend (CLI state unknown) -> retry the read, never the payment. - CLI exit 3 = watch window ended before a final state: money may be in flight, do not pay again. CLI exit 0 alone is not settlement; read state. - LINK_USED_OR_EXPIRED / LINK_NO_LONGER_PAYABLE = the Coinbase link itself is already paid or expired; check the OpenRouter balance and get a new link if it was not credited. - 409 PAYMENT_EXPIRED = an earlier order for this link expired. retryable:true (confirmed:false): it cannot be proved unfunded yet; wait a few minutes and retry the same create. confirmed:true: the link has used all its re-orders; get a new link from OpenRouter. - RATE_LIMITED (HTTP 429) on create-invoice: creation is capped at 200 calls per IP per UTC hour (each CLI pay makes two). The 429 carries Retry-After (seconds) and X-RateLimit-* headers; wait that long and resume with the links that are not settled. Need more? Email us. Support for batches: hi@rozo.ai ## x402 endpoints Can I use this to pay x402 endpoints? Yes, it is live. Top up a ROZO balance once with the coin you hold, then `npx @rozoai/checkout x402 pay ` pays any public x402 endpoint that asks for USDC on Base from that balance. The Solana payment leg is coming later. Commands, limits and raw HTTP: see "Paying x402 APIs" above and https://checkout.rozo.ai/x402 Need an endpoint or payment network we do not cover yet? Tell us which endpoint you want to pay and which coin you hold: hi@rozo.ai, or the "Join the x402 waitlist" button on https://checkout.rozo.ai/agent.html ## Payment minimum and support The minimum depends on the merchant and the payment option used to create your link. Check the accepted credit amount at the merchant checkout and the final ROZO quote before paying. Credits and the total paid may differ because of fees. Contact support with the transaction hash. We reply within one business day and review recovery case by case. Recovery is not guaranteed; completion time depends on the case. Do not pay again while we investigate. Standard crypto Checkout adds 1% to the merchant invoice. Network fees and conversion spreads are additional. TRON Alpha charges 1% with a $0.50 minimum; TON Alpha charges 1% only. UPI has separate pricing. Review the final quote before paying.