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

# Quickstart

> Go from a fresh AroPay account to your first confidential transfer in about five minutes.

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.

<Info>
  You need an AroPay account provisioned by your Aro Media contact. AroPay is
  currently an MVP sandbox for B2B users, so there is no self-serve sign-up;
  request access before starting.
</Info>

<Steps>
  <Step title="Sign in and set your password">
    Open [aropay.aro.media](https://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.

    <Tip>
      While you're in **Settings**, consider enabling
      [two-factor authentication](/security/two-factor-authentication) or adding a
      [passkey](/security/passkeys).
    </Tip>
  </Step>

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

    ```bash theme={null}
    export BASE="https://aropay.aro.media/api/v1"
    export KEY="aro_sk_…"
    ```

    <Note>
      API keys can be created and revoked only from a browser session, never with
      another key. See [API keys](/security/api-keys) for limits and expiry.
    </Note>
  </Step>

  <Step title="Create a custodial wallet">
    Custodial wallets are generated server-side, and the sandbox signs
    transactions for them, which is exactly what makes key-driven money
    movement possible.

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

    ```json theme={null}
    {
      "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:

    ```bash theme={null}
    export WALLET="ckwlt0001…"
    ```
  </Step>

  <Step title="Fund it from the faucet">
    The faucet sends test stablecoin **and** tops up Sepolia ETH for gas in one
    call:

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

    The response is a transaction object. Faucet requests count against a
    rolling 24-hour cap per account.
  </Step>

  <Step title="Mint cAROUSD">
    Convert 100 units of public stablecoin into encrypted cAROUSD:

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

    <Note>
      Amounts are always **decimal strings in human units**: `"100"`, not an
      integer and not wei.
    </Note>
  </Step>

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

    ```bash theme={null}
    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.
  </Step>

  <Step title="Redeem back to stablecoin">
    Burn 10 cAROUSD and receive test stablecoin 1:1. Redemptions settle
    asynchronously:

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

    The transaction moves `PENDING → SETTLING → SETTLED`; the payout hash lands
    in `settlementTxHash`.
  </Step>

  <Step title="Check balances and history">
    ```bash theme={null}
    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.
  </Step>
</Steps>

## Where to go next

<CardGroup cols={2}>
  <Card title="How AroPay works" icon="diagram-project" iconType="duotone" href="/concepts/how-aropay-works">
    Understand the rails, the operator wallet, and backed vs. float minting.
  </Card>

  <Card title="Transactions & lifecycle" icon="arrow-right-arrow-left" iconType="duotone" href="/concepts/transactions">
    Statuses, lazy reconciliation, and how to poll like a good citizen.
  </Card>

  <Card title="Authentication" icon="key" iconType="duotone" href="/security/authentication">
    Sessions vs. API keys, and which endpoints require a browser session.
  </Card>

  <Card title="API reference" icon="code" iconType="duotone" href="/api-reference/introduction">
    Full schemas and an interactive playground for all 30 endpoints.
  </Card>
</CardGroup>