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

# Fiat

> Accept deposits from local bank accounts and payment rails via a Daimo-hosted flow

Fiat lets your users deposit through supported local bank and wallet rails.
Daimo hosts identity verification and the deposit UI, settles the fiat transfer,
and delivers the stablecoin to your destination. The user pays in their local
currency and never touches crypto.

Fiat rails are part of the same integration. With
[`paymentMethods: { mode: "auto" }`](/guides/payment-methods), the fiat rails
enabled for your org appear automatically in each user's localized picker,
alongside exchanges and wallets.

<Info>
  Fiat rails are enabled per-org. [Contact us](mailto:support@daimo.com) to
  request access and have specific rails enabled.
</Info>

## Supported rails

| Rail      | `fiatMethod` | Region                                     | Currency | Verification                         | Settlement        |
| --------- | ------------ | ------------------------------------------ | -------- | ------------------------------------ | ----------------- |
| Interac   | `interac`    | Canada                                     | CAD      | ID and selfie verification · \~5 min | Instant           |
| Apple Pay | `apple_pay`  | United States                              | USD      | Phone verification · \~1 min         | Instant           |
| ACH       | `ach`        | United States                              | USD      | ID verification · \~3 min            | 2–3 business days |
| SEPA      | `sepa`       | Europe (SEPA)                              | EUR      | ID verification · \~3 min            | Instant           |
| JPYC      | `jpyc`       | Japan, Singapore, South Korea, Philippines | JPY      | No verification                      | Instant           |
| ARS       | `ars`        | Argentina                                  | ARS      | ID verification · \~3 min            | Instant           |
| Bre-B     | `breb`       | Colombia                                   | COP      | ID and selfie verification · \~5 min | Instant           |

A rail appears for a user when it's offered in their region and enabled for
your org.

## Verification

Each rail carries the verification requirement shown above. First-time users
complete it once inside the hosted flow; returning users skip through.

* **No verification**: the user can pay immediately.
* **Phone verification**: a one-time phone confirmation (\~1 min).
* **ID verification**: name, address, and a government-issued ID (\~3 min).
* **ID and selfie verification**: the above plus a selfie check (\~5 min).

Verification happens entirely on the Daimo-hosted page; you never collect or
store identity data. If your users are already verified elsewhere, see
[KYC Import](/advanced/kyc-import).

## Fiat in auto mode

With `paymentMethods: { mode: "auto" }`:

* Bank rails fold into one Bank transfer entry that expands to the rails
  available.
* Apple Pay renders as its own entry.
* Users in a country with no enabled fiat rail see crypto, exchange, and wallet
  methods instead.

