Quickstart

This walkthrough covers the full sandbox loop: sign in, create an API key, spin up a custodial wallet, fund it from the faucet, mint cAROUSD, send a private transfer, and redeem back to test stablecoin.

You need an AroPay account provisioned by your Aro Media contact; there is no self-serve sign-up, so request access before starting. This guide runs against the Sandbox environment (dev.aropay.aro.media, Sepolia): funds are test-denominated and the faucet is available. The same calls work on Production (aropay.aro.media, Ethereum Mainnet) with your production credentials, except the faucet, which is sandbox-only; production wallets are funded by real deposits.

Open dev.aropay.aro.media and sign in with the email and one-time temporary password you received. The sandbox forces a password rotation on first login. Pick a password with at least 10 characters including an uppercase letter, a lowercase letter, and a digit.

While you’re in Settings, consider enabling two-factor authentication or adding a passkey.

Create an API key

Go to Settings → API keys and create a key. The plaintext value (prefixed aro_sk_) is shown exactly once, so store it in your secret manager now.Export it for the rest of this guide:

export BASE="https://dev.aropay.aro.media/api/v1"
export KEY="aro_sk_…"

API keys can be created and revoked only from a browser session, never with another key. See API keys for limits and expiry.

Create a custodial wallet

Custodial wallets are generated server-side, and AroPay signs transactions for them, which is exactly what makes key-driven money movement possible.

curl -s "$BASE/wallets" \
  -H "Authorization: Bearer $KEY" \
  -H "content-type: application/json" \
  -d '{"type":"custodial","label":"Treasury test"}'

{
  "ok": true,
  "data": {
    "wallet": {
      "id": "ckwlt0001…",
      "address": "0x8Ba1f109551bD432803012645Ac136ddd64DBA72",
      "type": "CUSTODIAL",
      "label": "Treasury test",
      "isPrimary": true,
      "createdAt": "2026-08-13T09:30:00.000Z"
    }
  }
}

Save the wallet ID:

export WALLET="ckwlt0001…"

Fund it from the faucet

The faucet sends test stablecoin and tops up ETH for gas in one call (sandbox-only; on production, fund wallets by depositing to their address):

curl -s "$BASE/fund" \
  -H "Authorization: Bearer $KEY" \
  -H "content-type: application/json" \
  -d "{\"walletId\":\"$WALLET\"}"

The response is a transaction object in status QUEUED: the request has been accepted and a background worker submits it to the chain within a few seconds. Save its id and poll GET /transactions/{id} until the status is CONFIRMED (or FAILED) before moving on; the mint below needs the faucet’s stablecoin and gas to have landed. Faucet requests count against a rolling 24-hour cap per account.

export TX="cktxn0001…"   # data.transaction.id from the response
until [[ "$(curl -s "$BASE/transactions/$TX" -H "Authorization: Bearer $KEY" \
  | jq -r .data.transaction.status)" =~ ^(CONFIRMED|SETTLED|FAILED)$ ]]; do sleep 5; done

Mint cAROUSD

Convert 100 units of public stablecoin into encrypted cAROUSD:

curl -s "$BASE/mint" \
  -H "Authorization: Bearer $KEY" \
  -H "content-type: application/json" \
  -d "{\"walletId\":\"$WALLET\",\"amount\":\"100\"}"

Amounts are always decimal strings in human units: "100", not an integer and not wei.

Send a private transfer

Send 25 cAROUSD to a counterparty. On-chain, the amount is FHE-encrypted; observers see that a transfer happened, but not how much:

curl -s "$BASE/transfer" \
  -H "Authorization: Bearer $KEY" \
  -H "content-type: application/json" \
  -d "{\"walletId\":\"$WALLET\",\"to\":\"0xRecipient…\",\"amount\":\"25\",\"type\":\"private\"}"

Switch "type" to "public" for a standard ERC-20 stablecoin transfer.

Redeem back to stablecoin

Burn 10 cAROUSD and receive test stablecoin 1:1. Redemptions settle asynchronously:

curl -s "$BASE/redeem" \
  -H "Authorization: Bearer $KEY" \
  -H "content-type: application/json" \
  -d "{\"walletId\":\"$WALLET\",\"amount\":\"10\"}"

The transaction moves QUEUED → PENDING → SETTLING → SETTLED; the payout hash lands in settlementTxHash. Every money-movement call in this guide returns 201 with a QUEUED transaction and is executed by a background worker; poll each one to a terminal status (CONFIRMED, SETTLED, or FAILED) the same way as the faucet step above.

Check balances and history

curl -s "$BASE/balances" -H "Authorization: Bearer $KEY"
curl -s "$BASE/transactions?pageSize=10" -H "Authorization: Bearer $KEY"

Balances come back per wallet as a triple: normal (public stable), confidential (cAROUSD, decrypted server-side for custodial wallets), and total, plus the wallet’s ETH gas balance.

Where to go next

How AroPay works

Understand the rails, the operator wallet, and backed vs. float minting.

Transactions & lifecycle

Statuses, background execution, and how to poll like a good citizen.

Authentication

Sessions vs. API keys, and which endpoints require a browser session.

API reference

Full schemas and an interactive playground for all 44 endpoints.

Get started

Core concepts

Guides

Security & access

Support

Where to go next

How AroPay works

Transactions & lifecycle

Authentication

API reference

​Where to go next

How AroPay works

Transactions & lifecycle

Authentication

API reference

Where to go next