Rain

Real-time authorization & on-chain USDC settlement

Rain's edge is collapsing the card-money and on-chain-money flows into one loop. Authorization and settlement logic run on-chain against user-owned smart-contract collateral, and Rain settles its net obligation to Visa in USDC.

• Collateral: each end user deposits stablecoins into a smart contract they own and control; it backs a credit line rather than pre-funding a fiat float account.
• Authorization: at the swipe, Rain decisions in real time against that on-chain collateral and fronts fiat to the merchant over Visa.
• Settlement: Rain pays Visa natively in USDC on-chain, 7 days/week, 365 days/year — including weekends/holidays when fiat-wire settlement windows are closed.
• Float financing: receivables are tokenized, so Rain borrows stablecoins from capital partners and repays programmatically via smart contracts — 'closed-loop' on-chain receivable financing.
• Omni-chain + asset-agnostic: native settlement across ~10 chains (ETH, Base, Polygon, Optimism, Avalanche, Arbitrum, ZKsync, Solana, Stellar, Tron) and multiple stablecoins (USDC, USDT, DAI, PYUSD).

The Visa Principal Member advantage

Most card programs rent access through a BIN sponsor; Rain is itself a Visa Principal Member, which compresses the stack and the economics.

• Direct issuance: Rain issues, authorizes, and settles itself (cards issued by partner bank Third National under Rain's Visa license) — partners don't source a separate sponsor.
• Acceptance: cards work at 150M+ (Rain cites up to 175M+) Visa merchant locations worldwide on day one.
• Pilot status: Rain participates in Visa's stablecoin-settlement program, settling card obligations in USDC rather than only fiat.
• Speed-to-market: a partner ships a compliant card program via API instead of spending 12–18 months assembling sponsor bank + processor + network access.

Interchange & capital economics

Rain monetizes like a vertically integrated issuer-processor, with an extra on-chain financing layer that most card platforms don't have.

• Interchange: a share of the merchant interchange on every transaction is the core revenue line.
• Platform fees: per-card / per-transaction issuing + processing fees, plus subscription fees for expense/program management (Brex/Ramp analog).
• Capital efficiency: USDC settlement frees working capital that fiat T+1/T+2 cycles tie up; tokenized receivables let Rain borrow + repay float programmatically, lowering cost of capital for credit programs.
• Lender side: capital partners get 'superior collateral' (on-chain, programmatically repaid) — turning the float into a financing product, not just a cost.

Regulatory & regional risk

• Card-issuing, credit, and interchange rules differ sharply by jurisdiction, gating which geographies a program can serve (Rain reports activity across 100+ countries, but per-program coverage varies).
• Dependence on Visa membership + the sponsoring bank (Third National): a change in either is existential to the model.
• Collateral/credit risk: volatility or de-peg of backing assets and on-chain liquidation mechanics must hold up under stress.
• Capital-markets dependency: the receivable-financing engine needs ongoing lender appetite to fund float at attractive rates.

Architecture

Rain is the issuer-processor AND a Visa Principal Member, so it owns the full path: card issuance, real-time authorization, and settlement — no external BIN sponsor in the loop (cards are issued by partner bank Third National under Rain's Visa license). The novel piece is that authorization logic and settlement run on-chain. Each end user gets a smart contract they own and control, holding stablecoin collateral. When a swipe hits the Visa network, Rain authorizes against that collateral in real time and fronts fiat to the merchant; it then settles its net obligation to Visa in USDC on-chain, daily/365. Receivables are tokenized, so Rain borrows stablecoins from capital partners to fund the float and repays programmatically via smart contracts. The stack is omni-chain (native settlement on ~10 networks) and asset-agnostic across major stablecoins.

Integration shape

Partners integrate a developer-first, full-stack issuing API that supports both custodial and non-custodial wallets and operates natively across multiple chains. A program covers KYC/KYB + compliance, card creation (virtual/physical), collateral/credit-line setup tied to the user's smart contract, real-time authorization controls, and webhooks for transaction/settlement events. Public API reference is access-gated (docs.rain.xyz requires an access code), so exact endpoint names below are conceptual and marked [verify].

API surface

POST /cardholders (KYC/KYB)

Onboard an end user or business, run identity/compliance, create the cardholder record. [verify exact path]

POST /collateral-accounts

Provision the user-owned smart-contract account and register the stablecoin collateral / credit line backing it. [verify]

POST /cards

Issue a virtual or physical Visa card bound to a cardholder + collateral account; set spend controls/limits. [verify]

Authorization webhook / decisioning

Real-time auth events Rain evaluates against on-chain collateral; partner may apply program-level approve/decline rules. [verify]

GET /transactions

Retrieve authorizations, captures, and on-chain USDC settlement records for reconciliation. [verify]

Webhooks (events)

Subscribe to card lifecycle, authorization, settlement, and collateral/repayment events — treat these as source of truth. [verify]

Settlement / repayment ledger

Programmatic draw-down + repayment against collateral and capital-partner stablecoin float, recorded on-chain. [verify]

Minimal integration

Conceptual flow: onboard a cardholder, register on-chain collateral, issue a Visa card, then react to an authorization webhook. Endpoint shapes are illustrative — confirm against Rain's gated docs.

import { Rain } from '@rain/sdk'; // conceptual — confirm package name

const rain = new Rain({ apiKey: process.env.RAIN_API_KEY });

// 1. Onboard the cardholder (KYC/KYB handled by Rain)
const holder = await rain.cardholders.create({
  type: 'individual',
  email: 'user@rails.app',
});

// 2. Register the user-owned smart-contract collateral account.
//    The user deposits USDC into a contract THEY control; it backs the credit line.
const collateral = await rain.collateralAccounts.create({
  cardholderId: holder.id,
  chain: 'base',            // ethereum | base | polygon | solana | stellar | tron ...
  asset: 'USDC',            // also USDT | DAI | PYUSD
  contractAddress: '0xUserOwnedSmartContract...',
});

// 3. Issue the Visa card bound to that collateral.
const card = await rain.cards.create({
  cardholderId: holder.id,
  collateralAccountId: collateral.id,
  type: 'virtual',          // or 'physical'
  spendLimit: { amount: 5000_00, interval: 'monthly' },
});

// 4. Real-time authorization webhook: Rain authorizes against on-chain
//    collateral, fronts fiat to the merchant, then settles to Visa in USDC.
export async function onWebhook(event: RainEvent) {
  switch (event.type) {
    case 'authorization.created':
      // optional program-level approve/decline on top of Rain's collateral check
      break;
    case 'settlement.completed':
      // USDC settled on-chain to Visa; reconcile + repay capital float
      break;
  }
}

Build notes

• Self-custody is the design center: collateral lives in a smart contract the END USER owns — Rain authorizes against it but does not custody it.
• Settlement is the headline: Rain pays Visa in USDC on-chain daily/365, so float isn't stranded over weekends/holidays the way fiat-wire settlement is.
• Treat webhooks (authorization + settlement events) as the source of truth for reconciliation; the on-chain settlement record is the ledger of record.
• Region availability is gated by card/credit + interchange regulation — confirm supported geographies per program with Rain.
• [verify exact endpoint names, SDK package, and auth scheme — Rain's API reference at docs.rain.xyz is access-code gated and not public.]