See [Payment Methods](/guides/payment-methods#what-auto-renders) for the full
per-country breakdown.

## How the hosted flow works

When the user picks a fiat rail, they're handed off to a Daimo-hosted page that
walks them through:

1. **Rail selection**: choose the rail. Skipped if the flow is pinned to one.
2. **Identity verification**: first-time users complete the KYC step for that
   rail. Returning users skip through.
3. **Payment**: the user pays through their chosen rail, e.g. an Interac
   e-Transfer, ACH debit, Apple Pay charge, or SEPA bank transfer.
4. **Confirmation**: once the fiat payment clears, the page confirms success
   and the user returns to your app. Daimo delivers the stablecoin to your
   destination.

## Integration

### Modal SDK

Set `paymentMethods` when [creating the session](/api-reference/create-session).
`{ mode: "auto" }` includes every fiat rail enabled for the user's country in
the localized picker; `{ mode: "fixed", type }` pins the session to a single
rail.

```typescript theme={null}
await fetch("https://api.daimo.com/v1/sessions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DAIMO_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    destination: {
      type: "evm",
      address: "0xYourAddress",
      chainId: 8453,
      tokenAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      amountUnits: "25.00",
    },
    display: {
      title: "Deposit to Acme",
      verb: "Deposit",
      paymentMethods: { mode: "auto" },
      // or pin one rail: { mode: "fixed", type: "Interac" }
    },
  }),
});
```

Fixed `type` values for fiat: `Interac`, `ApplePay`, `ACH`, `SEPA`, `JPYC`, `ARS`, `BreB`.
See [Payment Methods](/guides/payment-methods) for the full reference.

### Auth prefill

If you already know the user's email or phone, include it in session metadata:

```json theme={null}
{
  "metadata": {
    "email": "account@daimo.com",
    "phone": "+14155552671"
  }
}
```

Daimo uses these values as account auth hints for fiat deposits. Signed-out
users with `metadata.email` skip email entry and start at OTP verification.
Apple Pay users with `metadata.phone` skip phone entry and start at SMS OTP
verification. They still verify each value before any account is created or
reused. Phone numbers must be E.164. If a hint is missing or invalid, Daimo
shows the normal entry step.

### Custom integration

If you're not using the modal, drive the flow yourself: create the session,
then call [`POST /v1/sessions/{id}/paymentMethods`](/api-reference/create-payment-method)
with `{ type: "fiat" }` to get back a `fiat.hostedUrl`.

[Render that URL in a WebView, iframe, or new tab](#rendering-the-hosted-url).
The hosted page handles KYC and payment collection, and Daimo delivers the
stablecoin once the fiat transfer clears. See the full four-step flow for
[custom integrations](/guides/custom-integration).

Pass the `clientSecret` returned by [`POST /v1/sessions`](/api-reference/create-session).

<Warning>
  `fiat.hostedUrl` is returned **only once** from `POST /paymentMethods`. It is
  **not** returned from `GET /v1/sessions/{id}`. Store it on the client as soon
  as you receive it.
</Warning>

Here is the fiat-specific [`POST /paymentMethods`](/api-reference/create-payment-method) request and response:

<CodeGroup>
  ```bash curl theme={null}
  curl -X POST https://api.daimo.com/v1/sessions/{sessionId}/paymentMethods \
    -H "Content-Type: application/json" \
    -d '{
      "clientSecret": "SESSION_CLIENT_SECRET",
      "paymentMethod": { "type": "fiat", "fiatMethod": "interac" }
    }'
  ```

  ```typescript SDK theme={null}
  const result = await daimo.sessions.paymentMethods.create(sessionId, {
    clientSecret: "SESSION_CLIENT_SECRET",
    paymentMethod: { type: "fiat", fiatMethod: "interac" },
  });
  ```
</CodeGroup>

The response:

```json theme={null}
{
  "session": {
    "status": "waiting_payment",
    "paymentMethod": {
      "type": "fiat",
      "fiatMethod": "interac",
      "createdAt": 1700000000
    }
  },
  "fiat": {
    "hostedUrl": "https://daimo.com/webview?session=...&cs=...",
    "fiatMethod": "interac"
  }
}
```

Open `fiat.hostedUrl` in a WebView or a new browser tab. When the user finishes,
they return to your app; poll the session or use [webhooks](/guides/webhooks)
for the final status.

Omit `fiatMethod` to let the user pick from every rail enabled for your org, or
set it to one of `interac`, `apple_pay`, `ach`, `sepa`, `jpyc`, `ars`, `breb` to pin the flow to a specific one.

| Input                                  | Hosted page behavior                  |
| -------------------------------------- | ------------------------------------- |
| `{ type: "fiat" }`                     | Lists every rail enabled for the user |
| `{ type: "fiat", fiatMethod: "ach" }`  | Jumps straight into the ACH flow      |
| `{ type: "fiat", fiatMethod: "sepa" }` | Jumps straight into the SEPA flow     |

## Rendering the hosted URL

`hostedUrl` points to a mobile-friendly Daimo page. Three ways to render it:

* **Native iOS / Android / React Native app** → load in a WebView. The page
  posts session events back via `postMessage`. Full reference and code samples
  in [Native WebView](/guides/webview-native); on React Native,
  [`DaimoFrameRN`](/guides/webview) handles this for you.
* **Web app** → open in a new tab or redirect. No special integration needed.
* **In-page iframe** → append `?layout=embed` to render inline instead of as a
  modal.

## Tracking status

Fiat sessions use the same lifecycle, statuses, and webhooks as every other
session. For a full overview, see [Sessions](/guides/sessions#session-lifecycle)
and [Webhooks](/guides/webhooks).

| Session status    | What it means for fiat                                                  |
| ----------------- | ----------------------------------------------------------------------- |
| `waiting_payment` | Hosted URL is live; waiting for the user to complete the fiat transfer  |
| `processing`      | Fiat payment confirmed; Daimo is delivering the stablecoin on-chain     |
| `succeeded`       | Stablecoin delivered to the destination address                         |
| `bounced`         | On-chain delivery reverted (e.g. contract call failure); funds refunded |
| `expired`         | User didn't complete the fiat transfer in time                          |

Subscribe to `session.processing`, `session.succeeded`, and `session.bounced`
via [webhooks](/guides/webhooks) to drive order fulfillment.

## Reference

* [Payment Methods](/guides/payment-methods) - `auto` and `fixed` modes.
* [Create Session](/api-reference/create-session) - `display.paymentMethods`; optionally pass `metadata.email` or `metadata.phone` to skip fiat auth entry.
* [Create Payment Method](/api-reference/create-payment-method) - request body `{ type: "fiat", fiatMethod? }`, response `fiat.hostedUrl`.
* [Native WebView](/guides/webview-native) - load the hosted URL on iOS and Android.
* [React Native](/guides/webview) - embed with `DaimoFrameRN`.
* [KYC Import](/advanced/kyc-import) - reuse existing verified users.
* [Sessions](/guides/sessions#fiat) - payment method shape and lifecycle details.