Brale: white-label stablecoin issuance infrastructure on Solana

Sending $1,000,000 on-chain costs $0.0002 on Solana. The settlement cost is solved. What's left is the compliance stack — the licensing, reserve management, custody, attestations, and regulatory reporting that sit between "I want to issue a dollar-denominated token" and "I am now a regulated money transmitter."

Brale is the API layer that handles that entire stack. Your product, your stablecoin brand, Brale's regulated infrastructure underneath. One API covers issuance, custody, on/off-ramp, movement, compliance controls, and reconciliation — across 25+ chains including Solana. On Solana specifically, it builds on Token Extensions natively.

What Brale is

Brale is a SOC 2-certified stablecoin infrastructure provider operating under U.S. money-transmission licensing. It currently settles roughly $500 million per month for clients that include Coinflow (cfUSD) and Rain (rUSD). The proposition: you get a custom stablecoin under your own brand without acquiring a money transmitter license, managing reserves, or building custody infrastructure.

The five things Brale handles so you don't have to:

• Issuance — mint and burn logic, reserve backing, smart contract deployment (under an hour on Solana)
• Custody — wallet management, permission controls, multi-party custody with BitGo
• Movement — ACH, wire, RTP, and on-chain transfers through a unified endpoint
• Compliance — transfer hooks, address screening, approvals, audit trails
• Reconciliation — reserve attestations, reporting, auditable event logs

How it works on Solana

Brale launched Solana support in October 2023 and builds on Token Extensions (Token-2022) natively rather than plain SPL tokens. Two extensions do most of the heavy lifting:

• Transfer hooks — every transfer calls a program that runs Brale's compliance checks (address screening, transfer limits, blacklist enforcement) before the transfer completes. This happens at the token level — the issuer doesn't need to build or maintain the screening logic in their own program.
• Confidential transfers — masks transfer amounts for privacy-sensitive use cases (payroll, B2B settlement) where counterparties shouldn't see transaction sizes. Built into the token, not an extra protocol layer.

The result is that compliance and privacy are enforced at the mint level — every wallet that holds the token inherits the controls. You don't patch them in after the fact.

Ecosystem integrations are live with Phantom, Solflare, and Backpack, and Coinflow handles fiat on/off-ramp on the Solana side.

The API model

Everything goes through a REST API authenticated with a bearer token. The core resource model has three objects: accounts (a customer or platform entity), addresses (wallets or bank accounts attached to an account), and transfers (movement of value — fiat or stablecoin).

A full on-ramp-to-on-chain flow looks like this:

# 1. Create a platform account for your customer
curl -X POST https://api.brale.xyz/accounts \
  -H "Authorization: Bearer $BRALE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "SquareFi Customer #1234"}'
# → { "id": "acc_abc123", ... }

# 2. Register their Solana wallet as an external address
curl -X POST https://api.brale.xyz/accounts/acc_abc123/addresses \
  -H "Authorization: Bearer $BRALE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "SolanaSOL",
    "address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU"
  }'

# 3. Register their bank account
curl -X POST https://api.brale.xyz/accounts/acc_abc123/addresses \
  -H "Authorization: Bearer $BRALE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "ach",
    "routing_number": "021000021",
    "account_number": "1234567890"
  }'
# → { "id": "addr_bank456", ... }

# 4. On-ramp: move fiat → stablecoin to their Solana wallet
curl -X POST https://api.brale.xyz/accounts/acc_abc123/transfers \
  -H "Authorization: Bearer $BRALE_API_KEY" \
  -H "Idempotency-Key: txn-$(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "id": "addr_bank456" },
    "destination": { "chain": "SolanaSOL", "address": "7xKXt..." },
    "amount": "1000.00",
    "currency": "USDM"
  }'
# → { "id": "txn_xyz789", "status": "pending", ... }

Webhooks

Transfers are async. Brale fires webhooks as state transitions happen — register an endpoint in the dashboard and listen for the events that matter:

// transfer.completed webhook payload
{
  "event": "transfer.completed",
  "data": {
    "id": "txn_xyz789",
    "account_id": "acc_abc123",
    "amount": "1000.00",
    "currency": "USDM",
    "chain": "SolanaSOL",
    "destination_address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
    "tx_signature": "5eykt4UsFv8P...",
    "completed_at": "2026-06-27T09:14:33Z"
  }
}

Other events: transfer.pending, transfer.failed, address.approved (for compliance-gated address registration), account.updated.

User-to-user transfers (on-chain)

