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

# Para Wallet integration

> Use Para to provision self-custody wallets and Brale to on/off-ramp and orchestrate stablecoin flows to those wallets.

## Overview

This guide shows a common pairing:

* [**Para**](https://www.getpara.com/) for embedded / self-custody wallet UX and key management
* **Brale** for regulated stablecoin issuance + on/off-ramps + orchestration

At a high level:

1. Para provisions a wallet and gives you an onchain address
2. You register that address with Brale as an `Address` (`type=external`)
3. Brale returns an `address_id`
4. Use that `address_id` as the destination (or source) in Brale Transfers

<Note>
  Para’s Brale walkthrough includes example Brale requests for convenience. For the latest Brale auth, required headers (like `Idempotency-Key`), and request body shapes, refer to Brale API Docs.
</Note>

## What is Para?

Para is an embedded wallet platform that helps fintech and payments teams ship **self-custody wallets** with a polished wallet UX and **modern authentication** (like passkeys), without forcing users into seed phrases or external wallet apps.

**Why teams choose Para (briefly):**

* **Smooth onboarding:** familiar sign-in flows with embedded wallet UX.
* **Self-custody security model:** 2-of-2 MPC + passkeys and a defense-in-depth security architecture.
* **Flexible integration options:** SDK-first (React and more) plus a REST API for server-side wallet + signing workflows.
* **User-friendly signing controls:** permission prompts for transaction/message approvals (so you don’t have to build the entire approval UI).

## Prerequisites

* Para SDK integrated in your app (web/mobile/server) and you can access the user wallet address
* Brale API credentials (`client_id`, `client_secret`)
* You’ve chosen the chain(s) you want to support (examples below use EVM chains like `base`)

***

## Step 1 — Authenticate with Brale

Exchange your Brale client credentials for a bearer token:

```bash theme={null}
CLIENT_CREDENTIALS=$(
  printf "%s:%s" "${CLIENT_ID}" "${CLIENT_SECRET}" | base64 | tr -d '\n'
)

curl --request POST \
  --url https://auth.brale.xyz/oauth2/token \
  --header "Authorization: Basic ${CLIENT_CREDENTIALS}" \
  --header "Content-Type: application/x-www-form-urlencoded" \
  --data grant_type=client_credentials
```

Store the returned `access_token` and refresh it before it expires (`expires_in`).

## Step 2 — Get your `account_id`

```bash theme={null}
curl --request GET \
  --url https://api.brale.xyz/accounts \
  --header "Authorization: Bearer ${AUTH_TOKEN}"
```

If you operate managed accounts, select the correct `account_id` for the customer you’re funding.

***

## Step 3 — Get the user’s wallet address from Para (minimal)

You only need one thing from Para to use Brale: the onchain address you want to fund.

### Option A: Current selected wallet (React)

`useWallet` returns the wallet currently selected in the `ParaModal`.

```tsx theme={null}
import { useWallet } from "@getpara/react-sdk";

export default function CurrentWallet() {
  const { data: wallet } = useWallet();

  if (!wallet) return <div>No wallet connected</div>;

  return (
    <div>
      <p>Address: {wallet.address}</p>
      <p>Type: {wallet.scheme}</p>
      <p>ID: {wallet.id}</p>
    </div>
  );
}
```

### Option B: All wallets (embedded + external) (React)

Use `useAccount` to access wallet information for both embedded and external types.

```tsx theme={null}
import { useAccount } from "@getpara/react-sdk";

export default function AllWallets() {
  const { embedded, external } = useAccount();

  const embeddedList = Object.values(embedded?.wallets ?? {});
  const externalList = Object.values(external?.wallets ?? {});

  return (
    <div>
      <h3>Embedded</h3>
      {embeddedList.map((w) => (
        <div key={w.id}>
          <p>
            {w.scheme}: {w.address}
          </p>
        </div>
      ))}

      <h3>External</h3>
      {externalList.map((w) => (
        <div key={w.id}>
          <p>
            {w.scheme}: {w.address}
          </p>
        </div>
      ))}
    </div>
  );
}
```

<Note>
  Not using React? Para supports other environments (REST API, server-side, React Native, etc.). Use Para’s docs as the source of truth for retrieving wallet data and for signing/broadcasting transactions.
</Note>

***

## Step 4 — Register the Para wallet in Brale (create an external Address)

Create an external address and capture the returned `address_id`.

```bash theme={null}
curl --request POST \
  --url "https://api.brale.xyz/accounts/${ACCOUNT_ID}/addresses/external" \
  --header "Authorization: Bearer ${AUTH_TOKEN}" \
  --header "Content-Type: application/json" \
  --header "Idempotency-Key: $(uuidgen)" \
  --data '{
    "name": "User Para Wallet (EVM)",
    "address": "0xE57e438aE0b1557bFC1ad70BD7751635E473D888",
    "transfer_types": ["base", "ethereum"]
  }'
```

Response:

```json theme={null}
{ "id": "2VcUIIsgARwVbEGlIYbhg6fGG57" }
```

That `id` is the Brale `address_id` you’ll use in Transfers.

<Tip>
  If the same address format is valid across multiple networks (e.g., EVM chains), include all relevant onchain `transfer_types`. Otherwise, create separate external Addresses per chain/wallet type.
</Tip>

***

## Step 5 — Fund the Para wallet via Brale Transfers

### Option A: Wire → stablecoin → Para wallet

```bash theme={null}
PARA_ADDRESS_ID="2VcUIIsgARwVbEGlIYbhg6fGG57"

curl --request POST \
  --url "https://api.brale.xyz/accounts/${ACCOUNT_ID}/transfers" \
  --header "Content-Type: application/json" \
  --header "Authorization: Bearer ${AUTH_TOKEN}" \
  --header "Idempotency-Key: $(uuidgen)" \
  --data '{
    "amount": { "value": "10", "currency": "USD" },
    "source": { "value_type": "USD", "transfer_type": "wire" },
    "destination": {
      "address_id": "'"${PARA_ADDRESS_ID}"'",
      "value_type": "SBC",
      "transfer_type": "base"
    }
  }'
```

<Note>
  Examples use `SBC` as a placeholder stablecoin. Replace it with the value type you intend to mint or pay out.
</Note>

### Option B: ach\_debit → stablecoin → Para wallet

`ach_debit` flows require additional setup (end-user funding addresses, Plaid flows, etc.). Once configured, the Transfer pattern is the same: the destination is your Para `address_id`.

See: [ach\_debit to end user wallet](/guides/ach-on-ramp)

***

## Step 6 — Spending / sending from the Para wallet

Once funds land in the Para wallet, your app uses Para to sign and broadcast onchain transactions to send stablecoins onward. Brale does not custody the keys for external wallets.

***

## Offramping (stablecoin → USD) with a self-custody wallet

To offramp to USD:

1. Send stablecoins **from the Para wallet** to a Brale custodial deposit address (`type=internal`) for the customer’s Brale account.
2. Use Brale’s stablecoin-to-fiat workflow to send USD to an external bank Address.

See: [Stablecoin to Fiat (Offramp)](/guides/stablecoin-to-fiat-offramp)

***

## Troubleshooting

* `401`: refresh the Brale bearer token and retry POST requests with the **same** `Idempotency-Key`
* `404 compatible_address_not_found`: confirm:
  * you used the correct `account_id`
  * the destination `address_id` supports the `transfer_type` you’re using
* Balance visibility:
  * Brale can return balances for custodial addresses (`type=internal`)
  * external wallets are outside Brale custody

***

## References

**Brale**

* [Quick Start - Your First Brale Stablecoin Transfer](/overview/quick-start)
* [Authentication](/key-concepts/authentication)
* [Create a new external address](/api-reference/brale/create-address)
* [Add an External Destination](/guides/how-to/add-external-destination)
* [Stablecoin to Fiat (Offramp)](/guides/stablecoin-to-fiat-offramp)

**Para**

* [Integrate Brale with Para](https://docs.getpara.com/v2/walkthroughs/brale)
* [Get Wallet Data (useWallet / useAccount)](https://docs.getpara.com/v2/react/guides/web3-operations/get-wallet-address)
* [Key Management System](https://docs.getpara.com/v2/concepts/key-management)
* [Security Mechanisms](https://docs.getpara.com/v2/concepts/security)
* [Permissions (Transaction Prompts)](https://docs.getpara.com/v2/react/guides/permissions)
* [REST API Overview](https://docs.getpara.com/v2/rest/overview)