Once both users hold your stablecoin on Solana, peer transfers don't need to go through Brale's API at all — they're standard SPL (Token-2022) transfers and settle in 400ms. The transfer hook fires on every transfer, but that happens at the token program level transparently. If you want Brale to orchestrate it (for ledger reconciliation), use the transfers endpoint:

# Move USDM between two platform accounts
curl -X POST https://api.brale.xyz/accounts/acc_abc123/transfers \
  -H "Authorization: Bearer $BRALE_API_KEY" \
  -H "Idempotency-Key: txn-$(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "chain": "SolanaSOL",
      "address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU"
    },
    "destination": {
      "chain": "SolanaSOL",
      "address": "3Kzh9qAqVWQhEsfQz7zEQL1EuSx5tyNLmFFvkV4HQzr"
    },
    "amount": "250.00",
    "currency": "USDM"
  }'

Off-ramp: stablecoin → bank

# Burn USDM, release USD to bank account
curl -X POST https://api.brale.xyz/accounts/acc_abc123/transfers \
  -H "Authorization: Bearer $BRALE_API_KEY" \
  -H "Idempotency-Key: txn-$(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "chain": "SolanaSOL",
      "address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU"
    },
    "destination": { "id": "addr_bank456" },
    "amount": "1000.00",
    "currency": "USDM"
  }'

The burn happens on-chain; Brale releases the ACH or wire on the fiat side once the on-chain transaction confirms. Settlement to bank is typically next-business-day for ACH, same-day for RTP where available.

Case study: SquareFi + MainUSD

SquareFi is a white-label fintech stack — accounts, cards, wallets, fiat/crypto conversion, and cross-border payments across 150+ countries. They process $250M in transaction volume. When they wanted to offer a custom stablecoin under their brand (MainUSD, ticker USDM), they had two options: become a stablecoin infrastructure company themselves, or use Brale.

Anton Lobintsev (Co-Founder & CPO) on the decision: "With Brale, it's a capability we switch on."

SquareFi didn't write a mint program. They didn't acquire a money transmitter license. They registered API credentials, configured MainUSD through the Brale dashboard, and wired up the eight-step transfer workflow above. MainUSD launched in production on Polygon and Ethereum; the same API pattern applies to Solana.

What Brale handles vs what you own

It's worth being explicit about the split:

• Brale owns: reserve management (assets held at regulated U.S. financial institutions), attestations, licensing, the transfer hook program, compliance screening, custody (via BitGo), and fiat banking rails.
• You own: the stablecoin brand and ticker, your customer accounts, the product UX, and your integration code. The stablecoin mint address on Solana is yours.

From your users' perspective, they're holding your stablecoin in their Phantom or Backpack wallet. Brale is invisible infrastructure.

Multi-chain without re-architecting

The same API call that moves USDM on Solana works on Ethereum, Polygon, Base, Arbitrum, Stellar, XRPL, Algorand, Monad, and 15+ others. You change the chain field. Brale handles the cross-chain mechanics, bridge liquidity, and reconciliation. If your user on Solana wants to receive on Base, that's a parameter, not an engineering project.

This is what makes the SquareFi use case compelling for 150-country coverage: different regions have different preferred chains and on-ramp partners. One API, Brale's routing, not your problem.

Getting started

Brale has a sandbox environment on Solana devnet — you don't need production credentials to start integrating:

1. Create an account at brale.xyz and generate API credentials in the dashboard.
2. Configure your stablecoin — name, ticker, chain (select SolanaSOL for mainnet or SolanaDevnet for testing).
3. Create a platform account, register addresses, and run the on-ramp transfer flow in sandbox.
4. Set up your webhook endpoint and verify you're receiving transfer.completed events.
5. Go through Brale's KYB and licensing review before switching to production.

Integration examples are in the Brale Commons GitHub repo.

When to reach for Brale

Brale is the right tool when you want a stablecoin under your own brand and can't or don't want to become a licensed money transmitter. Concretely:

• Fintech products wanting a yield-bearing or compliant dollar token under their brand
• Enterprises tokenizing deposits or payroll on Solana without acquiring crypto-native regulatory capacity
• Builders who need regulated fiat on/off-ramp wired to their Solana program without stitching together Coinflow + custody + compliance separately

If you need a plain USDC or USDT integration, Brale is overkill — use the existing stablecoin rails directly. But if you're looking at "we want our own dollar token with our name on it," the alternative to Brale is a compliance and infrastructure team — not a competing library.